@intlify/message-compiler 9.13.1 → 10.0.0-alpha.2

package/dist/message-compiler.node.mjs

@@ -1,5 +1,5 @@
 /*!
-  * message-compiler v9.13.1
+  * message-compiler v10.0.0-alpha.2
   * (c) 2024 kazuya kawaguchi
   * Released under the MIT License.
   */
@@ -21,23 +21,6 @@ function createLocation(start, end, source) {
     return loc;
 }
 
-const CompileWarnCodes = {
-    USE_MODULO_SYNTAX: 1,
-    __EXTEND_POINT__: 2
-};
-/** @internal */
-const warnMessages = {
-    [CompileWarnCodes.USE_MODULO_SYNTAX]: `Use modulo before '{{0}}'.`
-};
-function createCompileWarn(code, loc, ...args) {
-    const msg = (process.env.NODE_ENV !== 'production') ? format(warnMessages[code] || '', ...(args || [])) : code;
-    const message = { message: String(msg), code };
-    if (loc) {
-        message.location = loc;
-    }
-    return message;
-}
-
 const CompileErrorCodes = {
     // tokenizer error codes
     EXPECTED_TOKEN: 1,
@@ -163,7 +146,6 @@ function createScanner(str) {
     }
     function skipToPeek() {
         const target = _index + _peekOffset;
-        // eslint-disable-next-line no-unmodified-loop-condition
         while (target !== _index) {
             next();
         }
@@ -197,11 +179,11 @@ function createTokenizer(source, options = {}) {
     const _initLoc = currentPosition();
     const _initOffset = currentOffset();
     const _context = {
-        currentType: 14 /* TokenTypes.EOF */,
+        currentType: 13 /* TokenTypes.EOF */,
         offset: _initOffset,
         startLoc: _initLoc,
         endLoc: _initLoc,
-        lastType: 14 /* TokenTypes.EOF */,
+        lastType: 13 /* TokenTypes.EOF */,
         lastOffset: _initOffset,
         lastStartLoc: _initLoc,
         lastEndLoc: _initLoc,
@@ -236,7 +218,7 @@ function createTokenizer(source, options = {}) {
         }
         return token;
     }
-    const getEndToken = (context) => getToken(context, 14 /* TokenTypes.EOF */);
+    const getEndToken = (context) => getToken(context, 13 /* TokenTypes.EOF */);
     function eat(scnr, ch) {
         if (scnr.currentChar() === ch) {
             scnr.next();
@@ -310,7 +292,7 @@ function createTokenizer(source, options = {}) {
     }
     function isLinkedDotStart(scnr, context) {
         const { currentType } = context;
-        if (currentType !== 8 /* TokenTypes.LinkedAlias */) {
+        if (currentType !== 7 /* TokenTypes.LinkedAlias */) {
             return false;
         }
         peekSpaces(scnr);
@@ -320,7 +302,7 @@ function createTokenizer(source, options = {}) {
     }
     function isLinkedModifierStart(scnr, context) {
         const { currentType } = context;
-        if (currentType !== 9 /* TokenTypes.LinkedDot */) {
+        if (currentType !== 8 /* TokenTypes.LinkedDot */) {
             return false;
         }
         peekSpaces(scnr);
@@ -330,8 +312,8 @@ function createTokenizer(source, options = {}) {
     }
     function isLinkedDelimiterStart(scnr, context) {
         const { currentType } = context;
-        if (!(currentType === 8 /* TokenTypes.LinkedAlias */ ||
-            currentType === 12 /* TokenTypes.LinkedModifier */)) {
+        if (!(currentType === 7 /* TokenTypes.LinkedAlias */ ||
+            currentType === 11 /* TokenTypes.LinkedModifier */)) {
             return false;
         }
         peekSpaces(scnr);
@@ -341,7 +323,7 @@ function createTokenizer(source, options = {}) {
     }
     function isLinkedReferStart(scnr, context) {
         const { currentType } = context;
-        if (currentType !== 10 /* TokenTypes.LinkedDelimiter */) {
+        if (currentType !== 9 /* TokenTypes.LinkedDelimiter */) {
             return false;
         }
         const fn = () => {
@@ -350,7 +332,6 @@ function createTokenizer(source, options = {}) {
                 return isIdentifierStart(scnr.peek());
             }
             else if (ch === "@" /* TokenChars.LinkedAlias */ ||
-                ch === "%" /* TokenChars.Modulo */ ||
                 ch === "|" /* TokenChars.Pipe */ ||
                 ch === ":" /* TokenChars.LinkedDelimiter */ ||
                 ch === "." /* TokenChars.LinkedDot */ ||
@@ -377,41 +358,25 @@ function createTokenizer(source, options = {}) {
         scnr.resetPeek();
         return ret;
     }
-    function detectModuloStart(scnr) {
-        const spaces = peekSpaces(scnr);
-        const ret = scnr.currentPeek() === "%" /* TokenChars.Modulo */ &&
-            scnr.peek() === "{" /* TokenChars.BraceLeft */;
-        scnr.resetPeek();
-        return {
-            isModulo: ret,
-            hasSpace: spaces.length > 0
-        };
-    }
     function isTextStart(scnr, reset = true) {
-        const fn = (hasSpace = false, prev = '', detectModulo = false) => {
+        const fn = (hasSpace = false, prev = '') => {
             const ch = scnr.currentPeek();
             if (ch === "{" /* TokenChars.BraceLeft */) {
-                return prev === "%" /* TokenChars.Modulo */ ? false : hasSpace;
+                return hasSpace;
             }
             else if (ch === "@" /* TokenChars.LinkedAlias */ || !ch) {
-                return prev === "%" /* TokenChars.Modulo */ ? true : hasSpace;
-            }
-            else if (ch === "%" /* TokenChars.Modulo */) {
-                scnr.peek();
-                return fn(hasSpace, "%" /* TokenChars.Modulo */, true);
+                return hasSpace;
             }
             else if (ch === "|" /* TokenChars.Pipe */) {
-                return prev === "%" /* TokenChars.Modulo */ || detectModulo
-                    ? true
-                    : !(prev === CHAR_SP || prev === CHAR_LF);
+                return !(prev === CHAR_SP || prev === CHAR_LF);
             }
             else if (ch === CHAR_SP) {
                 scnr.peek();
-                return fn(true, CHAR_SP, detectModulo);
+                return fn(true, CHAR_SP);
             }
             else if (ch === CHAR_LF) {
                 scnr.peek();
-                return fn(true, CHAR_LF, detectModulo);
+                return fn(true, CHAR_LF);
             }
             else {
                 return true;
@@ -481,18 +446,8 @@ function createTokenizer(source, options = {}) {
         }
         return num;
     }
-    function readModulo(scnr) {
-        skipSpaces(scnr);
-        const ch = scnr.currentChar();
-        if (ch !== "%" /* TokenChars.Modulo */) {
-            emitError(CompileErrorCodes.EXPECTED_TOKEN, currentPosition(), 0, ch);
-        }
-        scnr.next();
-        return "%" /* TokenChars.Modulo */;
-    }
     function readText(scnr) {
         let buf = '';
-        // eslint-disable-next-line no-constant-condition
         while (true) {
             const ch = scnr.currentChar();
             if (ch === "{" /* TokenChars.BraceLeft */ ||
@@ -502,15 +457,6 @@ function createTokenizer(source, options = {}) {
                 !ch) {
                 break;
             }
-            else if (ch === "%" /* TokenChars.Modulo */) {
-                if (isTextStart(scnr)) {
-                    buf += ch;
-                    scnr.next();
-                }
-                else {
-                    break;
-                }
-            }
             else if (ch === CHAR_SP || ch === CHAR_LF) {
                 if (isTextStart(scnr)) {
                     buf += ch;
@@ -646,7 +592,6 @@ function createTokenizer(source, options = {}) {
         const fn = (buf) => {
             const ch = scnr.currentChar();
             if (ch === "{" /* TokenChars.BraceLeft */ ||
-                ch === "%" /* TokenChars.Modulo */ ||
                 ch === "@" /* TokenChars.LinkedAlias */ ||
                 ch === "|" /* TokenChars.Pipe */ ||
                 ch === "(" /* TokenChars.ParenLeft */ ||
@@ -725,31 +670,31 @@ function createTokenizer(source, options = {}) {
                     return token;
                 }
                 if (context.braceNest > 0 &&
-                    (context.currentType === 5 /* TokenTypes.Named */ ||
-                        context.currentType === 6 /* TokenTypes.List */ ||
-                        context.currentType === 7 /* TokenTypes.Literal */)) {
+                    (context.currentType === 4 /* TokenTypes.Named */ ||
+                        context.currentType === 5 /* TokenTypes.List */ ||
+                        context.currentType === 6 /* TokenTypes.Literal */)) {
                     emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
                     context.braceNest = 0;
                     return readToken(scnr, context);
                 }
                 if ((validNamedIdentifier = isNamedIdentifierStart(scnr, context))) {
-                    token = getToken(context, 5 /* TokenTypes.Named */, readNamedIdentifier(scnr));
+                    token = getToken(context, 4 /* TokenTypes.Named */, readNamedIdentifier(scnr));
                     skipSpaces(scnr);
                     return token;
                 }
                 if ((validListIdentifier = isListIdentifierStart(scnr, context))) {
-                    token = getToken(context, 6 /* TokenTypes.List */, readListIdentifier(scnr));
+                    token = getToken(context, 5 /* TokenTypes.List */, readListIdentifier(scnr));
                     skipSpaces(scnr);
                     return token;
                 }
                 if ((validLiteral = isLiteralStart(scnr, context))) {
-                    token = getToken(context, 7 /* TokenTypes.Literal */, readLiteral(scnr));
+                    token = getToken(context, 6 /* TokenTypes.Literal */, readLiteral(scnr));
                     skipSpaces(scnr);
                     return token;
                 }
                 if (!validNamedIdentifier && !validListIdentifier && !validLiteral) {
                     // TODO: we should be re-designed invalid cases, when we will extend message syntax near the future ...
-                    token = getToken(context, 13 /* TokenTypes.InvalidPlace */, readInvalidIdentifier(scnr));
+                    token = getToken(context, 12 /* TokenTypes.InvalidPlace */, readInvalidIdentifier(scnr));
                     emitError(CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER, currentPosition(), 0, token.value);
                     skipSpaces(scnr);
                     return token;
@@ -764,27 +709,27 @@ function createTokenizer(source, options = {}) {
         const { currentType } = context;
         let token = null;
         const ch = scnr.currentChar();
-        if ((currentType === 8 /* TokenTypes.LinkedAlias */ ||
-            currentType === 9 /* TokenTypes.LinkedDot */ ||
-            currentType === 12 /* TokenTypes.LinkedModifier */ ||
-            currentType === 10 /* TokenTypes.LinkedDelimiter */) &&
+        if ((currentType === 7 /* TokenTypes.LinkedAlias */ ||
+            currentType === 8 /* TokenTypes.LinkedDot */ ||
+            currentType === 11 /* TokenTypes.LinkedModifier */ ||
+            currentType === 9 /* TokenTypes.LinkedDelimiter */) &&
             (ch === CHAR_LF || ch === CHAR_SP)) {
             emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
         }
         switch (ch) {
             case "@" /* TokenChars.LinkedAlias */:
                 scnr.next();
-                token = getToken(context, 8 /* TokenTypes.LinkedAlias */, "@" /* TokenChars.LinkedAlias */);
+                token = getToken(context, 7 /* TokenTypes.LinkedAlias */, "@" /* TokenChars.LinkedAlias */);
                 context.inLinked = true;
                 return token;
             case "." /* TokenChars.LinkedDot */:
                 skipSpaces(scnr);
                 scnr.next();
-                return getToken(context, 9 /* TokenTypes.LinkedDot */, "." /* TokenChars.LinkedDot */);
+                return getToken(context, 8 /* TokenTypes.LinkedDot */, "." /* TokenChars.LinkedDot */);
             case ":" /* TokenChars.LinkedDelimiter */:
                 skipSpaces(scnr);
                 scnr.next();
-                return getToken(context, 10 /* TokenTypes.LinkedDelimiter */, ":" /* TokenChars.LinkedDelimiter */);
+                return getToken(context, 9 /* TokenTypes.LinkedDelimiter */, ":" /* TokenChars.LinkedDelimiter */);
             default:
                 if (isPluralStart(scnr)) {
                     token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
@@ -800,7 +745,7 @@ function createTokenizer(source, options = {}) {
                 }
                 if (isLinkedModifierStart(scnr, context)) {
                     skipSpaces(scnr);
-                    return getToken(context, 12 /* TokenTypes.LinkedModifier */, readLinkedModifier(scnr));
+                    return getToken(context, 11 /* TokenTypes.LinkedModifier */, readLinkedModifier(scnr));
                 }
                 if (isLinkedReferStart(scnr, context)) {
                     skipSpaces(scnr);
@@ -809,10 +754,10 @@ function createTokenizer(source, options = {}) {
                         return readTokenInPlaceholder(scnr, context) || token;
                     }
                     else {
-                        return getToken(context, 11 /* TokenTypes.LinkedKey */, readLinkedRefer(scnr));
+                        return getToken(context, 10 /* TokenTypes.LinkedKey */, readLinkedRefer(scnr));
                     }
                 }
-                if (currentType === 8 /* TokenTypes.LinkedAlias */) {
+                if (currentType === 7 /* TokenTypes.LinkedAlias */) {
                     emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
                 }
                 context.braceNest = 0;
@@ -822,7 +767,7 @@ function createTokenizer(source, options = {}) {
     }
     // TODO: We need refactoring of token parsing ...
     function readToken(scnr, context) {
-        let token = { type: 14 /* TokenTypes.EOF */ };
+        let token = { type: 13 /* TokenTypes.EOF */ };
         if (context.braceNest > 0) {
             return readTokenInPlaceholder(scnr, context) || getEndToken(context);
         }
@@ -847,12 +792,6 @@ function createTokenizer(source, options = {}) {
                     context.inLinked = false;
                     return token;
                 }
-                const { isModulo, hasSpace } = detectModuloStart(scnr);
-                if (isModulo) {
-                    return hasSpace
-                        ? getToken(context, 0 /* TokenTypes.Text */, readText(scnr))
-                        : getToken(context, 4 /* TokenTypes.Modulo */, readModulo(scnr));
-                }
                 if (isTextStart(scnr)) {
                     return getToken(context, 0 /* TokenTypes.Text */, readText(scnr));
                 }
@@ -870,7 +809,7 @@ function createTokenizer(source, options = {}) {
         _context.offset = currentOffset();
         _context.startLoc = currentPosition();
         if (_scnr.currentChar() === EOF) {
-            return getToken(_context, 14 /* TokenTypes.EOF */);
+            return getToken(_context, 13 /* TokenTypes.EOF */);
         }
         return readToken(_scnr, _context);
     }
@@ -906,7 +845,7 @@ function fromEscapeSequence(match, codePoint4, codePoint6) {
 }
 function createParser(options = {}) {
     const location = options.location !== false;
-    const { onError, onWarn } = options;
+    const { onError } = options;
     function emitError(tokenzer, code, start, offset, ...args) {
         const end = tokenzer.currentPosition();
         end.offset += offset;
@@ -920,15 +859,6 @@ function createParser(options = {}) {
             onError(err);
         }
     }
-    function emitWarn(tokenzer, code, start, offset, ...args) {
-        const end = tokenzer.currentPosition();
-        end.offset += offset;
-        end.column += offset;
-        if (onWarn) {
-            const loc = location ? createLocation(start, end) : null;
-            onWarn(createCompileWarn(code, loc, args));
-        }
-    }
     function startNode(type, offset, loc) {
         const node = { type };
         if (location) {
@@ -965,14 +895,11 @@ function createParser(options = {}) {
         endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
         return node;
     }
-    function parseNamed(tokenizer, key, modulo) {
+    function parseNamed(tokenizer, key) {
         const context = tokenizer.context();
         const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
         const node = startNode(4 /* NodeTypes.Named */, offset, loc);
         node.key = key;
-        if (modulo === true) {
-            node.modulo = true;
-        }
         tokenizer.nextToken(); // skip brach right
         endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
         return node;
@@ -991,7 +918,7 @@ function createParser(options = {}) {
         const context = tokenizer.context();
         const { lastOffset: offset, lastStartLoc: loc } = context; // get linked dot loc
         const node = startNode(8 /* NodeTypes.LinkedModifier */, offset, loc);
-        if (token.type !== 12 /* TokenTypes.LinkedModifier */) {
+        if (token.type !== 11 /* TokenTypes.LinkedModifier */) {
             // empty modifier
             emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_MODIFIER, context.lastStartLoc, 0);
             node.value = '';
@@ -1022,13 +949,13 @@ function createParser(options = {}) {
         const context = tokenizer.context();
         const linkedNode = startNode(6 /* NodeTypes.Linked */, context.offset, context.startLoc);
         let token = tokenizer.nextToken();
-        if (token.type === 9 /* TokenTypes.LinkedDot */) {
+        if (token.type === 8 /* TokenTypes.LinkedDot */) {
             const parsed = parseLinkedModifier(tokenizer);
             linkedNode.modifier = parsed.node;
             token = parsed.nextConsumeToken || tokenizer.nextToken();
         }
         // asset check token
-        if (token.type !== 10 /* TokenTypes.LinkedDelimiter */) {
+        if (token.type !== 9 /* TokenTypes.LinkedDelimiter */) {
             emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
         }
         token = tokenizer.nextToken();
@@ -1037,25 +964,25 @@ function createParser(options = {}) {
             token = tokenizer.nextToken();
         }
         switch (token.type) {
-            case 11 /* TokenTypes.LinkedKey */:
+            case 10 /* TokenTypes.LinkedKey */:
                 if (token.value == null) {
                     emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
                 }
                 linkedNode.key = parseLinkedKey(tokenizer, token.value || '');
                 break;
-            case 5 /* TokenTypes.Named */:
+            case 4 /* TokenTypes.Named */:
                 if (token.value == null) {
                     emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
                 }
                 linkedNode.key = parseNamed(tokenizer, token.value || '');
                 break;
-            case 6 /* TokenTypes.List */:
+            case 5 /* TokenTypes.List */:
                 if (token.value == null) {
                     emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
                 }
                 linkedNode.key = parseList(tokenizer, token.value || '');
                 break;
-            case 7 /* TokenTypes.Literal */:
+            case 6 /* TokenTypes.Literal */:
                 if (token.value == null) {
                     emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
                 }
@@ -1092,7 +1019,6 @@ function createParser(options = {}) {
         const node = startNode(2 /* NodeTypes.Message */, startOffset, startLoc);
         node.items = [];
         let nextToken = null;
-        let modulo = null;
         do {
             const token = nextToken || tokenizer.nextToken();
             nextToken = null;
@@ -1103,39 +1029,32 @@ function createParser(options = {}) {
                     }
                     node.items.push(parseText(tokenizer, token.value || ''));
                     break;
-                case 6 /* TokenTypes.List */:
+                case 5 /* TokenTypes.List */:
                     if (token.value == null) {
                         emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
                     }
                     node.items.push(parseList(tokenizer, token.value || ''));
                     break;
-                case 4 /* TokenTypes.Modulo */:
-                    modulo = true;
-                    break;
-                case 5 /* TokenTypes.Named */:
+                case 4 /* TokenTypes.Named */:
                     if (token.value == null) {
                         emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
                     }
-                    node.items.push(parseNamed(tokenizer, token.value || '', !!modulo));
-                    if (modulo) {
-                        emitWarn(tokenizer, CompileWarnCodes.USE_MODULO_SYNTAX, context.lastStartLoc, 0, getTokenCaption(token));
-                        modulo = null;
-                    }
+                    node.items.push(parseNamed(tokenizer, token.value || ''));
                     break;
-                case 7 /* TokenTypes.Literal */:
+                case 6 /* TokenTypes.Literal */:
                     if (token.value == null) {
                         emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
                     }
                     node.items.push(parseLiteral(tokenizer, token.value || ''));
                     break;
-                case 8 /* TokenTypes.LinkedAlias */: {
+                case 7 /* TokenTypes.LinkedAlias */: {
                     const parsed = parseLinked(tokenizer);
                     node.items.push(parsed.node);
                     nextToken = parsed.nextConsumeToken || null;
                     break;
                 }
             }
-        } while (context.currentType !== 14 /* TokenTypes.EOF */ &&
+        } while (context.currentType !== 13 /* TokenTypes.EOF */ &&
             context.currentType !== 1 /* TokenTypes.Pipe */);
         // adjust message node loc
         const endOffset = context.currentType === 1 /* TokenTypes.Pipe */
@@ -1159,7 +1078,7 @@ function createParser(options = {}) {
                 hasEmptyMessage = msg.items.length === 0;
             }
             node.cases.push(msg);
-        } while (context.currentType !== 14 /* TokenTypes.EOF */);
+        } while (context.currentType !== 13 /* TokenTypes.EOF */);
         if (hasEmptyMessage) {
             emitError(tokenizer, CompileErrorCodes.MUST_HAVE_MESSAGES_IN_PLURAL, loc, 0);
         }
@@ -1170,7 +1089,7 @@ function createParser(options = {}) {
         const context = tokenizer.context();
         const { offset, startLoc } = context;
         const msgNode = parseMessage(tokenizer);
-        if (context.currentType === 14 /* TokenTypes.EOF */) {
+        if (context.currentType === 13 /* TokenTypes.EOF */) {
             return msgNode;
         }
         else {
@@ -1189,7 +1108,7 @@ function createParser(options = {}) {
             node.cacheKey = options.onCacheKey(source);
         }
         // assert whether achieved to EOF
-        if (context.currentType !== 14 /* TokenTypes.EOF */) {
+        if (context.currentType !== 13 /* TokenTypes.EOF */) {
             emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, source[context.offset] || '');
         }
         endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
@@ -1198,7 +1117,7 @@ function createParser(options = {}) {
     return { parse };
 }
 function getTokenCaption(token) {
-    if (token.type === 14 /* TokenTypes.EOF */) {
+    if (token.type === 13 /* TokenTypes.EOF */) {
         return 'EOF';
     }
     const name = (token.value || '').replace(/\r?\n/gu, '\\n');
@@ -1560,8 +1479,7 @@ function generateNode(generator, node) {
     }
 }
 // generate code from AST
-const generate = (ast, options = {} // eslint-disable-line
-) => {
+const generate = (ast, options = {}) => {
     const mode = isString(options.mode) ? options.mode : 'normal';
     const filename = isString(options.filename)
         ? options.filename
@@ -1657,4 +1575,4 @@ function baseCompile(source, options = {}) {
     }
 }
 
-export { CompileErrorCodes, CompileWarnCodes, ERROR_DOMAIN$2 as ERROR_DOMAIN, LOCATION_STUB, baseCompile, createCompileError, createCompileWarn, createLocation, createParser, createPosition, defaultOnError, detectHtmlTag, errorMessages, warnMessages };
+export { CompileErrorCodes, ERROR_DOMAIN$2 as ERROR_DOMAIN, LOCATION_STUB, baseCompile, createCompileError, createLocation, createParser, createPosition, defaultOnError, detectHtmlTag, errorMessages };