@intlify/core-base 9.3.0-beta.10 → 9.3.0-beta.11

package/dist/core-base.esm-browser.js

@@ -1,5 +1,5 @@
 /*!
-  * core-base v9.3.0-beta.10
+  * core-base v9.3.0-beta.11
   * (c) 2022 kazuya kawaguchi
   * Released under the MIT License.
   */
@@ -16,8 +16,11 @@ let measure;
         perf.mark &&
         perf.measure &&
         perf.clearMarks &&
+        // @ts-ignore browser compat
         perf.clearMeasures) {
-        mark = (tag) => perf.mark(tag);
+        mark = (tag) => {
+            perf.mark(tag);
+        };
         measure = (name, startTag, endTag) => {
             perf.measure(name, startTag, endTag);
             perf.clearMarks(startTag);
@@ -76,8 +79,8 @@ const isArray = Array.isArray;
 const isFunction = (val) => typeof val === 'function';
 const isString = (val) => typeof val === 'string';
 const isBoolean = (val) => typeof val === 'boolean';
-const isObject = (val) => // eslint-disable-line
- val !== null && typeof val === 'object';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const isObject = (val) => val !== null && typeof val === 'object';
 const objectToString = Object.prototype.toString;
 const toTypeString = (value) => objectToString.call(value);
 const isPlainObject = (val) => toTypeString(val) === '[object Object]';
@@ -279,11 +282,11 @@ function createTokenizer(source, options = {}) {
     const _initLoc = currentPosition();
     const _initOffset = currentOffset();
     const _context = {
-        currentType: 14 /* EOF */,
+        currentType: 14 /* TokenTypes.EOF */,
         offset: _initOffset,
         startLoc: _initLoc,
         endLoc: _initLoc,
-        lastType: 14 /* EOF */,
+        lastType: 14 /* TokenTypes.EOF */,
         lastOffset: _initOffset,
         lastStartLoc: _initLoc,
         lastEndLoc: _initLoc,
@@ -318,7 +321,7 @@ function createTokenizer(source, options = {}) {
         }
         return token;
     }
-    const getEndToken = (context) => getToken(context, 14 /* EOF */);
+    const getEndToken = (context) => getToken(context, 14 /* TokenTypes.EOF */);
     function eat(scnr, ch) {
         if (scnr.currentChar() === ch) {
             scnr.next();
@@ -361,7 +364,7 @@ function createTokenizer(source, options = {}) {
     }
     function isNamedIdentifierStart(scnr, context) {
         const { currentType } = context;
-        if (currentType !== 2 /* BraceLeft */) {
+        if (currentType !== 2 /* TokenTypes.BraceLeft */) {
             return false;
         }
         peekSpaces(scnr);
@@ -371,7 +374,7 @@ function createTokenizer(source, options = {}) {
     }
     function isListIdentifierStart(scnr, context) {
         const { currentType } = context;
-        if (currentType !== 2 /* BraceLeft */) {
+        if (currentType !== 2 /* TokenTypes.BraceLeft */) {
             return false;
         }
         peekSpaces(scnr);
@@ -382,7 +385,7 @@ function createTokenizer(source, options = {}) {
     }
     function isLiteralStart(scnr, context) {
         const { currentType } = context;
-        if (currentType !== 2 /* BraceLeft */) {
+        if (currentType !== 2 /* TokenTypes.BraceLeft */) {
             return false;
         }
         peekSpaces(scnr);
@@ -392,17 +395,17 @@ function createTokenizer(source, options = {}) {
     }
     function isLinkedDotStart(scnr, context) {
         const { currentType } = context;
-        if (currentType !== 8 /* LinkedAlias */) {
+        if (currentType !== 8 /* TokenTypes.LinkedAlias */) {
             return false;
         }
         peekSpaces(scnr);
-        const ret = scnr.currentPeek() === "." /* LinkedDot */;
+        const ret = scnr.currentPeek() === "." /* TokenChars.LinkedDot */;
         scnr.resetPeek();
         return ret;
     }
     function isLinkedModifierStart(scnr, context) {
         const { currentType } = context;
-        if (currentType !== 9 /* LinkedDot */) {
+        if (currentType !== 9 /* TokenTypes.LinkedDot */) {
             return false;
         }
         peekSpaces(scnr);
@@ -412,30 +415,30 @@ function createTokenizer(source, options = {}) {
     }
     function isLinkedDelimiterStart(scnr, context) {
         const { currentType } = context;
-        if (!(currentType === 8 /* LinkedAlias */ ||
-            currentType === 12 /* LinkedModifier */)) {
+        if (!(currentType === 8 /* TokenTypes.LinkedAlias */ ||
+            currentType === 12 /* TokenTypes.LinkedModifier */)) {
             return false;
         }
         peekSpaces(scnr);
-        const ret = scnr.currentPeek() === ":" /* LinkedDelimiter */;
+        const ret = scnr.currentPeek() === ":" /* TokenChars.LinkedDelimiter */;
         scnr.resetPeek();
         return ret;
     }
     function isLinkedReferStart(scnr, context) {
         const { currentType } = context;
-        if (currentType !== 10 /* LinkedDelimiter */) {
+        if (currentType !== 10 /* TokenTypes.LinkedDelimiter */) {
             return false;
         }
         const fn = () => {
             const ch = scnr.currentPeek();
-            if (ch === "{" /* BraceLeft */) {
+            if (ch === "{" /* TokenChars.BraceLeft */) {
                 return isIdentifierStart(scnr.peek());
             }
-            else if (ch === "@" /* LinkedAlias */ ||
-                ch === "%" /* Modulo */ ||
-                ch === "|" /* Pipe */ ||
-                ch === ":" /* LinkedDelimiter */ ||
-                ch === "." /* LinkedDot */ ||
+            else if (ch === "@" /* TokenChars.LinkedAlias */ ||
+                ch === "%" /* TokenChars.Modulo */ ||
+                ch === "|" /* TokenChars.Pipe */ ||
+                ch === ":" /* TokenChars.LinkedDelimiter */ ||
+                ch === "." /* TokenChars.LinkedDot */ ||
                 ch === CHAR_SP ||
                 !ch) {
                 return false;
@@ -455,14 +458,14 @@ function createTokenizer(source, options = {}) {
     }
     function isPluralStart(scnr) {
         peekSpaces(scnr);
-        const ret = scnr.currentPeek() === "|" /* Pipe */;
+        const ret = scnr.currentPeek() === "|" /* TokenChars.Pipe */;
         scnr.resetPeek();
         return ret;
     }
     function detectModuloStart(scnr) {
         const spaces = peekSpaces(scnr);
-        const ret = scnr.currentPeek() === "%" /* Modulo */ &&
-            scnr.peek() === "{" /* BraceLeft */;
+        const ret = scnr.currentPeek() === "%" /* TokenChars.Modulo */ &&
+            scnr.peek() === "{" /* TokenChars.BraceLeft */;
         scnr.resetPeek();
         return {
             isModulo: ret,
@@ -472,18 +475,18 @@ function createTokenizer(source, options = {}) {
     function isTextStart(scnr, reset = true) {
         const fn = (hasSpace = false, prev = '', detectModulo = false) => {
             const ch = scnr.currentPeek();
-            if (ch === "{" /* BraceLeft */) {
-                return prev === "%" /* Modulo */ ? false : hasSpace;
+            if (ch === "{" /* TokenChars.BraceLeft */) {
+                return prev === "%" /* TokenChars.Modulo */ ? false : hasSpace;
             }
-            else if (ch === "@" /* LinkedAlias */ || !ch) {
-                return prev === "%" /* Modulo */ ? true : hasSpace;
+            else if (ch === "@" /* TokenChars.LinkedAlias */ || !ch) {
+                return prev === "%" /* TokenChars.Modulo */ ? true : hasSpace;
             }
-            else if (ch === "%" /* Modulo */) {
+            else if (ch === "%" /* TokenChars.Modulo */) {
                 scnr.peek();
-                return fn(hasSpace, "%" /* Modulo */, true);
+                return fn(hasSpace, "%" /* TokenChars.Modulo */, true);
             }
-            else if (ch === "|" /* Pipe */) {
-                return prev === "%" /* Modulo */ || detectModulo
+            else if (ch === "|" /* TokenChars.Pipe */) {
+                return prev === "%" /* TokenChars.Modulo */ || detectModulo
                     ? true
                     : !(prev === CHAR_SP || prev === CHAR_LF);
             }
@@ -553,24 +556,24 @@ function createTokenizer(source, options = {}) {
     function readModulo(scnr) {
         skipSpaces(scnr);
         const ch = scnr.currentChar();
-        if (ch !== "%" /* Modulo */) {
+        if (ch !== "%" /* TokenChars.Modulo */) {
             emitError(CompileErrorCodes.EXPECTED_TOKEN, currentPosition(), 0, ch);
         }
         scnr.next();
-        return "%" /* Modulo */;
+        return "%" /* TokenChars.Modulo */;
     }
     function readText(scnr) {
         let buf = '';
         while (true) {
             const ch = scnr.currentChar();
-            if (ch === "{" /* BraceLeft */ ||
-                ch === "}" /* BraceRight */ ||
-                ch === "@" /* LinkedAlias */ ||
-                ch === "|" /* Pipe */ ||
+            if (ch === "{" /* TokenChars.BraceLeft */ ||
+                ch === "}" /* TokenChars.BraceRight */ ||
+                ch === "@" /* TokenChars.LinkedAlias */ ||
+                ch === "|" /* TokenChars.Pipe */ ||
                 !ch) {
                 break;
             }
-            else if (ch === "%" /* Modulo */) {
+            else if (ch === "%" /* TokenChars.Modulo */) {
                 if (isTextStart(scnr)) {
                     buf += ch;
                     scnr.next();
@@ -686,8 +689,8 @@ function createTokenizer(source, options = {}) {
         skipSpaces(scnr);
         let ch = '';
         let identifiers = '';
-        const closure = (ch) => ch !== "{" /* BraceLeft */ &&
-            ch !== "}" /* BraceRight */ &&
+        const closure = (ch) => ch !== "{" /* TokenChars.BraceLeft */ &&
+            ch !== "}" /* TokenChars.BraceRight */ &&
             ch !== CHAR_SP &&
             ch !== CHAR_LF;
         while ((ch = takeChar(scnr, closure))) {
@@ -706,10 +709,10 @@ function createTokenizer(source, options = {}) {
     function readLinkedRefer(scnr) {
         const fn = (detect = false, buf) => {
             const ch = scnr.currentChar();
-            if (ch === "{" /* BraceLeft */ ||
-                ch === "%" /* Modulo */ ||
-                ch === "@" /* LinkedAlias */ ||
-                ch === "|" /* Pipe */ ||
+            if (ch === "{" /* TokenChars.BraceLeft */ ||
+                ch === "%" /* TokenChars.Modulo */ ||
+                ch === "@" /* TokenChars.LinkedAlias */ ||
+                ch === "|" /* TokenChars.Pipe */ ||
                 !ch) {
                 return buf;
             }
@@ -731,7 +734,7 @@ function createTokenizer(source, options = {}) {
     }
     function readPlural(scnr) {
         skipSpaces(scnr);
-        const plural = eat(scnr, "|" /* Pipe */);
+        const plural = eat(scnr, "|" /* TokenChars.Pipe */);
         skipSpaces(scnr);
         return plural;
     }
@@ -740,29 +743,29 @@ function createTokenizer(source, options = {}) {
         let token = null;
         const ch = scnr.currentChar();
         switch (ch) {
-            case "{" /* BraceLeft */:
+            case "{" /* TokenChars.BraceLeft */:
                 if (context.braceNest >= 1) {
                     emitError(CompileErrorCodes.NOT_ALLOW_NEST_PLACEHOLDER, currentPosition(), 0);
                 }
                 scnr.next();
-                token = getToken(context, 2 /* BraceLeft */, "{" /* BraceLeft */);
+                token = getToken(context, 2 /* TokenTypes.BraceLeft */, "{" /* TokenChars.BraceLeft */);
                 skipSpaces(scnr);
                 context.braceNest++;
                 return token;
-            case "}" /* BraceRight */:
+            case "}" /* TokenChars.BraceRight */:
                 if (context.braceNest > 0 &&
-                    context.currentType === 2 /* BraceLeft */) {
+                    context.currentType === 2 /* TokenTypes.BraceLeft */) {
                     emitError(CompileErrorCodes.EMPTY_PLACEHOLDER, currentPosition(), 0);
                 }
                 scnr.next();
-                token = getToken(context, 3 /* BraceRight */, "}" /* BraceRight */);
+                token = getToken(context, 3 /* TokenTypes.BraceRight */, "}" /* TokenChars.BraceRight */);
                 context.braceNest--;
                 context.braceNest > 0 && skipSpaces(scnr);
                 if (context.inLinked && context.braceNest === 0) {
                     context.inLinked = false;
                 }
                 return token;
-            case "@" /* LinkedAlias */:
+            case "@" /* TokenChars.LinkedAlias */:
                 if (context.braceNest > 0) {
                     emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
                 }
@@ -777,38 +780,38 @@ function createTokenizer(source, options = {}) {
                     if (context.braceNest > 0) {
                         emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
                     }
-                    token = getToken(context, 1 /* Pipe */, readPlural(scnr));
+                    token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
                     // reset
                     context.braceNest = 0;
                     context.inLinked = false;
                     return token;
                 }
                 if (context.braceNest > 0 &&
-                    (context.currentType === 5 /* Named */ ||
-                        context.currentType === 6 /* List */ ||
-                        context.currentType === 7 /* Literal */)) {
+                    (context.currentType === 5 /* TokenTypes.Named */ ||
+                        context.currentType === 6 /* TokenTypes.List */ ||
+                        context.currentType === 7 /* 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 /* Named */, readNamedIdentifier(scnr));
+                    token = getToken(context, 5 /* TokenTypes.Named */, readNamedIdentifier(scnr));
                     skipSpaces(scnr);
                     return token;
                 }
                 if ((validListIdentifier = isListIdentifierStart(scnr, context))) {
-                    token = getToken(context, 6 /* List */, readListIdentifier(scnr));
+                    token = getToken(context, 6 /* TokenTypes.List */, readListIdentifier(scnr));
                     skipSpaces(scnr);
                     return token;
                 }
                 if ((validLiteral = isLiteralStart(scnr, context))) {
-                    token = getToken(context, 7 /* Literal */, readLiteral(scnr));
+                    token = getToken(context, 7 /* 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 /* InvalidPlace */, readInvalidIdentifier(scnr));
+                    token = getToken(context, 13 /* TokenTypes.InvalidPlace */, readInvalidIdentifier(scnr));
                     emitError(CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER, currentPosition(), 0, token.value);
                     skipSpaces(scnr);
                     return token;
@@ -822,30 +825,30 @@ function createTokenizer(source, options = {}) {
         const { currentType } = context;
         let token = null;
         const ch = scnr.currentChar();
-        if ((currentType === 8 /* LinkedAlias */ ||
-            currentType === 9 /* LinkedDot */ ||
-            currentType === 12 /* LinkedModifier */ ||
-            currentType === 10 /* LinkedDelimiter */) &&
+        if ((currentType === 8 /* TokenTypes.LinkedAlias */ ||
+            currentType === 9 /* TokenTypes.LinkedDot */ ||
+            currentType === 12 /* TokenTypes.LinkedModifier */ ||
+            currentType === 10 /* TokenTypes.LinkedDelimiter */) &&
             (ch === CHAR_LF || ch === CHAR_SP)) {
             emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
         }
         switch (ch) {
-            case "@" /* LinkedAlias */:
+            case "@" /* TokenChars.LinkedAlias */:
                 scnr.next();
-                token = getToken(context, 8 /* LinkedAlias */, "@" /* LinkedAlias */);
+                token = getToken(context, 8 /* TokenTypes.LinkedAlias */, "@" /* TokenChars.LinkedAlias */);
                 context.inLinked = true;
                 return token;
-            case "." /* LinkedDot */:
+            case "." /* TokenChars.LinkedDot */:
                 skipSpaces(scnr);
                 scnr.next();
-                return getToken(context, 9 /* LinkedDot */, "." /* LinkedDot */);
-            case ":" /* LinkedDelimiter */:
+                return getToken(context, 9 /* TokenTypes.LinkedDot */, "." /* TokenChars.LinkedDot */);
+            case ":" /* TokenChars.LinkedDelimiter */:
                 skipSpaces(scnr);
                 scnr.next();
-                return getToken(context, 10 /* LinkedDelimiter */, ":" /* LinkedDelimiter */);
+                return getToken(context, 10 /* TokenTypes.LinkedDelimiter */, ":" /* TokenChars.LinkedDelimiter */);
             default:
                 if (isPluralStart(scnr)) {
-                    token = getToken(context, 1 /* Pipe */, readPlural(scnr));
+                    token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
                     // reset
                     context.braceNest = 0;
                     context.inLinked = false;
@@ -858,19 +861,19 @@ function createTokenizer(source, options = {}) {
                 }
                 if (isLinkedModifierStart(scnr, context)) {
                     skipSpaces(scnr);
-                    return getToken(context, 12 /* LinkedModifier */, readLinkedModifier(scnr));
+                    return getToken(context, 12 /* TokenTypes.LinkedModifier */, readLinkedModifier(scnr));
                 }
                 if (isLinkedReferStart(scnr, context)) {
                     skipSpaces(scnr);
-                    if (ch === "{" /* BraceLeft */) {
+                    if (ch === "{" /* TokenChars.BraceLeft */) {
                         // scan the placeholder
                         return readTokenInPlaceholder(scnr, context) || token;
                     }
                     else {
-                        return getToken(context, 11 /* LinkedKey */, readLinkedRefer(scnr));
+                        return getToken(context, 11 /* TokenTypes.LinkedKey */, readLinkedRefer(scnr));
                     }
                 }
-                if (currentType === 8 /* LinkedAlias */) {
+                if (currentType === 8 /* TokenTypes.LinkedAlias */) {
                     emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
                 }
                 context.braceNest = 0;
@@ -880,7 +883,7 @@ function createTokenizer(source, options = {}) {
     }
     // TODO: We need refactoring of token parsing ...
     function readToken(scnr, context) {
-        let token = { type: 14 /* EOF */ };
+        let token = { type: 14 /* TokenTypes.EOF */ };
         if (context.braceNest > 0) {
             return readTokenInPlaceholder(scnr, context) || getEndToken(context);
         }
@@ -889,17 +892,17 @@ function createTokenizer(source, options = {}) {
         }
         const ch = scnr.currentChar();
         switch (ch) {
-            case "{" /* BraceLeft */:
+            case "{" /* TokenChars.BraceLeft */:
                 return readTokenInPlaceholder(scnr, context) || getEndToken(context);
-            case "}" /* BraceRight */:
+            case "}" /* TokenChars.BraceRight */:
                 emitError(CompileErrorCodes.UNBALANCED_CLOSING_BRACE, currentPosition(), 0);
                 scnr.next();
-                return getToken(context, 3 /* BraceRight */, "}" /* BraceRight */);
-            case "@" /* LinkedAlias */:
+                return getToken(context, 3 /* TokenTypes.BraceRight */, "}" /* TokenChars.BraceRight */);
+            case "@" /* TokenChars.LinkedAlias */:
                 return readTokenInLinked(scnr, context) || getEndToken(context);
             default:
                 if (isPluralStart(scnr)) {
-                    token = getToken(context, 1 /* Pipe */, readPlural(scnr));
+                    token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
                     // reset
                     context.braceNest = 0;
                     context.inLinked = false;
@@ -908,11 +911,11 @@ function createTokenizer(source, options = {}) {
                 const { isModulo, hasSpace } = detectModuloStart(scnr);
                 if (isModulo) {
                     return hasSpace
-                        ? getToken(context, 0 /* Text */, readText(scnr))
-                        : getToken(context, 4 /* Modulo */, readModulo(scnr));
+                        ? getToken(context, 0 /* TokenTypes.Text */, readText(scnr))
+                        : getToken(context, 4 /* TokenTypes.Modulo */, readModulo(scnr));
                 }
                 if (isTextStart(scnr)) {
-                    return getToken(context, 0 /* Text */, readText(scnr));
+                    return getToken(context, 0 /* TokenTypes.Text */, readText(scnr));
                 }
                 break;
         }
@@ -927,7 +930,7 @@ function createTokenizer(source, options = {}) {
         _context.offset = currentOffset();
         _context.startLoc = currentPosition();
         if (_scnr.currentChar() === EOF) {
-            return getToken(_context, 14 /* EOF */);
+            return getToken(_context, 14 /* TokenTypes.EOF */);
         }
         return readToken(_scnr, _context);
     }
@@ -997,7 +1000,7 @@ function createParser(options = {}) {
     }
     function parseText(tokenizer, value) {
         const context = tokenizer.context();
-        const node = startNode(3 /* Text */, context.offset, context.startLoc);
+        const node = startNode(3 /* NodeTypes.Text */, context.offset, context.startLoc);
         node.value = value;
         endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
         return node;
@@ -1005,7 +1008,7 @@ function createParser(options = {}) {
     function parseList(tokenizer, index) {
         const context = tokenizer.context();
         const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
-        const node = startNode(5 /* List */, offset, loc);
+        const node = startNode(5 /* NodeTypes.List */, offset, loc);
         node.index = parseInt(index, 10);
         tokenizer.nextToken(); // skip brach right
         endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
@@ -1014,7 +1017,7 @@ function createParser(options = {}) {
     function parseNamed(tokenizer, key) {
         const context = tokenizer.context();
         const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
-        const node = startNode(4 /* Named */, offset, loc);
+        const node = startNode(4 /* NodeTypes.Named */, offset, loc);
         node.key = key;
         tokenizer.nextToken(); // skip brach right
         endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
@@ -1023,7 +1026,7 @@ function createParser(options = {}) {
     function parseLiteral(tokenizer, value) {
         const context = tokenizer.context();
         const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
-        const node = startNode(9 /* Literal */, offset, loc);
+        const node = startNode(9 /* NodeTypes.Literal */, offset, loc);
         node.value = value.replace(KNOWN_ESCAPES, fromEscapeSequence);
         tokenizer.nextToken(); // skip brach right
         endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
@@ -1033,8 +1036,8 @@ function createParser(options = {}) {
         const token = tokenizer.nextToken();
         const context = tokenizer.context();
         const { lastOffset: offset, lastStartLoc: loc } = context; // get linked dot loc
-        const node = startNode(8 /* LinkedModifier */, offset, loc);
-        if (token.type !== 12 /* LinkedModifier */) {
+        const node = startNode(8 /* NodeTypes.LinkedModifier */, offset, loc);
+        if (token.type !== 12 /* TokenTypes.LinkedModifier */) {
             // empty modifier
             emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_MODIFIER, context.lastStartLoc, 0);
             node.value = '';
@@ -1056,49 +1059,49 @@ function createParser(options = {}) {
     }
     function parseLinkedKey(tokenizer, value) {
         const context = tokenizer.context();
-        const node = startNode(7 /* LinkedKey */, context.offset, context.startLoc);
+        const node = startNode(7 /* NodeTypes.LinkedKey */, context.offset, context.startLoc);
         node.value = value;
         endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
         return node;
     }
     function parseLinked(tokenizer) {
         const context = tokenizer.context();
-        const linkedNode = startNode(6 /* Linked */, context.offset, context.startLoc);
+        const linkedNode = startNode(6 /* NodeTypes.Linked */, context.offset, context.startLoc);
         let token = tokenizer.nextToken();
-        if (token.type === 9 /* LinkedDot */) {
+        if (token.type === 9 /* TokenTypes.LinkedDot */) {
             const parsed = parseLinkedModifier(tokenizer);
             linkedNode.modifier = parsed.node;
             token = parsed.nextConsumeToken || tokenizer.nextToken();
         }
         // asset check token
-        if (token.type !== 10 /* LinkedDelimiter */) {
+        if (token.type !== 10 /* TokenTypes.LinkedDelimiter */) {
             emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
         }
         token = tokenizer.nextToken();
         // skip brace left
-        if (token.type === 2 /* BraceLeft */) {
+        if (token.type === 2 /* TokenTypes.BraceLeft */) {
             token = tokenizer.nextToken();
         }
         switch (token.type) {
-            case 11 /* LinkedKey */:
+            case 11 /* 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 /* Named */:
+            case 5 /* 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 /* List */:
+            case 6 /* 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 /* Literal */:
+            case 7 /* TokenTypes.Literal */:
                 if (token.value == null) {
                     emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
                 }
@@ -1108,7 +1111,7 @@ function createParser(options = {}) {
                 // empty key
                 emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_KEY, context.lastStartLoc, 0);
                 const nextContext = tokenizer.context();
-                const emptyLinkedKeyNode = startNode(7 /* LinkedKey */, nextContext.offset, nextContext.startLoc);
+                const emptyLinkedKeyNode = startNode(7 /* NodeTypes.LinkedKey */, nextContext.offset, nextContext.startLoc);
                 emptyLinkedKeyNode.value = '';
                 endNode(emptyLinkedKeyNode, nextContext.offset, nextContext.startLoc);
                 linkedNode.key = emptyLinkedKeyNode;
@@ -1125,56 +1128,56 @@ function createParser(options = {}) {
     }
     function parseMessage(tokenizer) {
         const context = tokenizer.context();
-        const startOffset = context.currentType === 1 /* Pipe */
+        const startOffset = context.currentType === 1 /* TokenTypes.Pipe */
             ? tokenizer.currentOffset()
             : context.offset;
-        const startLoc = context.currentType === 1 /* Pipe */
+        const startLoc = context.currentType === 1 /* TokenTypes.Pipe */
             ? context.endLoc
             : context.startLoc;
-        const node = startNode(2 /* Message */, startOffset, startLoc);
+        const node = startNode(2 /* NodeTypes.Message */, startOffset, startLoc);
         node.items = [];
         let nextToken = null;
         do {
             const token = nextToken || tokenizer.nextToken();
             nextToken = null;
             switch (token.type) {
-                case 0 /* Text */:
+                case 0 /* TokenTypes.Text */:
                     if (token.value == null) {
                         emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
                     }
                     node.items.push(parseText(tokenizer, token.value || ''));
                     break;
-                case 6 /* List */:
+                case 6 /* 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 5 /* Named */:
+                case 5 /* TokenTypes.Named */:
                     if (token.value == null) {
                         emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
                     }
                     node.items.push(parseNamed(tokenizer, token.value || ''));
                     break;
-                case 7 /* Literal */:
+                case 7 /* 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 /* LinkedAlias */:
+                case 8 /* TokenTypes.LinkedAlias */:
                     const parsed = parseLinked(tokenizer);
                     node.items.push(parsed.node);
                     nextToken = parsed.nextConsumeToken || null;
                     break;
             }
-        } while (context.currentType !== 14 /* EOF */ &&
-            context.currentType !== 1 /* Pipe */);
+        } while (context.currentType !== 14 /* TokenTypes.EOF */ &&
+            context.currentType !== 1 /* TokenTypes.Pipe */);
         // adjust message node loc
-        const endOffset = context.currentType === 1 /* Pipe */
+        const endOffset = context.currentType === 1 /* TokenTypes.Pipe */
             ? context.lastOffset
             : tokenizer.currentOffset();
-        const endLoc = context.currentType === 1 /* Pipe */
+        const endLoc = context.currentType === 1 /* TokenTypes.Pipe */
             ? context.lastEndLoc
             : tokenizer.currentPosition();
         endNode(node, endOffset, endLoc);
@@ -1183,7 +1186,7 @@ function createParser(options = {}) {
     function parsePlural(tokenizer, offset, loc, msgNode) {
         const context = tokenizer.context();
         let hasEmptyMessage = msgNode.items.length === 0;
-        const node = startNode(1 /* Plural */, offset, loc);
+        const node = startNode(1 /* NodeTypes.Plural */, offset, loc);
         node.cases = [];
         node.cases.push(msgNode);
         do {
@@ -1192,7 +1195,7 @@ function createParser(options = {}) {
                 hasEmptyMessage = msg.items.length === 0;
             }
             node.cases.push(msg);
-        } while (context.currentType !== 14 /* EOF */);
+        } while (context.currentType !== 14 /* TokenTypes.EOF */);
         if (hasEmptyMessage) {
             emitError(tokenizer, CompileErrorCodes.MUST_HAVE_MESSAGES_IN_PLURAL, loc, 0);
         }
@@ -1203,7 +1206,7 @@ function createParser(options = {}) {
         const context = tokenizer.context();
         const { offset, startLoc } = context;
         const msgNode = parseMessage(tokenizer);
-        if (context.currentType === 14 /* EOF */) {
+        if (context.currentType === 14 /* TokenTypes.EOF */) {
             return msgNode;
         }
         else {
@@ -1213,13 +1216,13 @@ function createParser(options = {}) {
     function parse(source) {
         const tokenizer = createTokenizer(source, assign({}, options));
         const context = tokenizer.context();
-        const node = startNode(0 /* Resource */, context.offset, context.startLoc);
+        const node = startNode(0 /* NodeTypes.Resource */, context.offset, context.startLoc);
         if (location && node.loc) {
             node.loc.source = source;
         }
         node.body = parseResource(tokenizer);
         // assert whether achieved to EOF
-        if (context.currentType !== 14 /* EOF */) {
+        if (context.currentType !== 14 /* TokenTypes.EOF */) {
             emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, source[context.offset] || '');
         }
         endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
@@ -1228,7 +1231,7 @@ function createParser(options = {}) {
     return { parse };
 }
 function getTokenCaption(token) {
-    if (token.type === 14 /* EOF */) {
+    if (token.type === 14 /* TokenTypes.EOF */) {
         return 'EOF';
     }
     const name = (token.value || '').replace(/\r?\n/gu, '\\n');
@@ -1256,26 +1259,26 @@ function traverseNodes(nodes, transformer) {
 function traverseNode(node, transformer) {
     // TODO: if we need pre-hook of transform, should be implemented to here
     switch (node.type) {
-        case 1 /* Plural */:
+        case 1 /* NodeTypes.Plural */:
             traverseNodes(node.cases, transformer);
-            transformer.helper("plural" /* PLURAL */);
+            transformer.helper("plural" /* HelperNameMap.PLURAL */);
             break;
-        case 2 /* Message */:
+        case 2 /* NodeTypes.Message */:
             traverseNodes(node.items, transformer);
             break;
-        case 6 /* Linked */:
+        case 6 /* NodeTypes.Linked */:
             const linked = node;
             traverseNode(linked.key, transformer);
-            transformer.helper("linked" /* LINKED */);
-            transformer.helper("type" /* TYPE */);
+            transformer.helper("linked" /* HelperNameMap.LINKED */);
+            transformer.helper("type" /* HelperNameMap.TYPE */);
             break;
-        case 5 /* List */:
-            transformer.helper("interpolate" /* INTERPOLATE */);
-            transformer.helper("list" /* LIST */);
+        case 5 /* NodeTypes.List */:
+            transformer.helper("interpolate" /* HelperNameMap.INTERPOLATE */);
+            transformer.helper("list" /* HelperNameMap.LIST */);
             break;
-        case 4 /* Named */:
-            transformer.helper("interpolate" /* INTERPOLATE */);
-            transformer.helper("named" /* NAMED */);
+        case 4 /* NodeTypes.Named */:
+            transformer.helper("interpolate" /* HelperNameMap.INTERPOLATE */);
+            transformer.helper("named" /* HelperNameMap.NAMED */);
             break;
     }
     // TODO: if we need post-hook of transform, should be implemented to here
@@ -1284,7 +1287,7 @@ function traverseNode(node, transformer) {
 function transform(ast, options = {} // eslint-disable-line
 ) {
     const transformer = createTransformer(ast);
-    transformer.helper("normalize" /* NORMALIZE */);
+    transformer.helper("normalize" /* HelperNameMap.NORMALIZE */);
     // traverse
     ast.body && traverseNode(ast.body, transformer);
     // set meta information
@@ -1339,7 +1342,7 @@ function createCodeGenerator(ast, options) {
 }
 function generateLinkedNode(generator, node) {
     const { helper } = generator;
-    generator.push(`${helper("linked" /* LINKED */)}(`);
+    generator.push(`${helper("linked" /* HelperNameMap.LINKED */)}(`);
     generateNode(generator, node.key);
     if (node.modifier) {
         generator.push(`, `);
@@ -1353,7 +1356,7 @@ function generateLinkedNode(generator, node) {
 }
 function generateMessageNode(generator, node) {
     const { helper, needIndent } = generator;
-    generator.push(`${helper("normalize" /* NORMALIZE */)}([`);
+    generator.push(`${helper("normalize" /* HelperNameMap.NORMALIZE */)}([`);
     generator.indent(needIndent());
     const length = node.items.length;
     for (let i = 0; i < length; i++) {
@@ -1369,7 +1372,7 @@ function generateMessageNode(generator, node) {
 function generatePluralNode(generator, node) {
     const { helper, needIndent } = generator;
     if (node.cases.length > 1) {
-        generator.push(`${helper("plural" /* PLURAL */)}([`);
+        generator.push(`${helper("plural" /* HelperNameMap.PLURAL */)}([`);
         generator.indent(needIndent());
         const length = node.cases.length;
         for (let i = 0; i < length; i++) {
@@ -1394,34 +1397,34 @@ function generateResource(generator, node) {
 function generateNode(generator, node) {
     const { helper } = generator;
     switch (node.type) {
-        case 0 /* Resource */:
+        case 0 /* NodeTypes.Resource */:
             generateResource(generator, node);
             break;
-        case 1 /* Plural */:
+        case 1 /* NodeTypes.Plural */:
             generatePluralNode(generator, node);
             break;
-        case 2 /* Message */:
+        case 2 /* NodeTypes.Message */:
             generateMessageNode(generator, node);
             break;
-        case 6 /* Linked */:
+        case 6 /* NodeTypes.Linked */:
             generateLinkedNode(generator, node);
             break;
-        case 8 /* LinkedModifier */:
+        case 8 /* NodeTypes.LinkedModifier */:
             generator.push(JSON.stringify(node.value), node);
             break;
-        case 7 /* LinkedKey */:
+        case 7 /* NodeTypes.LinkedKey */:
             generator.push(JSON.stringify(node.value), node);
             break;
-        case 5 /* List */:
-            generator.push(`${helper("interpolate" /* INTERPOLATE */)}(${helper("list" /* LIST */)}(${node.index}))`, node);
+        case 5 /* NodeTypes.List */:
+            generator.push(`${helper("interpolate" /* HelperNameMap.INTERPOLATE */)}(${helper("list" /* HelperNameMap.LIST */)}(${node.index}))`, node);
             break;
-        case 4 /* Named */:
-            generator.push(`${helper("interpolate" /* INTERPOLATE */)}(${helper("named" /* NAMED */)}(${JSON.stringify(node.key)}))`, node);
+        case 4 /* NodeTypes.Named */:
+            generator.push(`${helper("interpolate" /* HelperNameMap.INTERPOLATE */)}(${helper("named" /* HelperNameMap.NAMED */)}(${JSON.stringify(node.key)}))`, node);
             break;
-        case 9 /* Literal */:
+        case 9 /* NodeTypes.Literal */:
             generator.push(JSON.stringify(node.value), node);
             break;
-        case 3 /* Text */:
+        case 3 /* NodeTypes.Text */:
             generator.push(JSON.stringify(node.value), node);
             break;
         default:
@@ -1483,51 +1486,51 @@ function baseCompile(source, options = {}) {
 }
 
 const pathStateMachine =  [];
-pathStateMachine[0 /* BEFORE_PATH */] = {
-    ["w" /* WORKSPACE */]: [0 /* BEFORE_PATH */],
-    ["i" /* IDENT */]: [3 /* IN_IDENT */, 0 /* APPEND */],
-    ["[" /* LEFT_BRACKET */]: [4 /* IN_SUB_PATH */],
-    ["o" /* END_OF_FAIL */]: [7 /* AFTER_PATH */]
+pathStateMachine[0 /* States.BEFORE_PATH */] = {
+    ["w" /* PathCharTypes.WORKSPACE */]: [0 /* States.BEFORE_PATH */],
+    ["i" /* PathCharTypes.IDENT */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
+    ["[" /* PathCharTypes.LEFT_BRACKET */]: [4 /* States.IN_SUB_PATH */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: [7 /* States.AFTER_PATH */]
 };
-pathStateMachine[1 /* IN_PATH */] = {
-    ["w" /* WORKSPACE */]: [1 /* IN_PATH */],
-    ["." /* DOT */]: [2 /* BEFORE_IDENT */],
-    ["[" /* LEFT_BRACKET */]: [4 /* IN_SUB_PATH */],
-    ["o" /* END_OF_FAIL */]: [7 /* AFTER_PATH */]
+pathStateMachine[1 /* States.IN_PATH */] = {
+    ["w" /* PathCharTypes.WORKSPACE */]: [1 /* States.IN_PATH */],
+    ["." /* PathCharTypes.DOT */]: [2 /* States.BEFORE_IDENT */],
+    ["[" /* PathCharTypes.LEFT_BRACKET */]: [4 /* States.IN_SUB_PATH */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: [7 /* States.AFTER_PATH */]
 };
-pathStateMachine[2 /* BEFORE_IDENT */] = {
-    ["w" /* WORKSPACE */]: [2 /* BEFORE_IDENT */],
-    ["i" /* IDENT */]: [3 /* IN_IDENT */, 0 /* APPEND */],
-    ["0" /* ZERO */]: [3 /* IN_IDENT */, 0 /* APPEND */]
+pathStateMachine[2 /* States.BEFORE_IDENT */] = {
+    ["w" /* PathCharTypes.WORKSPACE */]: [2 /* States.BEFORE_IDENT */],
+    ["i" /* PathCharTypes.IDENT */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
+    ["0" /* PathCharTypes.ZERO */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */]
 };
-pathStateMachine[3 /* IN_IDENT */] = {
-    ["i" /* IDENT */]: [3 /* IN_IDENT */, 0 /* APPEND */],
-    ["0" /* ZERO */]: [3 /* IN_IDENT */, 0 /* APPEND */],
-    ["w" /* WORKSPACE */]: [1 /* IN_PATH */, 1 /* PUSH */],
-    ["." /* DOT */]: [2 /* BEFORE_IDENT */, 1 /* PUSH */],
-    ["[" /* LEFT_BRACKET */]: [4 /* IN_SUB_PATH */, 1 /* PUSH */],
-    ["o" /* END_OF_FAIL */]: [7 /* AFTER_PATH */, 1 /* PUSH */]
+pathStateMachine[3 /* States.IN_IDENT */] = {
+    ["i" /* PathCharTypes.IDENT */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
+    ["0" /* PathCharTypes.ZERO */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
+    ["w" /* PathCharTypes.WORKSPACE */]: [1 /* States.IN_PATH */, 1 /* Actions.PUSH */],
+    ["." /* PathCharTypes.DOT */]: [2 /* States.BEFORE_IDENT */, 1 /* Actions.PUSH */],
+    ["[" /* PathCharTypes.LEFT_BRACKET */]: [4 /* States.IN_SUB_PATH */, 1 /* Actions.PUSH */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: [7 /* States.AFTER_PATH */, 1 /* Actions.PUSH */]
 };
-pathStateMachine[4 /* IN_SUB_PATH */] = {
-    ["'" /* SINGLE_QUOTE */]: [5 /* IN_SINGLE_QUOTE */, 0 /* APPEND */],
-    ["\"" /* DOUBLE_QUOTE */]: [6 /* IN_DOUBLE_QUOTE */, 0 /* APPEND */],
-    ["[" /* LEFT_BRACKET */]: [
-        4 /* IN_SUB_PATH */,
-        2 /* INC_SUB_PATH_DEPTH */
+pathStateMachine[4 /* States.IN_SUB_PATH */] = {
+    ["'" /* PathCharTypes.SINGLE_QUOTE */]: [5 /* States.IN_SINGLE_QUOTE */, 0 /* Actions.APPEND */],
+    ["\"" /* PathCharTypes.DOUBLE_QUOTE */]: [6 /* States.IN_DOUBLE_QUOTE */, 0 /* Actions.APPEND */],
+    ["[" /* PathCharTypes.LEFT_BRACKET */]: [
+        4 /* States.IN_SUB_PATH */,
+        2 /* Actions.INC_SUB_PATH_DEPTH */
     ],
-    ["]" /* RIGHT_BRACKET */]: [1 /* IN_PATH */, 3 /* PUSH_SUB_PATH */],
-    ["o" /* END_OF_FAIL */]: 8 /* ERROR */,
-    ["l" /* ELSE */]: [4 /* IN_SUB_PATH */, 0 /* APPEND */]
+    ["]" /* PathCharTypes.RIGHT_BRACKET */]: [1 /* States.IN_PATH */, 3 /* Actions.PUSH_SUB_PATH */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: 8 /* States.ERROR */,
+    ["l" /* PathCharTypes.ELSE */]: [4 /* States.IN_SUB_PATH */, 0 /* Actions.APPEND */]
 };
-pathStateMachine[5 /* IN_SINGLE_QUOTE */] = {
-    ["'" /* SINGLE_QUOTE */]: [4 /* IN_SUB_PATH */, 0 /* APPEND */],
-    ["o" /* END_OF_FAIL */]: 8 /* ERROR */,
-    ["l" /* ELSE */]: [5 /* IN_SINGLE_QUOTE */, 0 /* APPEND */]
+pathStateMachine[5 /* States.IN_SINGLE_QUOTE */] = {
+    ["'" /* PathCharTypes.SINGLE_QUOTE */]: [4 /* States.IN_SUB_PATH */, 0 /* Actions.APPEND */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: 8 /* States.ERROR */,
+    ["l" /* PathCharTypes.ELSE */]: [5 /* States.IN_SINGLE_QUOTE */, 0 /* Actions.APPEND */]
 };
-pathStateMachine[6 /* IN_DOUBLE_QUOTE */] = {
-    ["\"" /* DOUBLE_QUOTE */]: [4 /* IN_SUB_PATH */, 0 /* APPEND */],
-    ["o" /* END_OF_FAIL */]: 8 /* ERROR */,
-    ["l" /* ELSE */]: [6 /* IN_DOUBLE_QUOTE */, 0 /* APPEND */]
+pathStateMachine[6 /* States.IN_DOUBLE_QUOTE */] = {
+    ["\"" /* PathCharTypes.DOUBLE_QUOTE */]: [4 /* States.IN_SUB_PATH */, 0 /* Actions.APPEND */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: 8 /* States.ERROR */,
+    ["l" /* PathCharTypes.ELSE */]: [6 /* States.IN_DOUBLE_QUOTE */, 0 /* Actions.APPEND */]
 };
 /**
  * Check if an expression is a literal value.
@@ -1549,7 +1552,7 @@ function stripQuotes(str) {
  */
 function getPathCharType(ch) {
     if (ch === undefined || ch === null) {
-        return "o" /* END_OF_FAIL */;
+        return "o" /* PathCharTypes.END_OF_FAIL */;
     }
     const code = ch.charCodeAt(0);
     switch (code) {
@@ -1562,7 +1565,7 @@ function getPathCharType(ch) {
         case 0x5f: // _
         case 0x24: // $
         case 0x2d: // -
-            return "i" /* IDENT */;
+            return "i" /* PathCharTypes.IDENT */;
         case 0x09: // Tab (HT)
         case 0x0a: // Newline (LF)
         case 0x0d: // Return (CR)
@@ -1570,9 +1573,9 @@ function getPathCharType(ch) {
         case 0xfeff: // Byte Order Mark (BOM)
         case 0x2028: // Line Separator (LS)
         case 0x2029: // Paragraph Separator (PS)
-            return "w" /* WORKSPACE */;
+            return "w" /* PathCharTypes.WORKSPACE */;
     }
-    return "i" /* IDENT */;
+    return "i" /* PathCharTypes.IDENT */;
 }
 /**
  * Format a subPath, return its plain form if it is
@@ -1587,7 +1590,7 @@ function formatSubPath(path) {
     }
     return isLiteral(trimmed)
         ? stripQuotes(trimmed)
-        : "*" /* ASTARISK */ + trimmed;
+        : "*" /* PathCharTypes.ASTARISK */ + trimmed;
 }
 /**
  * Parse a string path into an array of segments
@@ -1595,7 +1598,7 @@ function formatSubPath(path) {
 function parse(path) {
     const keys = [];
     let index = -1;
-    let mode = 0 /* BEFORE_PATH */;
+    let mode = 0 /* States.BEFORE_PATH */;
     let subPathDepth = 0;
     let c;
     let key; // eslint-disable-line
@@ -1605,7 +1608,7 @@ function parse(path) {
     let action;
     let typeMap;
     const actions = [];
-    actions[0 /* APPEND */] = () => {
+    actions[0 /* Actions.APPEND */] = () => {
         if (key === undefined) {
             key = newChar;
         }
@@ -1613,21 +1616,21 @@ function parse(path) {
             key += newChar;
         }
     };
-    actions[1 /* PUSH */] = () => {
+    actions[1 /* Actions.PUSH */] = () => {
         if (key !== undefined) {
             keys.push(key);
             key = undefined;
         }
     };
-    actions[2 /* INC_SUB_PATH_DEPTH */] = () => {
-        actions[0 /* APPEND */]();
+    actions[2 /* Actions.INC_SUB_PATH_DEPTH */] = () => {
+        actions[0 /* Actions.APPEND */]();
         subPathDepth++;
     };
-    actions[3 /* PUSH_SUB_PATH */] = () => {
+    actions[3 /* Actions.PUSH_SUB_PATH */] = () => {
         if (subPathDepth > 0) {
             subPathDepth--;
-            mode = 4 /* IN_SUB_PATH */;
-            actions[0 /* APPEND */]();
+            mode = 4 /* States.IN_SUB_PATH */;
+            actions[0 /* Actions.APPEND */]();
         }
         else {
             subPathDepth = 0;
@@ -1639,19 +1642,19 @@ function parse(path) {
                 return false;
             }
             else {
-                actions[1 /* PUSH */]();
+                actions[1 /* Actions.PUSH */]();
             }
         }
     };
     function maybeUnescapeQuote() {
         const nextChar = path[index + 1];
-        if ((mode === 5 /* IN_SINGLE_QUOTE */ &&
-            nextChar === "'" /* SINGLE_QUOTE */) ||
-            (mode === 6 /* IN_DOUBLE_QUOTE */ &&
-                nextChar === "\"" /* DOUBLE_QUOTE */)) {
+        if ((mode === 5 /* States.IN_SINGLE_QUOTE */ &&
+            nextChar === "'" /* PathCharTypes.SINGLE_QUOTE */) ||
+            (mode === 6 /* States.IN_DOUBLE_QUOTE */ &&
+                nextChar === "\"" /* PathCharTypes.DOUBLE_QUOTE */)) {
             index++;
             newChar = '\\' + nextChar;
-            actions[0 /* APPEND */]();
+            actions[0 /* Actions.APPEND */]();
             return true;
         }
     }
@@ -1663,9 +1666,9 @@ function parse(path) {
         }
         type = getPathCharType(c);
         typeMap = pathStateMachine[mode];
-        transition = typeMap[type] || typeMap["l" /* ELSE */] || 8 /* ERROR */;
+        transition = typeMap[type] || typeMap["l" /* PathCharTypes.ELSE */] || 8 /* States.ERROR */;
         // check parse error
-        if (transition === 8 /* ERROR */) {
+        if (transition === 8 /* States.ERROR */) {
             return;
         }
         mode = transition[0];
@@ -1679,7 +1682,7 @@ function parse(path) {
             }
         }
         // check parse finish
-        if (mode === 7 /* AFTER_PATH */) {
+        if (mode === 7 /* States.AFTER_PATH */) {
             return keys;
         }
     }
@@ -1863,14 +1866,14 @@ function createMessageContext(options = {}) {
         return modifier ? _modifier(modifier)(msg, type) : msg;
     };
     const ctx = {
-        ["list" /* LIST */]: list,
-        ["named" /* NAMED */]: named,
-        ["plural" /* PLURAL */]: plural,
-        ["linked" /* LINKED */]: linked,
-        ["message" /* MESSAGE */]: message,
-        ["type" /* TYPE */]: type,
-        ["interpolate" /* INTERPOLATE */]: interpolate,
-        ["normalize" /* NORMALIZE */]: normalize
+        ["list" /* HelperNameMap.LIST */]: list,
+        ["named" /* HelperNameMap.NAMED */]: named,
+        ["plural" /* HelperNameMap.PLURAL */]: plural,
+        ["linked" /* HelperNameMap.LINKED */]: linked,
+        ["message" /* HelperNameMap.MESSAGE */]: message,
+        ["type" /* HelperNameMap.TYPE */]: type,
+        ["interpolate" /* HelperNameMap.INTERPOLATE */]: interpolate,
+        ["normalize" /* HelperNameMap.NORMALIZE */]: normalize
     };
     return ctx;
 }
@@ -2045,7 +2048,7 @@ function appendItemToChain(chain, target, blocks) {
  * Intlify core-base version
  * @internal
  */
-const VERSION = '9.3.0-beta.10';
+const VERSION = '9.3.0-beta.11';
 const NOT_REOSLVED = -1;
 const DEFAULT_LOCALE = 'en-US';
 const MISSING_RESOLVE_VALUE = '';
@@ -2105,7 +2108,7 @@ function registerLocaleFallbacker(fallbacker) {
     _fallbacker = fallbacker;
 }
 // Additional Meta for Intlify DevTools
-let _additionalMeta = null;
+let _additionalMeta =  null;
 const setAdditionalMeta =  (meta) => {
     _additionalMeta = meta;
 };
@@ -2240,7 +2243,7 @@ function handleMissing(context, key, locale, missingWarn, type) {
     {
         const emitter = context.__v_emitter;
         if (emitter) {
-            emitter.emit("missing" /* MISSING */, {
+            emitter.emit("missing" /* VueDevToolsTimelineEvents.MISSING */, {
                 locale,
                 key,
                 type,
@@ -2473,7 +2476,7 @@ function resolveMessageFormat(context, key, locale, fallbackLocale, fallbackWarn
         if (locale !== targetLocale) {
             const emitter = context.__v_emitter;
             if (emitter) {
-                emitter.emit("fallback" /* FALBACK */, {
+                emitter.emit("fallback" /* VueDevToolsTimelineEvents.FALBACK */, {
                     type,
                     key,
                     from,
@@ -2503,8 +2506,8 @@ function resolveMessageFormat(context, key, locale, fallbackLocale, fallbackWarn
             const end = window.performance.now();
             const emitter = context.__v_emitter;
             if (emitter && start && format) {
-                emitter.emit("message-resolve" /* MESSAGE_RESOLVE */, {
-                    type: "message-resolve" /* MESSAGE_RESOLVE */,
+                emitter.emit("message-resolve" /* VueDevToolsTimelineEvents.MESSAGE_RESOLVE */, {
+                    type: "message-resolve" /* VueDevToolsTimelineEvents.MESSAGE_RESOLVE */,
                     key,
                     message: format,
                     time: end - start,
@@ -2557,8 +2560,8 @@ function compileMessageFormat(context, key, targetLocale, format, cacheBaseKey,
         const end = window.performance.now();
         const emitter = context.__v_emitter;
         if (emitter && start) {
-            emitter.emit("message-compilation" /* MESSAGE_COMPILATION */, {
-                type: "message-compilation" /* MESSAGE_COMPILATION */,
+            emitter.emit("message-compilation" /* VueDevToolsTimelineEvents.MESSAGE_COMPILATION */, {
+                type: "message-compilation" /* VueDevToolsTimelineEvents.MESSAGE_COMPILATION */,
                 message: format,
                 time: end - start,
                 groupId: `${'translate'}:${key}`
@@ -2591,8 +2594,8 @@ function evaluateMessage(context, msg, msgCtx) {
         const end = window.performance.now();
         const emitter = context.__v_emitter;
         if (emitter && start) {
-            emitter.emit("message-evaluation" /* MESSAGE_EVALUATION */, {
-                type: "message-evaluation" /* MESSAGE_EVALUATION */,
+            emitter.emit("message-evaluation" /* VueDevToolsTimelineEvents.MESSAGE_EVALUATION */, {
+                type: "message-evaluation" /* VueDevToolsTimelineEvents.MESSAGE_EVALUATION */,
                 value: messaged,
                 time: end - start,
                 groupId: `${'translate'}:${msg.key}`
@@ -2652,7 +2655,7 @@ function getCompileOptions(context, locale, key, source, warnHtmlMessage, errorD
                     generateCodeFrame(source, err.location.start.offset, err.location.end.offset);
                 const emitter = context.__v_emitter;
                 if (emitter) {
-                    emitter.emit("compile-error" /* COMPILE_ERROR */, {
+                    emitter.emit("compile-error" /* VueDevToolsTimelineEvents.COMPILE_ERROR */, {
                         message: source,
                         error: err.message,
                         start: err.location && err.location.start.offset,
@@ -2762,7 +2765,7 @@ function datetime(context, ...args) {
         if (locale !== targetLocale) {
             const emitter = context.__v_emitter;
             if (emitter) {
-                emitter.emit("fallback" /* FALBACK */, {
+                emitter.emit("fallback" /* VueDevToolsTimelineEvents.FALBACK */, {
                     type,
                     key,
                     from,
@@ -2936,7 +2939,7 @@ function number(context, ...args) {
         if (locale !== targetLocale) {
             const emitter = context.__v_emitter;
             if (emitter) {
-                emitter.emit("fallback" /* FALBACK */, {
+                emitter.emit("fallback" /* VueDevToolsTimelineEvents.FALBACK */, {
                     type,
                     key,
                     from,