langsys-js-typescript 0.6.4 → 0.7.0

package/dist/pure.js

@@ -0,0 +1,1196 @@
+'use strict';
+
+var intlMessageformat = require('intl-messageformat');
+
+// src/utils.ts
+var isEmpty = (data) => {
+  if (typeof data === "number" || typeof data === "boolean") return false;
+  if (typeof data === "undefined" || data === null) return true;
+  if (typeof data.length !== "undefined") {
+    return data.length === 0;
+  }
+  if (typeof data === "object") return Object.keys(data).length === 0;
+  return false;
+};
+function toUtf8ByteString(input) {
+  const bytes = new TextEncoder().encode(input);
+  let out = "";
+  for (let i = 0; i < bytes.length; i += 8192) {
+    out += String.fromCharCode(...bytes.subarray(i, i + 8192));
+  }
+  return out;
+}
+function md5(inputString) {
+  if (typeof inputString !== "string") inputString = JSON.stringify(inputString);
+  return md5Core(toUtf8ByteString(inputString));
+}
+function md5Legacy(inputString) {
+  if (typeof inputString !== "string") inputString = JSON.stringify(inputString);
+  return md5Core(inputString);
+}
+function md5Core(inputString) {
+  const hc = "0123456789abcdef";
+  function rh(n) {
+    let j, s = "";
+    for (j = 0; j <= 3; j++) s += hc.charAt(n >> j * 8 + 4 & 15) + hc.charAt(n >> j * 8 & 15);
+    return s;
+  }
+  function ad(x2, y) {
+    const l = (x2 & 65535) + (y & 65535);
+    const m = (x2 >> 16) + (y >> 16) + (l >> 16);
+    return m << 16 | l & 65535;
+  }
+  function rl(n, c2) {
+    return n << c2 | n >>> 32 - c2;
+  }
+  function cm(q, a2, b2, x2, s, t) {
+    return ad(rl(ad(ad(a2, q), ad(x2, t)), s), b2);
+  }
+  function ff(a2, b2, c2, d2, x2, s, t) {
+    return cm(b2 & c2 | ~b2 & d2, a2, b2, x2, s, t);
+  }
+  function gg(a2, b2, c2, d2, x2, s, t) {
+    return cm(b2 & d2 | c2 & ~d2, a2, b2, x2, s, t);
+  }
+  function hh(a2, b2, c2, d2, x2, s, t) {
+    return cm(b2 ^ c2 ^ d2, a2, b2, x2, s, t);
+  }
+  function ii(a2, b2, c2, d2, x2, s, t) {
+    return cm(c2 ^ (b2 | ~d2), a2, b2, x2, s, t);
+  }
+  function sb(x2) {
+    let i2;
+    const nblk = (x2.length + 8 >> 6) + 1;
+    const blks = new Array(nblk * 16);
+    for (i2 = 0; i2 < nblk * 16; i2++) blks[i2] = 0;
+    for (i2 = 0; i2 < x2.length; i2++) blks[i2 >> 2] |= x2.charCodeAt(i2) << i2 % 4 * 8;
+    blks[i2 >> 2] |= 128 << i2 % 4 * 8;
+    blks[nblk * 16 - 2] = x2.length * 8;
+    return blks;
+  }
+  let i, x = sb("" + inputString), a = 1732584193, b = -271733879, c = -1732584194, d = 271733878, olda, oldb, oldc, oldd;
+  for (i = 0; i < x.length; i += 16) {
+    olda = a;
+    oldb = b;
+    oldc = c;
+    oldd = d;
+    a = ff(a, b, c, d, x[i + 0], 7, -680876936);
+    d = ff(d, a, b, c, x[i + 1], 12, -389564586);
+    c = ff(c, d, a, b, x[i + 2], 17, 606105819);
+    b = ff(b, c, d, a, x[i + 3], 22, -1044525330);
+    a = ff(a, b, c, d, x[i + 4], 7, -176418897);
+    d = ff(d, a, b, c, x[i + 5], 12, 1200080426);
+    c = ff(c, d, a, b, x[i + 6], 17, -1473231341);
+    b = ff(b, c, d, a, x[i + 7], 22, -45705983);
+    a = ff(a, b, c, d, x[i + 8], 7, 1770035416);
+    d = ff(d, a, b, c, x[i + 9], 12, -1958414417);
+    c = ff(c, d, a, b, x[i + 10], 17, -42063);
+    b = ff(b, c, d, a, x[i + 11], 22, -1990404162);
+    a = ff(a, b, c, d, x[i + 12], 7, 1804603682);
+    d = ff(d, a, b, c, x[i + 13], 12, -40341101);
+    c = ff(c, d, a, b, x[i + 14], 17, -1502002290);
+    b = ff(b, c, d, a, x[i + 15], 22, 1236535329);
+    a = gg(a, b, c, d, x[i + 1], 5, -165796510);
+    d = gg(d, a, b, c, x[i + 6], 9, -1069501632);
+    c = gg(c, d, a, b, x[i + 11], 14, 643717713);
+    b = gg(b, c, d, a, x[i + 0], 20, -373897302);
+    a = gg(a, b, c, d, x[i + 5], 5, -701558691);
+    d = gg(d, a, b, c, x[i + 10], 9, 38016083);
+    c = gg(c, d, a, b, x[i + 15], 14, -660478335);
+    b = gg(b, c, d, a, x[i + 4], 20, -405537848);
+    a = gg(a, b, c, d, x[i + 9], 5, 568446438);
+    d = gg(d, a, b, c, x[i + 14], 9, -1019803690);
+    c = gg(c, d, a, b, x[i + 3], 14, -187363961);
+    b = gg(b, c, d, a, x[i + 8], 20, 1163531501);
+    a = gg(a, b, c, d, x[i + 13], 5, -1444681467);
+    d = gg(d, a, b, c, x[i + 2], 9, -51403784);
+    c = gg(c, d, a, b, x[i + 7], 14, 1735328473);
+    b = gg(b, c, d, a, x[i + 12], 20, -1926607734);
+    a = hh(a, b, c, d, x[i + 5], 4, -378558);
+    d = hh(d, a, b, c, x[i + 8], 11, -2022574463);
+    c = hh(c, d, a, b, x[i + 11], 16, 1839030562);
+    b = hh(b, c, d, a, x[i + 14], 23, -35309556);
+    a = hh(a, b, c, d, x[i + 1], 4, -1530992060);
+    d = hh(d, a, b, c, x[i + 4], 11, 1272893353);
+    c = hh(c, d, a, b, x[i + 7], 16, -155497632);
+    b = hh(b, c, d, a, x[i + 10], 23, -1094730640);
+    a = hh(a, b, c, d, x[i + 13], 4, 681279174);
+    d = hh(d, a, b, c, x[i + 0], 11, -358537222);
+    c = hh(c, d, a, b, x[i + 3], 16, -722521979);
+    b = hh(b, c, d, a, x[i + 6], 23, 76029189);
+    a = hh(a, b, c, d, x[i + 9], 4, -640364487);
+    d = hh(d, a, b, c, x[i + 12], 11, -421815835);
+    c = hh(c, d, a, b, x[i + 15], 16, 530742520);
+    b = hh(b, c, d, a, x[i + 2], 23, -995338651);
+    a = ii(a, b, c, d, x[i + 0], 6, -198630844);
+    d = ii(d, a, b, c, x[i + 7], 10, 1126891415);
+    c = ii(c, d, a, b, x[i + 14], 15, -1416354905);
+    b = ii(b, c, d, a, x[i + 5], 21, -57434055);
+    a = ii(a, b, c, d, x[i + 12], 6, 1700485571);
+    d = ii(d, a, b, c, x[i + 3], 10, -1894986606);
+    c = ii(c, d, a, b, x[i + 10], 15, -1051523);
+    b = ii(b, c, d, a, x[i + 1], 21, -2054922799);
+    a = ii(a, b, c, d, x[i + 8], 6, 1873313359);
+    d = ii(d, a, b, c, x[i + 15], 10, -30611744);
+    c = ii(c, d, a, b, x[i + 6], 15, -1560198380);
+    b = ii(b, c, d, a, x[i + 13], 21, 1309151649);
+    a = ii(a, b, c, d, x[i + 4], 6, -145523070);
+    d = ii(d, a, b, c, x[i + 11], 10, -1120210379);
+    c = ii(c, d, a, b, x[i + 2], 15, 718787259);
+    b = ii(b, c, d, a, x[i + 9], 21, -343485551);
+    a = ad(a, olda);
+    b = ad(b, oldb);
+    c = ad(c, oldc);
+    d = ad(d, oldd);
+  }
+  return rh(a) + rh(b) + rh(c) + rh(d);
+}
+
+// src/identity.ts
+var TRANSLATABLE_ATTRIBUTES = [
+  "placeholder",
+  "alt",
+  "title",
+  "label",
+  // <option>, <optgroup>, <track> — the text a user reads in the picker
+  "aria-label",
+  "aria-placeholder",
+  "aria-description",
+  "aria-valuetext",
+  // the spoken value of a slider/meter
+  "aria-roledescription",
+  "data-error",
+  "data-error-message",
+  "data-validation-message",
+  "data-invalid-message",
+  "data-required-message",
+  "data-pattern-message",
+  // The 12 below converge on langsys-php's list, verified against
+  // `src/Html/HtmlParser.php` rather than taken on report. ORDER IS IDENTITY:
+  // `custom_id` hashes the token array, so these must stay appended in PHP's
+  // order — reordering them silently re-keys every block using one.
+  "data-confirm",
+  // Rails-style confirmation dialogs
+  "data-tooltip",
+  "data-title",
+  "data-content",
+  "data-original-title",
+  // Bootstrap 4 tooltip/popover
+  "data-bs-title",
+  // Bootstrap 5
+  "data-bs-content",
+  "data-loading-text",
+  "data-success-message",
+  "data-warning-message",
+  "data-empty-message",
+  "data-placeholder"
+  // editors that shadow the native attribute
+];
+var NON_TRANSLATABLE_ELEMENTS = ["script", "style", "template", "noscript", "math"];
+function isTranslationExcluded(element) {
+  if ((element.getAttribute("translate") ?? "").toLowerCase() === "no") return true;
+  if (!element.hasAttribute("data-notrans")) return false;
+  const value = (element.getAttribute("data-notrans") ?? "").trim().toLowerCase();
+  return value !== "false" && value !== "0";
+}
+var PHRASE_MARKER_ATTR = "data-ls-phrase";
+var PHRASE_MARKER_ATTR_LEGACY = "data-langsys-phrase";
+var PHRASE_MARKER_ATTRS = [PHRASE_MARKER_ATTR, PHRASE_MARKER_ATTR_LEGACY];
+var CONTENT_BLOCK_MARKER_ATTR = "data-ls-contentblock";
+var CONTENT_BLOCK_MARKER_ATTR_LEGACY = "data-langsys-contentblock";
+var CONTENT_BLOCK_MARKER_ATTRS = [
+  CONTENT_BLOCK_MARKER_ATTR,
+  CONTENT_BLOCK_MARKER_ATTR_LEGACY
+];
+var RESOLVED_MARKER_ATTR = "data-ls-resolved";
+var RESOLVED_MARKER_ATTR_LEGACY = "data-langsys-resolved";
+var RESOLVED_MARKER_ATTRS = [RESOLVED_MARKER_ATTR, RESOLVED_MARKER_ATTR_LEGACY];
+function normalizeTokenText(value) {
+  return stripC0Controls(value).replace(/\s+/g, " ").trim();
+}
+function stripC0Controls(value) {
+  return value.replace(/[\u0001-\u0008\u000B\u000C\u000E-\u001F]/g, "");
+}
+function normalizeMarkupPlaceholders(text) {
+  return text.replace(/%([A-Za-z_][A-Za-z0-9_]*)%/g, "{$1}");
+}
+function generateCustomId(category, tokens) {
+  return md5(canonicalContentBlockJson(category, tokens));
+}
+function hashableCategory(category) {
+  return !category || category === "__uncategorized__" ? "" : category;
+}
+function canonicalContentBlockJson(category, tokens) {
+  return JSON.stringify([hashableCategory(category), tokens]);
+}
+function generateLegacyCustomId(category, tokens) {
+  return md5Legacy(JSON.stringify([category, tokens]));
+}
+function encodeRichPhrase(nodes) {
+  const slots = [];
+  const assembled = _encodeRichNodes(nodes, slots);
+  return { phrase: normalizeMarkupPlaceholders(normalizeTokenText(assembled)), slots };
+}
+function _encodeRichNodes(nodes, slots) {
+  let out = "";
+  for (const node of nodes) {
+    if ("text" in node) {
+      out += node.text;
+      continue;
+    }
+    if ("param" in node) {
+      out += `{${node.param}}`;
+      continue;
+    }
+    const index = slots.length;
+    slots.push(node.payload);
+    out += `{m${index}o}` + _encodeRichNodes(node.children, slots) + `{m${index}c}`;
+  }
+  return out;
+}
+
+// src/logger.ts
+var STYLES = {
+  log: "display:inline-block;background:rgb(239,239,244);color:black;font-weight:bold;padding:3px 7px;border-radius:3px",
+  warn: "display:inline-block;background:gold;color:black;font-weight:bold;padding:3px 7px;border-radius:3px",
+  error: "display:inline-block;background:#e0005a;color:#fff;font-weight:bold;padding:3px 7px;border-radius:3px"
+};
+function supportsStyle() {
+  try {
+    if (typeof window === "undefined") return false;
+    return !(typeof navigator !== "undefined" && navigator.product === "ReactNative");
+  } catch {
+    return false;
+  }
+}
+function emit(level, label, args) {
+  if (supportsStyle()) {
+    console[level](`%c${label}`, STYLES[level], ...args);
+  } else {
+    console[level](`[${label}]`, ...args);
+  }
+}
+var Logger = class {
+  constructor(debugEnabled = false) {
+    this.debugEnabled = debugEnabled;
+  }
+  log(...args) {
+    if (!this.debugEnabled) return;
+    emit("log", "Langsys Debug", args);
+  }
+  warn(...args) {
+    emit("warn", "Langsys Warning", args);
+  }
+  error(...args) {
+    emit("error", "Langsys Error", args);
+  }
+};
+var logger = new Logger(false);
+
+// src/locale.ts
+var LANGUAGE_SCRIPT_REGION = /^(?:[a-z]{2,3}|[a-z]{5,8})(?:-[a-z]{4})?(?:-(?:[a-z]{2}|\d{3}))?(?=-|$)/i;
+function canonicalizeLocale(locale) {
+  if (!locale || typeof locale !== "string") return locale;
+  const cleaned = locale.trim().replace(/_/g, "-");
+  try {
+    Intl.getCanonicalLocales(cleaned);
+    const [head] = LANGUAGE_SCRIPT_REGION.exec(cleaned);
+    return (Intl.getCanonicalLocales(head)[0] + cleaned.slice(head.length)).toLowerCase();
+  } catch {
+    if (logger.debugEnabled) logger.warn(
+      `"${locale}" is not a valid BCP 47 locale tag. Falling back to lowercasing it as-is, which will very likely miss the catalog and render base language with no other symptom.`
+    );
+    return cleaned.toLowerCase();
+  }
+}
+function maximizedLangScript(locale) {
+  try {
+    const max = new Intl.Locale(canonicalizeLocale(locale)).maximize();
+    return `${max.language}-${max.script ?? ""}`.toLowerCase();
+  } catch {
+    return null;
+  }
+}
+function isICU(template) {
+  return ICU_PATTERN.test(template);
+}
+var ICU_PATTERN = /\{[^{}]+,\s*(plural|select|selectordinal|number|date|time)\s*[,}]/;
+function adoptPercentPlaceholders(template, params) {
+  if (!template.includes("%") || !params) return template;
+  return template.replace(
+    /%([A-Za-z_][A-Za-z0-9_]*)%/g,
+    (whole, name) => Object.prototype.hasOwnProperty.call(params, name) ? `{${name}}` : whole
+  );
+}
+var IDENTIFIER_KEY = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var GENDER_COMPANION = /^(.+)_gender$/;
+function escapeForRegExp(key2) {
+  return key2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function findUnusedParamKeys(texts, params) {
+  if (!params) return [];
+  const keys = Object.keys(params);
+  if (!keys.length || !texts.length) return keys;
+  const haystack = texts.join("\0");
+  const isPlaceholder = (key2) => {
+    const escaped = escapeForRegExp(key2);
+    const percent = IDENTIFIER_KEY.test(key2) ? `|%${escaped}%` : "";
+    return new RegExp(`\\{\\s*${escaped}\\s*[,}]${percent}`).test(haystack);
+  };
+  return keys.filter((key2) => {
+    if (isPlaceholder(key2)) return false;
+    const genderOf = GENDER_COMPANION.exec(key2)?.[1];
+    return !(genderOf && isPlaceholder(genderOf));
+  });
+}
+function interpolate(template, params = {}, locale, options = {}) {
+  template = adoptPercentPlaceholders(template, params);
+  if (isICU(template)) {
+    const resolved = locale || "en";
+    const hasNullParam = !!params && Object.values(params).some((value) => value === null);
+    let formatterError;
+    if (!hasNullParam) {
+      try {
+        return formatIcu(new intlMessageformat.IntlMessageFormat(template, resolved), params, resolved);
+      } catch (error) {
+        formatterError = error;
+      }
+    }
+    let ast;
+    try {
+      ast = new intlMessageformat.IntlMessageFormat(template, resolved).ast;
+    } catch {
+      return simpleInterpolate(template, params, locale);
+    }
+    if (!Array.isArray(ast)) return simpleInterpolate(template, params, locale);
+    const defaulted = [];
+    const recovered = _recoverMissingArgs(JSON.parse(JSON.stringify(ast)), params, defaulted);
+    if (defaulted.length) {
+      if (options.onDefaulted) options.onDefaulted([...new Set(defaulted)], template, resolved);
+      else noteDefaultedArgs(template, resolved, defaulted);
+    }
+    if (defaulted.length || formatterError === void 0) {
+      try {
+        return formatIcu(new intlMessageformat.IntlMessageFormat(recovered, resolved), params, resolved);
+      } catch (error) {
+        formatterError = error;
+      }
+    }
+    if (options.onFormatterFailure) options.onFormatterFailure(formatterError, template, resolved);
+    else noteFormatterFailure(template, resolved, formatterError);
+    return renderWithoutFormatter(ast, params, resolved);
+  }
+  return simpleInterpolate(template, params, locale);
+}
+function defaultedArguments(template, params = {}, locale = "en") {
+  template = adoptPercentPlaceholders(template, params);
+  if (!isICU(template)) return [];
+  let ast;
+  try {
+    ast = new intlMessageformat.IntlMessageFormat(template, locale).ast;
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(ast)) return [];
+  const defaulted = [];
+  _recoverMissingArgs(JSON.parse(JSON.stringify(ast)), params, defaulted);
+  return [...new Set(defaulted)];
+}
+var ICU_LITERAL = 0;
+var ICU_ARGUMENT = 1;
+var ICU_NUMBER = 2;
+var ICU_DATE = 3;
+var ICU_TIME = 4;
+var ICU_SELECT = 5;
+var ICU_PLURAL = 6;
+var ICU_POUND = 7;
+var ICU_TAG = 8;
+var notifiedDefaults = /* @__PURE__ */ new Set();
+function noteDefaultedArgs(template, locale, names) {
+  if (!logger.debugEnabled) return;
+  const key2 = `${locale}\0${template}`;
+  if (notifiedDefaults.has(key2)) return;
+  notifiedDefaults.add(key2);
+  const unique = [...new Set(names)];
+  logger.warn(
+    `Interpolation defaulted ${unique.length === 1 ? "argument" : "arguments"} ${unique.map((n) => `"${n}"`).join(", ")} while rendering a '${locale}' string. The translated phrase asks for ${unique.length === 1 ? "it" : "them"} but the source phrase does not, which is normal \u2014 a gendered target locale can introduce an argument the source never had. The neutral branch was used. Pass ${unique.length === 1 ? "the value" : "the values"} in \`params\` if your app knows ${unique.length === 1 ? "it" : "them"}.`
+  );
+}
+function _recoverMissingArgs(nodes, params, defaulted) {
+  const out = [];
+  for (const node of nodes) {
+    const name = node.value;
+    const value = name !== void 0 && name in params ? params[name] : void 0;
+    const supplied = value !== void 0 && value !== null;
+    if (node.type === ICU_TAG) {
+      out.push({ ...node, children: _recoverMissingArgs(node.children ?? [], params, defaulted) });
+      continue;
+    }
+    if (node.type === ICU_SELECT || node.type === ICU_PLURAL) {
+      if (supplied) {
+        const options = {};
+        for (const [key2, branch2] of Object.entries(node.options ?? {})) {
+          options[key2] = { value: _recoverMissingArgs(branch2.value, params, defaulted) };
+        }
+        out.push({ ...node, options });
+        continue;
+      }
+      const other = node.options?.other;
+      if (!other) {
+        out.push(node);
+        continue;
+      }
+      if (name) defaulted.push(name);
+      const branch = _recoverMissingArgs(other.value, params, defaulted);
+      out.push(
+        ...branch.map(
+          (child) => child.type === ICU_POUND ? { type: ICU_LITERAL, value: `{${name}}` } : child
+        )
+      );
+      continue;
+    }
+    if (!supplied && (node.type === ICU_ARGUMENT || node.type === ICU_NUMBER || node.type === ICU_DATE || node.type === ICU_TIME)) {
+      if (name) defaulted.push(name);
+      out.push({ type: ICU_LITERAL, value: `{${name}}` });
+      continue;
+    }
+    out.push(node);
+  }
+  return out;
+}
+var notifiedFailures = /* @__PURE__ */ new Set();
+function noteFormatterFailure(template, locale, error) {
+  const key2 = `${locale}\0${template}`;
+  if (notifiedFailures.has(key2)) return;
+  notifiedFailures.add(key2);
+  const reason = error instanceof Error ? error.message : String(error);
+  logger.warn(
+    `The message formatter failed on a '${locale}' phrase, so it was rendered by the SDK's own branch selection. Fix the phrase: ${JSON.stringify(template)}. Formatter error: ${reason}`
+  );
+}
+function renderWithoutFormatter(nodes, params, locale, pound) {
+  let out = "";
+  for (const node of nodes) {
+    const name = node.value;
+    const value = name !== void 0 && params && name in params ? params[name] : void 0;
+    const supplied = value !== void 0 && value !== null;
+    switch (node.type) {
+      case ICU_LITERAL:
+        out += node.value ?? "";
+        break;
+      case ICU_POUND:
+        out += pound === void 0 ? "#" : typeof pound === "string" ? pound : formatScalar(pound, locale);
+        break;
+      case ICU_TAG:
+        out += `<${name}>${renderWithoutFormatter(node.children ?? [], params, locale, pound)}</${name}>`;
+        break;
+      case ICU_SELECT: {
+        const options = node.options ?? {};
+        const branch = (supplied ? options[String(value)] : void 0) ?? options.other;
+        out += branch ? renderWithoutFormatter(branch.value, params, locale, pound) : `{${name}}`;
+        break;
+      }
+      case ICU_PLURAL: {
+        const options = node.options ?? {};
+        const count = supplied ? Number(value) : NaN;
+        if (Number.isNaN(count)) {
+          const other = options.other;
+          out += other ? renderWithoutFormatter(other.value, params, locale, `{${name}}`) : `{${name}}`;
+          break;
+        }
+        const adjusted = count - (node.offset ?? 0);
+        let branch = options[`=${count}`];
+        if (!branch) {
+          try {
+            branch = options[new Intl.PluralRules(locale, { type: node.pluralType ?? "cardinal" }).select(adjusted)];
+          } catch {
+          }
+        }
+        branch = branch ?? options.other;
+        out += branch ? renderWithoutFormatter(branch.value, params, locale, adjusted) : `{${name}}`;
+        break;
+      }
+      default:
+        out += supplied ? formatScalar(value, locale) : `{${name}}`;
+    }
+  }
+  return out;
+}
+function formatIcu(message, params, locale) {
+  const scalars = Object.fromEntries(Object.entries(params ?? {}).map(([name, value]) => [name, typeof value === "boolean" ? String(value) : value]));
+  const out = message.format(scalars);
+  if (typeof out === "string") return out;
+  return Array.isArray(out) ? out.map((part) => typeof part === "string" ? part : formatScalar(part, locale)).join("") : formatScalar(out, locale);
+}
+function formatScalar(value, locale) {
+  try {
+    if (value instanceof Date) return new Intl.DateTimeFormat(locale, { dateStyle: "medium" }).format(value);
+    if (typeof value === "number" || typeof value === "bigint") return new Intl.NumberFormat(locale).format(value);
+  } catch {
+  }
+  return value instanceof Date ? value.toISOString() : String(value);
+}
+function simpleInterpolate(template, params, locale) {
+  return template.replace(/\{([^{},]+)\}/g, (match, rawKey) => {
+    const key2 = rawKey.trim();
+    if (!(key2 in params)) return match;
+    const value = params[key2];
+    if (value === void 0 || value === null) return match;
+    if (value instanceof Date) {
+      try {
+        return new Intl.DateTimeFormat(locale || "en", { dateStyle: "medium" }).format(value);
+      } catch {
+        return value.toISOString();
+      }
+    }
+    if (typeof value === "number" || typeof value === "bigint") {
+      try {
+        return new Intl.NumberFormat(locale || "en").format(value);
+      } catch {
+        return String(value);
+      }
+    }
+    return String(value);
+  });
+}
+
+// src/legacy-value.ts
+var LEGACY_FORMATS = ["laravel", "vue-i18n", "i18next", "gettext", "rails-i18n", "plain"];
+var SUPPORTED_LEGACY_FORMATS = ["i18next", "vue-i18n", "plain"];
+var PLURAL_CATEGORIES = ["zero", "one", "two", "few", "many", "other"];
+var PLACEHOLDER = /%%|%\{([A-Za-z_][A-Za-z0-9_]*)\}|%\(([A-Za-z_][A-Za-z0-9_]*)\)[sd]|%\([A-Za-z_][A-Za-z0-9_]*\)[-+ #0-9.]*[a-zA-Z]|%<[A-Za-z_][A-Za-z0-9_]*>[-+ #0-9.]*[a-zA-Z]|%(?:\.\d+)?[sdif](?![A-Za-z])|\{\{\s*([A-Za-z_][A-Za-z0-9_]*)\s*\}\}|(?<![\w:]):([a-z][a-z0-9_]*)/g;
+var CASE_TRANSFORM = /(?<![\w:]):[A-Z][A-Za-z0-9_]*/;
+var Unconvertible = class extends Error {
+};
+function convertLegacyValue(value, format = "plain") {
+  value = String(value);
+  if (CASE_TRANSFORM.test(value)) {
+    return unrecognised(value, "uses a case-transforming placeholder (:Name or :NAME), which ICU cannot express");
+  }
+  if (!value.includes("|")) return convertPlaceholders(value);
+  if (format === "vue-i18n") return convertVuePipes(value);
+  return unrecognised(
+    value,
+    format === "i18next" ? 'holds a "|", which i18next does not read as a plural' : `holds a "|" in a file with no plural format declared; declare the file's format to convert it`
+  );
+}
+function convertLegacyPluralForms(forms) {
+  const raw = PLURAL_CATEGORIES.filter((c) => forms[c] !== void 0).map((c) => forms[c]).join(" | ");
+  if (forms.other === void 0) return unrecognised(raw, 'is a plural with no "other" form');
+  const branches = [];
+  for (const category of PLURAL_CATEGORIES) {
+    const text = forms[category];
+    if (text === void 0) continue;
+    if (CASE_TRANSFORM.test(text)) {
+      return unrecognised(raw, "uses a case-transforming placeholder (:Name or :NAME), which ICU cannot express");
+    }
+    branches.push([category, text]);
+  }
+  return plural(branches, raw);
+}
+function convertLegacyCall(text, entryPoint) {
+  if (entryPoint === "t") return { text: String(text), recognised: true, issue: null };
+  if (entryPoint === "vue-i18n" || entryPoint === "i18next") return convertLegacyValue(text, entryPoint);
+  throw new Error(`Unknown entry point "${String(entryPoint)}"; expected t, vue-i18n or i18next`);
+}
+function convertVuePipes(value) {
+  const segments = value.split("|").map((s) => s.trim());
+  if (segments.length === 2) return plural([["=1", segments[0]], ["other", segments[1]]], value);
+  if (segments.length === 3) return plural([["=0", segments[0]], ["=1", segments[1]], ["other", segments[2]]], value);
+  return unrecognised(value, `is a vue-i18n plural with ${segments.length} forms; only 2 or 3 map to ICU`);
+}
+function plural(branches, raw) {
+  const parts = [];
+  for (const [selector, text] of branches) {
+    const converted = convertPlaceholders(text);
+    if (!converted.recognised) return unrecognised(raw, converted.issue);
+    parts.push(`${selector} {${converted.text.replace(/\{(?:count|n)\}/g, "#")}}`);
+  }
+  return { text: `{count, plural, ${parts.join(" ")}}`, recognised: true, issue: null };
+}
+function convertPlaceholders(value) {
+  try {
+    const text = value.replace(PLACEHOLDER, (match, rails, python, braces, laravel) => {
+      if (match === "%%") return "%";
+      const name = rails ?? python ?? braces ?? laravel;
+      if (name !== void 0) return `{${name}}`;
+      throw new Unconvertible(
+        match.startsWith("%(") || match.startsWith("%<") ? `uses a formatted placeholder (${match}), which {name} cannot express` : `uses a positional placeholder (${match}), which names no argument`
+      );
+    });
+    return { text, recognised: true, issue: null };
+  } catch (error) {
+    if (error instanceof Unconvertible) return unrecognised(value, error.message);
+    throw error;
+  }
+}
+function unrecognised(value, issue) {
+  return { text: value, recognised: false, issue };
+}
+
+// src/legacy-keys.ts
+var LegacyFormatError = class extends Error {
+  constructor(message, file, format) {
+    super(message);
+    this.file = file;
+    this.format = format;
+    this.name = "LegacyFormatError";
+  }
+};
+var FOREIGN_EXTENSIONS = {
+  php: "laravel",
+  yml: "rails-i18n",
+  yaml: "rails-i18n",
+  po: "gettext",
+  mo: "gettext"
+};
+function createLegacyKeys(files) {
+  const normalized = files.map(normalize);
+  return {
+    resolve(key2) {
+      if (typeof key2 !== "string" || key2 === "") return null;
+      for (const file of normalized) {
+        const found = lookup(file, key2);
+        if (!found) continue;
+        const converted = convert(found.value, file.format);
+        return { ...converted, phrase: converted.text, category: found.category, key: key2, file: file.name };
+      }
+      return null;
+    },
+    duplicates() {
+      const seen = {};
+      for (const file of normalized) {
+        for (const key2 of Object.keys(leaves(file))) (seen[key2] ??= []).push(file.name);
+      }
+      return Object.fromEntries(Object.entries(seen).filter(([, names]) => names.length > 1));
+    },
+    problems() {
+      const problems = [];
+      for (const file of normalized) {
+        if (file.data === null) {
+          problems.push({ file: file.name, key: null, issue: "is not a JSON object", fix: "pass the parsed contents of the file" });
+          continue;
+        }
+        for (const [key2, value] of Object.entries(leaves(file))) {
+          const converted = convert(value, file.format);
+          if (!converted.recognised) {
+            problems.push({
+              file: file.name,
+              key: key2,
+              issue: converted.issue,
+              fix: "rewrite the value as Langsys source text, or declare the file's format"
+            });
+          }
+        }
+      }
+      return problems;
+    }
+  };
+}
+function normalize(file) {
+  const name = String(file?.name ?? "");
+  const extension = name.includes(".") ? name.slice(name.lastIndexOf(".") + 1).toLowerCase() : "";
+  if (extension === "mo") {
+    const po = name.slice(0, -3) + ".po";
+    throw new LegacyFormatError(
+      `The legacy file ${name} is a compiled gettext catalog. gettext reads .po only (${po}), and gettext is not a format this core reads; it reads ${SUPPORTED_LEGACY_FORMATS.join(", ")}.`,
+      name,
+      "gettext"
+    );
+  }
+  const declared = file?.format;
+  const format = declared ?? FOREIGN_EXTENSIONS[extension] ?? "plain";
+  if (!SUPPORTED_LEGACY_FORMATS.includes(format)) {
+    const known = LEGACY_FORMATS.includes(format);
+    throw new LegacyFormatError(
+      `The legacy file ${name} is in the ${known ? "" : "unknown "}format "${format}", which this core does not read. It reads ${SUPPORTED_LEGACY_FORMATS.join(", ")}.`,
+      name,
+      format
+    );
+  }
+  const data = isRecord(file?.data) ? file.data : null;
+  return { name, format, namespace: file?.namespace ? String(file.namespace) : null, data };
+}
+function lookup(file, key2) {
+  if (!file.data) return null;
+  const pairs = file.format === "i18next";
+  if (file.namespace !== null) {
+    if (!key2.startsWith(file.namespace + ".")) return null;
+    const value2 = valueAt(file.data, key2.slice(file.namespace.length + 1).split("."), pairs);
+    return value2 === null ? null : { value: value2, category: file.namespace };
+  }
+  if (!key2.includes(".")) {
+    const value2 = valueAt(file.data, [key2], pairs);
+    return value2 === null ? null : { value: value2, category: null };
+  }
+  const flat = file.data[key2];
+  if (typeof flat === "string") return { value: flat, category: looksLikeAPath(key2) ? key2.slice(0, key2.indexOf(".")) : null };
+  const value = valueAt(file.data, key2.split("."), pairs);
+  return value === null ? null : { value, category: key2.slice(0, key2.indexOf(".")) };
+}
+function valueAt(data, segments, pairs) {
+  const last = segments.pop();
+  let container = data;
+  for (const segment of segments) {
+    if (!isRecord(container) || !(segment in container)) return null;
+    container = container[segment];
+  }
+  if (!isRecord(container)) return null;
+  if (pairs) {
+    const forms = {};
+    for (const category of PLURAL_CATEGORIES) {
+      const value2 = container[`${last}_${category}`];
+      if (typeof value2 === "string") forms[category] = value2;
+    }
+    if (Object.keys(forms).length > 0) return forms;
+    const singular = container[last];
+    const pluralForm = container[`${last}_plural`];
+    if (typeof singular === "string" && typeof pluralForm === "string") return { one: singular, other: pluralForm };
+  }
+  const value = container[last];
+  return typeof value === "string" ? value : null;
+}
+function leaves(file) {
+  const out = {};
+  if (!file.data) return out;
+  const prefix = file.namespace !== null ? file.namespace + "." : "";
+  collect(file.data, prefix, out, file.format === "i18next");
+  return out;
+}
+var SUFFIXES = [...PLURAL_CATEGORIES.map((c) => `_${c}`), "_plural"];
+function collect(node, prefix, out, pairs) {
+  for (const [key2, value] of Object.entries(node)) {
+    if (isRecord(value)) {
+      collect(value, `${prefix}${key2}.`, out, pairs);
+      continue;
+    }
+    if (typeof value !== "string") continue;
+    if (pairs) {
+      const suffix = SUFFIXES.find((s) => key2.endsWith(s) && key2.length > s.length);
+      if (suffix) {
+        const base = key2.slice(0, -suffix.length);
+        const forms = valueAt(node, [base], true);
+        if (forms !== null && typeof forms !== "string") {
+          out[prefix + base] = forms;
+          continue;
+        }
+      }
+    }
+    if (!(prefix + key2 in out)) out[prefix + key2] = value;
+  }
+}
+function convert(value, format) {
+  return typeof value === "string" ? convertLegacyValue(value, format) : convertLegacyPluralForms(value);
+}
+function looksLikeAPath(key2) {
+  return /^[A-Za-z0-9_-]+(\.[A-Za-z0-9_-]+)+$/.test(key2);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/snapshot.ts
+var SNAPSHOT_FORMAT = "langsys-catalog-snapshot";
+var SNAPSHOT_VERSION = 1;
+var SnapshotError = class extends Error {
+  constructor(message, reason) {
+    super(message);
+    this.reason = reason;
+    this.name = "SnapshotError";
+  }
+};
+var PAYLOAD_MEMBERS = ["project_id", "generated_at", "base_locale", "locales", "categories", "catalog"];
+function canonicalSnapshotJson(value) {
+  if (value === null) return "null";
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number" || typeof value === "boolean") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(canonicalSnapshotJson).join(",")}]`;
+  if (typeof value === "object") {
+    const record = value;
+    const keys = Object.keys(record).filter((key2) => record[key2] !== void 0).sort(compareCodePoints);
+    return `{${keys.map((key2) => `${JSON.stringify(key2)}:${canonicalSnapshotJson(record[key2])}`).join(",")}}`;
+  }
+  throw new TypeError(`A snapshot cannot hold a ${typeof value}.`);
+}
+function snapshotChecksum(payload) {
+  const hashed = {};
+  for (const member of PAYLOAD_MEMBERS) hashed[member] = payload[member];
+  return "sha256:" + sha256Hex(canonicalSnapshotJson(hashed));
+}
+function buildSnapshot(options) {
+  const categories = [...new Set(options.categories.map(String))].sort(compareCodePoints);
+  const catalog = {};
+  for (const [locale, categoriesForLocale] of Object.entries(options.catalogs)) {
+    const kept = {};
+    for (const category of categories) {
+      if (Object.prototype.hasOwnProperty.call(categoriesForLocale, category)) kept[category] = categoriesForLocale[category];
+    }
+    catalog[locale.toLowerCase()] = kept;
+  }
+  const payload = {
+    project_id: String(options.projectId),
+    generated_at: (options.generatedAt ?? /* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z"),
+    base_locale: options.baseLocale.toLowerCase(),
+    locales: Object.keys(catalog).sort(compareCodePoints),
+    categories,
+    catalog
+  };
+  return { format: SNAPSHOT_FORMAT, version: SNAPSHOT_VERSION, ...payload, checksum: snapshotChecksum(payload) };
+}
+function parseSnapshot(input) {
+  let document = input;
+  if (typeof input === "string") {
+    try {
+      document = JSON.parse(input);
+    } catch {
+      throw new SnapshotError("This is not a Langsys catalog snapshot: it is not JSON.", "not-json");
+    }
+  }
+  if (typeof document !== "object" || document === null || Array.isArray(document)) {
+    throw new SnapshotError("This is not a Langsys catalog snapshot: it is not a JSON object.", "not-json");
+  }
+  const doc = document;
+  if (doc.format !== SNAPSHOT_FORMAT) {
+    throw new SnapshotError(`This is not a Langsys catalog snapshot: its format is ${JSON.stringify(doc.format)}, not "${SNAPSHOT_FORMAT}".`, "format");
+  }
+  if (doc.version !== SNAPSHOT_VERSION) {
+    throw new SnapshotError(`This snapshot is version ${JSON.stringify(doc.version)}; this SDK reads version ${SNAPSHOT_VERSION}. Export it again.`, "version");
+  }
+  for (const member of [...PAYLOAD_MEMBERS, "checksum"]) {
+    if (!Object.prototype.hasOwnProperty.call(doc, member)) {
+      throw new SnapshotError(`This snapshot has no "${member}". Export it again.`, "missing-member");
+    }
+  }
+  if (doc.checksum !== snapshotChecksum(doc)) {
+    throw new SnapshotError(
+      "This snapshot was changed after it was exported: its checksum does not match. A snapshot is a cache and is never edited; export it again.",
+      "checksum"
+    );
+  }
+  return doc;
+}
+function compareCodePoints(a, b) {
+  const ia = a[Symbol.iterator]();
+  const ib = b[Symbol.iterator]();
+  for (; ; ) {
+    const ca = ia.next();
+    const cb = ib.next();
+    if (ca.done || cb.done) return ca.done && cb.done ? 0 : ca.done ? -1 : 1;
+    const diff = ca.value.codePointAt(0) - cb.value.codePointAt(0);
+    if (diff !== 0) return diff;
+  }
+}
+function sha256Hex(text) {
+  const bytes = new TextEncoder().encode(text);
+  const length = bytes.length;
+  const blocks = Math.ceil((length + 9) / 64);
+  const words = new Uint32Array(blocks * 16);
+  for (let i = 0; i < length; i++) words[i >> 2] |= bytes[i] << 24 - i % 4 * 8;
+  words[length >> 2] |= 128 << 24 - length % 4 * 8;
+  words[words.length - 2] = Math.floor(length * 8 / 4294967296);
+  words[words.length - 1] = length * 8 >>> 0;
+  const h = new Uint32Array([1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225]);
+  const w = new Uint32Array(64);
+  for (let block = 0; block < words.length; block += 16) {
+    for (let t = 0; t < 16; t++) w[t] = words[block + t];
+    for (let t = 16; t < 64; t++) {
+      const s0 = rotr(w[t - 15], 7) ^ rotr(w[t - 15], 18) ^ w[t - 15] >>> 3;
+      const s1 = rotr(w[t - 2], 17) ^ rotr(w[t - 2], 19) ^ w[t - 2] >>> 10;
+      w[t] = w[t - 16] + s0 + w[t - 7] + s1 >>> 0;
+    }
+    let [a, b, c, d, e, f, g, hh] = [h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7]];
+    for (let t = 0; t < 64; t++) {
+      const t1 = hh + (rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)) + (e & f ^ ~e & g) + K[t] + w[t] >>> 0;
+      const t2 = (rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + (a & b ^ a & c ^ b & c) >>> 0;
+      hh = g;
+      g = f;
+      f = e;
+      e = d + t1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 >>> 0;
+    }
+    h[0] = h[0] + a >>> 0;
+    h[1] = h[1] + b >>> 0;
+    h[2] = h[2] + c >>> 0;
+    h[3] = h[3] + d >>> 0;
+    h[4] = h[4] + e >>> 0;
+    h[5] = h[5] + f >>> 0;
+    h[6] = h[6] + g >>> 0;
+    h[7] = h[7] + hh >>> 0;
+  }
+  return Array.from(h, (word) => word.toString(16).padStart(8, "0")).join("");
+}
+function rotr(value, bits) {
+  return value >>> bits | value << 32 - bits;
+}
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+
+// src/server-messages.ts
+var DEFAULT_SERVER_MESSAGE_CATEGORY = "Errors";
+var MARKER = /\{([a-z][a-z0-9_]*)\}/g;
+function templateMarkers(template) {
+  if (typeof template !== "string" || template === "") return [];
+  const names = [];
+  for (const match of template.matchAll(MARKER)) {
+    if (!names.includes(match[1])) names.push(match[1]);
+  }
+  return names;
+}
+function fillTemplate(template, params = {}) {
+  return String(template).replace(MARKER, (marker, name) => {
+    if (!Object.prototype.hasOwnProperty.call(params, name)) return marker;
+    const value = params[name];
+    if (value === void 0 || typeof value === "object" || typeof value === "function") return marker;
+    return String(value);
+  });
+}
+function toServerMessage(value, pieces = {}) {
+  if (!isRecord2(value)) return null;
+  const read = (piece) => value[pieces[piece] ?? piece];
+  const template = read("template");
+  const message = read("message");
+  const params = read("params");
+  const field = read("field");
+  const code = read("code");
+  const hasTemplate = typeof template === "string";
+  const hasMessage = typeof message === "string";
+  if (!hasTemplate && !hasMessage) return null;
+  return {
+    ...hasTemplate ? { template } : {},
+    ...isRecord2(params) ? { params } : {},
+    ...hasMessage ? { message } : {},
+    ...field !== void 0 && field !== null && field !== "" ? { field } : {},
+    ...code !== void 0 && code !== null ? { code } : {}
+  };
+}
+function resolveServerMessages(body, options) {
+  const { key: key2, resolver, pieces } = options ?? {};
+  if (typeof resolver !== "function" && (typeof key2 !== "string" || key2 === "")) {
+    throw new TypeError(
+      'resolveServerMessages needs to know where the entries sit: pass { key } with the path your server attaches them under (Laravel: "langsys_errors"), or { resolver }.'
+    );
+  }
+  if (typeof body === "string") {
+    try {
+      body = JSON.parse(body);
+    } catch {
+      return [];
+    }
+  }
+  const found = typeof resolver === "function" ? resolver(body) : dig(body, key2);
+  return toItems(found).map((item) => toServerMessage(item, pieces)).filter((entry) => entry !== null);
+}
+function toItems(found) {
+  if (Array.isArray(found)) return found;
+  if (!isRecord2(found)) return [];
+  const values = Object.values(found);
+  return values.every((value) => Array.isArray(value)) && values.length > 0 ? values.flat() : [found];
+}
+function dig(body, path) {
+  let node = body;
+  for (const segment of path.split(".")) {
+    if (typeof node !== "object" || node === null || !Object.prototype.hasOwnProperty.call(node, segment)) {
+      return void 0;
+    }
+    node = node[segment];
+  }
+  return node;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/var-names.ts
+var GRAMMAR = /^[a-z][a-z0-9_]*$/;
+var RESERVED = /^m\d+[oc]$/;
+var COUNT = /* @__PURE__ */ new Set(["length", "size", "count"]);
+var VALUE = /* @__PURE__ */ new Set(["value", "current"]);
+function snakeCase(segment) {
+  const snake = segment.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").toLowerCase().replace(/[^a-z0-9_]+/g, "_").replace(/_+/g, "_").replace(/^[^a-z]+/, "").replace(/_+$/, "");
+  return snake && GRAMMAR.test(snake) ? snake : null;
+}
+function derive(shape) {
+  if ("identifier" in shape) {
+    const name = snakeCase(shape.identifier);
+    return name ? { name, prev: null } : null;
+  }
+  if ("member" in shape) {
+    const segments = shape.member;
+    if (segments.length === 0) return null;
+    const last = segments[segments.length - 1];
+    if (segments.length >= 2 && (COUNT.has(last) || VALUE.has(last))) {
+      const base = snakeCase(segments[segments.length - 2]);
+      if (!base) return null;
+      const prev = segments.length >= 3 ? snakeCase(segments[segments.length - 3]) : null;
+      return { name: COUNT.has(last) ? `${base}_count` : base, prev };
+    }
+    const name = snakeCase(last);
+    if (!name) return null;
+    return { name, prev: segments.length >= 2 ? snakeCase(segments[segments.length - 2]) : null };
+  }
+  if ("call" in shape) {
+    return shape.call.args.length === 1 ? derive(shape.call.args[0]) : null;
+  }
+  return null;
+}
+var key = (shape) => JSON.stringify(shape);
+function identifies(shape) {
+  if ("call" in shape) return shape.call.callee !== "" && shape.call.args.every(identifies);
+  return !("other" in shape);
+}
+function derivePlaceholderNames(expressions) {
+  const names = expressions.map((e) => e.explicit ? snakeCase(e.explicit) ?? e.explicit : null);
+  const taken = new Set(names.filter((n) => n !== null));
+  const derived = expressions.map((e, i) => names[i] === null ? derive(e.shape) : null);
+  const firstOf = /* @__PURE__ */ new Map();
+  const sameAs = expressions.map((e, i) => {
+    if (names[i] !== null || !identifies(e.shape)) return i;
+    const k = key(e.shape);
+    if (!firstOf.has(k)) firstOf.set(k, i);
+    return firstOf.get(k);
+  });
+  const wanted = /* @__PURE__ */ new Map();
+  derived.forEach((d, i) => {
+    if (d && sameAs[i] === i) wanted.set(d.name, [...wanted.get(d.name) ?? [], i]);
+  });
+  const claim = (name) => {
+    let candidate = name;
+    for (let n = 2; taken.has(candidate) || RESERVED.test(candidate); n++) candidate = `${name}_${n}`;
+    taken.add(candidate);
+    return candidate;
+  };
+  for (let i = 0; i < expressions.length; i++) {
+    if (names[i] !== null || sameAs[i] !== i) continue;
+    const d = derived[i];
+    if (!d) continue;
+    const collides = (wanted.get(d.name)?.length ?? 0) > 1 || taken.has(d.name) || RESERVED.test(d.name);
+    names[i] = claim(collides && d.prev ? `${d.prev}_${d.name}` : d.name);
+  }
+  for (let i = 0; i < expressions.length; i++) {
+    if (names[i] === null && sameAs[i] === i) names[i] = claim("value");
+  }
+  return expressions.map((_, i) => names[sameAs[i]]);
+}
+
+// src/var-markers.ts
+var VAR_PARAM_ATTR = "data-ls-param";
+
+exports.CONTENT_BLOCK_MARKER_ATTR = CONTENT_BLOCK_MARKER_ATTR;
+exports.CONTENT_BLOCK_MARKER_ATTRS = CONTENT_BLOCK_MARKER_ATTRS;
+exports.CONTENT_BLOCK_MARKER_ATTR_LEGACY = CONTENT_BLOCK_MARKER_ATTR_LEGACY;
+exports.DEFAULT_SERVER_MESSAGE_CATEGORY = DEFAULT_SERVER_MESSAGE_CATEGORY;
+exports.LEGACY_FORMATS = LEGACY_FORMATS;
+exports.LegacyFormatError = LegacyFormatError;
+exports.NON_TRANSLATABLE_ELEMENTS = NON_TRANSLATABLE_ELEMENTS;
+exports.PHRASE_MARKER_ATTR = PHRASE_MARKER_ATTR;
+exports.PHRASE_MARKER_ATTRS = PHRASE_MARKER_ATTRS;
+exports.PHRASE_MARKER_ATTR_LEGACY = PHRASE_MARKER_ATTR_LEGACY;
+exports.RESOLVED_MARKER_ATTR = RESOLVED_MARKER_ATTR;
+exports.RESOLVED_MARKER_ATTRS = RESOLVED_MARKER_ATTRS;
+exports.RESOLVED_MARKER_ATTR_LEGACY = RESOLVED_MARKER_ATTR_LEGACY;
+exports.SNAPSHOT_FORMAT = SNAPSHOT_FORMAT;
+exports.SNAPSHOT_VERSION = SNAPSHOT_VERSION;
+exports.SUPPORTED_LEGACY_FORMATS = SUPPORTED_LEGACY_FORMATS;
+exports.SnapshotError = SnapshotError;
+exports.TRANSLATABLE_ATTRIBUTES = TRANSLATABLE_ATTRIBUTES;
+exports.VAR_PARAM_ATTR = VAR_PARAM_ATTR;
+exports.buildSnapshot = buildSnapshot;
+exports.canonicalContentBlockJson = canonicalContentBlockJson;
+exports.canonicalSnapshotJson = canonicalSnapshotJson;
+exports.canonicalizeLocale = canonicalizeLocale;
+exports.convertLegacyCall = convertLegacyCall;
+exports.convertLegacyPluralForms = convertLegacyPluralForms;
+exports.convertLegacyValue = convertLegacyValue;
+exports.createLegacyKeys = createLegacyKeys;
+exports.defaultedArguments = defaultedArguments;
+exports.derivePlaceholderNames = derivePlaceholderNames;
+exports.encodeRichPhrase = encodeRichPhrase;
+exports.fillTemplate = fillTemplate;
+exports.findUnusedParamKeys = findUnusedParamKeys;
+exports.generateCustomId = generateCustomId;
+exports.generateLegacyCustomId = generateLegacyCustomId;
+exports.interpolate = interpolate;
+exports.isEmpty = isEmpty;
+exports.isICU = isICU;
+exports.isTranslationExcluded = isTranslationExcluded;
+exports.maximizedLangScript = maximizedLangScript;
+exports.md5 = md5;
+exports.md5Legacy = md5Legacy;
+exports.normalizeMarkupPlaceholders = normalizeMarkupPlaceholders;
+exports.normalizeTokenText = normalizeTokenText;
+exports.parseSnapshot = parseSnapshot;
+exports.resolveServerMessages = resolveServerMessages;
+exports.snakeCase = snakeCase;
+exports.snapshotChecksum = snapshotChecksum;
+exports.stripC0Controls = stripC0Controls;
+exports.templateMarkers = templateMarkers;
+exports.toServerMessage = toServerMessage;
+//# sourceMappingURL=pure.js.map
+//# sourceMappingURL=pure.js.map