service-flow-designer 0.0.1-beta.5 → 0.0.1-beta.6

package/dist/es/node_modules/.pnpm/@intlify_message-compiler@9.13.1/node_modules/@intlify/message-compiler/dist/message-compiler.esm-browser.js

@@ -1,1567 +0,0 @@
-/*!
-  * message-compiler v9.13.1
-  * (c) 2024 kazuya kawaguchi
-  * Released under the MIT License.
-  */
-function createPosition(line, column, offset) {
-  return { line, column, offset };
-}
-function createLocation(start, end, source) {
-  const loc = { start, end };
-  return loc;
-}
-const RE_ARGS = /\{([0-9a-zA-Z]+)\}/g;
-function format(message, ...args) {
-  if (args.length === 1 && isObject(args[0])) {
-    args = args[0];
-  }
-  if (!args || !args.hasOwnProperty) {
-    args = {};
-  }
-  return message.replace(RE_ARGS, (match, identifier) => {
-    return args.hasOwnProperty(identifier) ? args[identifier] : "";
-  });
-}
-const assign = Object.assign;
-const isString = (val) => typeof val === "string";
-const isObject = (val) => val !== null && typeof val === "object";
-function join(items, separator = "") {
-  return items.reduce((str, item, index) => index === 0 ? str + item : str + separator + item, "");
-}
-const CompileWarnCodes = {
-  USE_MODULO_SYNTAX: 1,
-  __EXTEND_POINT__: 2
-};
-const warnMessages = {
-  [CompileWarnCodes.USE_MODULO_SYNTAX]: `Use modulo before '{{0}}'.`
-};
-function createCompileWarn(code, loc, ...args) {
-  const msg = format(warnMessages[code], ...args || []);
-  const message = { message: String(msg), code };
-  if (loc) {
-    message.location = loc;
-  }
-  return message;
-}
-const CompileErrorCodes = {
-  // tokenizer error codes
-  EXPECTED_TOKEN: 1,
-  INVALID_TOKEN_IN_PLACEHOLDER: 2,
-  UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER: 3,
-  UNKNOWN_ESCAPE_SEQUENCE: 4,
-  INVALID_UNICODE_ESCAPE_SEQUENCE: 5,
-  UNBALANCED_CLOSING_BRACE: 6,
-  UNTERMINATED_CLOSING_BRACE: 7,
-  EMPTY_PLACEHOLDER: 8,
-  NOT_ALLOW_NEST_PLACEHOLDER: 9,
-  INVALID_LINKED_FORMAT: 10,
-  // parser error codes
-  MUST_HAVE_MESSAGES_IN_PLURAL: 11,
-  UNEXPECTED_EMPTY_LINKED_MODIFIER: 12,
-  UNEXPECTED_EMPTY_LINKED_KEY: 13,
-  UNEXPECTED_LEXICAL_ANALYSIS: 14,
-  // generator error codes
-  UNHANDLED_CODEGEN_NODE_TYPE: 15,
-  // minifier error codes
-  UNHANDLED_MINIFIER_NODE_TYPE: 16,
-  // Special value for higher-order compilers to pick up the last code
-  // to avoid collision of error codes. This should always be kept as the last
-  // item.
-  __EXTEND_POINT__: 17
-};
-const errorMessages = {
-  // tokenizer error messages
-  [CompileErrorCodes.EXPECTED_TOKEN]: `Expected token: '{0}'`,
-  [CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER]: `Invalid token in placeholder: '{0}'`,
-  [CompileErrorCodes.UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER]: `Unterminated single quote in placeholder`,
-  [CompileErrorCodes.UNKNOWN_ESCAPE_SEQUENCE]: `Unknown escape sequence: \\{0}`,
-  [CompileErrorCodes.INVALID_UNICODE_ESCAPE_SEQUENCE]: `Invalid unicode escape sequence: {0}`,
-  [CompileErrorCodes.UNBALANCED_CLOSING_BRACE]: `Unbalanced closing brace`,
-  [CompileErrorCodes.UNTERMINATED_CLOSING_BRACE]: `Unterminated closing brace`,
-  [CompileErrorCodes.EMPTY_PLACEHOLDER]: `Empty placeholder`,
-  [CompileErrorCodes.NOT_ALLOW_NEST_PLACEHOLDER]: `Not allowed nest placeholder`,
-  [CompileErrorCodes.INVALID_LINKED_FORMAT]: `Invalid linked format`,
-  // parser error messages
-  [CompileErrorCodes.MUST_HAVE_MESSAGES_IN_PLURAL]: `Plural must have messages`,
-  [CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_MODIFIER]: `Unexpected empty linked modifier`,
-  [CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_KEY]: `Unexpected empty linked key`,
-  [CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS]: `Unexpected lexical analysis in token: '{0}'`,
-  // generator error messages
-  [CompileErrorCodes.UNHANDLED_CODEGEN_NODE_TYPE]: `unhandled codegen node type: '{0}'`,
-  // minimizer error messages
-  [CompileErrorCodes.UNHANDLED_MINIFIER_NODE_TYPE]: `unhandled mimifier node type: '{0}'`
-};
-function createCompileError(code, loc, options = {}) {
-  const { domain, messages, args } = options;
-  const msg = format((messages || errorMessages)[code] || "", ...args || []);
-  const error = new SyntaxError(String(msg));
-  error.code = code;
-  if (loc) {
-    error.location = loc;
-  }
-  error.domain = domain;
-  return error;
-}
-function defaultOnError(error) {
-  throw error;
-}
-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(8232);
-const CHAR_PS = String.fromCharCode(8233);
-function createScanner(str) {
-  const _buf = str;
-  let _index = 0;
-  let _line = 1;
-  let _column = 1;
-  let _peekOffset = 0;
-  const isCRLF = (index2) => _buf[index2] === CHAR_CR && _buf[index2 + 1] === CHAR_LF;
-  const isLF = (index2) => _buf[index2] === CHAR_LF;
-  const isPS = (index2) => _buf[index2] === CHAR_PS;
-  const isLS = (index2) => _buf[index2] === CHAR_LS;
-  const isLineEnd = (index2) => isCRLF(index2) || isLF(index2) || isPS(index2) || isLS(index2);
-  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 = void 0;
-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: 14,
-    offset: _initOffset,
-    startLoc: _initLoc,
-    endLoc: _initLoc,
-    lastType: 14,
-    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 getToken(context2, type, value) {
-    context2.endLoc = currentPosition();
-    context2.currentType = type;
-    const token = { type };
-    if (location) {
-      token.loc = createLocation(context2.startLoc, context2.endLoc);
-    }
-    if (value != null) {
-      token.value = value;
-    }
-    return token;
-  }
-  const getEndToken = (context2) => getToken(
-    context2,
-    14
-    /* 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
-    cc === 95;
-  }
-  function isNumberStart(ch) {
-    if (ch === EOF) {
-      return false;
-    }
-    const cc = ch.charCodeAt(0);
-    return cc >= 48 && cc <= 57;
-  }
-  function isNamedIdentifierStart(scnr, context2) {
-    const { currentType } = context2;
-    if (currentType !== 2) {
-      return false;
-    }
-    peekSpaces(scnr);
-    const ret = isIdentifierStart(scnr.currentPeek());
-    scnr.resetPeek();
-    return ret;
-  }
-  function isListIdentifierStart(scnr, context2) {
-    const { currentType } = context2;
-    if (currentType !== 2) {
-      return false;
-    }
-    peekSpaces(scnr);
-    const ch = scnr.currentPeek() === "-" ? scnr.peek() : scnr.currentPeek();
-    const ret = isNumberStart(ch);
-    scnr.resetPeek();
-    return ret;
-  }
-  function isLiteralStart(scnr, context2) {
-    const { currentType } = context2;
-    if (currentType !== 2) {
-      return false;
-    }
-    peekSpaces(scnr);
-    const ret = scnr.currentPeek() === LITERAL_DELIMITER;
-    scnr.resetPeek();
-    return ret;
-  }
-  function isLinkedDotStart(scnr, context2) {
-    const { currentType } = context2;
-    if (currentType !== 8) {
-      return false;
-    }
-    peekSpaces(scnr);
-    const ret = scnr.currentPeek() === ".";
-    scnr.resetPeek();
-    return ret;
-  }
-  function isLinkedModifierStart(scnr, context2) {
-    const { currentType } = context2;
-    if (currentType !== 9) {
-      return false;
-    }
-    peekSpaces(scnr);
-    const ret = isIdentifierStart(scnr.currentPeek());
-    scnr.resetPeek();
-    return ret;
-  }
-  function isLinkedDelimiterStart(scnr, context2) {
-    const { currentType } = context2;
-    if (!(currentType === 8 || currentType === 12)) {
-      return false;
-    }
-    peekSpaces(scnr);
-    const ret = scnr.currentPeek() === ":";
-    scnr.resetPeek();
-    return ret;
-  }
-  function isLinkedReferStart(scnr, context2) {
-    const { currentType } = context2;
-    if (currentType !== 10) {
-      return false;
-    }
-    const fn = () => {
-      const ch = scnr.currentPeek();
-      if (ch === "{") {
-        return isIdentifierStart(scnr.peek());
-      } else if (ch === "@" || ch === "%" || ch === "|" || ch === ":" || ch === "." || ch === CHAR_SP || !ch) {
-        return false;
-      } else if (ch === CHAR_LF) {
-        scnr.peek();
-        return fn();
-      } else {
-        return isTextStart(scnr, false);
-      }
-    };
-    const ret = fn();
-    scnr.resetPeek();
-    return ret;
-  }
-  function isPluralStart(scnr) {
-    peekSpaces(scnr);
-    const ret = scnr.currentPeek() === "|";
-    scnr.resetPeek();
-    return ret;
-  }
-  function detectModuloStart(scnr) {
-    const spaces = peekSpaces(scnr);
-    const ret = scnr.currentPeek() === "%" && scnr.peek() === "{";
-    scnr.resetPeek();
-    return {
-      isModulo: ret,
-      hasSpace: spaces.length > 0
-    };
-  }
-  function isTextStart(scnr, reset = true) {
-    const fn = (hasSpace = false, prev = "", detectModulo = false) => {
-      const ch = scnr.currentPeek();
-      if (ch === "{") {
-        return prev === "%" ? false : hasSpace;
-      } else if (ch === "@" || !ch) {
-        return prev === "%" ? true : hasSpace;
-      } else if (ch === "%") {
-        scnr.peek();
-        return fn(hasSpace, "%", true);
-      } else if (ch === "|") {
-        return prev === "%" || detectModulo ? true : !(prev === CHAR_SP || prev === CHAR_LF);
-      } else if (ch === CHAR_SP) {
-        scnr.peek();
-        return fn(true, CHAR_SP, detectModulo);
-      } else if (ch === CHAR_LF) {
-        scnr.peek();
-        return fn(true, CHAR_LF, detectModulo);
-      } else {
-        return true;
-      }
-    };
-    const ret = fn();
-    reset && scnr.resetPeek();
-    return ret;
-  }
-  function takeChar(scnr, fn) {
-    const ch = scnr.currentChar();
-    if (ch === EOF) {
-      return EOF;
-    }
-    if (fn(ch)) {
-      scnr.next();
-      return ch;
-    }
-    return null;
-  }
-  function isIdentifier(ch) {
-    const cc = ch.charCodeAt(0);
-    return cc >= 97 && cc <= 122 || // a-z
-    cc >= 65 && cc <= 90 || // A-Z
-    cc >= 48 && cc <= 57 || // 0-9
-    cc === 95 || // _
-    cc === 36;
-  }
-  function takeIdentifierChar(scnr) {
-    return takeChar(scnr, isIdentifier);
-  }
-  function isNamedIdentifier(ch) {
-    const cc = ch.charCodeAt(0);
-    return cc >= 97 && cc <= 122 || // a-z
-    cc >= 65 && cc <= 90 || // A-Z
-    cc >= 48 && cc <= 57 || // 0-9
-    cc === 95 || // _
-    cc === 36 || // $
-    cc === 45;
-  }
-  function takeNamedIdentifierChar(scnr) {
-    return takeChar(scnr, isNamedIdentifier);
-  }
-  function isDigit(ch) {
-    const cc = ch.charCodeAt(0);
-    return cc >= 48 && cc <= 57;
-  }
-  function takeDigit(scnr) {
-    return takeChar(scnr, isDigit);
-  }
-  function isHexDigit(ch) {
-    const cc = ch.charCodeAt(0);
-    return cc >= 48 && cc <= 57 || // 0-9
-    cc >= 65 && cc <= 70 || // A-F
-    cc >= 97 && cc <= 102;
-  }
-  function takeHexDigit(scnr) {
-    return takeChar(scnr, isHexDigit);
-  }
-  function getDigits(scnr) {
-    let ch = "";
-    let num = "";
-    while (ch = takeDigit(scnr)) {
-      num += ch;
-    }
-    return num;
-  }
-  function readModulo(scnr) {
-    skipSpaces(scnr);
-    const ch = scnr.currentChar();
-    if (ch !== "%") {
-      emitError(CompileErrorCodes.EXPECTED_TOKEN, currentPosition(), 0, ch);
-    }
-    scnr.next();
-    return "%";
-  }
-  function readText(scnr) {
-    let buf = "";
-    while (true) {
-      const ch = scnr.currentChar();
-      if (ch === "{" || ch === "}" || ch === "@" || ch === "|" || !ch) {
-        break;
-      } else if (ch === "%") {
-        if (isTextStart(scnr)) {
-          buf += ch;
-          scnr.next();
-        } else {
-          break;
-        }
-      } else if (ch === CHAR_SP || ch === CHAR_LF) {
-        if (isTextStart(scnr)) {
-          buf += ch;
-          scnr.next();
-        } else if (isPluralStart(scnr)) {
-          break;
-        } else {
-          buf += ch;
-          scnr.next();
-        }
-      } else {
-        buf += ch;
-        scnr.next();
-      }
-    }
-    return buf;
-  }
-  function readNamedIdentifier(scnr) {
-    skipSpaces(scnr);
-    let ch = "";
-    let name = "";
-    while (ch = takeNamedIdentifierChar(scnr)) {
-      name += ch;
-    }
-    if (scnr.currentChar() === EOF) {
-      emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
-    }
-    return name;
-  }
-  function readListIdentifier(scnr) {
-    skipSpaces(scnr);
-    let value = "";
-    if (scnr.currentChar() === "-") {
-      scnr.next();
-      value += `-${getDigits(scnr)}`;
-    } else {
-      value += getDigits(scnr);
-    }
-    if (scnr.currentChar() === EOF) {
-      emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
-    }
-    return value;
-  }
-  function isLiteral(ch) {
-    return ch !== LITERAL_DELIMITER && ch !== CHAR_LF;
-  }
-  function readLiteral(scnr) {
-    skipSpaces(scnr);
-    eat(scnr, `'`);
-    let ch = "";
-    let literal = "";
-    while (ch = takeChar(scnr, isLiteral)) {
-      if (ch === "\\") {
-        literal += readEscapeSequence(scnr);
-      } else {
-        literal += ch;
-      }
-    }
-    const current = scnr.currentChar();
-    if (current === CHAR_LF || current === EOF) {
-      emitError(CompileErrorCodes.UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER, currentPosition(), 0);
-      if (current === CHAR_LF) {
-        scnr.next();
-        eat(scnr, `'`);
-      }
-      return literal;
-    }
-    eat(scnr, `'`);
-    return literal;
-  }
-  function readEscapeSequence(scnr) {
-    const ch = scnr.currentChar();
-    switch (ch) {
-      case "\\":
-      case `'`:
-        scnr.next();
-        return `\\${ch}`;
-      case "u":
-        return readUnicodeEscapeSequence(scnr, ch, 4);
-      case "U":
-        return readUnicodeEscapeSequence(scnr, ch, 6);
-      default:
-        emitError(CompileErrorCodes.UNKNOWN_ESCAPE_SEQUENCE, currentPosition(), 0, ch);
-        return "";
-    }
-  }
-  function readUnicodeEscapeSequence(scnr, unicode, digits) {
-    eat(scnr, unicode);
-    let sequence = "";
-    for (let i = 0; i < digits; i++) {
-      const ch = takeHexDigit(scnr);
-      if (!ch) {
-        emitError(CompileErrorCodes.INVALID_UNICODE_ESCAPE_SEQUENCE, currentPosition(), 0, `\\${unicode}${sequence}${scnr.currentChar()}`);
-        break;
-      }
-      sequence += ch;
-    }
-    return `\\${unicode}${sequence}`;
-  }
-  function isInvalidIdentifier(ch) {
-    return ch !== "{" && ch !== "}" && ch !== CHAR_SP && ch !== CHAR_LF;
-  }
-  function readInvalidIdentifier(scnr) {
-    skipSpaces(scnr);
-    let ch = "";
-    let identifiers = "";
-    while (ch = takeChar(scnr, isInvalidIdentifier)) {
-      identifiers += ch;
-    }
-    return identifiers;
-  }
-  function readLinkedModifier(scnr) {
-    let ch = "";
-    let name = "";
-    while (ch = takeIdentifierChar(scnr)) {
-      name += ch;
-    }
-    return name;
-  }
-  function readLinkedRefer(scnr) {
-    const fn = (buf) => {
-      const ch = scnr.currentChar();
-      if (ch === "{" || ch === "%" || ch === "@" || ch === "|" || ch === "(" || ch === ")" || !ch) {
-        return buf;
-      } else if (ch === CHAR_SP) {
-        return buf;
-      } else if (ch === CHAR_LF || ch === DOT) {
-        buf += ch;
-        scnr.next();
-        return fn(buf);
-      } else {
-        buf += ch;
-        scnr.next();
-        return fn(buf);
-      }
-    };
-    return fn("");
-  }
-  function readPlural(scnr) {
-    skipSpaces(scnr);
-    const plural = eat(
-      scnr,
-      "|"
-      /* TokenChars.Pipe */
-    );
-    skipSpaces(scnr);
-    return plural;
-  }
-  function readTokenInPlaceholder(scnr, context2) {
-    let token = null;
-    const ch = scnr.currentChar();
-    switch (ch) {
-      case "{":
-        if (context2.braceNest >= 1) {
-          emitError(CompileErrorCodes.NOT_ALLOW_NEST_PLACEHOLDER, currentPosition(), 0);
-        }
-        scnr.next();
-        token = getToken(
-          context2,
-          2,
-          "{"
-          /* TokenChars.BraceLeft */
-        );
-        skipSpaces(scnr);
-        context2.braceNest++;
-        return token;
-      case "}":
-        if (context2.braceNest > 0 && context2.currentType === 2) {
-          emitError(CompileErrorCodes.EMPTY_PLACEHOLDER, currentPosition(), 0);
-        }
-        scnr.next();
-        token = getToken(
-          context2,
-          3,
-          "}"
-          /* TokenChars.BraceRight */
-        );
-        context2.braceNest--;
-        context2.braceNest > 0 && skipSpaces(scnr);
-        if (context2.inLinked && context2.braceNest === 0) {
-          context2.inLinked = false;
-        }
-        return token;
-      case "@":
-        if (context2.braceNest > 0) {
-          emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
-        }
-        token = readTokenInLinked(scnr, context2) || getEndToken(context2);
-        context2.braceNest = 0;
-        return token;
-      default: {
-        let validNamedIdentifier = true;
-        let validListIdentifier = true;
-        let validLiteral = true;
-        if (isPluralStart(scnr)) {
-          if (context2.braceNest > 0) {
-            emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
-          }
-          token = getToken(context2, 1, readPlural(scnr));
-          context2.braceNest = 0;
-          context2.inLinked = false;
-          return token;
-        }
-        if (context2.braceNest > 0 && (context2.currentType === 5 || context2.currentType === 6 || context2.currentType === 7)) {
-          emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
-          context2.braceNest = 0;
-          return readToken(scnr, context2);
-        }
-        if (validNamedIdentifier = isNamedIdentifierStart(scnr, context2)) {
-          token = getToken(context2, 5, readNamedIdentifier(scnr));
-          skipSpaces(scnr);
-          return token;
-        }
-        if (validListIdentifier = isListIdentifierStart(scnr, context2)) {
-          token = getToken(context2, 6, readListIdentifier(scnr));
-          skipSpaces(scnr);
-          return token;
-        }
-        if (validLiteral = isLiteralStart(scnr, context2)) {
-          token = getToken(context2, 7, readLiteral(scnr));
-          skipSpaces(scnr);
-          return token;
-        }
-        if (!validNamedIdentifier && !validListIdentifier && !validLiteral) {
-          token = getToken(context2, 13, readInvalidIdentifier(scnr));
-          emitError(CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER, currentPosition(), 0, token.value);
-          skipSpaces(scnr);
-          return token;
-        }
-        break;
-      }
-    }
-    return token;
-  }
-  function readTokenInLinked(scnr, context2) {
-    const { currentType } = context2;
-    let token = null;
-    const ch = scnr.currentChar();
-    if ((currentType === 8 || currentType === 9 || currentType === 12 || currentType === 10) && (ch === CHAR_LF || ch === CHAR_SP)) {
-      emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
-    }
-    switch (ch) {
-      case "@":
-        scnr.next();
-        token = getToken(
-          context2,
-          8,
-          "@"
-          /* TokenChars.LinkedAlias */
-        );
-        context2.inLinked = true;
-        return token;
-      case ".":
-        skipSpaces(scnr);
-        scnr.next();
-        return getToken(
-          context2,
-          9,
-          "."
-          /* TokenChars.LinkedDot */
-        );
-      case ":":
-        skipSpaces(scnr);
-        scnr.next();
-        return getToken(
-          context2,
-          10,
-          ":"
-          /* TokenChars.LinkedDelimiter */
-        );
-      default:
-        if (isPluralStart(scnr)) {
-          token = getToken(context2, 1, readPlural(scnr));
-          context2.braceNest = 0;
-          context2.inLinked = false;
-          return token;
-        }
-        if (isLinkedDotStart(scnr, context2) || isLinkedDelimiterStart(scnr, context2)) {
-          skipSpaces(scnr);
-          return readTokenInLinked(scnr, context2);
-        }
-        if (isLinkedModifierStart(scnr, context2)) {
-          skipSpaces(scnr);
-          return getToken(context2, 12, readLinkedModifier(scnr));
-        }
-        if (isLinkedReferStart(scnr, context2)) {
-          skipSpaces(scnr);
-          if (ch === "{") {
-            return readTokenInPlaceholder(scnr, context2) || token;
-          } else {
-            return getToken(context2, 11, readLinkedRefer(scnr));
-          }
-        }
-        if (currentType === 8) {
-          emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
-        }
-        context2.braceNest = 0;
-        context2.inLinked = false;
-        return readToken(scnr, context2);
-    }
-  }
-  function readToken(scnr, context2) {
-    let token = {
-      type: 14
-      /* TokenTypes.EOF */
-    };
-    if (context2.braceNest > 0) {
-      return readTokenInPlaceholder(scnr, context2) || getEndToken(context2);
-    }
-    if (context2.inLinked) {
-      return readTokenInLinked(scnr, context2) || getEndToken(context2);
-    }
-    const ch = scnr.currentChar();
-    switch (ch) {
-      case "{":
-        return readTokenInPlaceholder(scnr, context2) || getEndToken(context2);
-      case "}":
-        emitError(CompileErrorCodes.UNBALANCED_CLOSING_BRACE, currentPosition(), 0);
-        scnr.next();
-        return getToken(
-          context2,
-          3,
-          "}"
-          /* TokenChars.BraceRight */
-        );
-      case "@":
-        return readTokenInLinked(scnr, context2) || getEndToken(context2);
-      default: {
-        if (isPluralStart(scnr)) {
-          token = getToken(context2, 1, readPlural(scnr));
-          context2.braceNest = 0;
-          context2.inLinked = false;
-          return token;
-        }
-        const { isModulo, hasSpace } = detectModuloStart(scnr);
-        if (isModulo) {
-          return hasSpace ? getToken(context2, 0, readText(scnr)) : getToken(context2, 4, readModulo(scnr));
-        }
-        if (isTextStart(scnr)) {
-          return getToken(context2, 0, readText(scnr));
-        }
-        break;
-      }
-    }
-    return token;
-  }
-  function nextToken() {
-    const { currentType, offset, startLoc, endLoc } = _context;
-    _context.lastType = currentType;
-    _context.lastOffset = offset;
-    _context.lastStartLoc = startLoc;
-    _context.lastEndLoc = endLoc;
-    _context.offset = currentOffset();
-    _context.startLoc = currentPosition();
-    if (_scnr.currentChar() === EOF) {
-      return getToken(
-        _context,
-        14
-        /* TokenTypes.EOF */
-      );
-    }
-    return readToken(_scnr, _context);
-  }
-  return {
-    nextToken,
-    currentOffset,
-    currentPosition,
-    context
-  };
-}
-const ERROR_DOMAIN$2 = "parser";
-const KNOWN_ESCAPES = /(?:\\\\|\\'|\\u([0-9a-fA-F]{4})|\\U([0-9a-fA-F]{6}))/g;
-function fromEscapeSequence(match, codePoint4, codePoint6) {
-  switch (match) {
-    case `\\\\`:
-      return `\\`;
-    case `\\'`:
-      return `'`;
-    default: {
-      const codePoint = parseInt(codePoint4 || codePoint6, 16);
-      if (codePoint <= 55295 || codePoint >= 57344) {
-        return String.fromCodePoint(codePoint);
-      }
-      return "�";
-    }
-  }
-}
-function createParser(options = {}) {
-  const location = options.location !== false;
-  const { onError, onWarn } = options;
-  function emitError(tokenzer, code, start, offset, ...args) {
-    const end = tokenzer.currentPosition();
-    end.offset += offset;
-    end.column += offset;
-    if (onError) {
-      const loc = location ? createLocation(start, end) : null;
-      const err = createCompileError(code, loc, {
-        domain: ERROR_DOMAIN$2,
-        args
-      });
-      onError(err);
-    }
-  }
-  function emitWarn(tokenzer, code, start, offset, ...args) {
-    const end = tokenzer.currentPosition();
-    end.offset += offset;
-    end.column += offset;
-    if (onWarn) {
-      const loc = location ? createLocation(start, end) : null;
-      onWarn(createCompileWarn(code, loc, args));
-    }
-  }
-  function startNode(type, offset, loc) {
-    const node = { type };
-    if (location) {
-      node.start = offset;
-      node.end = offset;
-      node.loc = { start: loc, end: loc };
-    }
-    return node;
-  }
-  function endNode(node, offset, pos, type) {
-    if (location) {
-      node.end = offset;
-      if (node.loc) {
-        node.loc.end = pos;
-      }
-    }
-  }
-  function parseText(tokenizer, value) {
-    const context = tokenizer.context();
-    const node = startNode(3, context.offset, context.startLoc);
-    node.value = value;
-    endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
-    return node;
-  }
-  function parseList(tokenizer, index) {
-    const context = tokenizer.context();
-    const { lastOffset: offset, lastStartLoc: loc } = context;
-    const node = startNode(5, offset, loc);
-    node.index = parseInt(index, 10);
-    tokenizer.nextToken();
-    endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
-    return node;
-  }
-  function parseNamed(tokenizer, key, modulo) {
-    const context = tokenizer.context();
-    const { lastOffset: offset, lastStartLoc: loc } = context;
-    const node = startNode(4, offset, loc);
-    node.key = key;
-    if (modulo === true) {
-      node.modulo = true;
-    }
-    tokenizer.nextToken();
-    endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
-    return node;
-  }
-  function parseLiteral(tokenizer, value) {
-    const context = tokenizer.context();
-    const { lastOffset: offset, lastStartLoc: loc } = context;
-    const node = startNode(9, offset, loc);
-    node.value = value.replace(KNOWN_ESCAPES, fromEscapeSequence);
-    tokenizer.nextToken();
-    endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
-    return node;
-  }
-  function parseLinkedModifier(tokenizer) {
-    const token = tokenizer.nextToken();
-    const context = tokenizer.context();
-    const { lastOffset: offset, lastStartLoc: loc } = context;
-    const node = startNode(8, offset, loc);
-    if (token.type !== 12) {
-      emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_MODIFIER, context.lastStartLoc, 0);
-      node.value = "";
-      endNode(node, offset, loc);
-      return {
-        nextConsumeToken: token,
-        node
-      };
-    }
-    if (token.value == null) {
-      emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
-    }
-    node.value = token.value || "";
-    endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
-    return {
-      node
-    };
-  }
-  function parseLinkedKey(tokenizer, value) {
-    const context = tokenizer.context();
-    const node = startNode(7, 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, context.offset, context.startLoc);
-    let token = tokenizer.nextToken();
-    if (token.type === 9) {
-      const parsed = parseLinkedModifier(tokenizer);
-      linkedNode.modifier = parsed.node;
-      token = parsed.nextConsumeToken || tokenizer.nextToken();
-    }
-    if (token.type !== 10) {
-      emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
-    }
-    token = tokenizer.nextToken();
-    if (token.type === 2) {
-      token = tokenizer.nextToken();
-    }
-    switch (token.type) {
-      case 11:
-        if (token.value == null) {
-          emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
-        }
-        linkedNode.key = parseLinkedKey(tokenizer, token.value || "");
-        break;
-      case 5:
-        if (token.value == null) {
-          emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
-        }
-        linkedNode.key = parseNamed(tokenizer, token.value || "");
-        break;
-      case 6:
-        if (token.value == null) {
-          emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
-        }
-        linkedNode.key = parseList(tokenizer, token.value || "");
-        break;
-      case 7:
-        if (token.value == null) {
-          emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
-        }
-        linkedNode.key = parseLiteral(tokenizer, token.value || "");
-        break;
-      default: {
-        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_KEY, context.lastStartLoc, 0);
-        const nextContext = tokenizer.context();
-        const emptyLinkedKeyNode = startNode(7, nextContext.offset, nextContext.startLoc);
-        emptyLinkedKeyNode.value = "";
-        endNode(emptyLinkedKeyNode, nextContext.offset, nextContext.startLoc);
-        linkedNode.key = emptyLinkedKeyNode;
-        endNode(linkedNode, nextContext.offset, nextContext.startLoc);
-        return {
-          nextConsumeToken: token,
-          node: linkedNode
-        };
-      }
-    }
-    endNode(linkedNode, tokenizer.currentOffset(), tokenizer.currentPosition());
-    return {
-      node: linkedNode
-    };
-  }
-  function parseMessage(tokenizer) {
-    const context = tokenizer.context();
-    const startOffset = context.currentType === 1 ? tokenizer.currentOffset() : context.offset;
-    const startLoc = context.currentType === 1 ? context.endLoc : context.startLoc;
-    const node = startNode(2, startOffset, startLoc);
-    node.items = [];
-    let nextToken = null;
-    let modulo = null;
-    do {
-      const token = nextToken || tokenizer.nextToken();
-      nextToken = null;
-      switch (token.type) {
-        case 0:
-          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:
-          if (token.value == null) {
-            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
-          }
-          node.items.push(parseList(tokenizer, token.value || ""));
-          break;
-        case 4:
-          modulo = true;
-          break;
-        case 5:
-          if (token.value == null) {
-            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
-          }
-          node.items.push(parseNamed(tokenizer, token.value || "", !!modulo));
-          if (modulo) {
-            emitWarn(tokenizer, CompileWarnCodes.USE_MODULO_SYNTAX, context.lastStartLoc, 0, getTokenCaption(token));
-            modulo = null;
-          }
-          break;
-        case 7:
-          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: {
-          const parsed = parseLinked(tokenizer);
-          node.items.push(parsed.node);
-          nextToken = parsed.nextConsumeToken || null;
-          break;
-        }
-      }
-    } while (context.currentType !== 14 && context.currentType !== 1);
-    const endOffset = context.currentType === 1 ? context.lastOffset : tokenizer.currentOffset();
-    const endLoc = context.currentType === 1 ? context.lastEndLoc : tokenizer.currentPosition();
-    endNode(node, endOffset, endLoc);
-    return node;
-  }
-  function parsePlural(tokenizer, offset, loc, msgNode) {
-    const context = tokenizer.context();
-    let hasEmptyMessage = msgNode.items.length === 0;
-    const node = startNode(1, offset, loc);
-    node.cases = [];
-    node.cases.push(msgNode);
-    do {
-      const msg = parseMessage(tokenizer);
-      if (!hasEmptyMessage) {
-        hasEmptyMessage = msg.items.length === 0;
-      }
-      node.cases.push(msg);
-    } while (context.currentType !== 14);
-    if (hasEmptyMessage) {
-      emitError(tokenizer, CompileErrorCodes.MUST_HAVE_MESSAGES_IN_PLURAL, loc, 0);
-    }
-    endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
-    return node;
-  }
-  function parseResource(tokenizer) {
-    const context = tokenizer.context();
-    const { offset, startLoc } = context;
-    const msgNode = parseMessage(tokenizer);
-    if (context.currentType === 14) {
-      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, context.offset, context.startLoc);
-    if (location && node.loc) {
-      node.loc.source = source;
-    }
-    node.body = parseResource(tokenizer);
-    if (options.onCacheKey) {
-      node.cacheKey = options.onCacheKey(source);
-    }
-    if (context.currentType !== 14) {
-      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 === 14) {
-    return "EOF";
-  }
-  const name = (token.value || "").replace(/\r?\n/gu, "\\n");
-  return name.length > 10 ? name.slice(0, 9) + "…" : name;
-}
-function createTransformer(ast, options = {}) {
-  const _context = {
-    ast,
-    helpers: /* @__PURE__ */ 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) {
-  switch (node.type) {
-    case 1:
-      traverseNodes(node.cases, transformer);
-      transformer.helper(
-        "plural"
-        /* HelperNameMap.PLURAL */
-      );
-      break;
-    case 2:
-      traverseNodes(node.items, transformer);
-      break;
-    case 6: {
-      const linked = node;
-      traverseNode(linked.key, transformer);
-      transformer.helper(
-        "linked"
-        /* HelperNameMap.LINKED */
-      );
-      transformer.helper(
-        "type"
-        /* HelperNameMap.TYPE */
-      );
-      break;
-    }
-    case 5:
-      transformer.helper(
-        "interpolate"
-        /* HelperNameMap.INTERPOLATE */
-      );
-      transformer.helper(
-        "list"
-        /* HelperNameMap.LIST */
-      );
-      break;
-    case 4:
-      transformer.helper(
-        "interpolate"
-        /* HelperNameMap.INTERPOLATE */
-      );
-      transformer.helper(
-        "named"
-        /* HelperNameMap.NAMED */
-      );
-      break;
-  }
-}
-function transform(ast, options = {}) {
-  const transformer = createTransformer(ast);
-  transformer.helper(
-    "normalize"
-    /* HelperNameMap.NORMALIZE */
-  );
-  ast.body && traverseNode(ast.body, transformer);
-  const context = transformer.context();
-  ast.helpers = Array.from(context.helpers);
-}
-function optimize(ast) {
-  const body = ast.body;
-  if (body.type === 2) {
-    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 || item.type === 9) {
-      message.static = item.value;
-      delete item.value;
-    }
-  } else {
-    const values = [];
-    for (let i = 0; i < message.items.length; i++) {
-      const item = message.items[i];
-      if (!(item.type === 3 || item.type === 9)) {
-        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 || item.type === 9) {
-          delete item.value;
-        }
-      }
-    }
-  }
-}
-const ERROR_DOMAIN$1 = "minifier";
-function minify(node) {
-  node.t = node.type;
-  switch (node.type) {
-    case 0: {
-      const resource = node;
-      minify(resource.body);
-      resource.b = resource.body;
-      delete resource.body;
-      break;
-    }
-    case 1: {
-      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: {
-      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:
-    case 9:
-    case 8:
-    case 7: {
-      const valueNode = node;
-      if (valueNode.value) {
-        valueNode.v = valueNode.value;
-        delete valueNode.value;
-      }
-      break;
-    }
-    case 6: {
-      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;
-    }
-    case 5: {
-      const list = node;
-      list.i = list.index;
-      delete list.index;
-      break;
-    }
-    case 4: {
-      const named = node;
-      named.k = named.key;
-      delete named.key;
-      break;
-    }
-    default: {
-      throw createCompileError(CompileErrorCodes.UNHANDLED_MINIFIER_NODE_TYPE, null, {
-        domain: ERROR_DOMAIN$1,
-        args: [node.type]
-      });
-    }
-  }
-  delete node.type;
-}
-const ERROR_DOMAIN = "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: void 0,
-    breakLineCode,
-    needIndent: _needIndent,
-    indentLevel: 0
-  };
-  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
-  };
-}
-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 generateNode(generator, node) {
-  const { helper } = generator;
-  switch (node.type) {
-    case 0:
-      generateResource(generator, node);
-      break;
-    case 1:
-      generatePluralNode(generator, node);
-      break;
-    case 2:
-      generateMessageNode(generator, node);
-      break;
-    case 6:
-      generateLinkedNode(generator, node);
-      break;
-    case 8:
-      generator.push(JSON.stringify(node.value), node);
-      break;
-    case 7:
-      generator.push(JSON.stringify(node.value), node);
-      break;
-    case 5:
-      generator.push(`${helper(
-        "interpolate"
-        /* HelperNameMap.INTERPOLATE */
-      )}(${helper(
-        "list"
-        /* HelperNameMap.LIST */
-      )}(${node.index}))`, node);
-      break;
-    case 4:
-      generator.push(`${helper(
-        "interpolate"
-        /* HelperNameMap.INTERPOLATE */
-      )}(${helper(
-        "named"
-        /* HelperNameMap.NAMED */
-      )}(${JSON.stringify(node.key)}))`, node);
-      break;
-    case 9:
-      generator.push(JSON.stringify(node.value), node);
-      break;
-    case 3:
-      generator.push(JSON.stringify(node.value), node);
-      break;
-    default: {
-      throw createCompileError(CompileErrorCodes.UNHANDLED_CODEGEN_NODE_TYPE, null, {
-        domain: ERROR_DOMAIN,
-        args: [node.type]
-      });
-    }
-  }
-}
-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;
-  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() : void 0
-    // 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 parser = createParser(assignedOptions);
-  const ast = parser.parse(source);
-  if (!jit) {
-    transform(ast, assignedOptions);
-    return generate(ast, assignedOptions);
-  } else {
-    enambeOptimize && optimize(ast);
-    enalbeMinify && minify(ast);
-    return { ast, code: "" };
-  }
-}
-export {
-  CompileErrorCodes,
-  CompileWarnCodes,
-  ERROR_DOMAIN$2 as ERROR_DOMAIN,
-  baseCompile,
-  createCompileError,
-  createCompileWarn,
-  createLocation,
-  createParser,
-  createPosition,
-  defaultOnError,
-  detectHtmlTag,
-  errorMessages,
-  warnMessages
-};