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

package/dist/message-compiler.esm-browser.js

@@ -1,5 +1,5 @@
 /*!
-  * message-compiler v9.3.0-beta.10
+  * message-compiler v9.3.0-beta.11
   * (c) 2022 kazuya kawaguchi
   * Released under the MIT License.
   */
@@ -22,8 +22,8 @@ function format(message, ...args) {
 }
 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
@@ -185,11 +185,11 @@ function createTokenizer(source, options = {}) {
     const _initLoc = currentPosition();
     const _initOffset = currentOffset();
     const _context = {
-        currentType: 14 /* EOF */,
+        currentType: 14 /* TokenTypes.EOF */,
         offset: _initOffset,
         startLoc: _initLoc,
         endLoc: _initLoc,
-        lastType: 14 /* EOF */,
+        lastType: 14 /* TokenTypes.EOF */,
         lastOffset: _initOffset,
         lastStartLoc: _initLoc,
         lastEndLoc: _initLoc,
@@ -224,7 +224,7 @@ function createTokenizer(source, options = {}) {
         }
         return token;
     }
-    const getEndToken = (context) => getToken(context, 14 /* EOF */);
+    const getEndToken = (context) => getToken(context, 14 /* TokenTypes.EOF */);
     function eat(scnr, ch) {
         if (scnr.currentChar() === ch) {
             scnr.next();
@@ -267,7 +267,7 @@ function createTokenizer(source, options = {}) {
     }
     function isNamedIdentifierStart(scnr, context) {
         const { currentType } = context;
-        if (currentType !== 2 /* BraceLeft */) {
+        if (currentType !== 2 /* TokenTypes.BraceLeft */) {
             return false;
         }
         peekSpaces(scnr);
@@ -277,7 +277,7 @@ function createTokenizer(source, options = {}) {
     }
     function isListIdentifierStart(scnr, context) {
         const { currentType } = context;
-        if (currentType !== 2 /* BraceLeft */) {
+        if (currentType !== 2 /* TokenTypes.BraceLeft */) {
             return false;
         }
         peekSpaces(scnr);
@@ -288,7 +288,7 @@ function createTokenizer(source, options = {}) {
     }
     function isLiteralStart(scnr, context) {
         const { currentType } = context;
-        if (currentType !== 2 /* BraceLeft */) {
+        if (currentType !== 2 /* TokenTypes.BraceLeft */) {
             return false;
         }
         peekSpaces(scnr);
@@ -298,17 +298,17 @@ function createTokenizer(source, options = {}) {
     }
     function isLinkedDotStart(scnr, context) {
         const { currentType } = context;
-        if (currentType !== 8 /* LinkedAlias */) {
+        if (currentType !== 8 /* TokenTypes.LinkedAlias */) {
             return false;
         }
         peekSpaces(scnr);
-        const ret = scnr.currentPeek() === "." /* LinkedDot */;
+        const ret = scnr.currentPeek() === "." /* TokenChars.LinkedDot */;
         scnr.resetPeek();
         return ret;
     }
     function isLinkedModifierStart(scnr, context) {
         const { currentType } = context;
-        if (currentType !== 9 /* LinkedDot */) {
+        if (currentType !== 9 /* TokenTypes.LinkedDot */) {
             return false;
         }
         peekSpaces(scnr);
@@ -318,30 +318,30 @@ function createTokenizer(source, options = {}) {
     }
     function isLinkedDelimiterStart(scnr, context) {
         const { currentType } = context;
-        if (!(currentType === 8 /* LinkedAlias */ ||
-            currentType === 12 /* LinkedModifier */)) {
+        if (!(currentType === 8 /* TokenTypes.LinkedAlias */ ||
+            currentType === 12 /* TokenTypes.LinkedModifier */)) {
             return false;
         }
         peekSpaces(scnr);
-        const ret = scnr.currentPeek() === ":" /* LinkedDelimiter */;
+        const ret = scnr.currentPeek() === ":" /* TokenChars.LinkedDelimiter */;
         scnr.resetPeek();
         return ret;
     }
     function isLinkedReferStart(scnr, context) {
         const { currentType } = context;
-        if (currentType !== 10 /* LinkedDelimiter */) {
+        if (currentType !== 10 /* TokenTypes.LinkedDelimiter */) {
             return false;
         }
         const fn = () => {
             const ch = scnr.currentPeek();
-            if (ch === "{" /* BraceLeft */) {
+            if (ch === "{" /* TokenChars.BraceLeft */) {
                 return isIdentifierStart(scnr.peek());
             }
-            else if (ch === "@" /* LinkedAlias */ ||
-                ch === "%" /* Modulo */ ||
-                ch === "|" /* Pipe */ ||
-                ch === ":" /* LinkedDelimiter */ ||
-                ch === "." /* LinkedDot */ ||
+            else if (ch === "@" /* TokenChars.LinkedAlias */ ||
+                ch === "%" /* TokenChars.Modulo */ ||
+                ch === "|" /* TokenChars.Pipe */ ||
+                ch === ":" /* TokenChars.LinkedDelimiter */ ||
+                ch === "." /* TokenChars.LinkedDot */ ||
                 ch === CHAR_SP ||
                 !ch) {
                 return false;
@@ -361,14 +361,14 @@ function createTokenizer(source, options = {}) {
     }
     function isPluralStart(scnr) {
         peekSpaces(scnr);
-        const ret = scnr.currentPeek() === "|" /* Pipe */;
+        const ret = scnr.currentPeek() === "|" /* TokenChars.Pipe */;
         scnr.resetPeek();
         return ret;
     }
     function detectModuloStart(scnr) {
         const spaces = peekSpaces(scnr);
-        const ret = scnr.currentPeek() === "%" /* Modulo */ &&
-            scnr.peek() === "{" /* BraceLeft */;
+        const ret = scnr.currentPeek() === "%" /* TokenChars.Modulo */ &&
+            scnr.peek() === "{" /* TokenChars.BraceLeft */;
         scnr.resetPeek();
         return {
             isModulo: ret,
@@ -378,18 +378,18 @@ function createTokenizer(source, options = {}) {
     function isTextStart(scnr, reset = true) {
         const fn = (hasSpace = false, prev = '', detectModulo = false) => {
             const ch = scnr.currentPeek();
-            if (ch === "{" /* BraceLeft */) {
-                return prev === "%" /* Modulo */ ? false : hasSpace;
+            if (ch === "{" /* TokenChars.BraceLeft */) {
+                return prev === "%" /* TokenChars.Modulo */ ? false : hasSpace;
             }
-            else if (ch === "@" /* LinkedAlias */ || !ch) {
-                return prev === "%" /* Modulo */ ? true : hasSpace;
+            else if (ch === "@" /* TokenChars.LinkedAlias */ || !ch) {
+                return prev === "%" /* TokenChars.Modulo */ ? true : hasSpace;
             }
-            else if (ch === "%" /* Modulo */) {
+            else if (ch === "%" /* TokenChars.Modulo */) {
                 scnr.peek();
-                return fn(hasSpace, "%" /* Modulo */, true);
+                return fn(hasSpace, "%" /* TokenChars.Modulo */, true);
             }
-            else if (ch === "|" /* Pipe */) {
-                return prev === "%" /* Modulo */ || detectModulo
+            else if (ch === "|" /* TokenChars.Pipe */) {
+                return prev === "%" /* TokenChars.Modulo */ || detectModulo
                     ? true
                     : !(prev === CHAR_SP || prev === CHAR_LF);
             }
@@ -459,24 +459,24 @@ function createTokenizer(source, options = {}) {
     function readModulo(scnr) {
         skipSpaces(scnr);
         const ch = scnr.currentChar();
-        if (ch !== "%" /* Modulo */) {
+        if (ch !== "%" /* TokenChars.Modulo */) {
             emitError(CompileErrorCodes.EXPECTED_TOKEN, currentPosition(), 0, ch);
         }
         scnr.next();
-        return "%" /* Modulo */;
+        return "%" /* TokenChars.Modulo */;
     }
     function readText(scnr) {
         let buf = '';
         while (true) {
             const ch = scnr.currentChar();
-            if (ch === "{" /* BraceLeft */ ||
-                ch === "}" /* BraceRight */ ||
-                ch === "@" /* LinkedAlias */ ||
-                ch === "|" /* Pipe */ ||
+            if (ch === "{" /* TokenChars.BraceLeft */ ||
+                ch === "}" /* TokenChars.BraceRight */ ||
+                ch === "@" /* TokenChars.LinkedAlias */ ||
+                ch === "|" /* TokenChars.Pipe */ ||
                 !ch) {
                 break;
             }
-            else if (ch === "%" /* Modulo */) {
+            else if (ch === "%" /* TokenChars.Modulo */) {
                 if (isTextStart(scnr)) {
                     buf += ch;
                     scnr.next();
@@ -592,8 +592,8 @@ function createTokenizer(source, options = {}) {
         skipSpaces(scnr);
         let ch = '';
         let identifiers = '';
-        const closure = (ch) => ch !== "{" /* BraceLeft */ &&
-            ch !== "}" /* BraceRight */ &&
+        const closure = (ch) => ch !== "{" /* TokenChars.BraceLeft */ &&
+            ch !== "}" /* TokenChars.BraceRight */ &&
             ch !== CHAR_SP &&
             ch !== CHAR_LF;
         while ((ch = takeChar(scnr, closure))) {
@@ -612,10 +612,10 @@ function createTokenizer(source, options = {}) {
     function readLinkedRefer(scnr) {
         const fn = (detect = false, buf) => {
             const ch = scnr.currentChar();
-            if (ch === "{" /* BraceLeft */ ||
-                ch === "%" /* Modulo */ ||
-                ch === "@" /* LinkedAlias */ ||
-                ch === "|" /* Pipe */ ||
+            if (ch === "{" /* TokenChars.BraceLeft */ ||
+                ch === "%" /* TokenChars.Modulo */ ||
+                ch === "@" /* TokenChars.LinkedAlias */ ||
+                ch === "|" /* TokenChars.Pipe */ ||
                 !ch) {
                 return buf;
             }
@@ -637,7 +637,7 @@ function createTokenizer(source, options = {}) {
     }
     function readPlural(scnr) {
         skipSpaces(scnr);
-        const plural = eat(scnr, "|" /* Pipe */);
+        const plural = eat(scnr, "|" /* TokenChars.Pipe */);
         skipSpaces(scnr);
         return plural;
     }
@@ -646,29 +646,29 @@ function createTokenizer(source, options = {}) {
         let token = null;
         const ch = scnr.currentChar();
         switch (ch) {
-            case "{" /* BraceLeft */:
+            case "{" /* TokenChars.BraceLeft */:
                 if (context.braceNest >= 1) {
                     emitError(CompileErrorCodes.NOT_ALLOW_NEST_PLACEHOLDER, currentPosition(), 0);
                 }
                 scnr.next();
-                token = getToken(context, 2 /* BraceLeft */, "{" /* BraceLeft */);
+                token = getToken(context, 2 /* TokenTypes.BraceLeft */, "{" /* TokenChars.BraceLeft */);
                 skipSpaces(scnr);
                 context.braceNest++;
                 return token;
-            case "}" /* BraceRight */:
+            case "}" /* TokenChars.BraceRight */:
                 if (context.braceNest > 0 &&
-                    context.currentType === 2 /* BraceLeft */) {
+                    context.currentType === 2 /* TokenTypes.BraceLeft */) {
                     emitError(CompileErrorCodes.EMPTY_PLACEHOLDER, currentPosition(), 0);
                 }
                 scnr.next();
-                token = getToken(context, 3 /* BraceRight */, "}" /* BraceRight */);
+                token = getToken(context, 3 /* TokenTypes.BraceRight */, "}" /* TokenChars.BraceRight */);
                 context.braceNest--;
                 context.braceNest > 0 && skipSpaces(scnr);
                 if (context.inLinked && context.braceNest === 0) {
                     context.inLinked = false;
                 }
                 return token;
-            case "@" /* LinkedAlias */:
+            case "@" /* TokenChars.LinkedAlias */:
                 if (context.braceNest > 0) {
                     emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
                 }
@@ -683,38 +683,38 @@ function createTokenizer(source, options = {}) {
                     if (context.braceNest > 0) {
                         emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
                     }
-                    token = getToken(context, 1 /* Pipe */, readPlural(scnr));
+                    token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
                     // reset
                     context.braceNest = 0;
                     context.inLinked = false;
                     return token;
                 }
                 if (context.braceNest > 0 &&
-                    (context.currentType === 5 /* Named */ ||
-                        context.currentType === 6 /* List */ ||
-                        context.currentType === 7 /* Literal */)) {
+                    (context.currentType === 5 /* TokenTypes.Named */ ||
+                        context.currentType === 6 /* TokenTypes.List */ ||
+                        context.currentType === 7 /* TokenTypes.Literal */)) {
                     emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
                     context.braceNest = 0;
                     return readToken(scnr, context);
                 }
                 if ((validNamedIdentifier = isNamedIdentifierStart(scnr, context))) {
-                    token = getToken(context, 5 /* Named */, readNamedIdentifier(scnr));
+                    token = getToken(context, 5 /* TokenTypes.Named */, readNamedIdentifier(scnr));
                     skipSpaces(scnr);
                     return token;
                 }
                 if ((validListIdentifier = isListIdentifierStart(scnr, context))) {
-                    token = getToken(context, 6 /* List */, readListIdentifier(scnr));
+                    token = getToken(context, 6 /* TokenTypes.List */, readListIdentifier(scnr));
                     skipSpaces(scnr);
                     return token;
                 }
                 if ((validLiteral = isLiteralStart(scnr, context))) {
-                    token = getToken(context, 7 /* Literal */, readLiteral(scnr));
+                    token = getToken(context, 7 /* TokenTypes.Literal */, readLiteral(scnr));
                     skipSpaces(scnr);
                     return token;
                 }
                 if (!validNamedIdentifier && !validListIdentifier && !validLiteral) {
                     // TODO: we should be re-designed invalid cases, when we will extend message syntax near the future ...
-                    token = getToken(context, 13 /* InvalidPlace */, readInvalidIdentifier(scnr));
+                    token = getToken(context, 13 /* TokenTypes.InvalidPlace */, readInvalidIdentifier(scnr));
                     emitError(CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER, currentPosition(), 0, token.value);
                     skipSpaces(scnr);
                     return token;
@@ -728,30 +728,30 @@ function createTokenizer(source, options = {}) {
         const { currentType } = context;
         let token = null;
         const ch = scnr.currentChar();
-        if ((currentType === 8 /* LinkedAlias */ ||
-            currentType === 9 /* LinkedDot */ ||
-            currentType === 12 /* LinkedModifier */ ||
-            currentType === 10 /* LinkedDelimiter */) &&
+        if ((currentType === 8 /* TokenTypes.LinkedAlias */ ||
+            currentType === 9 /* TokenTypes.LinkedDot */ ||
+            currentType === 12 /* TokenTypes.LinkedModifier */ ||
+            currentType === 10 /* TokenTypes.LinkedDelimiter */) &&
             (ch === CHAR_LF || ch === CHAR_SP)) {
             emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
         }
         switch (ch) {
-            case "@" /* LinkedAlias */:
+            case "@" /* TokenChars.LinkedAlias */:
                 scnr.next();
-                token = getToken(context, 8 /* LinkedAlias */, "@" /* LinkedAlias */);
+                token = getToken(context, 8 /* TokenTypes.LinkedAlias */, "@" /* TokenChars.LinkedAlias */);
                 context.inLinked = true;
                 return token;
-            case "." /* LinkedDot */:
+            case "." /* TokenChars.LinkedDot */:
                 skipSpaces(scnr);
                 scnr.next();
-                return getToken(context, 9 /* LinkedDot */, "." /* LinkedDot */);
-            case ":" /* LinkedDelimiter */:
+                return getToken(context, 9 /* TokenTypes.LinkedDot */, "." /* TokenChars.LinkedDot */);
+            case ":" /* TokenChars.LinkedDelimiter */:
                 skipSpaces(scnr);
                 scnr.next();
-                return getToken(context, 10 /* LinkedDelimiter */, ":" /* LinkedDelimiter */);
+                return getToken(context, 10 /* TokenTypes.LinkedDelimiter */, ":" /* TokenChars.LinkedDelimiter */);
             default:
                 if (isPluralStart(scnr)) {
-                    token = getToken(context, 1 /* Pipe */, readPlural(scnr));
+                    token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
                     // reset
                     context.braceNest = 0;
                     context.inLinked = false;
@@ -764,19 +764,19 @@ function createTokenizer(source, options = {}) {
                 }
                 if (isLinkedModifierStart(scnr, context)) {
                     skipSpaces(scnr);
-                    return getToken(context, 12 /* LinkedModifier */, readLinkedModifier(scnr));
+                    return getToken(context, 12 /* TokenTypes.LinkedModifier */, readLinkedModifier(scnr));
                 }
                 if (isLinkedReferStart(scnr, context)) {
                     skipSpaces(scnr);
-                    if (ch === "{" /* BraceLeft */) {
+                    if (ch === "{" /* TokenChars.BraceLeft */) {
                         // scan the placeholder
                         return readTokenInPlaceholder(scnr, context) || token;
                     }
                     else {
-                        return getToken(context, 11 /* LinkedKey */, readLinkedRefer(scnr));
+                        return getToken(context, 11 /* TokenTypes.LinkedKey */, readLinkedRefer(scnr));
                     }
                 }
-                if (currentType === 8 /* LinkedAlias */) {
+                if (currentType === 8 /* TokenTypes.LinkedAlias */) {
                     emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
                 }
                 context.braceNest = 0;
@@ -786,7 +786,7 @@ function createTokenizer(source, options = {}) {
     }
     // TODO: We need refactoring of token parsing ...
     function readToken(scnr, context) {
-        let token = { type: 14 /* EOF */ };
+        let token = { type: 14 /* TokenTypes.EOF */ };
         if (context.braceNest > 0) {
             return readTokenInPlaceholder(scnr, context) || getEndToken(context);
         }
@@ -795,17 +795,17 @@ function createTokenizer(source, options = {}) {
         }
         const ch = scnr.currentChar();
         switch (ch) {
-            case "{" /* BraceLeft */:
+            case "{" /* TokenChars.BraceLeft */:
                 return readTokenInPlaceholder(scnr, context) || getEndToken(context);
-            case "}" /* BraceRight */:
+            case "}" /* TokenChars.BraceRight */:
                 emitError(CompileErrorCodes.UNBALANCED_CLOSING_BRACE, currentPosition(), 0);
                 scnr.next();
-                return getToken(context, 3 /* BraceRight */, "}" /* BraceRight */);
-            case "@" /* LinkedAlias */:
+                return getToken(context, 3 /* TokenTypes.BraceRight */, "}" /* TokenChars.BraceRight */);
+            case "@" /* TokenChars.LinkedAlias */:
                 return readTokenInLinked(scnr, context) || getEndToken(context);
             default:
                 if (isPluralStart(scnr)) {
-                    token = getToken(context, 1 /* Pipe */, readPlural(scnr));
+                    token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
                     // reset
                     context.braceNest = 0;
                     context.inLinked = false;
@@ -814,11 +814,11 @@ function createTokenizer(source, options = {}) {
                 const { isModulo, hasSpace } = detectModuloStart(scnr);
                 if (isModulo) {
                     return hasSpace
-                        ? getToken(context, 0 /* Text */, readText(scnr))
-                        : getToken(context, 4 /* Modulo */, readModulo(scnr));
+                        ? getToken(context, 0 /* TokenTypes.Text */, readText(scnr))
+                        : getToken(context, 4 /* TokenTypes.Modulo */, readModulo(scnr));
                 }
                 if (isTextStart(scnr)) {
-                    return getToken(context, 0 /* Text */, readText(scnr));
+                    return getToken(context, 0 /* TokenTypes.Text */, readText(scnr));
                 }
                 break;
         }
@@ -833,7 +833,7 @@ function createTokenizer(source, options = {}) {
         _context.offset = currentOffset();
         _context.startLoc = currentPosition();
         if (_scnr.currentChar() === EOF) {
-            return getToken(_context, 14 /* EOF */);
+            return getToken(_context, 14 /* TokenTypes.EOF */);
         }
         return readToken(_scnr, _context);
     }
@@ -903,7 +903,7 @@ function createParser(options = {}) {
     }
     function parseText(tokenizer, value) {
         const context = tokenizer.context();
-        const node = startNode(3 /* Text */, context.offset, context.startLoc);
+        const node = startNode(3 /* NodeTypes.Text */, context.offset, context.startLoc);
         node.value = value;
         endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
         return node;
@@ -911,7 +911,7 @@ function createParser(options = {}) {
     function parseList(tokenizer, index) {
         const context = tokenizer.context();
         const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
-        const node = startNode(5 /* List */, offset, loc);
+        const node = startNode(5 /* NodeTypes.List */, offset, loc);
         node.index = parseInt(index, 10);
         tokenizer.nextToken(); // skip brach right
         endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
@@ -920,7 +920,7 @@ function createParser(options = {}) {
     function parseNamed(tokenizer, key) {
         const context = tokenizer.context();
         const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
-        const node = startNode(4 /* Named */, offset, loc);
+        const node = startNode(4 /* NodeTypes.Named */, offset, loc);
         node.key = key;
         tokenizer.nextToken(); // skip brach right
         endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
@@ -929,7 +929,7 @@ function createParser(options = {}) {
     function parseLiteral(tokenizer, value) {
         const context = tokenizer.context();
         const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
-        const node = startNode(9 /* Literal */, offset, loc);
+        const node = startNode(9 /* NodeTypes.Literal */, offset, loc);
         node.value = value.replace(KNOWN_ESCAPES, fromEscapeSequence);
         tokenizer.nextToken(); // skip brach right
         endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
@@ -939,8 +939,8 @@ function createParser(options = {}) {
         const token = tokenizer.nextToken();
         const context = tokenizer.context();
         const { lastOffset: offset, lastStartLoc: loc } = context; // get linked dot loc
-        const node = startNode(8 /* LinkedModifier */, offset, loc);
-        if (token.type !== 12 /* LinkedModifier */) {
+        const node = startNode(8 /* NodeTypes.LinkedModifier */, offset, loc);
+        if (token.type !== 12 /* TokenTypes.LinkedModifier */) {
             // empty modifier
             emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_MODIFIER, context.lastStartLoc, 0);
             node.value = '';
@@ -962,49 +962,49 @@ function createParser(options = {}) {
     }
     function parseLinkedKey(tokenizer, value) {
         const context = tokenizer.context();
-        const node = startNode(7 /* LinkedKey */, context.offset, context.startLoc);
+        const node = startNode(7 /* NodeTypes.LinkedKey */, context.offset, context.startLoc);
         node.value = value;
         endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
         return node;
     }
     function parseLinked(tokenizer) {
         const context = tokenizer.context();
-        const linkedNode = startNode(6 /* Linked */, context.offset, context.startLoc);
+        const linkedNode = startNode(6 /* NodeTypes.Linked */, context.offset, context.startLoc);
         let token = tokenizer.nextToken();
-        if (token.type === 9 /* LinkedDot */) {
+        if (token.type === 9 /* TokenTypes.LinkedDot */) {
             const parsed = parseLinkedModifier(tokenizer);
             linkedNode.modifier = parsed.node;
             token = parsed.nextConsumeToken || tokenizer.nextToken();
         }
         // asset check token
-        if (token.type !== 10 /* LinkedDelimiter */) {
+        if (token.type !== 10 /* TokenTypes.LinkedDelimiter */) {
             emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
         }
         token = tokenizer.nextToken();
         // skip brace left
-        if (token.type === 2 /* BraceLeft */) {
+        if (token.type === 2 /* TokenTypes.BraceLeft */) {
             token = tokenizer.nextToken();
         }
         switch (token.type) {
-            case 11 /* LinkedKey */:
+            case 11 /* TokenTypes.LinkedKey */:
                 if (token.value == null) {
                     emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
                 }
                 linkedNode.key = parseLinkedKey(tokenizer, token.value || '');
                 break;
-            case 5 /* Named */:
+            case 5 /* TokenTypes.Named */:
                 if (token.value == null) {
                     emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
                 }
                 linkedNode.key = parseNamed(tokenizer, token.value || '');
                 break;
-            case 6 /* List */:
+            case 6 /* TokenTypes.List */:
                 if (token.value == null) {
                     emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
                 }
                 linkedNode.key = parseList(tokenizer, token.value || '');
                 break;
-            case 7 /* Literal */:
+            case 7 /* TokenTypes.Literal */:
                 if (token.value == null) {
                     emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
                 }
@@ -1014,7 +1014,7 @@ function createParser(options = {}) {
                 // empty key
                 emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_KEY, context.lastStartLoc, 0);
                 const nextContext = tokenizer.context();
-                const emptyLinkedKeyNode = startNode(7 /* LinkedKey */, nextContext.offset, nextContext.startLoc);
+                const emptyLinkedKeyNode = startNode(7 /* NodeTypes.LinkedKey */, nextContext.offset, nextContext.startLoc);
                 emptyLinkedKeyNode.value = '';
                 endNode(emptyLinkedKeyNode, nextContext.offset, nextContext.startLoc);
                 linkedNode.key = emptyLinkedKeyNode;
@@ -1031,56 +1031,56 @@ function createParser(options = {}) {
     }
     function parseMessage(tokenizer) {
         const context = tokenizer.context();
-        const startOffset = context.currentType === 1 /* Pipe */
+        const startOffset = context.currentType === 1 /* TokenTypes.Pipe */
             ? tokenizer.currentOffset()
             : context.offset;
-        const startLoc = context.currentType === 1 /* Pipe */
+        const startLoc = context.currentType === 1 /* TokenTypes.Pipe */
             ? context.endLoc
             : context.startLoc;
-        const node = startNode(2 /* Message */, startOffset, startLoc);
+        const node = startNode(2 /* NodeTypes.Message */, startOffset, startLoc);
         node.items = [];
         let nextToken = null;
         do {
             const token = nextToken || tokenizer.nextToken();
             nextToken = null;
             switch (token.type) {
-                case 0 /* Text */:
+                case 0 /* TokenTypes.Text */:
                     if (token.value == null) {
                         emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
                     }
                     node.items.push(parseText(tokenizer, token.value || ''));
                     break;
-                case 6 /* List */:
+                case 6 /* TokenTypes.List */:
                     if (token.value == null) {
                         emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
                     }
                     node.items.push(parseList(tokenizer, token.value || ''));
                     break;
-                case 5 /* Named */:
+                case 5 /* TokenTypes.Named */:
                     if (token.value == null) {
                         emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
                     }
                     node.items.push(parseNamed(tokenizer, token.value || ''));
                     break;
-                case 7 /* Literal */:
+                case 7 /* TokenTypes.Literal */:
                     if (token.value == null) {
                         emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
                     }
                     node.items.push(parseLiteral(tokenizer, token.value || ''));
                     break;
-                case 8 /* LinkedAlias */:
+                case 8 /* TokenTypes.LinkedAlias */:
                     const parsed = parseLinked(tokenizer);
                     node.items.push(parsed.node);
                     nextToken = parsed.nextConsumeToken || null;
                     break;
             }
-        } while (context.currentType !== 14 /* EOF */ &&
-            context.currentType !== 1 /* Pipe */);
+        } while (context.currentType !== 14 /* TokenTypes.EOF */ &&
+            context.currentType !== 1 /* TokenTypes.Pipe */);
         // adjust message node loc
-        const endOffset = context.currentType === 1 /* Pipe */
+        const endOffset = context.currentType === 1 /* TokenTypes.Pipe */
             ? context.lastOffset
             : tokenizer.currentOffset();
-        const endLoc = context.currentType === 1 /* Pipe */
+        const endLoc = context.currentType === 1 /* TokenTypes.Pipe */
             ? context.lastEndLoc
             : tokenizer.currentPosition();
         endNode(node, endOffset, endLoc);
@@ -1089,7 +1089,7 @@ function createParser(options = {}) {
     function parsePlural(tokenizer, offset, loc, msgNode) {
         const context = tokenizer.context();
         let hasEmptyMessage = msgNode.items.length === 0;
-        const node = startNode(1 /* Plural */, offset, loc);
+        const node = startNode(1 /* NodeTypes.Plural */, offset, loc);
         node.cases = [];
         node.cases.push(msgNode);
         do {
@@ -1098,7 +1098,7 @@ function createParser(options = {}) {
                 hasEmptyMessage = msg.items.length === 0;
             }
             node.cases.push(msg);
-        } while (context.currentType !== 14 /* EOF */);
+        } while (context.currentType !== 14 /* TokenTypes.EOF */);
         if (hasEmptyMessage) {
             emitError(tokenizer, CompileErrorCodes.MUST_HAVE_MESSAGES_IN_PLURAL, loc, 0);
         }
@@ -1109,7 +1109,7 @@ function createParser(options = {}) {
         const context = tokenizer.context();
         const { offset, startLoc } = context;
         const msgNode = parseMessage(tokenizer);
-        if (context.currentType === 14 /* EOF */) {
+        if (context.currentType === 14 /* TokenTypes.EOF */) {
             return msgNode;
         }
         else {
@@ -1119,13 +1119,13 @@ function createParser(options = {}) {
     function parse(source) {
         const tokenizer = createTokenizer(source, assign({}, options));
         const context = tokenizer.context();
-        const node = startNode(0 /* Resource */, context.offset, context.startLoc);
+        const node = startNode(0 /* NodeTypes.Resource */, context.offset, context.startLoc);
         if (location && node.loc) {
             node.loc.source = source;
         }
         node.body = parseResource(tokenizer);
         // assert whether achieved to EOF
-        if (context.currentType !== 14 /* EOF */) {
+        if (context.currentType !== 14 /* TokenTypes.EOF */) {
             emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, source[context.offset] || '');
         }
         endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
@@ -1134,7 +1134,7 @@ function createParser(options = {}) {
     return { parse };
 }
 function getTokenCaption(token) {
-    if (token.type === 14 /* EOF */) {
+    if (token.type === 14 /* TokenTypes.EOF */) {
         return 'EOF';
     }
     const name = (token.value || '').replace(/\r?\n/gu, '\\n');
@@ -1162,26 +1162,26 @@ function traverseNodes(nodes, transformer) {
 function traverseNode(node, transformer) {
     // TODO: if we need pre-hook of transform, should be implemented to here
     switch (node.type) {
-        case 1 /* Plural */:
+        case 1 /* NodeTypes.Plural */:
             traverseNodes(node.cases, transformer);
-            transformer.helper("plural" /* PLURAL */);
+            transformer.helper("plural" /* HelperNameMap.PLURAL */);
             break;
-        case 2 /* Message */:
+        case 2 /* NodeTypes.Message */:
             traverseNodes(node.items, transformer);
             break;
-        case 6 /* Linked */:
+        case 6 /* NodeTypes.Linked */:
             const linked = node;
             traverseNode(linked.key, transformer);
-            transformer.helper("linked" /* LINKED */);
-            transformer.helper("type" /* TYPE */);
+            transformer.helper("linked" /* HelperNameMap.LINKED */);
+            transformer.helper("type" /* HelperNameMap.TYPE */);
             break;
-        case 5 /* List */:
-            transformer.helper("interpolate" /* INTERPOLATE */);
-            transformer.helper("list" /* LIST */);
+        case 5 /* NodeTypes.List */:
+            transformer.helper("interpolate" /* HelperNameMap.INTERPOLATE */);
+            transformer.helper("list" /* HelperNameMap.LIST */);
             break;
-        case 4 /* Named */:
-            transformer.helper("interpolate" /* INTERPOLATE */);
-            transformer.helper("named" /* NAMED */);
+        case 4 /* NodeTypes.Named */:
+            transformer.helper("interpolate" /* HelperNameMap.INTERPOLATE */);
+            transformer.helper("named" /* HelperNameMap.NAMED */);
             break;
     }
     // TODO: if we need post-hook of transform, should be implemented to here
@@ -1190,7 +1190,7 @@ function traverseNode(node, transformer) {
 function transform(ast, options = {} // eslint-disable-line
 ) {
     const transformer = createTransformer(ast);
-    transformer.helper("normalize" /* NORMALIZE */);
+    transformer.helper("normalize" /* HelperNameMap.NORMALIZE */);
     // traverse
     ast.body && traverseNode(ast.body, transformer);
     // set meta information
@@ -1245,7 +1245,7 @@ function createCodeGenerator(ast, options) {
 }
 function generateLinkedNode(generator, node) {
     const { helper } = generator;
-    generator.push(`${helper("linked" /* LINKED */)}(`);
+    generator.push(`${helper("linked" /* HelperNameMap.LINKED */)}(`);
     generateNode(generator, node.key);
     if (node.modifier) {
         generator.push(`, `);
@@ -1259,7 +1259,7 @@ function generateLinkedNode(generator, node) {
 }
 function generateMessageNode(generator, node) {
     const { helper, needIndent } = generator;
-    generator.push(`${helper("normalize" /* NORMALIZE */)}([`);
+    generator.push(`${helper("normalize" /* HelperNameMap.NORMALIZE */)}([`);
     generator.indent(needIndent());
     const length = node.items.length;
     for (let i = 0; i < length; i++) {
@@ -1275,7 +1275,7 @@ function generateMessageNode(generator, node) {
 function generatePluralNode(generator, node) {
     const { helper, needIndent } = generator;
     if (node.cases.length > 1) {
-        generator.push(`${helper("plural" /* PLURAL */)}([`);
+        generator.push(`${helper("plural" /* HelperNameMap.PLURAL */)}([`);
         generator.indent(needIndent());
         const length = node.cases.length;
         for (let i = 0; i < length; i++) {
@@ -1300,34 +1300,34 @@ function generateResource(generator, node) {
 function generateNode(generator, node) {
     const { helper } = generator;
     switch (node.type) {
-        case 0 /* Resource */:
+        case 0 /* NodeTypes.Resource */:
             generateResource(generator, node);
             break;
-        case 1 /* Plural */:
+        case 1 /* NodeTypes.Plural */:
             generatePluralNode(generator, node);
             break;
-        case 2 /* Message */:
+        case 2 /* NodeTypes.Message */:
             generateMessageNode(generator, node);
             break;
-        case 6 /* Linked */:
+        case 6 /* NodeTypes.Linked */:
             generateLinkedNode(generator, node);
             break;
-        case 8 /* LinkedModifier */:
+        case 8 /* NodeTypes.LinkedModifier */:
             generator.push(JSON.stringify(node.value), node);
             break;
-        case 7 /* LinkedKey */:
+        case 7 /* NodeTypes.LinkedKey */:
             generator.push(JSON.stringify(node.value), node);
             break;
-        case 5 /* List */:
-            generator.push(`${helper("interpolate" /* INTERPOLATE */)}(${helper("list" /* LIST */)}(${node.index}))`, node);
+        case 5 /* NodeTypes.List */:
+            generator.push(`${helper("interpolate" /* HelperNameMap.INTERPOLATE */)}(${helper("list" /* HelperNameMap.LIST */)}(${node.index}))`, node);
             break;
-        case 4 /* Named */:
-            generator.push(`${helper("interpolate" /* INTERPOLATE */)}(${helper("named" /* NAMED */)}(${JSON.stringify(node.key)}))`, node);
+        case 4 /* NodeTypes.Named */:
+            generator.push(`${helper("interpolate" /* HelperNameMap.INTERPOLATE */)}(${helper("named" /* HelperNameMap.NAMED */)}(${JSON.stringify(node.key)}))`, node);
             break;
-        case 9 /* Literal */:
+        case 9 /* NodeTypes.Literal */:
             generator.push(JSON.stringify(node.value), node);
             break;
-        case 3 /* Text */:
+        case 3 /* NodeTypes.Text */:
             generator.push(JSON.stringify(node.value), node);
             break;
         default: