@dialpad/i18n 1.22.3 → 1.24.1

package/dist/i18n.cjs

@@ -765,7 +765,7 @@ var init_esm_shims$1 = __esm$1({
   }
 });
 var require_rfdc = __commonJS$1({
-  "../../node_modules/.pnpm/rfdc@1.4.1/node_modules/rfdc/index.js"(exports2, module2) {
+  "../../node_modules/.pnpm/rfdc@1.4.1/node_modules/rfdc/index.js"(exports$1, module2) {
     init_esm_shims$1();
     module2.exports = rfdc2;
     function copyBuffer(cur) {
@@ -1271,7 +1271,7 @@ var init_esm_shims = __esm({
   }
 });
 var require_speakingurl = __commonJS({
-  "../../node_modules/.pnpm/speakingurl@14.0.1/node_modules/speakingurl/lib/speakingurl.js"(exports2, module2) {
+  "../../node_modules/.pnpm/speakingurl@14.0.1/node_modules/speakingurl/lib/speakingurl.js"(exports$1, module2) {
     init_esm_shims();
     (function(root) {
       var charMap = {
@@ -2792,11 +2792,11 @@ var require_speakingurl = __commonJS({
         } catch (e) {
         }
       }
-    })(exports2);
+    })(exports$1);
   }
 });
 var require_speakingurl2 = __commonJS({
-  "../../node_modules/.pnpm/speakingurl@14.0.1/node_modules/speakingurl/index.js"(exports2, module2) {
+  "../../node_modules/.pnpm/speakingurl@14.0.1/node_modules/speakingurl/index.js"(exports$1, module2) {
     init_esm_shims();
     module2.exports = require_speakingurl();
   }
@@ -3358,7 +3358,7 @@ init_esm_shims();
 init_esm_shims();
 var TIMELINE_LAYERS_STATE_STORAGE_ID = "__VUE_DEVTOOLS_KIT_TIMELINE_LAYERS_STATE__";
 function getTimelineLayersStateFromStorage() {
-  if (!isBrowser || typeof localStorage === "undefined" || localStorage === null) {
+  if (typeof window === "undefined" || !isBrowser || typeof localStorage === "undefined" || localStorage === null) {
     return {
       recordingState: false,
       mouseEventEnabled: false,
@@ -3368,7 +3368,7 @@ function getTimelineLayersStateFromStorage() {
       selected: ""
     };
   }
-  const state = localStorage.getItem(TIMELINE_LAYERS_STATE_STORAGE_ID);
+  const state = typeof localStorage.getItem !== "undefined" ? localStorage.getItem(TIMELINE_LAYERS_STATE_STORAGE_ID) : null;
   return state ? JSON.parse(state) : {
     recordingState: false,
     mouseEventEnabled: false,
@@ -5579,889 +5579,889 @@ function createStorageWrapper() {
   }
   return globalThis.__i18nStorage;
 }
-class FluentType2 {
-  /**
-   * Create a `FluentType` instance.
-   *
-   * @param value The JavaScript value to wrap.
-   */
-  constructor(value) {
-    this.value = value;
-  }
-  /**
-   * Unwrap the raw value stored by this `FluentType`.
-   */
-  valueOf() {
-    return this.value;
-  }
-}
-class FluentNone2 extends FluentType2 {
-  /**
-   * Create an instance of `FluentNone` with an optional fallback value.
-   * @param value The fallback value of this `FluentNone`.
-   */
-  constructor(value = "???") {
-    super(value);
-  }
-  /**
-   * Format this `FluentNone` to the fallback string.
-   */
-  toString(scope) {
-    return `{${this.value}}`;
-  }
-}
-class FluentNumber2 extends FluentType2 {
-  /**
-   * Create an instance of `FluentNumber` with options to the
-   * `Intl.NumberFormat` constructor.
-   *
-   * @param value The number value of this `FluentNumber`.
-   * @param opts Options which will be passed to `Intl.NumberFormat`.
-   */
-  constructor(value, opts = {}) {
-    super(value);
-    this.opts = opts;
-  }
-  /**
-   * Format this `FluentNumber` to a string.
-   */
-  toString(scope) {
-    try {
-      const nf = scope.memoizeIntlObject(Intl.NumberFormat, this.opts);
-      return nf.format(this.value);
-    } catch (err) {
-      scope.reportError(err);
-      return this.value.toString(10);
+const RE_MESSAGE_START = /^(-?[a-zA-Z][\w-]*) *= */gm;
+const RE_ATTRIBUTE_START = /\.([a-zA-Z][\w-]*) *= */y;
+const RE_VARIANT_START = /\*?\[/y;
+const RE_NUMBER_LITERAL = /(-?[0-9]+(?:\.([0-9]+))?)/y;
+const RE_IDENTIFIER = /([a-zA-Z][\w-]*)/y;
+const RE_REFERENCE = /([$-])?([a-zA-Z][\w-]*)(?:\.([a-zA-Z][\w-]*))?/y;
+const RE_FUNCTION_NAME = /^[A-Z][A-Z0-9_-]*$/;
+const RE_TEXT_RUN = /([^{}\n\r]+)/y;
+const RE_STRING_RUN = /([^\\"\n\r]*)/y;
+const RE_STRING_ESCAPE = /\\([\\"])/y;
+const RE_UNICODE_ESCAPE = /\\u([a-fA-F0-9]{4})|\\U([a-fA-F0-9]{6})/y;
+const RE_LEADING_NEWLINES = /^\n+/;
+const RE_TRAILING_SPACES = / +$/;
+const RE_BLANK_LINES = / *\r?\n/g;
+const RE_INDENT = /( *)$/;
+const TOKEN_BRACE_OPEN = /{\s*/y;
+const TOKEN_BRACE_CLOSE = /\s*}/y;
+const TOKEN_BRACKET_OPEN = /\[\s*/y;
+const TOKEN_BRACKET_CLOSE = /\s*] */y;
+const TOKEN_PAREN_OPEN = /\s*\(\s*/y;
+const TOKEN_ARROW = /\s*->\s*/y;
+const TOKEN_COLON = /\s*:\s*/y;
+const TOKEN_COMMA = /\s*,?\s*/y;
+const TOKEN_BLANK = /\s+/y;
+class FluentResource {
+  constructor(source) {
+    this.body = [];
+    RE_MESSAGE_START.lastIndex = 0;
+    let cursor = 0;
+    while (true) {
+      let next = RE_MESSAGE_START.exec(source);
+      if (next === null) {
+        break;
+      }
+      cursor = RE_MESSAGE_START.lastIndex;
+      try {
+        this.body.push(parseMessage(next[1]));
+      } catch (err) {
+        if (err instanceof SyntaxError) {
+          continue;
+        }
+        throw err;
+      }
     }
-  }
-}
-class FluentDateTime2 extends FluentType2 {
-  /**
-   * Create an instance of `FluentDateTime` with options to the
-   * `Intl.DateTimeFormat` constructor.
-   *
-   * @param value The number value of this `FluentDateTime`, in milliseconds.
-   * @param opts Options which will be passed to `Intl.DateTimeFormat`.
-   */
-  constructor(value, opts = {}) {
-    super(value);
-    this.opts = opts;
-  }
-  /**
-   * Format this `FluentDateTime` to a string.
-   */
-  toString(scope) {
-    try {
-      const dtf = scope.memoizeIntlObject(Intl.DateTimeFormat, this.opts);
-      return dtf.format(this.value);
-    } catch (err) {
-      scope.reportError(err);
-      return new Date(this.value).toISOString();
+    function test(re) {
+      re.lastIndex = cursor;
+      return re.test(source);
     }
-  }
-}
-const MAX_PLACEABLES = 100;
-const FSI = "⁨";
-const PDI = "⁩";
-function match(scope, selector, key) {
-  if (key === selector) {
-    return true;
-  }
-  if (key instanceof FluentNumber2 && selector instanceof FluentNumber2 && key.value === selector.value) {
-    return true;
-  }
-  if (selector instanceof FluentNumber2 && typeof key === "string") {
-    let category = scope.memoizeIntlObject(Intl.PluralRules, selector.opts).select(selector.value);
-    if (key === category) {
-      return true;
+    function consumeChar(char, errorClass) {
+      if (source[cursor] === char) {
+        cursor++;
+        return true;
+      }
+      if (errorClass) {
+        throw new errorClass(`Expected ${char}`);
+      }
+      return false;
     }
-  }
-  return false;
-}
-function getDefault(scope, variants, star) {
-  if (variants[star]) {
-    return resolvePattern(scope, variants[star].value);
-  }
-  scope.reportError(new RangeError("No default"));
-  return new FluentNone2();
-}
-function getArguments(scope, args) {
-  const positional = [];
-  const named = /* @__PURE__ */ Object.create(null);
-  for (const arg of args) {
-    if (arg.type === "narg") {
-      named[arg.name] = resolveExpression(scope, arg.value);
-    } else {
-      positional.push(resolveExpression(scope, arg));
+    function consumeToken(re, errorClass) {
+      if (test(re)) {
+        cursor = re.lastIndex;
+        return true;
+      }
+      if (errorClass) {
+        throw new errorClass(`Expected ${re.toString()}`);
+      }
+      return false;
     }
-  }
-  return { positional, named };
-}
-function resolveExpression(scope, expr) {
-  switch (expr.type) {
-    case "str":
-      return expr.value;
-    case "num":
-      return new FluentNumber2(expr.value, {
-        minimumFractionDigits: expr.precision
-      });
-    case "var":
-      return resolveVariableReference(scope, expr);
-    case "mesg":
-      return resolveMessageReference(scope, expr);
-    case "term":
-      return resolveTermReference(scope, expr);
-    case "func":
-      return resolveFunctionReference(scope, expr);
-    case "select":
-      return resolveSelectExpression(scope, expr);
-    default:
-      return new FluentNone2();
-  }
-}
-function resolveVariableReference(scope, { name }) {
-  let arg;
-  if (scope.params) {
-    if (Object.prototype.hasOwnProperty.call(scope.params, name)) {
-      arg = scope.params[name];
-    } else {
-      return new FluentNone2(`$${name}`);
+    function match2(re) {
+      re.lastIndex = cursor;
+      let result = re.exec(source);
+      if (result === null) {
+        throw new SyntaxError(`Expected ${re.toString()}`);
+      }
+      cursor = re.lastIndex;
+      return result;
     }
-  } else if (scope.args && Object.prototype.hasOwnProperty.call(scope.args, name)) {
-    arg = scope.args[name];
-  } else {
-    scope.reportError(new ReferenceError(`Unknown variable: $${name}`));
-    return new FluentNone2(`$${name}`);
-  }
-  if (arg instanceof FluentType2) {
-    return arg;
-  }
-  switch (typeof arg) {
-    case "string":
-      return arg;
-    case "number":
-      return new FluentNumber2(arg);
-    case "object":
-      if (arg instanceof Date) {
-        return new FluentDateTime2(arg.getTime());
+    function match1(re) {
+      return match2(re)[1];
+    }
+    function parseMessage(id) {
+      let value = parsePattern();
+      let attributes = parseAttributes();
+      if (value === null && Object.keys(attributes).length === 0) {
+        throw new SyntaxError("Expected message value or attributes");
       }
-    default:
-      scope.reportError(new TypeError(`Variable type not supported: $${name}, ${typeof arg}`));
-      return new FluentNone2(`$${name}`);
-  }
-}
-function resolveMessageReference(scope, { name, attr }) {
-  const message = scope.bundle._messages.get(name);
-  if (!message) {
-    scope.reportError(new ReferenceError(`Unknown message: ${name}`));
-    return new FluentNone2(name);
-  }
-  if (attr) {
-    const attribute = message.attributes[attr];
-    if (attribute) {
-      return resolvePattern(scope, attribute);
+      return { id, value, attributes };
     }
-    scope.reportError(new ReferenceError(`Unknown attribute: ${attr}`));
-    return new FluentNone2(`${name}.${attr}`);
-  }
-  if (message.value) {
-    return resolvePattern(scope, message.value);
-  }
-  scope.reportError(new ReferenceError(`No value: ${name}`));
-  return new FluentNone2(name);
-}
-function resolveTermReference(scope, { name, attr, args }) {
-  const id = `-${name}`;
-  const term = scope.bundle._terms.get(id);
-  if (!term) {
-    scope.reportError(new ReferenceError(`Unknown term: ${id}`));
-    return new FluentNone2(id);
-  }
-  if (attr) {
-    const attribute = term.attributes[attr];
-    if (attribute) {
-      scope.params = getArguments(scope, args).named;
-      const resolved2 = resolvePattern(scope, attribute);
-      scope.params = null;
-      return resolved2;
-    }
-    scope.reportError(new ReferenceError(`Unknown attribute: ${attr}`));
-    return new FluentNone2(`${id}.${attr}`);
-  }
-  scope.params = getArguments(scope, args).named;
-  const resolved = resolvePattern(scope, term.value);
-  scope.params = null;
-  return resolved;
-}
-function resolveFunctionReference(scope, { name, args }) {
-  let func = scope.bundle._functions[name];
-  if (!func) {
-    scope.reportError(new ReferenceError(`Unknown function: ${name}()`));
-    return new FluentNone2(`${name}()`);
-  }
-  if (typeof func !== "function") {
-    scope.reportError(new TypeError(`Function ${name}() is not callable`));
-    return new FluentNone2(`${name}()`);
-  }
-  try {
-    let resolved = getArguments(scope, args);
-    return func(resolved.positional, resolved.named);
-  } catch (err) {
-    scope.reportError(err);
-    return new FluentNone2(`${name}()`);
-  }
-}
-function resolveSelectExpression(scope, { selector, variants, star }) {
-  let sel = resolveExpression(scope, selector);
-  if (sel instanceof FluentNone2) {
-    return getDefault(scope, variants, star);
-  }
-  for (const variant of variants) {
-    const key = resolveExpression(scope, variant.key);
-    if (match(scope, sel, key)) {
-      return resolvePattern(scope, variant.value);
-    }
-  }
-  return getDefault(scope, variants, star);
-}
-function resolveComplexPattern(scope, ptn) {
-  if (scope.dirty.has(ptn)) {
-    scope.reportError(new RangeError("Cyclic reference"));
-    return new FluentNone2();
-  }
-  scope.dirty.add(ptn);
-  const result = [];
-  const useIsolating = scope.bundle._useIsolating && ptn.length > 1;
-  for (const elem of ptn) {
-    if (typeof elem === "string") {
-      result.push(scope.bundle._transform(elem));
-      continue;
+    function parseAttributes() {
+      let attrs = /* @__PURE__ */ Object.create(null);
+      while (test(RE_ATTRIBUTE_START)) {
+        let name = match1(RE_ATTRIBUTE_START);
+        let value = parsePattern();
+        if (value === null) {
+          throw new SyntaxError("Expected attribute value");
+        }
+        attrs[name] = value;
+      }
+      return attrs;
     }
-    scope.placeables++;
-    if (scope.placeables > MAX_PLACEABLES) {
-      scope.dirty.delete(ptn);
-      throw new RangeError(`Too many placeables expanded: ${scope.placeables}, max allowed is ${MAX_PLACEABLES}`);
+    function parsePattern() {
+      let first;
+      if (test(RE_TEXT_RUN)) {
+        first = match1(RE_TEXT_RUN);
+      }
+      if (source[cursor] === "{" || source[cursor] === "}") {
+        return parsePatternElements(first ? [first] : [], Infinity);
+      }
+      let indent = parseIndent();
+      if (indent) {
+        if (first) {
+          return parsePatternElements([first, indent], indent.length);
+        }
+        indent.value = trim(indent.value, RE_LEADING_NEWLINES);
+        return parsePatternElements([indent], indent.length);
+      }
+      if (first) {
+        return trim(first, RE_TRAILING_SPACES);
+      }
+      return null;
     }
-    if (useIsolating) {
-      result.push(FSI);
+    function parsePatternElements(elements = [], commonIndent) {
+      while (true) {
+        if (test(RE_TEXT_RUN)) {
+          elements.push(match1(RE_TEXT_RUN));
+          continue;
+        }
+        if (source[cursor] === "{") {
+          elements.push(parsePlaceable());
+          continue;
+        }
+        if (source[cursor] === "}") {
+          throw new SyntaxError("Unbalanced closing brace");
+        }
+        let indent = parseIndent();
+        if (indent) {
+          elements.push(indent);
+          commonIndent = Math.min(commonIndent, indent.length);
+          continue;
+        }
+        break;
+      }
+      let lastIndex = elements.length - 1;
+      let lastElement = elements[lastIndex];
+      if (typeof lastElement === "string") {
+        elements[lastIndex] = trim(lastElement, RE_TRAILING_SPACES);
+      }
+      let baked = [];
+      for (let element of elements) {
+        if (element instanceof Indent) {
+          element = element.value.slice(0, element.value.length - commonIndent);
+        }
+        if (element) {
+          baked.push(element);
+        }
+      }
+      return baked;
     }
-    result.push(resolveExpression(scope, elem).toString(scope));
-    if (useIsolating) {
-      result.push(PDI);
+    function parsePlaceable() {
+      consumeToken(TOKEN_BRACE_OPEN, SyntaxError);
+      let selector = parseInlineExpression();
+      if (consumeToken(TOKEN_BRACE_CLOSE)) {
+        return selector;
+      }
+      if (consumeToken(TOKEN_ARROW)) {
+        let variants = parseVariants();
+        consumeToken(TOKEN_BRACE_CLOSE, SyntaxError);
+        return {
+          type: "select",
+          selector,
+          ...variants
+        };
+      }
+      throw new SyntaxError("Unclosed placeable");
     }
-  }
-  scope.dirty.delete(ptn);
-  return result.join("");
-}
-function resolvePattern(scope, value) {
-  if (typeof value === "string") {
-    return scope.bundle._transform(value);
-  }
-  return resolveComplexPattern(scope, value);
-}
-class Scope2 {
-  constructor(bundle, errors, args) {
-    this.dirty = /* @__PURE__ */ new WeakSet();
-    this.params = null;
-    this.placeables = 0;
-    this.bundle = bundle;
-    this.errors = errors;
-    this.args = args;
-  }
-  reportError(error) {
-    if (!this.errors || !(error instanceof Error)) {
-      throw error;
+    function parseInlineExpression() {
+      if (source[cursor] === "{") {
+        return parsePlaceable();
+      }
+      if (test(RE_REFERENCE)) {
+        let [, sigil, name, attr = null] = match2(RE_REFERENCE);
+        if (sigil === "$") {
+          return { type: "var", name };
+        }
+        if (consumeToken(TOKEN_PAREN_OPEN)) {
+          let args = parseArguments();
+          if (sigil === "-") {
+            return { type: "term", name, attr, args };
+          }
+          if (RE_FUNCTION_NAME.test(name)) {
+            return { type: "func", name, args };
+          }
+          throw new SyntaxError("Function names must be all upper-case");
+        }
+        if (sigil === "-") {
+          return {
+            type: "term",
+            name,
+            attr,
+            args: []
+          };
+        }
+        return { type: "mesg", name, attr };
+      }
+      return parseLiteral();
     }
-    this.errors.push(error);
-  }
-  memoizeIntlObject(ctor, opts) {
-    let cache2 = this.bundle._intls.get(ctor);
-    if (!cache2) {
-      cache2 = {};
-      this.bundle._intls.set(ctor, cache2);
+    function parseArguments() {
+      let args = [];
+      while (true) {
+        switch (source[cursor]) {
+          case ")":
+            cursor++;
+            return args;
+          case void 0:
+            throw new SyntaxError("Unclosed argument list");
+        }
+        args.push(parseArgument());
+        consumeToken(TOKEN_COMMA);
+      }
     }
-    let id = JSON.stringify(opts);
-    if (!cache2[id]) {
-      cache2[id] = new ctor(this.bundle.locales, opts);
+    function parseArgument() {
+      let expr = parseInlineExpression();
+      if (expr.type !== "mesg") {
+        return expr;
+      }
+      if (consumeToken(TOKEN_COLON)) {
+        return {
+          type: "narg",
+          name: expr.name,
+          value: parseLiteral()
+        };
+      }
+      return expr;
     }
-    return cache2[id];
-  }
-}
-function values(opts, allowed) {
-  const unwrapped = /* @__PURE__ */ Object.create(null);
-  for (const [name, opt] of Object.entries(opts)) {
-    if (allowed.includes(name)) {
-      unwrapped[name] = opt.valueOf();
+    function parseVariants() {
+      let variants = [];
+      let count = 0;
+      let star;
+      while (test(RE_VARIANT_START)) {
+        if (consumeChar("*")) {
+          star = count;
+        }
+        let key = parseVariantKey();
+        let value = parsePattern();
+        if (value === null) {
+          throw new SyntaxError("Expected variant value");
+        }
+        variants[count++] = { key, value };
+      }
+      if (count === 0) {
+        return null;
+      }
+      if (star === void 0) {
+        throw new SyntaxError("Expected default variant");
+      }
+      return { variants, star };
+    }
+    function parseVariantKey() {
+      consumeToken(TOKEN_BRACKET_OPEN, SyntaxError);
+      let key;
+      if (test(RE_NUMBER_LITERAL)) {
+        key = parseNumberLiteral();
+      } else {
+        key = {
+          type: "str",
+          value: match1(RE_IDENTIFIER)
+        };
+      }
+      consumeToken(TOKEN_BRACKET_CLOSE, SyntaxError);
+      return key;
+    }
+    function parseLiteral() {
+      if (test(RE_NUMBER_LITERAL)) {
+        return parseNumberLiteral();
+      }
+      if (source[cursor] === '"') {
+        return parseStringLiteral();
+      }
+      throw new SyntaxError("Invalid expression");
+    }
+    function parseNumberLiteral() {
+      let [, value, fraction = ""] = match2(RE_NUMBER_LITERAL);
+      let precision = fraction.length;
+      return {
+        type: "num",
+        value: parseFloat(value),
+        precision
+      };
+    }
+    function parseStringLiteral() {
+      consumeChar('"', SyntaxError);
+      let value = "";
+      while (true) {
+        value += match1(RE_STRING_RUN);
+        if (source[cursor] === "\\") {
+          value += parseEscapeSequence();
+          continue;
+        }
+        if (consumeChar('"')) {
+          return { type: "str", value };
+        }
+        throw new SyntaxError("Unclosed string literal");
+      }
+    }
+    function parseEscapeSequence() {
+      if (test(RE_STRING_ESCAPE)) {
+        return match1(RE_STRING_ESCAPE);
+      }
+      if (test(RE_UNICODE_ESCAPE)) {
+        let [, codepoint4, codepoint6] = match2(RE_UNICODE_ESCAPE);
+        let codepoint = parseInt(codepoint4 || codepoint6, 16);
+        return codepoint <= 55295 || 57344 <= codepoint ? String.fromCodePoint(codepoint) : "�";
+      }
+      throw new SyntaxError("Unknown escape sequence");
+    }
+    function parseIndent() {
+      let start = cursor;
+      consumeToken(TOKEN_BLANK);
+      switch (source[cursor]) {
+        case ".":
+        case "[":
+        case "*":
+        case "}":
+        case void 0:
+          return false;
+        case "{":
+          return makeIndent(source.slice(start, cursor));
+      }
+      if (source[cursor - 1] === " ") {
+        return makeIndent(source.slice(start, cursor));
+      }
+      return false;
+    }
+    function trim(text, re) {
+      return text.replace(re, "");
+    }
+    function makeIndent(blank) {
+      let value = blank.replace(RE_BLANK_LINES, "\n");
+      let length = RE_INDENT.exec(blank)[1].length;
+      return new Indent(value, length);
     }
   }
-  return unwrapped;
-}
-const NUMBER_ALLOWED = [
-  "unitDisplay",
-  "currencyDisplay",
-  "useGrouping",
-  "minimumIntegerDigits",
-  "minimumFractionDigits",
-  "maximumFractionDigits",
-  "minimumSignificantDigits",
-  "maximumSignificantDigits"
-];
-function NUMBER(args, opts) {
-  let arg = args[0];
-  if (arg instanceof FluentNone2) {
-    return new FluentNone2(`NUMBER(${arg.valueOf()})`);
-  }
-  if (arg instanceof FluentNumber2) {
-    return new FluentNumber2(arg.valueOf(), {
-      ...arg.opts,
-      ...values(opts, NUMBER_ALLOWED)
-    });
-  }
-  if (arg instanceof FluentDateTime2) {
-    return new FluentNumber2(arg.valueOf(), {
-      ...values(opts, NUMBER_ALLOWED)
-    });
-  }
-  throw new TypeError("Invalid argument to NUMBER");
-}
-const DATETIME_ALLOWED = [
-  "dateStyle",
-  "timeStyle",
-  "fractionalSecondDigits",
-  "dayPeriod",
-  "hour12",
-  "weekday",
-  "era",
-  "year",
-  "month",
-  "day",
-  "hour",
-  "minute",
-  "second",
-  "timeZoneName"
-];
-function DATETIME(args, opts) {
-  let arg = args[0];
-  if (arg instanceof FluentNone2) {
-    return new FluentNone2(`DATETIME(${arg.valueOf()})`);
-  }
-  if (arg instanceof FluentDateTime2) {
-    return new FluentDateTime2(arg.valueOf(), {
-      ...arg.opts,
-      ...values(opts, DATETIME_ALLOWED)
-    });
-  }
-  if (arg instanceof FluentNumber2) {
-    return new FluentDateTime2(arg.valueOf(), {
-      ...values(opts, DATETIME_ALLOWED)
-    });
-  }
-  throw new TypeError("Invalid argument to DATETIME");
 }
-const cache = /* @__PURE__ */ new Map();
-function getMemoizerForLocale(locales) {
-  const stringLocale = Array.isArray(locales) ? locales.join(" ") : locales;
-  let memoizer = cache.get(stringLocale);
-  if (memoizer === void 0) {
-    memoizer = /* @__PURE__ */ new Map();
-    cache.set(stringLocale, memoizer);
+class Indent {
+  constructor(value, length) {
+    this.value = value;
+    this.length = length;
   }
-  return memoizer;
 }
-class FluentBundle2 {
+class FluentType2 {
   /**
-   * Create an instance of `FluentBundle`.
-   *
-   * The `locales` argument is used to instantiate `Intl` formatters used by
-   * translations. The `options` object can be used to configure the bundle.
-   *
-   * Examples:
-   *
-   *     let bundle = new FluentBundle(["en-US", "en"]);
-   *
-   *     let bundle = new FluentBundle(locales, {useIsolating: false});
-   *
-   *     let bundle = new FluentBundle(locales, {
-   *       useIsolating: true,
-   *       functions: {
-   *         NODE_ENV: () => process.env.NODE_ENV
-   *       }
-   *     });
-   *
-   * Available options:
-   *
-   *   - `functions` - an object of additional functions available to
-   *     translations as builtins.
-   *
-   *   - `useIsolating` - boolean specifying whether to use Unicode isolation
-   *     marks (FSI, PDI) for bidi interpolations. Default: `true`.
+   * Create a `FluentType` instance.
    *
-   *   - `transform` - a function used to transform string parts of patterns.
+   * @param value The JavaScript value to wrap.
    */
-  constructor(locales, { functions, useIsolating = true, transform = (v) => v } = {}) {
-    this._terms = /* @__PURE__ */ new Map();
-    this._messages = /* @__PURE__ */ new Map();
-    this.locales = Array.isArray(locales) ? locales : [locales];
-    this._functions = {
-      NUMBER,
-      DATETIME,
-      ...functions
-    };
-    this._useIsolating = useIsolating;
-    this._transform = transform;
-    this._intls = getMemoizerForLocale(locales);
+  constructor(value) {
+    this.value = value;
   }
   /**
-   * Check if a message is present in the bundle.
-   *
-   * @param id - The identifier of the message to check.
+   * Unwrap the raw value stored by this `FluentType`.
    */
-  hasMessage(id) {
-    return this._messages.has(id);
+  valueOf() {
+    return this.value;
   }
+}
+class FluentNone2 extends FluentType2 {
   /**
-   * Return a raw unformatted message object from the bundle.
-   *
-   * Raw messages are `{value, attributes}` shapes containing translation units
-   * called `Patterns`. `Patterns` are implementation-specific; they should be
-   * treated as black boxes and formatted with `FluentBundle.formatPattern`.
-   *
-   * @param id - The identifier of the message to check.
+   * Create an instance of `FluentNone` with an optional fallback value.
+   * @param value The fallback value of this `FluentNone`.
    */
-  getMessage(id) {
-    return this._messages.get(id);
+  constructor(value = "???") {
+    super(value);
   }
   /**
-   * Add a translation resource to the bundle.
-   *
-   * The translation resource must be an instance of `FluentResource`.
-   *
-   *     let res = new FluentResource("foo = Foo");
-   *     bundle.addResource(res);
-   *     bundle.getMessage("foo");
-   *     // → {value: .., attributes: {..}}
-   *
-   * Available options:
-   *
-   *   - `allowOverrides` - boolean specifying whether it's allowed to override
-   *     an existing message or term with a new value. Default: `false`.
+   * Format this `FluentNone` to the fallback string.
+   */
+  toString(scope) {
+    return `{${this.value}}`;
+  }
+}
+class FluentNumber2 extends FluentType2 {
+  /**
+   * Create an instance of `FluentNumber` with options to the
+   * `Intl.NumberFormat` constructor.
    *
-   * @param   res - FluentResource object.
-   * @param   options
+   * @param value The number value of this `FluentNumber`.
+   * @param opts Options which will be passed to `Intl.NumberFormat`.
    */
-  addResource(res, { allowOverrides = false } = {}) {
-    const errors = [];
-    for (let i = 0; i < res.body.length; i++) {
-      let entry = res.body[i];
-      if (entry.id.startsWith("-")) {
-        if (allowOverrides === false && this._terms.has(entry.id)) {
-          errors.push(new Error(`Attempt to override an existing term: "${entry.id}"`));
-          continue;
-        }
-        this._terms.set(entry.id, entry);
-      } else {
-        if (allowOverrides === false && this._messages.has(entry.id)) {
-          errors.push(new Error(`Attempt to override an existing message: "${entry.id}"`));
-          continue;
-        }
-        this._messages.set(entry.id, entry);
-      }
+  constructor(value, opts = {}) {
+    super(value);
+    this.opts = opts;
+  }
+  /**
+   * Format this `FluentNumber` to a string.
+   */
+  toString(scope) {
+    try {
+      const nf = scope.memoizeIntlObject(Intl.NumberFormat, this.opts);
+      return nf.format(this.value);
+    } catch (err) {
+      scope.reportError(err);
+      return this.value.toString(10);
     }
-    return errors;
   }
+}
+class FluentDateTime2 extends FluentType2 {
   /**
-   * Format a `Pattern` to a string.
-   *
-   * Format a raw `Pattern` into a string. `args` will be used to resolve
-   * references to variables passed as arguments to the translation.
-   *
-   * In case of errors `formatPattern` will try to salvage as much of the
-   * translation as possible and will still return a string. For performance
-   * reasons, the encountered errors are not returned but instead are appended
-   * to the `errors` array passed as the third argument.
-   *
-   *     let errors = [];
-   *     bundle.addResource(
-   *         new FluentResource("hello = Hello, {$name}!"));
-   *
-   *     let hello = bundle.getMessage("hello");
-   *     if (hello.value) {
-   *         bundle.formatPattern(hello.value, {name: "Jane"}, errors);
-   *         // Returns "Hello, Jane!" and `errors` is empty.
-   *
-   *         bundle.formatPattern(hello.value, undefined, errors);
-   *         // Returns "Hello, {$name}!" and `errors` is now:
-   *         // [<ReferenceError: Unknown variable: name>]
-   *     }
+   * Create an instance of `FluentDateTime` with options to the
+   * `Intl.DateTimeFormat` constructor.
    *
-   * If `errors` is omitted, the first encountered error will be thrown.
+   * @param value The number value of this `FluentDateTime`, in milliseconds.
+   * @param opts Options which will be passed to `Intl.DateTimeFormat`.
    */
-  formatPattern(pattern, args = null, errors = null) {
-    if (typeof pattern === "string") {
-      return this._transform(pattern);
-    }
-    let scope = new Scope2(this, errors, args);
+  constructor(value, opts = {}) {
+    super(value);
+    this.opts = opts;
+  }
+  /**
+   * Format this `FluentDateTime` to a string.
+   */
+  toString(scope) {
     try {
-      let value = resolveComplexPattern(scope, pattern);
-      return value.toString(scope);
+      const dtf = scope.memoizeIntlObject(Intl.DateTimeFormat, this.opts);
+      return dtf.format(this.value);
     } catch (err) {
-      if (scope.errors && err instanceof Error) {
-        scope.errors.push(err);
-        return new FluentNone2().toString(scope);
-      }
-      throw err;
+      scope.reportError(err);
+      return new Date(this.value).toISOString();
     }
   }
 }
-const RE_MESSAGE_START = /^(-?[a-zA-Z][\w-]*) *= */gm;
-const RE_ATTRIBUTE_START = /\.([a-zA-Z][\w-]*) *= */y;
-const RE_VARIANT_START = /\*?\[/y;
-const RE_NUMBER_LITERAL = /(-?[0-9]+(?:\.([0-9]+))?)/y;
-const RE_IDENTIFIER = /([a-zA-Z][\w-]*)/y;
-const RE_REFERENCE = /([$-])?([a-zA-Z][\w-]*)(?:\.([a-zA-Z][\w-]*))?/y;
-const RE_FUNCTION_NAME = /^[A-Z][A-Z0-9_-]*$/;
-const RE_TEXT_RUN = /([^{}\n\r]+)/y;
-const RE_STRING_RUN = /([^\\"\n\r]*)/y;
-const RE_STRING_ESCAPE = /\\([\\"])/y;
-const RE_UNICODE_ESCAPE = /\\u([a-fA-F0-9]{4})|\\U([a-fA-F0-9]{6})/y;
-const RE_LEADING_NEWLINES = /^\n+/;
-const RE_TRAILING_SPACES = / +$/;
-const RE_BLANK_LINES = / *\r?\n/g;
-const RE_INDENT = /( *)$/;
-const TOKEN_BRACE_OPEN = /{\s*/y;
-const TOKEN_BRACE_CLOSE = /\s*}/y;
-const TOKEN_BRACKET_OPEN = /\[\s*/y;
-const TOKEN_BRACKET_CLOSE = /\s*] */y;
-const TOKEN_PAREN_OPEN = /\s*\(\s*/y;
-const TOKEN_ARROW = /\s*->\s*/y;
-const TOKEN_COLON = /\s*:\s*/y;
-const TOKEN_COMMA = /\s*,?\s*/y;
-const TOKEN_BLANK = /\s+/y;
-class FluentResource {
-  constructor(source) {
-    this.body = [];
-    RE_MESSAGE_START.lastIndex = 0;
-    let cursor = 0;
-    while (true) {
-      let next = RE_MESSAGE_START.exec(source);
-      if (next === null) {
-        break;
-      }
-      cursor = RE_MESSAGE_START.lastIndex;
-      try {
-        this.body.push(parseMessage(next[1]));
-      } catch (err) {
-        if (err instanceof SyntaxError) {
-          continue;
-        }
-        throw err;
-      }
+const MAX_PLACEABLES = 100;
+const FSI = "⁨";
+const PDI = "⁩";
+function match(scope, selector, key) {
+  if (key === selector) {
+    return true;
+  }
+  if (key instanceof FluentNumber2 && selector instanceof FluentNumber2 && key.value === selector.value) {
+    return true;
+  }
+  if (selector instanceof FluentNumber2 && typeof key === "string") {
+    let category = scope.memoizeIntlObject(Intl.PluralRules, selector.opts).select(selector.value);
+    if (key === category) {
+      return true;
     }
-    function test(re) {
-      re.lastIndex = cursor;
-      return re.test(source);
+  }
+  return false;
+}
+function getDefault(scope, variants, star) {
+  if (variants[star]) {
+    return resolvePattern(scope, variants[star].value);
+  }
+  scope.reportError(new RangeError("No default"));
+  return new FluentNone2();
+}
+function getArguments(scope, args) {
+  const positional = [];
+  const named = /* @__PURE__ */ Object.create(null);
+  for (const arg of args) {
+    if (arg.type === "narg") {
+      named[arg.name] = resolveExpression(scope, arg.value);
+    } else {
+      positional.push(resolveExpression(scope, arg));
     }
-    function consumeChar(char, errorClass) {
-      if (source[cursor] === char) {
-        cursor++;
-        return true;
-      }
-      if (errorClass) {
-        throw new errorClass(`Expected ${char}`);
-      }
-      return false;
+  }
+  return { positional, named };
+}
+function resolveExpression(scope, expr) {
+  switch (expr.type) {
+    case "str":
+      return expr.value;
+    case "num":
+      return new FluentNumber2(expr.value, {
+        minimumFractionDigits: expr.precision
+      });
+    case "var":
+      return resolveVariableReference(scope, expr);
+    case "mesg":
+      return resolveMessageReference(scope, expr);
+    case "term":
+      return resolveTermReference(scope, expr);
+    case "func":
+      return resolveFunctionReference(scope, expr);
+    case "select":
+      return resolveSelectExpression(scope, expr);
+    default:
+      return new FluentNone2();
+  }
+}
+function resolveVariableReference(scope, { name }) {
+  let arg;
+  if (scope.params) {
+    if (Object.prototype.hasOwnProperty.call(scope.params, name)) {
+      arg = scope.params[name];
+    } else {
+      return new FluentNone2(`$${name}`);
     }
-    function consumeToken(re, errorClass) {
-      if (test(re)) {
-        cursor = re.lastIndex;
-        return true;
-      }
-      if (errorClass) {
-        throw new errorClass(`Expected ${re.toString()}`);
+  } else if (scope.args && Object.prototype.hasOwnProperty.call(scope.args, name)) {
+    arg = scope.args[name];
+  } else {
+    scope.reportError(new ReferenceError(`Unknown variable: $${name}`));
+    return new FluentNone2(`$${name}`);
+  }
+  if (arg instanceof FluentType2) {
+    return arg;
+  }
+  switch (typeof arg) {
+    case "string":
+      return arg;
+    case "number":
+      return new FluentNumber2(arg);
+    case "object":
+      if (arg instanceof Date) {
+        return new FluentDateTime2(arg.getTime());
       }
-      return false;
+    default:
+      scope.reportError(new TypeError(`Variable type not supported: $${name}, ${typeof arg}`));
+      return new FluentNone2(`$${name}`);
+  }
+}
+function resolveMessageReference(scope, { name, attr }) {
+  const message = scope.bundle._messages.get(name);
+  if (!message) {
+    scope.reportError(new ReferenceError(`Unknown message: ${name}`));
+    return new FluentNone2(name);
+  }
+  if (attr) {
+    const attribute = message.attributes[attr];
+    if (attribute) {
+      return resolvePattern(scope, attribute);
     }
-    function match2(re) {
-      re.lastIndex = cursor;
-      let result = re.exec(source);
-      if (result === null) {
-        throw new SyntaxError(`Expected ${re.toString()}`);
-      }
-      cursor = re.lastIndex;
-      return result;
+    scope.reportError(new ReferenceError(`Unknown attribute: ${attr}`));
+    return new FluentNone2(`${name}.${attr}`);
+  }
+  if (message.value) {
+    return resolvePattern(scope, message.value);
+  }
+  scope.reportError(new ReferenceError(`No value: ${name}`));
+  return new FluentNone2(name);
+}
+function resolveTermReference(scope, { name, attr, args }) {
+  const id = `-${name}`;
+  const term = scope.bundle._terms.get(id);
+  if (!term) {
+    scope.reportError(new ReferenceError(`Unknown term: ${id}`));
+    return new FluentNone2(id);
+  }
+  if (attr) {
+    const attribute = term.attributes[attr];
+    if (attribute) {
+      scope.params = getArguments(scope, args).named;
+      const resolved2 = resolvePattern(scope, attribute);
+      scope.params = null;
+      return resolved2;
     }
-    function match1(re) {
-      return match2(re)[1];
+    scope.reportError(new ReferenceError(`Unknown attribute: ${attr}`));
+    return new FluentNone2(`${id}.${attr}`);
+  }
+  scope.params = getArguments(scope, args).named;
+  const resolved = resolvePattern(scope, term.value);
+  scope.params = null;
+  return resolved;
+}
+function resolveFunctionReference(scope, { name, args }) {
+  let func = scope.bundle._functions[name];
+  if (!func) {
+    scope.reportError(new ReferenceError(`Unknown function: ${name}()`));
+    return new FluentNone2(`${name}()`);
+  }
+  if (typeof func !== "function") {
+    scope.reportError(new TypeError(`Function ${name}() is not callable`));
+    return new FluentNone2(`${name}()`);
+  }
+  try {
+    let resolved = getArguments(scope, args);
+    return func(resolved.positional, resolved.named);
+  } catch (err) {
+    scope.reportError(err);
+    return new FluentNone2(`${name}()`);
+  }
+}
+function resolveSelectExpression(scope, { selector, variants, star }) {
+  let sel = resolveExpression(scope, selector);
+  if (sel instanceof FluentNone2) {
+    return getDefault(scope, variants, star);
+  }
+  for (const variant of variants) {
+    const key = resolveExpression(scope, variant.key);
+    if (match(scope, sel, key)) {
+      return resolvePattern(scope, variant.value);
     }
-    function parseMessage(id) {
-      let value = parsePattern();
-      let attributes = parseAttributes();
-      if (value === null && Object.keys(attributes).length === 0) {
-        throw new SyntaxError("Expected message value or attributes");
-      }
-      return { id, value, attributes };
+  }
+  return getDefault(scope, variants, star);
+}
+function resolveComplexPattern(scope, ptn) {
+  if (scope.dirty.has(ptn)) {
+    scope.reportError(new RangeError("Cyclic reference"));
+    return new FluentNone2();
+  }
+  scope.dirty.add(ptn);
+  const result = [];
+  const useIsolating = scope.bundle._useIsolating && ptn.length > 1;
+  for (const elem of ptn) {
+    if (typeof elem === "string") {
+      result.push(scope.bundle._transform(elem));
+      continue;
     }
-    function parseAttributes() {
-      let attrs = /* @__PURE__ */ Object.create(null);
-      while (test(RE_ATTRIBUTE_START)) {
-        let name = match1(RE_ATTRIBUTE_START);
-        let value = parsePattern();
-        if (value === null) {
-          throw new SyntaxError("Expected attribute value");
-        }
-        attrs[name] = value;
-      }
-      return attrs;
+    scope.placeables++;
+    if (scope.placeables > MAX_PLACEABLES) {
+      scope.dirty.delete(ptn);
+      throw new RangeError(`Too many placeables expanded: ${scope.placeables}, max allowed is ${MAX_PLACEABLES}`);
     }
-    function parsePattern() {
-      let first;
-      if (test(RE_TEXT_RUN)) {
-        first = match1(RE_TEXT_RUN);
-      }
-      if (source[cursor] === "{" || source[cursor] === "}") {
-        return parsePatternElements(first ? [first] : [], Infinity);
-      }
-      let indent = parseIndent();
-      if (indent) {
-        if (first) {
-          return parsePatternElements([first, indent], indent.length);
-        }
-        indent.value = trim(indent.value, RE_LEADING_NEWLINES);
-        return parsePatternElements([indent], indent.length);
-      }
-      if (first) {
-        return trim(first, RE_TRAILING_SPACES);
-      }
-      return null;
+    if (useIsolating) {
+      result.push(FSI);
     }
-    function parsePatternElements(elements = [], commonIndent) {
-      while (true) {
-        if (test(RE_TEXT_RUN)) {
-          elements.push(match1(RE_TEXT_RUN));
-          continue;
-        }
-        if (source[cursor] === "{") {
-          elements.push(parsePlaceable());
-          continue;
-        }
-        if (source[cursor] === "}") {
-          throw new SyntaxError("Unbalanced closing brace");
-        }
-        let indent = parseIndent();
-        if (indent) {
-          elements.push(indent);
-          commonIndent = Math.min(commonIndent, indent.length);
-          continue;
-        }
-        break;
-      }
-      let lastIndex = elements.length - 1;
-      let lastElement = elements[lastIndex];
-      if (typeof lastElement === "string") {
-        elements[lastIndex] = trim(lastElement, RE_TRAILING_SPACES);
-      }
-      let baked = [];
-      for (let element of elements) {
-        if (element instanceof Indent) {
-          element = element.value.slice(0, element.value.length - commonIndent);
-        }
-        if (element) {
-          baked.push(element);
-        }
-      }
-      return baked;
+    result.push(resolveExpression(scope, elem).toString(scope));
+    if (useIsolating) {
+      result.push(PDI);
     }
-    function parsePlaceable() {
-      consumeToken(TOKEN_BRACE_OPEN, SyntaxError);
-      let selector = parseInlineExpression();
-      if (consumeToken(TOKEN_BRACE_CLOSE)) {
-        return selector;
-      }
-      if (consumeToken(TOKEN_ARROW)) {
-        let variants = parseVariants();
-        consumeToken(TOKEN_BRACE_CLOSE, SyntaxError);
-        return {
-          type: "select",
-          selector,
-          ...variants
-        };
-      }
-      throw new SyntaxError("Unclosed placeable");
+  }
+  scope.dirty.delete(ptn);
+  return result.join("");
+}
+function resolvePattern(scope, value) {
+  if (typeof value === "string") {
+    return scope.bundle._transform(value);
+  }
+  return resolveComplexPattern(scope, value);
+}
+class Scope2 {
+  constructor(bundle, errors, args) {
+    this.dirty = /* @__PURE__ */ new WeakSet();
+    this.params = null;
+    this.placeables = 0;
+    this.bundle = bundle;
+    this.errors = errors;
+    this.args = args;
+  }
+  reportError(error) {
+    if (!this.errors || !(error instanceof Error)) {
+      throw error;
     }
-    function parseInlineExpression() {
-      if (source[cursor] === "{") {
-        return parsePlaceable();
-      }
-      if (test(RE_REFERENCE)) {
-        let [, sigil, name, attr = null] = match2(RE_REFERENCE);
-        if (sigil === "$") {
-          return { type: "var", name };
-        }
-        if (consumeToken(TOKEN_PAREN_OPEN)) {
-          let args = parseArguments();
-          if (sigil === "-") {
-            return { type: "term", name, attr, args };
-          }
-          if (RE_FUNCTION_NAME.test(name)) {
-            return { type: "func", name, args };
-          }
-          throw new SyntaxError("Function names must be all upper-case");
-        }
-        if (sigil === "-") {
-          return {
-            type: "term",
-            name,
-            attr,
-            args: []
-          };
-        }
-        return { type: "mesg", name, attr };
-      }
-      return parseLiteral();
+    this.errors.push(error);
+  }
+  memoizeIntlObject(ctor, opts) {
+    let cache2 = this.bundle._intls.get(ctor);
+    if (!cache2) {
+      cache2 = {};
+      this.bundle._intls.set(ctor, cache2);
     }
-    function parseArguments() {
-      let args = [];
-      while (true) {
-        switch (source[cursor]) {
-          case ")":
-            cursor++;
-            return args;
-          case void 0:
-            throw new SyntaxError("Unclosed argument list");
-        }
-        args.push(parseArgument());
-        consumeToken(TOKEN_COMMA);
-      }
+    let id = JSON.stringify(opts);
+    if (!cache2[id]) {
+      cache2[id] = new ctor(this.bundle.locales, opts);
     }
-    function parseArgument() {
-      let expr = parseInlineExpression();
-      if (expr.type !== "mesg") {
-        return expr;
-      }
-      if (consumeToken(TOKEN_COLON)) {
-        return {
-          type: "narg",
-          name: expr.name,
-          value: parseLiteral()
-        };
-      }
-      return expr;
+    return cache2[id];
+  }
+}
+function values(opts, allowed) {
+  const unwrapped = /* @__PURE__ */ Object.create(null);
+  for (const [name, opt] of Object.entries(opts)) {
+    if (allowed.includes(name)) {
+      unwrapped[name] = opt.valueOf();
     }
-    function parseVariants() {
-      let variants = [];
-      let count = 0;
-      let star;
-      while (test(RE_VARIANT_START)) {
-        if (consumeChar("*")) {
-          star = count;
-        }
-        let key = parseVariantKey();
-        let value = parsePattern();
-        if (value === null) {
-          throw new SyntaxError("Expected variant value");
+  }
+  return unwrapped;
+}
+const NUMBER_ALLOWED = [
+  "unitDisplay",
+  "currencyDisplay",
+  "useGrouping",
+  "minimumIntegerDigits",
+  "minimumFractionDigits",
+  "maximumFractionDigits",
+  "minimumSignificantDigits",
+  "maximumSignificantDigits"
+];
+function NUMBER(args, opts) {
+  let arg = args[0];
+  if (arg instanceof FluentNone2) {
+    return new FluentNone2(`NUMBER(${arg.valueOf()})`);
+  }
+  if (arg instanceof FluentNumber2) {
+    return new FluentNumber2(arg.valueOf(), {
+      ...arg.opts,
+      ...values(opts, NUMBER_ALLOWED)
+    });
+  }
+  if (arg instanceof FluentDateTime2) {
+    return new FluentNumber2(arg.valueOf(), {
+      ...values(opts, NUMBER_ALLOWED)
+    });
+  }
+  throw new TypeError("Invalid argument to NUMBER");
+}
+const DATETIME_ALLOWED = [
+  "dateStyle",
+  "timeStyle",
+  "fractionalSecondDigits",
+  "dayPeriod",
+  "hour12",
+  "weekday",
+  "era",
+  "year",
+  "month",
+  "day",
+  "hour",
+  "minute",
+  "second",
+  "timeZoneName"
+];
+function DATETIME(args, opts) {
+  let arg = args[0];
+  if (arg instanceof FluentNone2) {
+    return new FluentNone2(`DATETIME(${arg.valueOf()})`);
+  }
+  if (arg instanceof FluentDateTime2) {
+    return new FluentDateTime2(arg.valueOf(), {
+      ...arg.opts,
+      ...values(opts, DATETIME_ALLOWED)
+    });
+  }
+  if (arg instanceof FluentNumber2) {
+    return new FluentDateTime2(arg.valueOf(), {
+      ...values(opts, DATETIME_ALLOWED)
+    });
+  }
+  throw new TypeError("Invalid argument to DATETIME");
+}
+const cache = /* @__PURE__ */ new Map();
+function getMemoizerForLocale(locales) {
+  const stringLocale = Array.isArray(locales) ? locales.join(" ") : locales;
+  let memoizer = cache.get(stringLocale);
+  if (memoizer === void 0) {
+    memoizer = /* @__PURE__ */ new Map();
+    cache.set(stringLocale, memoizer);
+  }
+  return memoizer;
+}
+class FluentBundle2 {
+  /**
+   * Create an instance of `FluentBundle`.
+   *
+   * The `locales` argument is used to instantiate `Intl` formatters used by
+   * translations. The `options` object can be used to configure the bundle.
+   *
+   * Examples:
+   *
+   *     let bundle = new FluentBundle(["en-US", "en"]);
+   *
+   *     let bundle = new FluentBundle(locales, {useIsolating: false});
+   *
+   *     let bundle = new FluentBundle(locales, {
+   *       useIsolating: true,
+   *       functions: {
+   *         NODE_ENV: () => process.env.NODE_ENV
+   *       }
+   *     });
+   *
+   * Available options:
+   *
+   *   - `functions` - an object of additional functions available to
+   *     translations as builtins.
+   *
+   *   - `useIsolating` - boolean specifying whether to use Unicode isolation
+   *     marks (FSI, PDI) for bidi interpolations. Default: `true`.
+   *
+   *   - `transform` - a function used to transform string parts of patterns.
+   */
+  constructor(locales, { functions, useIsolating = true, transform = (v) => v } = {}) {
+    this._terms = /* @__PURE__ */ new Map();
+    this._messages = /* @__PURE__ */ new Map();
+    this.locales = Array.isArray(locales) ? locales : [locales];
+    this._functions = {
+      NUMBER,
+      DATETIME,
+      ...functions
+    };
+    this._useIsolating = useIsolating;
+    this._transform = transform;
+    this._intls = getMemoizerForLocale(locales);
+  }
+  /**
+   * Check if a message is present in the bundle.
+   *
+   * @param id - The identifier of the message to check.
+   */
+  hasMessage(id) {
+    return this._messages.has(id);
+  }
+  /**
+   * Return a raw unformatted message object from the bundle.
+   *
+   * Raw messages are `{value, attributes}` shapes containing translation units
+   * called `Patterns`. `Patterns` are implementation-specific; they should be
+   * treated as black boxes and formatted with `FluentBundle.formatPattern`.
+   *
+   * @param id - The identifier of the message to check.
+   */
+  getMessage(id) {
+    return this._messages.get(id);
+  }
+  /**
+   * Add a translation resource to the bundle.
+   *
+   * The translation resource must be an instance of `FluentResource`.
+   *
+   *     let res = new FluentResource("foo = Foo");
+   *     bundle.addResource(res);
+   *     bundle.getMessage("foo");
+   *     // → {value: .., attributes: {..}}
+   *
+   * Available options:
+   *
+   *   - `allowOverrides` - boolean specifying whether it's allowed to override
+   *     an existing message or term with a new value. Default: `false`.
+   *
+   * @param   res - FluentResource object.
+   * @param   options
+   */
+  addResource(res, { allowOverrides = false } = {}) {
+    const errors = [];
+    for (let i = 0; i < res.body.length; i++) {
+      let entry = res.body[i];
+      if (entry.id.startsWith("-")) {
+        if (allowOverrides === false && this._terms.has(entry.id)) {
+          errors.push(new Error(`Attempt to override an existing term: "${entry.id}"`));
+          continue;
         }
-        variants[count++] = { key, value };
-      }
-      if (count === 0) {
-        return null;
-      }
-      if (star === void 0) {
-        throw new SyntaxError("Expected default variant");
-      }
-      return { variants, star };
-    }
-    function parseVariantKey() {
-      consumeToken(TOKEN_BRACKET_OPEN, SyntaxError);
-      let key;
-      if (test(RE_NUMBER_LITERAL)) {
-        key = parseNumberLiteral();
+        this._terms.set(entry.id, entry);
       } else {
-        key = {
-          type: "str",
-          value: match1(RE_IDENTIFIER)
-        };
-      }
-      consumeToken(TOKEN_BRACKET_CLOSE, SyntaxError);
-      return key;
-    }
-    function parseLiteral() {
-      if (test(RE_NUMBER_LITERAL)) {
-        return parseNumberLiteral();
-      }
-      if (source[cursor] === '"') {
-        return parseStringLiteral();
-      }
-      throw new SyntaxError("Invalid expression");
-    }
-    function parseNumberLiteral() {
-      let [, value, fraction = ""] = match2(RE_NUMBER_LITERAL);
-      let precision = fraction.length;
-      return {
-        type: "num",
-        value: parseFloat(value),
-        precision
-      };
-    }
-    function parseStringLiteral() {
-      consumeChar('"', SyntaxError);
-      let value = "";
-      while (true) {
-        value += match1(RE_STRING_RUN);
-        if (source[cursor] === "\\") {
-          value += parseEscapeSequence();
+        if (allowOverrides === false && this._messages.has(entry.id)) {
+          errors.push(new Error(`Attempt to override an existing message: "${entry.id}"`));
           continue;
         }
-        if (consumeChar('"')) {
-          return { type: "str", value };
-        }
-        throw new SyntaxError("Unclosed string literal");
+        this._messages.set(entry.id, entry);
       }
     }
-    function parseEscapeSequence() {
-      if (test(RE_STRING_ESCAPE)) {
-        return match1(RE_STRING_ESCAPE);
-      }
-      if (test(RE_UNICODE_ESCAPE)) {
-        let [, codepoint4, codepoint6] = match2(RE_UNICODE_ESCAPE);
-        let codepoint = parseInt(codepoint4 || codepoint6, 16);
-        return codepoint <= 55295 || 57344 <= codepoint ? String.fromCodePoint(codepoint) : "�";
-      }
-      throw new SyntaxError("Unknown escape sequence");
+    return errors;
+  }
+  /**
+   * Format a `Pattern` to a string.
+   *
+   * Format a raw `Pattern` into a string. `args` will be used to resolve
+   * references to variables passed as arguments to the translation.
+   *
+   * In case of errors `formatPattern` will try to salvage as much of the
+   * translation as possible and will still return a string. For performance
+   * reasons, the encountered errors are not returned but instead are appended
+   * to the `errors` array passed as the third argument.
+   *
+   *     let errors = [];
+   *     bundle.addResource(
+   *         new FluentResource("hello = Hello, {$name}!"));
+   *
+   *     let hello = bundle.getMessage("hello");
+   *     if (hello.value) {
+   *         bundle.formatPattern(hello.value, {name: "Jane"}, errors);
+   *         // Returns "Hello, Jane!" and `errors` is empty.
+   *
+   *         bundle.formatPattern(hello.value, undefined, errors);
+   *         // Returns "Hello, {$name}!" and `errors` is now:
+   *         // [<ReferenceError: Unknown variable: name>]
+   *     }
+   *
+   * If `errors` is omitted, the first encountered error will be thrown.
+   */
+  formatPattern(pattern, args = null, errors = null) {
+    if (typeof pattern === "string") {
+      return this._transform(pattern);
     }
-    function parseIndent() {
-      let start = cursor;
-      consumeToken(TOKEN_BLANK);
-      switch (source[cursor]) {
-        case ".":
-        case "[":
-        case "*":
-        case "}":
-        case void 0:
-          return false;
-        case "{":
-          return makeIndent(source.slice(start, cursor));
-      }
-      if (source[cursor - 1] === " ") {
-        return makeIndent(source.slice(start, cursor));
+    let scope = new Scope2(this, errors, args);
+    try {
+      let value = resolveComplexPattern(scope, pattern);
+      return value.toString(scope);
+    } catch (err) {
+      if (scope.errors && err instanceof Error) {
+        scope.errors.push(err);
+        return new FluentNone2().toString(scope);
       }
-      return false;
-    }
-    function trim(text, re) {
-      return text.replace(re, "");
-    }
-    function makeIndent(blank) {
-      let value = blank.replace(RE_BLANK_LINES, "\n");
-      let length = RE_INDENT.exec(blank)[1].length;
-      return new Indent(value, length);
+      throw err;
     }
   }
 }
-class Indent {
-  constructor(value, length) {
-    this.value = value;
-    this.length = length;
-  }
-}
 class RawBundleSource {
   constructor(params) {
     __publicField(this, "bundles", /* @__PURE__ */ new Map());
@@ -6785,6 +6785,63 @@ class BaseLocaleManager {
     return `${locales}|${[...namespaces].sort()}`;
   }
 }
+const DEFAULT_FETCH = (key, init) => fetch(`/locales/${key}`, init);
+class HTTPBundleSource {
+  constructor(params) {
+    __publicField(this, "fetch");
+    __publicField(this, "resources", /* @__PURE__ */ new Map());
+    this.fetch = params.fetch ?? DEFAULT_FETCH;
+  }
+  addSource(resource) {
+    throw new Error("Method not implemented.");
+  }
+  getKey(locale, namespace) {
+    return `${namespace}/${locale}`;
+  }
+  getBundles(locales, namespaces) {
+    const bundles = [];
+    const promises = [];
+    for (const locale of locales) {
+      const bundle = new FluentBundle2(locale);
+      bundles.push(bundle);
+      for (const namespace of namespaces) {
+        const key = this.getKey(locale, namespace);
+        const resource = this.resources.get(key);
+        if (resource) bundle.addResource(resource);
+        else promises.push([bundle, key, this.fetchResource(key)]);
+      }
+    }
+    void this.awaitResources(promises);
+    return bundles;
+  }
+  async awaitResources(promises) {
+    for (const [bundle, key, promise] of promises) {
+      let resource = null;
+      try {
+        resource = await promise;
+      } catch (error) {
+        console.warn(`exception while fetching resource for "${key}"`);
+        console.error(error);
+      }
+      if (resource === null) {
+        console.warn(`couldn't load resource for "${key}"`);
+      } else {
+        bundle.addResource(resource);
+      }
+    }
+  }
+  async fetchResource(key) {
+    const response = await this.fetch(key);
+    if (response.ok) {
+      const resource = new FluentResource(await response.text());
+      this.resources.set(key, resource);
+      return resource;
+    } else {
+      console.warn(`could not load i18n for ${key}`);
+      return null;
+    }
+  }
+}
 const INJECTION_KEY_PREFIX = "GLOBAL_LOCALE_MANAGER";
 const globalLocaleManagers = /* @__PURE__ */ new Map();
 class LocaleManager extends BaseLocaleManager {
@@ -6917,66 +6974,14 @@ function useI18N(namespace = "default") {
 function parseInjectionName(namespace) {
   return `${INJECTION_KEY_PREFIX}.${namespace}`;
 }
-const DEFAULT_FETCH = (key, init) => fetch(`/locales/${key}`, init);
-class HTTPBundleSource {
-  constructor(params) {
-    __publicField(this, "fetch");
-    __publicField(this, "resources", /* @__PURE__ */ new Map());
-    this.fetch = params.fetch ?? DEFAULT_FETCH;
-  }
-  addSource(resource) {
-    throw new Error("Method not implemented.");
-  }
-  getKey(locale, namespace) {
-    return `${namespace}/${locale}`;
-  }
-  getBundles(locales, namespaces) {
-    const bundles = [];
-    const promises = [];
-    for (const locale of locales) {
-      const bundle = new FluentBundle2(locale);
-      bundles.push(bundle);
-      for (const namespace of namespaces) {
-        const key = this.getKey(locale, namespace);
-        const resource = this.resources.get(key);
-        if (resource) bundle.addResource(resource);
-        else promises.push([bundle, key, this.fetchResource(key)]);
-      }
-    }
-    void this.awaitResources(promises);
-    return bundles;
-  }
-  async awaitResources(promises) {
-    for (const [bundle, key, promise] of promises) {
-      let resource = null;
-      try {
-        resource = await promise;
-      } catch (error) {
-        console.warn(`exception while fetching resource for "${key}"`);
-        console.error(error);
-      }
-      if (resource === null) {
-        console.warn(`couldn't load resource for "${key}"`);
-      } else {
-        bundle.addResource(resource);
-      }
-    }
-  }
-  async fetchResource(key) {
-    const response = await this.fetch(key);
-    if (response.ok) {
-      const resource = new FluentResource(await response.text());
-      this.resources.set(key, resource);
-      return resource;
-    } else {
-      console.warn(`could not load i18n for ${key}`);
-      return null;
-    }
-  }
-}
+exports.BaseLocaleManager = BaseLocaleManager;
 exports.HTTPBundleSource = HTTPBundleSource;
 exports.INJECTION_KEY_PREFIX = INJECTION_KEY_PREFIX;
 exports.LocaleManager = LocaleManager;
+exports.MemoryStorageWrapper = MemoryStorageWrapper;
 exports.RawBundleSource = RawBundleSource;
+exports.createStorageWrapper = createStorageWrapper;
+exports.findLocaleManager = findLocaleManager;
+exports.globalLocaleManagers = globalLocaleManagers;
 exports.useI18N = useI18N;
 //# sourceMappingURL=i18n.cjs.map