@intlify/message-compiler 9.3.0-beta.1 → 9.3.0-beta.11

package/dist/message-compiler.global.js

@@ -1,5 +1,5 @@
 /*!
-  * message-compiler v9.3.0-beta.1
+  * message-compiler v9.3.0-beta.11
   * (c) 2022 kazuya kawaguchi
   * Released under the MIT License.
   */
@@ -25,8 +25,8 @@ var IntlifyMessageCompiler = (function (exports) {
   }
   const assign = Object.assign;
   const isString = (val) => typeof val === 'string';
-  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 CompileErrorCodes = {
       // tokenizer error codes
@@ -188,11 +188,11 @@ var IntlifyMessageCompiler = (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,
@@ -227,7 +227,7 @@ var IntlifyMessageCompiler = (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();
@@ -270,7 +270,7 @@ var IntlifyMessageCompiler = (function (exports) {
       }
       function isNamedIdentifierStart(scnr, context) {
           const { currentType } = context;
-          if (currentType !== 2 /* BraceLeft */) {
+          if (currentType !== 2 /* TokenTypes.BraceLeft */) {
               return false;
           }
           peekSpaces(scnr);
@@ -280,7 +280,7 @@ var IntlifyMessageCompiler = (function (exports) {
       }
       function isListIdentifierStart(scnr, context) {
           const { currentType } = context;
-          if (currentType !== 2 /* BraceLeft */) {
+          if (currentType !== 2 /* TokenTypes.BraceLeft */) {
               return false;
           }
           peekSpaces(scnr);
@@ -291,7 +291,7 @@ var IntlifyMessageCompiler = (function (exports) {
       }
       function isLiteralStart(scnr, context) {
           const { currentType } = context;
-          if (currentType !== 2 /* BraceLeft */) {
+          if (currentType !== 2 /* TokenTypes.BraceLeft */) {
               return false;
           }
           peekSpaces(scnr);
@@ -301,17 +301,17 @@ var IntlifyMessageCompiler = (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);
@@ -321,30 +321,30 @@ var IntlifyMessageCompiler = (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;
@@ -364,14 +364,14 @@ var IntlifyMessageCompiler = (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,
@@ -381,18 +381,18 @@ var IntlifyMessageCompiler = (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);
               }
@@ -462,24 +462,24 @@ var IntlifyMessageCompiler = (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();
@@ -595,8 +595,8 @@ var IntlifyMessageCompiler = (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))) {
@@ -615,10 +615,10 @@ var IntlifyMessageCompiler = (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;
               }
@@ -640,7 +640,7 @@ var IntlifyMessageCompiler = (function (exports) {
       }
       function readPlural(scnr) {
           skipSpaces(scnr);
-          const plural = eat(scnr, "|" /* Pipe */);
+          const plural = eat(scnr, "|" /* TokenChars.Pipe */);
           skipSpaces(scnr);
           return plural;
       }
@@ -649,29 +649,29 @@ var IntlifyMessageCompiler = (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);
                   }
@@ -686,38 +686,38 @@ var IntlifyMessageCompiler = (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;
@@ -731,30 +731,30 @@ var IntlifyMessageCompiler = (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;
@@ -767,19 +767,19 @@ var IntlifyMessageCompiler = (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;
@@ -789,7 +789,7 @@ var IntlifyMessageCompiler = (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);
           }
@@ -798,17 +798,17 @@ var IntlifyMessageCompiler = (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;
@@ -817,11 +817,11 @@ var IntlifyMessageCompiler = (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;
           }
@@ -836,7 +836,7 @@ var IntlifyMessageCompiler = (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);
       }
@@ -906,7 +906,7 @@ var IntlifyMessageCompiler = (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;
@@ -914,7 +914,7 @@ var IntlifyMessageCompiler = (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());
@@ -923,7 +923,7 @@ var IntlifyMessageCompiler = (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());
@@ -932,7 +932,7 @@ var IntlifyMessageCompiler = (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());
@@ -942,8 +942,8 @@ var IntlifyMessageCompiler = (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 = '';
@@ -965,49 +965,49 @@ var IntlifyMessageCompiler = (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));
                   }
@@ -1017,7 +1017,7 @@ var IntlifyMessageCompiler = (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;
@@ -1034,56 +1034,56 @@ var IntlifyMessageCompiler = (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);
@@ -1092,7 +1092,7 @@ var IntlifyMessageCompiler = (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 {
@@ -1101,7 +1101,7 @@ var IntlifyMessageCompiler = (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);
           }
@@ -1112,7 +1112,7 @@ var IntlifyMessageCompiler = (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 {
@@ -1122,13 +1122,13 @@ var IntlifyMessageCompiler = (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());
@@ -1137,7 +1137,7 @@ var IntlifyMessageCompiler = (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');
@@ -1165,26 +1165,26 @@ var IntlifyMessageCompiler = (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
@@ -1193,7 +1193,7 @@ var IntlifyMessageCompiler = (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
@@ -1248,7 +1248,7 @@ var IntlifyMessageCompiler = (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(`, `);
@@ -1262,7 +1262,7 @@ var IntlifyMessageCompiler = (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++) {
@@ -1278,7 +1278,7 @@ var IntlifyMessageCompiler = (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++) {
@@ -1303,34 +1303,34 @@ var IntlifyMessageCompiler = (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: