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

package/dist/core-base.global.js

@@ -1,5 +1,5 @@
 /*!
-  * core-base v9.3.0-beta.1
+  * core-base v9.3.0-beta.11
   * (c) 2022 kazuya kawaguchi
   * Released under the MIT License.
   */
@@ -19,8 +19,11 @@ var IntlifyCoreBase = (function (exports) {
           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);
@@ -79,8 +82,8 @@ var IntlifyCoreBase = (function (exports) {
   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]';
@@ -282,11 +285,11 @@ var IntlifyCoreBase = (function (exports) {
       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,
@@ -321,7 +324,7 @@ var IntlifyCoreBase = (function (exports) {
           }
           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();
@@ -364,7 +367,7 @@ var IntlifyCoreBase = (function (exports) {
       }
       function isNamedIdentifierStart(scnr, context) {
           const { currentType } = context;
-          if (currentType !== 2 /* BraceLeft */) {
+          if (currentType !== 2 /* TokenTypes.BraceLeft */) {
               return false;
           }
           peekSpaces(scnr);
@@ -374,7 +377,7 @@ var IntlifyCoreBase = (function (exports) {
       }
       function isListIdentifierStart(scnr, context) {
           const { currentType } = context;
-          if (currentType !== 2 /* BraceLeft */) {
+          if (currentType !== 2 /* TokenTypes.BraceLeft */) {
               return false;
           }
           peekSpaces(scnr);
@@ -385,7 +388,7 @@ var IntlifyCoreBase = (function (exports) {
       }
       function isLiteralStart(scnr, context) {
           const { currentType } = context;
-          if (currentType !== 2 /* BraceLeft */) {
+          if (currentType !== 2 /* TokenTypes.BraceLeft */) {
               return false;
           }
           peekSpaces(scnr);
@@ -395,17 +398,17 @@ var IntlifyCoreBase = (function (exports) {
       }
       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);
@@ -415,30 +418,30 @@ var IntlifyCoreBase = (function (exports) {
       }
       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;
@@ -458,14 +461,14 @@ var IntlifyCoreBase = (function (exports) {
       }
       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,
@@ -475,18 +478,18 @@ var IntlifyCoreBase = (function (exports) {
       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);
               }
@@ -556,24 +559,24 @@ var IntlifyCoreBase = (function (exports) {
       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();
@@ -689,8 +692,8 @@ var IntlifyCoreBase = (function (exports) {
           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))) {
@@ -709,10 +712,10 @@ var IntlifyCoreBase = (function (exports) {
       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;
               }
@@ -734,7 +737,7 @@ var IntlifyCoreBase = (function (exports) {
       }
       function readPlural(scnr) {
           skipSpaces(scnr);
-          const plural = eat(scnr, "|" /* Pipe */);
+          const plural = eat(scnr, "|" /* TokenChars.Pipe */);
           skipSpaces(scnr);
           return plural;
       }
@@ -743,29 +746,29 @@ var IntlifyCoreBase = (function (exports) {
           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);
                   }
@@ -780,38 +783,38 @@ var IntlifyCoreBase = (function (exports) {
                       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;
@@ -825,30 +828,30 @@ var IntlifyCoreBase = (function (exports) {
           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;
@@ -861,19 +864,19 @@ var IntlifyCoreBase = (function (exports) {
                   }
                   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;
@@ -883,7 +886,7 @@ var IntlifyCoreBase = (function (exports) {
       }
       // 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);
           }
@@ -892,17 +895,17 @@ var IntlifyCoreBase = (function (exports) {
           }
           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;
@@ -911,11 +914,11 @@ var IntlifyCoreBase = (function (exports) {
                   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;
           }
@@ -930,7 +933,7 @@ var IntlifyCoreBase = (function (exports) {
           _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);
       }
@@ -1000,7 +1003,7 @@ var IntlifyCoreBase = (function (exports) {
       }
       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;
@@ -1008,7 +1011,7 @@ var IntlifyCoreBase = (function (exports) {
       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());
@@ -1017,7 +1020,7 @@ var IntlifyCoreBase = (function (exports) {
       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());
@@ -1026,7 +1029,7 @@ var IntlifyCoreBase = (function (exports) {
       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());
@@ -1036,8 +1039,8 @@ var IntlifyCoreBase = (function (exports) {
           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 = '';
@@ -1059,49 +1062,49 @@ var IntlifyCoreBase = (function (exports) {
       }
       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));
                   }
@@ -1111,7 +1114,7 @@ var IntlifyCoreBase = (function (exports) {
                   // 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;
@@ -1128,56 +1131,56 @@ var IntlifyCoreBase = (function (exports) {
       }
       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);
@@ -1186,7 +1189,7 @@ var IntlifyCoreBase = (function (exports) {
       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 {
@@ -1195,7 +1198,7 @@ var IntlifyCoreBase = (function (exports) {
                   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);
           }
@@ -1206,7 +1209,7 @@ var IntlifyCoreBase = (function (exports) {
           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 {
@@ -1216,13 +1219,13 @@ var IntlifyCoreBase = (function (exports) {
       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());
@@ -1231,7 +1234,7 @@ var IntlifyCoreBase = (function (exports) {
       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');
@@ -1259,26 +1262,26 @@ var IntlifyCoreBase = (function (exports) {
   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
@@ -1287,7 +1290,7 @@ var IntlifyCoreBase = (function (exports) {
   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
@@ -1342,7 +1345,7 @@ var IntlifyCoreBase = (function (exports) {
   }
   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(`, `);
@@ -1356,7 +1359,7 @@ var IntlifyCoreBase = (function (exports) {
   }
   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++) {
@@ -1372,7 +1375,7 @@ var IntlifyCoreBase = (function (exports) {
   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++) {
@@ -1397,34 +1400,34 @@ var IntlifyCoreBase = (function (exports) {
   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:
@@ -1486,51 +1489,51 @@ var IntlifyCoreBase = (function (exports) {
   }
 
   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.
@@ -1552,7 +1555,7 @@ var IntlifyCoreBase = (function (exports) {
    */
   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) {
@@ -1565,7 +1568,7 @@ var IntlifyCoreBase = (function (exports) {
           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)
@@ -1573,9 +1576,9 @@ var IntlifyCoreBase = (function (exports) {
           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
@@ -1590,7 +1593,7 @@ var IntlifyCoreBase = (function (exports) {
       }
       return isLiteral(trimmed)
           ? stripQuotes(trimmed)
-          : "*" /* ASTARISK */ + trimmed;
+          : "*" /* PathCharTypes.ASTARISK */ + trimmed;
   }
   /**
    * Parse a string path into an array of segments
@@ -1598,7 +1601,7 @@ var IntlifyCoreBase = (function (exports) {
   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
@@ -1608,7 +1611,7 @@ var IntlifyCoreBase = (function (exports) {
       let action;
       let typeMap;
       const actions = [];
-      actions[0 /* APPEND */] = () => {
+      actions[0 /* Actions.APPEND */] = () => {
           if (key === undefined) {
               key = newChar;
           }
@@ -1616,21 +1619,21 @@ var IntlifyCoreBase = (function (exports) {
               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;
@@ -1642,19 +1645,19 @@ var IntlifyCoreBase = (function (exports) {
                   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;
           }
       }
@@ -1666,9 +1669,9 @@ var IntlifyCoreBase = (function (exports) {
           }
           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];
@@ -1682,7 +1685,7 @@ var IntlifyCoreBase = (function (exports) {
               }
           }
           // check parse finish
-          if (mode === 7 /* AFTER_PATH */) {
+          if (mode === 7 /* States.AFTER_PATH */) {
               return keys;
           }
       }
@@ -1866,14 +1869,14 @@ var IntlifyCoreBase = (function (exports) {
           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;
   }
@@ -2048,7 +2051,7 @@ var IntlifyCoreBase = (function (exports) {
    * Intlify core-base version
    * @internal
    */
-  const VERSION = '9.3.0-beta.1';
+  const VERSION = '9.3.0-beta.11';
   const NOT_REOSLVED = -1;
   const DEFAULT_LOCALE = 'en-US';
   const MISSING_RESOLVE_VALUE = '';
@@ -2108,7 +2111,7 @@ var IntlifyCoreBase = (function (exports) {
       _fallbacker = fallbacker;
   }
   // Additional Meta for Intlify DevTools
-  let _additionalMeta = null;
+  let _additionalMeta =  null;
   const setAdditionalMeta =  (meta) => {
       _additionalMeta = meta;
   };
@@ -2243,7 +2246,7 @@ var IntlifyCoreBase = (function (exports) {
       {
           const emitter = context.__v_emitter;
           if (emitter) {
-              emitter.emit("missing" /* MISSING */, {
+              emitter.emit("missing" /* VueDevToolsTimelineEvents.MISSING */, {
                   locale,
                   key,
                   type,
@@ -2476,7 +2479,7 @@ var IntlifyCoreBase = (function (exports) {
           if (locale !== targetLocale) {
               const emitter = context.__v_emitter;
               if (emitter) {
-                  emitter.emit("fallback" /* FALBACK */, {
+                  emitter.emit("fallback" /* VueDevToolsTimelineEvents.FALBACK */, {
                       type,
                       key,
                       from,
@@ -2506,8 +2509,8 @@ var IntlifyCoreBase = (function (exports) {
               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,
@@ -2560,8 +2563,8 @@ var IntlifyCoreBase = (function (exports) {
           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}`
@@ -2594,8 +2597,8 @@ var IntlifyCoreBase = (function (exports) {
           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}`
@@ -2655,7 +2658,7 @@ var IntlifyCoreBase = (function (exports) {
                       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,
@@ -2765,7 +2768,7 @@ var IntlifyCoreBase = (function (exports) {
           if (locale !== targetLocale) {
               const emitter = context.__v_emitter;
               if (emitter) {
-                  emitter.emit("fallback" /* FALBACK */, {
+                  emitter.emit("fallback" /* VueDevToolsTimelineEvents.FALBACK */, {
                       type,
                       key,
                       from,
@@ -2939,7 +2942,7 @@ var IntlifyCoreBase = (function (exports) {
           if (locale !== targetLocale) {
               const emitter = context.__v_emitter;
               if (emitter) {
-                  emitter.emit("fallback" /* FALBACK */, {
+                  emitter.emit("fallback" /* VueDevToolsTimelineEvents.FALBACK */, {
                       type,
                       key,
                       from,