@intlify/message-compiler 11.1.2 → 12.0.0-alpha.2

package/dist/message-compiler.global.js

@@ -1,26 +1,11 @@
 /*!
-  * message-compiler v11.1.2
-  * (c) 2025 kazuya kawaguchi
+  * message-compiler v12.0.0-alpha.2
+  * (c) 2016-present kazuya kawaguchi and contributors
   * Released under the MIT License.
   */
 var IntlifyMessageCompiler = (function (exports) {
   'use strict';
 
-  const LOCATION_STUB = {
-      start: { line: 1, column: 1, offset: 0 },
-      end: { line: 1, column: 1, offset: 0 }
-  };
-  function createPosition(line, column, offset) {
-      return { line, column, offset };
-  }
-  function createLocation(start, end, source) {
-      const loc = { start, end };
-      if (source != null) {
-          loc.source = source;
-      }
-      return loc;
-  }
-
   /**
    * Original Utilities
    * written by kazuya kawaguchi
@@ -46,6 +31,21 @@ var IntlifyMessageCompiler = (function (exports) {
       return items.reduce((str, item, index) => (index === 0 ? str + item : str + separator + item), '');
   }
 
+  const LOCATION_STUB = {
+      start: { line: 1, column: 1, offset: 0 },
+      end: { line: 1, column: 1, offset: 0 }
+  };
+  function createPosition(line, column, offset) {
+      return { line, column, offset };
+  }
+  function createLocation(start, end, source) {
+      const loc = { start, end };
+      if (source != null) {
+          loc.source = source;
+      }
+      return loc;
+  }
+
   const CompileErrorCodes = {
       // tokenizer error codes
       EXPECTED_TOKEN: 1,
@@ -112,164 +112,473 @@ var IntlifyMessageCompiler = (function (exports) {
       throw error;
   }
 
-  // eslint-disable-next-line no-useless-escape
-  const RE_HTML_TAG = /<\/?[\w\s="/.':;#-\/]+>/;
-  const detectHtmlTag = (source) => RE_HTML_TAG.test(source);
-
-  const CHAR_SP = ' ';
-  const CHAR_CR = '\r';
-  const CHAR_LF = '\n';
-  const CHAR_LS = String.fromCharCode(0x2028);
-  const CHAR_PS = String.fromCharCode(0x2029);
-  function createScanner(str) {
-      const _buf = str;
-      let _index = 0;
-      let _line = 1;
-      let _column = 1;
-      let _peekOffset = 0;
-      const isCRLF = (index) => _buf[index] === CHAR_CR && _buf[index + 1] === CHAR_LF;
-      const isLF = (index) => _buf[index] === CHAR_LF;
-      const isPS = (index) => _buf[index] === CHAR_PS;
-      const isLS = (index) => _buf[index] === CHAR_LS;
-      const isLineEnd = (index) => isCRLF(index) || isLF(index) || isPS(index) || isLS(index);
-      const index = () => _index;
-      const line = () => _line;
-      const column = () => _column;
-      const peekOffset = () => _peekOffset;
-      const charAt = (offset) => isCRLF(offset) || isPS(offset) || isLS(offset) ? CHAR_LF : _buf[offset];
-      const currentChar = () => charAt(_index);
-      const currentPeek = () => charAt(_index + _peekOffset);
-      function next() {
-          _peekOffset = 0;
-          if (isLineEnd(_index)) {
-              _line++;
-              _column = 0;
-          }
-          if (isCRLF(_index)) {
-              _index++;
-          }
-          _index++;
-          _column++;
-          return _buf[_index];
+  // eslint-disable-next-line @typescript-eslint/triple-slash-reference
+  /// <reference types="source-map-js" />
+  const ERROR_DOMAIN$3 = 'parser';
+  function createCodeGenerator(ast, options) {
+      const { sourceMap, filename, breakLineCode, needIndent: _needIndent } = options;
+      const location = options.location !== false;
+      const _context = {
+          filename,
+          code: '',
+          column: 1,
+          line: 1,
+          offset: 0,
+          map: undefined,
+          breakLineCode,
+          needIndent: _needIndent,
+          indentLevel: 0
+      };
+      if (location && ast.loc) {
+          _context.source = ast.loc.source;
       }
-      function peek() {
-          if (isCRLF(_index + _peekOffset)) {
-              _peekOffset++;
-          }
-          _peekOffset++;
-          return _buf[_index + _peekOffset];
+      const context = () => _context;
+      function push(code, node) {
+          _context.code += code;
       }
-      function reset() {
-          _index = 0;
-          _line = 1;
-          _column = 1;
-          _peekOffset = 0;
+      function _newline(n, withBreakLine = true) {
+          const _breakLineCode = withBreakLine ? breakLineCode : '';
+          push(_needIndent ? _breakLineCode + `  `.repeat(n) : _breakLineCode);
       }
-      function resetPeek(offset = 0) {
-          _peekOffset = offset;
+      function indent(withNewLine = true) {
+          const level = ++_context.indentLevel;
+          withNewLine && _newline(level);
       }
-      function skipToPeek() {
-          const target = _index + _peekOffset;
-          while (target !== _index) {
-              next();
-          }
-          _peekOffset = 0;
+      function deindent(withNewLine = true) {
+          const level = --_context.indentLevel;
+          withNewLine && _newline(level);
+      }
+      function newline() {
+          _newline(_context.indentLevel);
       }
+      const helper = (key) => `_${key}`;
+      const needIndent = () => _context.needIndent;
       return {
-          index,
-          line,
-          column,
-          peekOffset,
-          charAt,
-          currentChar,
-          currentPeek,
-          next,
-          peek,
-          reset,
-          resetPeek,
-          skipToPeek
+          context,
+          push,
+          indent,
+          deindent,
+          newline,
+          helper,
+          needIndent
       };
   }
-
-  const EOF = undefined;
-  const DOT = '.';
-  const LITERAL_DELIMITER = "'";
-  const ERROR_DOMAIN$3 = 'tokenizer';
-  function createTokenizer(source, options = {}) {
-      const location = options.location !== false;
-      const _scnr = createScanner(source);
-      const currentOffset = () => _scnr.index();
-      const currentPosition = () => createPosition(_scnr.line(), _scnr.column(), _scnr.index());
-      const _initLoc = currentPosition();
-      const _initOffset = currentOffset();
-      const _context = {
-          currentType: 13 /* TokenTypes.EOF */,
-          offset: _initOffset,
-          startLoc: _initLoc,
-          endLoc: _initLoc,
-          lastType: 13 /* TokenTypes.EOF */,
-          lastOffset: _initOffset,
-          lastStartLoc: _initLoc,
-          lastEndLoc: _initLoc,
-          braceNest: 0,
-          inLinked: false,
-          text: ''
-      };
-      const context = () => _context;
-      const { onError } = options;
-      function emitError(code, pos, offset, ...args) {
-          const ctx = context();
-          pos.column += offset;
-          pos.offset += offset;
-          if (onError) {
-              const loc = location ? createLocation(ctx.startLoc, pos) : null;
-              const err = createCompileError(code, loc, {
-                  domain: ERROR_DOMAIN$3,
-                  args
-              });
-              onError(err);
-          }
+  function generateLinkedNode(generator, node) {
+      const { helper } = generator;
+      generator.push(`${helper("linked" /* HelperNameMap.LINKED */)}(`);
+      generateNode(generator, node.key);
+      if (node.modifier) {
+          generator.push(`, `);
+          generateNode(generator, node.modifier);
+          generator.push(`, _type`);
       }
-      function getToken(context, type, value) {
-          context.endLoc = currentPosition();
-          context.currentType = type;
-          const token = { type };
-          if (location) {
-              token.loc = createLocation(context.startLoc, context.endLoc);
-          }
-          if (value != null) {
-              token.value = value;
-          }
-          return token;
+      else {
+          generator.push(`, undefined, _type`);
       }
-      const getEndToken = (context) => getToken(context, 13 /* TokenTypes.EOF */);
-      function eat(scnr, ch) {
-          if (scnr.currentChar() === ch) {
-              scnr.next();
-              return ch;
-          }
-          else {
-              emitError(CompileErrorCodes.EXPECTED_TOKEN, currentPosition(), 0, ch);
-              return '';
+      generator.push(`)`);
+  }
+  function generateMessageNode(generator, node) {
+      const { helper, needIndent } = generator;
+      generator.push(`${helper("normalize" /* HelperNameMap.NORMALIZE */)}([`);
+      generator.indent(needIndent());
+      const length = node.items.length;
+      for (let i = 0; i < length; i++) {
+          generateNode(generator, node.items[i]);
+          if (i === length - 1) {
+              break;
           }
+          generator.push(', ');
       }
-      function peekSpaces(scnr) {
-          let buf = '';
-          while (scnr.currentPeek() === CHAR_SP || scnr.currentPeek() === CHAR_LF) {
-              buf += scnr.currentPeek();
-              scnr.peek();
+      generator.deindent(needIndent());
+      generator.push('])');
+  }
+  function generatePluralNode(generator, node) {
+      const { helper, needIndent } = generator;
+      if (node.cases.length > 1) {
+          generator.push(`${helper("plural" /* HelperNameMap.PLURAL */)}([`);
+          generator.indent(needIndent());
+          const length = node.cases.length;
+          for (let i = 0; i < length; i++) {
+              generateNode(generator, node.cases[i]);
+              if (i === length - 1) {
+                  break;
+              }
+              generator.push(', ');
           }
-          return buf;
+          generator.deindent(needIndent());
+          generator.push(`])`);
       }
-      function skipSpaces(scnr) {
-          const buf = peekSpaces(scnr);
-          scnr.skipToPeek();
-          return buf;
+  }
+  function generateResource(generator, node) {
+      if (node.body) {
+          generateNode(generator, node.body);
       }
-      function isIdentifierStart(ch) {
-          if (ch === EOF) {
-              return false;
-          }
+      else {
+          generator.push('null');
+      }
+  }
+  function generateNode(generator, node) {
+      const { helper } = generator;
+      switch (node.type) {
+          case 0 /* NodeTypes.Resource */:
+              generateResource(generator, node);
+              break;
+          case 1 /* NodeTypes.Plural */:
+              generatePluralNode(generator, node);
+              break;
+          case 2 /* NodeTypes.Message */:
+              generateMessageNode(generator, node);
+              break;
+          case 6 /* NodeTypes.Linked */:
+              generateLinkedNode(generator, node);
+              break;
+          case 8 /* NodeTypes.LinkedModifier */:
+              generator.push(JSON.stringify(node.value), node);
+              break;
+          case 7 /* NodeTypes.LinkedKey */:
+              generator.push(JSON.stringify(node.value), node);
+              break;
+          case 5 /* NodeTypes.List */:
+              generator.push(`${helper("interpolate" /* HelperNameMap.INTERPOLATE */)}(${helper("list" /* HelperNameMap.LIST */)}(${node.index}))`, node);
+              break;
+          case 4 /* NodeTypes.Named */:
+              generator.push(`${helper("interpolate" /* HelperNameMap.INTERPOLATE */)}(${helper("named" /* HelperNameMap.NAMED */)}(${JSON.stringify(node.key)}))`, node);
+              break;
+          case 9 /* NodeTypes.Literal */:
+              generator.push(JSON.stringify(node.value), node);
+              break;
+          case 3 /* NodeTypes.Text */:
+              generator.push(JSON.stringify(node.value), node);
+              break;
+          default:
+              {
+                  throw createCompileError(CompileErrorCodes.UNHANDLED_CODEGEN_NODE_TYPE, null, {
+                      domain: ERROR_DOMAIN$3,
+                      args: [node.type]
+                  });
+              }
+      }
+  }
+  // generate code from AST
+  const generate = (ast, options = {}) => {
+      const mode = isString(options.mode) ? options.mode : 'normal';
+      const filename = isString(options.filename)
+          ? options.filename
+          : 'message.intl';
+      const sourceMap = !!options.sourceMap;
+      // prettier-ignore
+      const breakLineCode = options.breakLineCode != null
+          ? options.breakLineCode
+          : mode === 'arrow'
+              ? ';'
+              : '\n';
+      const needIndent = options.needIndent ? options.needIndent : mode !== 'arrow';
+      const helpers = ast.helpers || [];
+      const generator = createCodeGenerator(ast, {
+          mode,
+          filename,
+          sourceMap,
+          breakLineCode,
+          needIndent
+      });
+      generator.push(mode === 'normal' ? `function __msg__ (ctx) {` : `(ctx) => {`);
+      generator.indent(needIndent);
+      if (helpers.length > 0) {
+          generator.push(`const { ${join(helpers.map(s => `${s}: _${s}`), ', ')} } = ctx`);
+          generator.newline();
+      }
+      generator.push(`return `);
+      generateNode(generator, ast);
+      generator.deindent(needIndent);
+      generator.push(`}`);
+      delete ast.helpers;
+      const { code, map } = generator.context();
+      return {
+          ast,
+          code,
+          map: map ? map.toJSON() : undefined // eslint-disable-line @typescript-eslint/no-explicit-any
+      };
+  };
+
+  const ERROR_DOMAIN$2 = 'minifier';
+  /* eslint-disable @typescript-eslint/no-explicit-any */
+  function mangle(node) {
+      node.t = node.type;
+      switch (node.type) {
+          case 0 /* NodeTypes.Resource */: {
+              const resource = node;
+              mangle(resource.body);
+              resource.b = resource.body;
+              delete resource.body;
+              break;
+          }
+          case 1 /* NodeTypes.Plural */: {
+              const plural = node;
+              const cases = plural.cases;
+              for (let i = 0; i < cases.length; i++) {
+                  mangle(cases[i]);
+              }
+              plural.c = cases;
+              delete plural.cases;
+              break;
+          }
+          case 2 /* NodeTypes.Message */: {
+              const message = node;
+              const items = message.items;
+              for (let i = 0; i < items.length; i++) {
+                  mangle(items[i]);
+              }
+              message.i = items;
+              delete message.items;
+              if (message.static) {
+                  message.s = message.static;
+                  delete message.static;
+              }
+              break;
+          }
+          case 3 /* NodeTypes.Text */:
+          case 9 /* NodeTypes.Literal */:
+          case 8 /* NodeTypes.LinkedModifier */:
+          case 7 /* NodeTypes.LinkedKey */: {
+              const valueNode = node;
+              if (valueNode.value) {
+                  valueNode.v = valueNode.value;
+                  delete valueNode.value;
+              }
+              break;
+          }
+          case 6 /* NodeTypes.Linked */: {
+              const linked = node;
+              mangle(linked.key);
+              linked.k = linked.key;
+              delete linked.key;
+              if (linked.modifier) {
+                  mangle(linked.modifier);
+                  linked.m = linked.modifier;
+                  delete linked.modifier;
+              }
+              break;
+          }
+          case 5 /* NodeTypes.List */: {
+              const list = node;
+              list.i = list.index;
+              delete list.index;
+              break;
+          }
+          case 4 /* NodeTypes.Named */: {
+              const named = node;
+              named.k = named.key;
+              delete named.key;
+              break;
+          }
+          default:
+              {
+                  throw createCompileError(CompileErrorCodes.UNHANDLED_MINIFIER_NODE_TYPE, null, {
+                      domain: ERROR_DOMAIN$2,
+                      args: [node.type]
+                  });
+              }
+      }
+      delete node.type;
+  }
+  /* eslint-enable @typescript-eslint/no-explicit-any */
+
+  function optimize(ast) {
+      const body = ast.body;
+      if (body.type === 2 /* NodeTypes.Message */) {
+          optimizeMessageNode(body);
+      }
+      else {
+          body.cases.forEach(c => optimizeMessageNode(c));
+      }
+      return ast;
+  }
+  function optimizeMessageNode(message) {
+      if (message.items.length === 1) {
+          const item = message.items[0];
+          if (item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */) {
+              message.static = item.value;
+              delete item.value; // optimization for size
+          }
+      }
+      else {
+          const values = [];
+          for (let i = 0; i < message.items.length; i++) {
+              const item = message.items[i];
+              if (!(item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */)) {
+                  break;
+              }
+              if (item.value == null) {
+                  break;
+              }
+              values.push(item.value);
+          }
+          if (values.length === message.items.length) {
+              message.static = join(values);
+              for (let i = 0; i < message.items.length; i++) {
+                  const item = message.items[i];
+                  if (item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */) {
+                      delete item.value; // optimization for size
+                  }
+              }
+          }
+      }
+  }
+
+  const CHAR_SP = ' ';
+  const CHAR_CR = '\r';
+  const CHAR_LF = '\n';
+  const CHAR_LS = String.fromCharCode(0x2028);
+  const CHAR_PS = String.fromCharCode(0x2029);
+  function createScanner(str) {
+      const _buf = str;
+      let _index = 0;
+      let _line = 1;
+      let _column = 1;
+      let _peekOffset = 0;
+      const isCRLF = (index) => _buf[index] === CHAR_CR && _buf[index + 1] === CHAR_LF;
+      const isLF = (index) => _buf[index] === CHAR_LF;
+      const isPS = (index) => _buf[index] === CHAR_PS;
+      const isLS = (index) => _buf[index] === CHAR_LS;
+      const isLineEnd = (index) => isCRLF(index) || isLF(index) || isPS(index) || isLS(index);
+      const index = () => _index;
+      const line = () => _line;
+      const column = () => _column;
+      const peekOffset = () => _peekOffset;
+      const charAt = (offset) => isCRLF(offset) || isPS(offset) || isLS(offset) ? CHAR_LF : _buf[offset];
+      const currentChar = () => charAt(_index);
+      const currentPeek = () => charAt(_index + _peekOffset);
+      function next() {
+          _peekOffset = 0;
+          if (isLineEnd(_index)) {
+              _line++;
+              _column = 0;
+          }
+          if (isCRLF(_index)) {
+              _index++;
+          }
+          _index++;
+          _column++;
+          return _buf[_index];
+      }
+      function peek() {
+          if (isCRLF(_index + _peekOffset)) {
+              _peekOffset++;
+          }
+          _peekOffset++;
+          return _buf[_index + _peekOffset];
+      }
+      function reset() {
+          _index = 0;
+          _line = 1;
+          _column = 1;
+          _peekOffset = 0;
+      }
+      function resetPeek(offset = 0) {
+          _peekOffset = offset;
+      }
+      function skipToPeek() {
+          const target = _index + _peekOffset;
+          while (target !== _index) {
+              next();
+          }
+          _peekOffset = 0;
+      }
+      return {
+          index,
+          line,
+          column,
+          peekOffset,
+          charAt,
+          currentChar,
+          currentPeek,
+          next,
+          peek,
+          reset,
+          resetPeek,
+          skipToPeek
+      };
+  }
+
+  const EOF = undefined;
+  const DOT = '.';
+  const LITERAL_DELIMITER = "'";
+  const ERROR_DOMAIN$1 = 'tokenizer';
+  function createTokenizer(source, options = {}) {
+      const location = options.location !== false;
+      const _scnr = createScanner(source);
+      const currentOffset = () => _scnr.index();
+      const currentPosition = () => createPosition(_scnr.line(), _scnr.column(), _scnr.index());
+      const _initLoc = currentPosition();
+      const _initOffset = currentOffset();
+      const _context = {
+          currentType: 13 /* TokenTypes.EOF */,
+          offset: _initOffset,
+          startLoc: _initLoc,
+          endLoc: _initLoc,
+          lastType: 13 /* TokenTypes.EOF */,
+          lastOffset: _initOffset,
+          lastStartLoc: _initLoc,
+          lastEndLoc: _initLoc,
+          braceNest: 0,
+          inLinked: false,
+          text: ''
+      };
+      const context = () => _context;
+      const { onError } = options;
+      function emitError(code, pos, offset, ...args) {
+          const ctx = context();
+          pos.column += offset;
+          pos.offset += offset;
+          if (onError) {
+              const loc = location ? createLocation(ctx.startLoc, pos) : null;
+              const err = createCompileError(code, loc, {
+                  domain: ERROR_DOMAIN$1,
+                  args
+              });
+              onError(err);
+          }
+      }
+      function getToken(context, type, value) {
+          context.endLoc = currentPosition();
+          context.currentType = type;
+          const token = { type };
+          if (location) {
+              token.loc = createLocation(context.startLoc, context.endLoc);
+          }
+          if (value != null) {
+              token.value = value;
+          }
+          return token;
+      }
+      const getEndToken = (context) => getToken(context, 13 /* TokenTypes.EOF */);
+      function eat(scnr, ch) {
+          if (scnr.currentChar() === ch) {
+              scnr.next();
+              return ch;
+          }
+          else {
+              emitError(CompileErrorCodes.EXPECTED_TOKEN, currentPosition(), 0, ch);
+              return '';
+          }
+      }
+      function peekSpaces(scnr) {
+          let buf = '';
+          while (scnr.currentPeek() === CHAR_SP || scnr.currentPeek() === CHAR_LF) {
+              buf += scnr.currentPeek();
+              scnr.peek();
+          }
+          return buf;
+      }
+      function skipSpaces(scnr) {
+          const buf = peekSpaces(scnr);
+          scnr.skipToPeek();
+          return buf;
+      }
+      function isIdentifierStart(ch) {
+          if (ch === EOF) {
+              return false;
+          }
           const cc = ch.charCodeAt(0);
           return ((cc >= 97 && cc <= 122) || // a-z
               (cc >= 65 && cc <= 90) || // A-Z
@@ -845,7 +1154,7 @@ var IntlifyMessageCompiler = (function (exports) {
       };
   }
 
-  const ERROR_DOMAIN$2 = 'parser';
+  const ERROR_DOMAIN = 'parser';
   // Backslash backslash, backslash quote, uHHHH, UHHHHHH.
   const KNOWN_ESCAPES = /(?:\\\\|\\'|\\u([0-9a-fA-F]{4})|\\U([0-9a-fA-F]{6}))/g;
   function fromEscapeSequence(match, codePoint4, codePoint6) {
@@ -877,7 +1186,7 @@ var IntlifyMessageCompiler = (function (exports) {
           if (onError) {
               const loc = location ? createLocation(start, end) : null;
               const err = createCompileError(code, loc, {
-                  domain: ERROR_DOMAIN$2,
+                  domain: ERROR_DOMAIN,
                   args
               });
               onError(err);
@@ -1110,420 +1419,109 @@ var IntlifyMessageCompiler = (function (exports) {
           const context = tokenizer.context();
           const { offset, startLoc } = context;
           const msgNode = parseMessage(tokenizer);
-          if (context.currentType === 13 /* TokenTypes.EOF */) {
-              return msgNode;
-          }
-          else {
-              return parsePlural(tokenizer, offset, startLoc, msgNode);
-          }
-      }
-      function parse(source) {
-          const tokenizer = createTokenizer(source, assign({}, options));
-          const context = tokenizer.context();
-          const node = startNode(0 /* NodeTypes.Resource */, context.offset, context.startLoc);
-          if (location && node.loc) {
-              node.loc.source = source;
-          }
-          node.body = parseResource(tokenizer);
-          if (options.onCacheKey) {
-              node.cacheKey = options.onCacheKey(source);
-          }
-          // assert whether achieved to EOF
-          if (context.currentType !== 13 /* TokenTypes.EOF */) {
-              emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, source[context.offset] || '');
-          }
-          endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
-          return node;
-      }
-      return { parse };
-  }
-  function getTokenCaption(token) {
-      if (token.type === 13 /* TokenTypes.EOF */) {
-          return 'EOF';
-      }
-      const name = (token.value || '').replace(/\r?\n/gu, '\\n');
-      return name.length > 10 ? name.slice(0, 9) + '…' : name;
-  }
-
-  function createTransformer(ast, options = {} // eslint-disable-line
-  ) {
-      const _context = {
-          ast,
-          helpers: new Set()
-      };
-      const context = () => _context;
-      const helper = (name) => {
-          _context.helpers.add(name);
-          return name;
-      };
-      return { context, helper };
-  }
-  function traverseNodes(nodes, transformer) {
-      for (let i = 0; i < nodes.length; i++) {
-          traverseNode(nodes[i], transformer);
-      }
-  }
-  function traverseNode(node, transformer) {
-      // TODO: if we need pre-hook of transform, should be implemented to here
-      switch (node.type) {
-          case 1 /* NodeTypes.Plural */:
-              traverseNodes(node.cases, transformer);
-              transformer.helper("plural" /* HelperNameMap.PLURAL */);
-              break;
-          case 2 /* NodeTypes.Message */:
-              traverseNodes(node.items, transformer);
-              break;
-          case 6 /* NodeTypes.Linked */: {
-              const linked = node;
-              traverseNode(linked.key, transformer);
-              transformer.helper("linked" /* HelperNameMap.LINKED */);
-              transformer.helper("type" /* HelperNameMap.TYPE */);
-              break;
-          }
-          case 5 /* NodeTypes.List */:
-              transformer.helper("interpolate" /* HelperNameMap.INTERPOLATE */);
-              transformer.helper("list" /* HelperNameMap.LIST */);
-              break;
-          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
-  }
-  // transform AST
-  function transform(ast, options = {} // eslint-disable-line
-  ) {
-      const transformer = createTransformer(ast);
-      transformer.helper("normalize" /* HelperNameMap.NORMALIZE */);
-      // traverse
-      ast.body && traverseNode(ast.body, transformer);
-      // set meta information
-      const context = transformer.context();
-      ast.helpers = Array.from(context.helpers);
-  }
-
-  function optimize(ast) {
-      const body = ast.body;
-      if (body.type === 2 /* NodeTypes.Message */) {
-          optimizeMessageNode(body);
-      }
-      else {
-          body.cases.forEach(c => optimizeMessageNode(c));
-      }
-      return ast;
-  }
-  function optimizeMessageNode(message) {
-      if (message.items.length === 1) {
-          const item = message.items[0];
-          if (item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */) {
-              message.static = item.value;
-              delete item.value; // optimization for size
-          }
-      }
-      else {
-          const values = [];
-          for (let i = 0; i < message.items.length; i++) {
-              const item = message.items[i];
-              if (!(item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */)) {
-                  break;
-              }
-              if (item.value == null) {
-                  break;
-              }
-              values.push(item.value);
-          }
-          if (values.length === message.items.length) {
-              message.static = join(values);
-              for (let i = 0; i < message.items.length; i++) {
-                  const item = message.items[i];
-                  if (item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */) {
-                      delete item.value; // optimization for size
-                  }
-              }
-          }
-      }
-  }
-
-  const ERROR_DOMAIN$1 = 'minifier';
-  /* eslint-disable @typescript-eslint/no-explicit-any */
-  function minify(node) {
-      node.t = node.type;
-      switch (node.type) {
-          case 0 /* NodeTypes.Resource */: {
-              const resource = node;
-              minify(resource.body);
-              resource.b = resource.body;
-              delete resource.body;
-              break;
-          }
-          case 1 /* NodeTypes.Plural */: {
-              const plural = node;
-              const cases = plural.cases;
-              for (let i = 0; i < cases.length; i++) {
-                  minify(cases[i]);
-              }
-              plural.c = cases;
-              delete plural.cases;
-              break;
-          }
-          case 2 /* NodeTypes.Message */: {
-              const message = node;
-              const items = message.items;
-              for (let i = 0; i < items.length; i++) {
-                  minify(items[i]);
-              }
-              message.i = items;
-              delete message.items;
-              if (message.static) {
-                  message.s = message.static;
-                  delete message.static;
-              }
-              break;
-          }
-          case 3 /* NodeTypes.Text */:
-          case 9 /* NodeTypes.Literal */:
-          case 8 /* NodeTypes.LinkedModifier */:
-          case 7 /* NodeTypes.LinkedKey */: {
-              const valueNode = node;
-              if (valueNode.value) {
-                  valueNode.v = valueNode.value;
-                  delete valueNode.value;
-              }
-              break;
-          }
-          case 6 /* NodeTypes.Linked */: {
-              const linked = node;
-              minify(linked.key);
-              linked.k = linked.key;
-              delete linked.key;
-              if (linked.modifier) {
-                  minify(linked.modifier);
-                  linked.m = linked.modifier;
-                  delete linked.modifier;
-              }
-              break;
+          if (context.currentType === 13 /* TokenTypes.EOF */) {
+              return msgNode;
           }
-          case 5 /* NodeTypes.List */: {
-              const list = node;
-              list.i = list.index;
-              delete list.index;
-              break;
+          else {
+              return parsePlural(tokenizer, offset, startLoc, msgNode);
           }
-          case 4 /* NodeTypes.Named */: {
-              const named = node;
-              named.k = named.key;
-              delete named.key;
-              break;
+      }
+      function parse(source) {
+          const tokenizer = createTokenizer(source, assign({}, options));
+          const context = tokenizer.context();
+          const node = startNode(0 /* NodeTypes.Resource */, context.offset, context.startLoc);
+          if (location && node.loc) {
+              node.loc.source = source;
           }
-          default:
-              {
-                  throw createCompileError(CompileErrorCodes.UNHANDLED_MINIFIER_NODE_TYPE, null, {
-                      domain: ERROR_DOMAIN$1,
-                      args: [node.type]
-                  });
-              }
+          node.body = parseResource(tokenizer);
+          if (options.onCacheKey) {
+              node.cacheKey = options.onCacheKey(source);
+          }
+          // assert whether achieved to EOF
+          if (context.currentType !== 13 /* TokenTypes.EOF */) {
+              emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, source[context.offset] || '');
+          }
+          endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+          return node;
       }
-      delete node.type;
+      return { parse };
+  }
+  function getTokenCaption(token) {
+      if (token.type === 13 /* TokenTypes.EOF */) {
+          return 'EOF';
+      }
+      const name = (token.value || '').replace(/\r?\n/gu, '\\n');
+      return name.length > 10 ? name.slice(0, 9) + '…' : name;
   }
-  /* eslint-enable @typescript-eslint/no-explicit-any */
 
-  // eslint-disable-next-line @typescript-eslint/triple-slash-reference
-  /// <reference types="source-map-js" />
-  const ERROR_DOMAIN = 'parser';
-  function createCodeGenerator(ast, options) {
-      const { sourceMap, filename, breakLineCode, needIndent: _needIndent } = options;
-      const location = options.location !== false;
+  function createTransformer(ast, options = {} // eslint-disable-line
+  ) {
       const _context = {
-          filename,
-          code: '',
-          column: 1,
-          line: 1,
-          offset: 0,
-          map: undefined,
-          breakLineCode,
-          needIndent: _needIndent,
-          indentLevel: 0
+          ast,
+          helpers: new Set()
       };
-      if (location && ast.loc) {
-          _context.source = ast.loc.source;
-      }
       const context = () => _context;
-      function push(code, node) {
-          _context.code += code;
-      }
-      function _newline(n, withBreakLine = true) {
-          const _breakLineCode = withBreakLine ? breakLineCode : '';
-          push(_needIndent ? _breakLineCode + `  `.repeat(n) : _breakLineCode);
-      }
-      function indent(withNewLine = true) {
-          const level = ++_context.indentLevel;
-          withNewLine && _newline(level);
-      }
-      function deindent(withNewLine = true) {
-          const level = --_context.indentLevel;
-          withNewLine && _newline(level);
-      }
-      function newline() {
-          _newline(_context.indentLevel);
-      }
-      const helper = (key) => `_${key}`;
-      const needIndent = () => _context.needIndent;
-      return {
-          context,
-          push,
-          indent,
-          deindent,
-          newline,
-          helper,
-          needIndent
+      const helper = (name) => {
+          _context.helpers.add(name);
+          return name;
       };
+      return { context, helper };
   }
-  function generateLinkedNode(generator, node) {
-      const { helper } = generator;
-      generator.push(`${helper("linked" /* HelperNameMap.LINKED */)}(`);
-      generateNode(generator, node.key);
-      if (node.modifier) {
-          generator.push(`, `);
-          generateNode(generator, node.modifier);
-          generator.push(`, _type`);
-      }
-      else {
-          generator.push(`, undefined, _type`);
-      }
-      generator.push(`)`);
-  }
-  function generateMessageNode(generator, node) {
-      const { helper, needIndent } = generator;
-      generator.push(`${helper("normalize" /* HelperNameMap.NORMALIZE */)}([`);
-      generator.indent(needIndent());
-      const length = node.items.length;
-      for (let i = 0; i < length; i++) {
-          generateNode(generator, node.items[i]);
-          if (i === length - 1) {
-              break;
-          }
-          generator.push(', ');
-      }
-      generator.deindent(needIndent());
-      generator.push('])');
-  }
-  function generatePluralNode(generator, node) {
-      const { helper, needIndent } = generator;
-      if (node.cases.length > 1) {
-          generator.push(`${helper("plural" /* HelperNameMap.PLURAL */)}([`);
-          generator.indent(needIndent());
-          const length = node.cases.length;
-          for (let i = 0; i < length; i++) {
-              generateNode(generator, node.cases[i]);
-              if (i === length - 1) {
-                  break;
-              }
-              generator.push(', ');
-          }
-          generator.deindent(needIndent());
-          generator.push(`])`);
-      }
-  }
-  function generateResource(generator, node) {
-      if (node.body) {
-          generateNode(generator, node.body);
-      }
-      else {
-          generator.push('null');
+  function traverseNodes(nodes, transformer) {
+      for (let i = 0; i < nodes.length; i++) {
+          traverseNode(nodes[i], transformer);
       }
   }
-  function generateNode(generator, node) {
-      const { helper } = generator;
+  function traverseNode(node, transformer) {
+      // TODO: if we need pre-hook of transform, should be implemented to here
       switch (node.type) {
-          case 0 /* NodeTypes.Resource */:
-              generateResource(generator, node);
-              break;
           case 1 /* NodeTypes.Plural */:
-              generatePluralNode(generator, node);
+              traverseNodes(node.cases, transformer);
+              transformer.helper("plural" /* HelperNameMap.PLURAL */);
               break;
           case 2 /* NodeTypes.Message */:
-              generateMessageNode(generator, node);
-              break;
-          case 6 /* NodeTypes.Linked */:
-              generateLinkedNode(generator, node);
-              break;
-          case 8 /* NodeTypes.LinkedModifier */:
-              generator.push(JSON.stringify(node.value), node);
+              traverseNodes(node.items, transformer);
               break;
-          case 7 /* NodeTypes.LinkedKey */:
-              generator.push(JSON.stringify(node.value), node);
+          case 6 /* NodeTypes.Linked */: {
+              const linked = node;
+              traverseNode(linked.key, transformer);
+              transformer.helper("linked" /* HelperNameMap.LINKED */);
+              transformer.helper("type" /* HelperNameMap.TYPE */);
               break;
+          }
           case 5 /* NodeTypes.List */:
-              generator.push(`${helper("interpolate" /* HelperNameMap.INTERPOLATE */)}(${helper("list" /* HelperNameMap.LIST */)}(${node.index}))`, node);
+              transformer.helper("interpolate" /* HelperNameMap.INTERPOLATE */);
+              transformer.helper("list" /* HelperNameMap.LIST */);
               break;
           case 4 /* NodeTypes.Named */:
-              generator.push(`${helper("interpolate" /* HelperNameMap.INTERPOLATE */)}(${helper("named" /* HelperNameMap.NAMED */)}(${JSON.stringify(node.key)}))`, node);
-              break;
-          case 9 /* NodeTypes.Literal */:
-              generator.push(JSON.stringify(node.value), node);
-              break;
-          case 3 /* NodeTypes.Text */:
-              generator.push(JSON.stringify(node.value), node);
+              transformer.helper("interpolate" /* HelperNameMap.INTERPOLATE */);
+              transformer.helper("named" /* HelperNameMap.NAMED */);
               break;
-          default:
-              {
-                  throw createCompileError(CompileErrorCodes.UNHANDLED_CODEGEN_NODE_TYPE, null, {
-                      domain: ERROR_DOMAIN,
-                      args: [node.type]
-                  });
-              }
       }
+      // TODO: if we need post-hook of transform, should be implemented to here
+  }
+  // transform AST
+  function transform(ast, options = {} // eslint-disable-line
+  ) {
+      const transformer = createTransformer(ast);
+      transformer.helper("normalize" /* HelperNameMap.NORMALIZE */);
+      // traverse
+      ast.body && traverseNode(ast.body, transformer);
+      // set meta information
+      const context = transformer.context();
+      ast.helpers = Array.from(context.helpers);
   }
-  // generate code from AST
-  const generate = (ast, options = {}) => {
-      const mode = isString(options.mode) ? options.mode : 'normal';
-      const filename = isString(options.filename)
-          ? options.filename
-          : 'message.intl';
-      const sourceMap = !!options.sourceMap;
-      // prettier-ignore
-      const breakLineCode = options.breakLineCode != null
-          ? options.breakLineCode
-          : mode === 'arrow'
-              ? ';'
-              : '\n';
-      const needIndent = options.needIndent ? options.needIndent : mode !== 'arrow';
-      const helpers = ast.helpers || [];
-      const generator = createCodeGenerator(ast, {
-          mode,
-          filename,
-          sourceMap,
-          breakLineCode,
-          needIndent
-      });
-      generator.push(mode === 'normal' ? `function __msg__ (ctx) {` : `(ctx) => {`);
-      generator.indent(needIndent);
-      if (helpers.length > 0) {
-          generator.push(`const { ${join(helpers.map(s => `${s}: _${s}`), ', ')} } = ctx`);
-          generator.newline();
-      }
-      generator.push(`return `);
-      generateNode(generator, ast);
-      generator.deindent(needIndent);
-      generator.push(`}`);
-      delete ast.helpers;
-      const { code, map } = generator.context();
-      return {
-          ast,
-          code,
-          map: map ? map.toJSON() : undefined // eslint-disable-line @typescript-eslint/no-explicit-any
-      };
-  };
 
   function baseCompile(source, options = {}) {
       const assignedOptions = assign({}, options);
       const jit = !!assignedOptions.jit;
-      const enalbeMinify = !!assignedOptions.minify;
-      const enambeOptimize = assignedOptions.optimize == null ? true : assignedOptions.optimize;
+      const enableMangle = !!assignedOptions.mangle;
+      const enableOptimize = assignedOptions.optimize == null ? true : assignedOptions.optimize;
       // parse source codes
       const parser = createParser(assignedOptions);
       const ast = parser.parse(source);
+      // TODO:
+      // With the introduction of Jit compilation, code generation is no longer necessary. This function may no longer be needed since tree-shaking is not possible.
       if (!jit) {
           // transform ASTs
           transform(ast, assignedOptions);
@@ -1532,17 +1530,21 @@ var IntlifyMessageCompiler = (function (exports) {
       }
       else {
           // optimize ASTs
-          enambeOptimize && optimize(ast);
+          enableOptimize && optimize(ast);
           // minimize ASTs
-          enalbeMinify && minify(ast);
+          enableMangle && mangle(ast);
           // In JIT mode, no ast transform, no code generation.
           return { ast, code: '' };
       }
   }
 
+  // eslint-disable-next-line no-useless-escape
+  const RE_HTML_TAG = /<\/?[\w\s="/.':;#-\/]+>/;
+  const detectHtmlTag = (source) => RE_HTML_TAG.test(source);
+
   exports.COMPILE_ERROR_CODES_EXTEND_POINT = COMPILE_ERROR_CODES_EXTEND_POINT;
   exports.CompileErrorCodes = CompileErrorCodes;
-  exports.ERROR_DOMAIN = ERROR_DOMAIN$2;
+  exports.ERROR_DOMAIN = ERROR_DOMAIN;
   exports.LOCATION_STUB = LOCATION_STUB;
   exports.baseCompile = baseCompile;
   exports.createCompileError = createCompileError;
@@ -1552,6 +1554,8 @@ var IntlifyMessageCompiler = (function (exports) {
   exports.defaultOnError = defaultOnError;
   exports.detectHtmlTag = detectHtmlTag;
   exports.errorMessages = errorMessages;
+  exports.mangle = mangle;
+  exports.optimize = optimize;
 
   return exports;