@xndrjs/i18n 0.6.0 → 0.7.0-alpha.0

package/dist/index.js

@@ -1,4 +1,206 @@
 import { IntlMessageFormat } from 'intl-messageformat';
+import { parse } from '@formatjs/icu-messageformat-parser';
+
+// src/builder-loaders.ts
+async function invokeNamespaceLoader(loader, partition) {
+  if (partition === void 0) {
+    return await loader();
+  }
+  return await loader(partition);
+}
+
+// src/builder-multi.ts
+var I18nBuilderMultiInitialImpl = class {
+  constructor(engine, options) {
+    this.engine = engine;
+    this.options = options;
+  }
+  engine;
+  options;
+  withNamespaces(namespaces) {
+    return new I18nBuilderMultiReadyImpl(this.engine, this.options, { namespaces });
+  }
+};
+var I18nBuilderMultiReadyImpl = class _I18nBuilderMultiReadyImpl {
+  constructor(engine, options, state) {
+    this.engine = engine;
+    this.options = options;
+    this.state = state;
+  }
+  engine;
+  options;
+  state;
+  clone() {
+    return {
+      namespaces: this.state.namespaces,
+      ...this.state.locale !== void 0 ? { locale: this.state.locale } : {},
+      ...this.state.deliveryArea !== void 0 ? { deliveryArea: this.state.deliveryArea } : {}
+    };
+  }
+  withNamespaces(namespaces) {
+    return new _I18nBuilderMultiReadyImpl(this.engine, this.options, {
+      ...this.clone(),
+      namespaces
+    });
+  }
+  withLocale(locale) {
+    const { deliveryArea: _deliveryArea, ...rest } = this.clone();
+    return new I18nBuilderMultiForLocaleImpl(this.engine, this.options, { ...rest, locale });
+  }
+  withDeliveryArea(area) {
+    const { locale: _locale, ...rest } = this.clone();
+    return new I18nBuilderMultiPartitionedImpl(this.engine, this.options, { ...rest, deliveryArea: area });
+  }
+  async load() {
+    await applyMultiBuilderLoad(this.engine, this.options, this.state);
+    return this.engine.toScope({ namespaces: this.state.namespaces });
+  }
+};
+var I18nBuilderMultiPartitionedImpl = class _I18nBuilderMultiPartitionedImpl {
+  constructor(engine, options, state) {
+    this.engine = engine;
+    this.options = options;
+    this.state = state;
+  }
+  engine;
+  options;
+  state;
+  withNamespaces(namespaces) {
+    return new _I18nBuilderMultiPartitionedImpl(this.engine, this.options, {
+      ...this.state,
+      namespaces
+    });
+  }
+  async load() {
+    await applyMultiBuilderLoad(this.engine, this.options, this.state);
+    return this.engine.toScope({ namespaces: this.state.namespaces });
+  }
+};
+var I18nBuilderMultiForLocaleImpl = class {
+  constructor(engine, options, state) {
+    this.engine = engine;
+    this.options = options;
+    this.state = state;
+  }
+  engine;
+  options;
+  state;
+  async load() {
+    await applyMultiBuilderLoad(this.engine, this.options, this.state);
+    return this.engine.toScope({ namespaces: this.state.namespaces }).forLocale(this.state.locale);
+  }
+};
+async function applyMultiBuilderLoad(engine, options, state) {
+  if (state.namespaces.length === 0) {
+    throw new Error("[i18n] withNamespaces(...) is required before load().");
+  }
+  const partition = state.locale ?? state.deliveryArea;
+  await Promise.all(
+    state.namespaces.map(async (namespace) => {
+      const loader = options?.namespaceLoaders?.[namespace];
+      if (loader === void 0) {
+        return;
+      }
+      if (engine.hasBuilderResourceLoaded(namespace, partition)) {
+        return;
+      }
+      const data = await invokeNamespaceLoader(loader, partition);
+      engine.applyLoadMergeNamespace(namespace, data);
+      engine.markBuilderResourceLoaded(namespace, partition);
+    })
+  );
+}
+
+// src/single-builder.ts
+var I18nBuilderSingleImpl = class _I18nBuilderSingleImpl {
+  constructor(engine, options, state) {
+    this.engine = engine;
+    this.options = options;
+    if (state !== void 0) {
+      this.state = {
+        ...state.locale !== void 0 ? { locale: state.locale } : {},
+        ...state.deliveryArea !== void 0 ? { deliveryArea: state.deliveryArea } : {}
+      };
+    }
+  }
+  engine;
+  options;
+  state = {};
+  clone() {
+    return {
+      ...this.state.locale !== void 0 ? { locale: this.state.locale } : {},
+      ...this.state.deliveryArea !== void 0 ? { deliveryArea: this.state.deliveryArea } : {}
+    };
+  }
+  withLocale(locale) {
+    const { deliveryArea: _deliveryArea, ...rest } = this.clone();
+    return new I18nBuilderSingleForLocaleImpl(
+      this.engine,
+      this.options,
+      { ...rest, locale }
+    );
+  }
+  withDeliveryArea(_area) {
+    const { locale: _locale, ...rest } = this.clone();
+    return new _I18nBuilderSingleImpl(this.engine, this.options, {
+      ...rest,
+      deliveryArea: _area
+    });
+  }
+  async load() {
+    await applySingleBuilderLoad(this.engine, this.options, this.state);
+    return this.engine.toScope();
+  }
+};
+var I18nBuilderSingleForLocaleImpl = class {
+  constructor(engine, options, state) {
+    this.engine = engine;
+    this.options = options;
+    this.state = state;
+  }
+  engine;
+  options;
+  state;
+  async load() {
+    await applySingleBuilderLoad(this.engine, this.options, this.state);
+    return this.engine.toScope({ locale: this.state.locale });
+  }
+};
+async function applySingleBuilderLoad(engine, options, state) {
+  const partition = state.locale ?? state.deliveryArea;
+  const loader = options?.dictionaryLoader;
+  if (loader !== void 0) {
+    if (engine.hasBuilderResourceLoaded(partition)) {
+      return;
+    }
+    const data = await invokeNamespaceLoader(loader, partition);
+    engine.applyLoadMergeSingle(data);
+    engine.markBuilderResourceLoaded(partition);
+  }
+}
+
+// src/builder.ts
+function isMultiEngine(engine) {
+  return engine.__i18nEngineMode === "multi";
+}
+function createI18nSingleBuilder(engine, options) {
+  return new I18nBuilderSingleImpl(engine, options);
+}
+function createI18nMultiBuilder(engine, options) {
+  return new I18nBuilderMultiInitialImpl(engine, options);
+}
+function createI18nBuilder(engine, options) {
+  if (isMultiEngine(engine)) {
+    return createI18nMultiBuilder(
+      engine,
+      options
+    );
+  }
+  return createI18nSingleBuilder(
+    engine,
+    options
+  );
+}
 
 // src/deep-freeze.ts
 function deepFreeze(value) {
@@ -18,6 +220,21 @@ function cloneAndFreeze(value) {
   return deepFreeze(structuredClone(value));
 }
 
+// src/builder-load-registry.ts
+function formatBuilderResourceKey(namespace, partition) {
+  return `${namespace}\0${partition ?? ""}`;
+}
+var SINGLE_BUILDER_RESOURCE = "__dictionary__";
+var BuilderLoadRegistry = class {
+  loaded = /* @__PURE__ */ new Set();
+  has(namespace, partition) {
+    return this.loaded.has(formatBuilderResourceKey(namespace, partition));
+  }
+  mark(namespace, partition) {
+    this.loaded.add(formatBuilderResourceKey(namespace, partition));
+  }
+};
+
 // src/resolve-locale.ts
 function validateLocaleFallback(map) {
   for (const startLocale of Object.keys(map)) {
@@ -143,153 +360,238 @@ function resolveAndFormat(options) {
   }
 }
 
-// src/IcuTranslationProviderSingle.ts
-var IcuTranslationProviderSingleForLocale = class {
-  constructor(provider, locale) {
-    this.provider = provider;
-    this.locale = locale;
+// src/icu/extract-variables.ts
+function isPluralOrOrdinalNode(node) {
+  return node.type === 6 && "pluralType" in node && Boolean(node.pluralType);
+}
+function hasVariableName(node) {
+  return "value" in node && typeof node.value === "string";
+}
+function addVariableMeta(variables, name, type, role) {
+  const existing = variables[name];
+  if (!existing) {
+    variables[name] = { type, roles: /* @__PURE__ */ new Set([role]) };
+    return;
+  }
+  existing.roles.add(role);
+  existing.type = mergeVariableTypes(existing.type, type);
+}
+function mergeVariableTypes(left, right) {
+  if (left === right) {
+    return left;
   }
-  provider;
-  locale;
-  get(key, ...args) {
-    const params = args[0];
-    return this.provider.getWithLocale(String(key), this.locale, params);
+  if (left === "string" && right === "number" || left === "number" && right === "string") {
+    return "number";
   }
-};
-var IcuTranslationProviderSingle = class {
-  dictionary;
-  compiledCache = {};
-  localeFallback;
-  onMissing;
-  constructor(dictionary, options) {
-    this.dictionary = structuredClone(dictionary);
-    if (options?.localeFallback) {
-      validateLocaleFallback(options.localeFallback);
-      this.localeFallback = options.localeFallback;
+  return right;
+}
+function extractVariableMeta(nodes) {
+  const variables = {};
+  const walk = (walkNodes) => {
+    for (const node of walkNodes) {
+      if (node.type === 1 && hasVariableName(node)) {
+        addVariableMeta(variables, node.value, "string", "simple");
+      } else if (node.type === 2 && hasVariableName(node)) {
+        addVariableMeta(variables, node.value, "number", "number");
+      } else if (isPluralOrOrdinalNode(node) && hasVariableName(node)) {
+        const role = node.pluralType === "ordinal" ? "selectordinal" : "plural";
+        addVariableMeta(variables, node.value, "number", role);
+      } else if (node.type === 3 && hasVariableName(node)) {
+        addVariableMeta(variables, node.value, "date", "date");
+      } else if (node.type === 4 && hasVariableName(node)) {
+        addVariableMeta(variables, node.value, "date", "time");
+      } else if (node.type === 5 && hasVariableName(node)) {
+        addVariableMeta(variables, node.value, "string", "select");
+      }
+      if ("options" in node && node.options) {
+        for (const option of Object.values(node.options)) {
+          walk(option.value);
+        }
+      }
+      if ("children" in node && Array.isArray(node.children)) {
+        walk(node.children);
+      }
     }
-    this.onMissing = options?.onMissing ?? "throw";
+  };
+  walk(nodes);
+  return variables;
+}
+function variableMetaToSpec(meta) {
+  return Object.fromEntries(Object.entries(meta).map(([name, entry]) => [name, entry.type]));
+}
+function inferMergedVariableType(roles) {
+  const hasPlural = roles.has("plural");
+  const hasSelectordinal = roles.has("selectordinal");
+  const hasSelect = roles.has("select");
+  const hasSimple = roles.has("simple");
+  const hasNumber = roles.has("number");
+  const hasDate = roles.has("date");
+  const hasTime = roles.has("time");
+  if (hasPlural && hasSelectordinal) {
+    return "CONFLICT";
+  }
+  if (hasSelect && (hasPlural || hasSelectordinal || hasNumber)) {
+    return "CONFLICT";
+  }
+  if (hasPlural && hasSelect) {
+    return "CONFLICT";
+  }
+  if (hasSelectordinal && hasSelect) {
+    return "CONFLICT";
+  }
+  if (hasDate || hasTime) {
+    if (hasPlural || hasSelect || hasSelectordinal || hasSimple || hasNumber) {
+      return "CONFLICT";
+    }
+    return "date";
   }
-  get(key, locale, ...args) {
-    const params = args[0];
-    return this.getWithLocale(String(key), locale, params);
+  if (hasPlural || hasSelectordinal || hasNumber) {
+    return "number";
   }
-  getWithLocale(key, locale, params) {
-    return resolveAndFormat({
-      localeByKey: this.dictionary[key],
-      locale,
-      params,
-      getCache: (resolvedLocale) => {
-        if (!this.compiledCache[resolvedLocale]) {
-          this.compiledCache[resolvedLocale] = {};
-        }
-        return this.compiledCache[resolvedLocale];
-      },
-      context: {
-        key,
-        locale,
-        localeFallback: this.localeFallback,
-        onMissing: this.onMissing
-      }
-    });
+  if (hasSelect || hasSimple) {
+    return "string";
   }
-  forLocale(locale) {
-    return new IcuTranslationProviderSingleForLocale(this, locale);
+  return "string";
+}
+function mergeVariableMetaAcrossLocales(localeMetas) {
+  const keySignatures = localeMetas.map((meta) => Object.keys(meta).sort().join(","));
+  if (new Set(keySignatures).size > 1) {
+    return {
+      ok: false,
+      message: `Inconsistent ICU variable names across locales (keys: ${keySignatures.join(" vs ")})`
+    };
   }
-  getAll() {
-    return cloneAndFreeze(this.dictionary);
+  const merged = {};
+  const variableNames = new Set(localeMetas.flatMap((meta) => Object.keys(meta)));
+  for (const variableName of variableNames) {
+    const combinedRoles = /* @__PURE__ */ new Set();
+    for (const meta of localeMetas) {
+      for (const role of meta[variableName]?.roles ?? []) {
+        combinedRoles.add(role);
+      }
+    }
+    const mergedType = inferMergedVariableType(combinedRoles);
+    if (mergedType === "CONFLICT") {
+      const rolesByLocale = localeMetas.map((meta) => {
+        const entry = meta[variableName];
+        if (!entry) {
+          return null;
+        }
+        return [...entry.roles].sort().join("|");
+      }).filter((value) => value !== null);
+      return {
+        ok: false,
+        message: `Incompatible ICU variable "${variableName}" across locales (roles: ${rolesByLocale.join(" vs ")})`
+      };
+    }
+    merged[variableName] = mergedType;
   }
-  setAll(values) {
-    this.dictionary = structuredClone(values);
-    this.compiledCache = {};
+  return { ok: true, merged };
+}
+function parseTemplate(template) {
+  try {
+    const ast = parse(template);
+    const meta = extractVariableMeta(ast);
+    return { ok: true, args: variableMetaToSpec(meta), meta };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { ok: false, message };
   }
-};
+}
 
-// src/IcuTranslationProviderMulti.ts
-var IcuTranslationProviderMultiForLocale = class {
-  constructor(provider, locale) {
-    this.provider = provider;
-    this.locale = locale;
+// src/patch-key.ts
+function preloadKeySingle(key, locale) {
+  return `${key}:${locale}`;
+}
+function preloadKeyMulti(namespace, key, locale) {
+  return `${namespace}:${key}:${locale}`;
+}
+function seedPreloadedKeysSingle(dictionary, preloadedKeys) {
+  for (const [key, localeByKey] of Object.entries(dictionary)) {
+    if (localeByKey === void 0 || typeof localeByKey !== "object") {
+      continue;
+    }
+    for (const locale of Object.keys(localeByKey)) {
+      preloadedKeys.add(preloadKeySingle(key, locale));
+    }
   }
-  provider;
-  locale;
-  get(namespace, key, ...args) {
-    const params = args[0];
-    return this.provider.getWithLocale(String(namespace), String(key), this.locale, params);
+}
+function seedPreloadedKeysMulti(dictionary, preloadedKeys) {
+  for (const [namespace, keyDictionary] of Object.entries(dictionary)) {
+    if (keyDictionary === void 0 || typeof keyDictionary !== "object") {
+      continue;
+    }
+    for (const [key, localeByKey] of Object.entries(keyDictionary)) {
+      if (localeByKey === void 0 || typeof localeByKey !== "object") {
+        continue;
+      }
+      for (const locale of Object.keys(localeByKey)) {
+        preloadedKeys.add(preloadKeyMulti(namespace, key, locale));
+      }
+    }
   }
-};
-var IcuTranslationProviderMulti = class {
-  dictionary;
-  compiledCache = {};
-  localeFallback;
-  onMissing;
-  loadedNamespaces;
-  constructor(dictionary, options) {
-    this.dictionary = structuredClone(dictionary);
-    this.loadedNamespaces = new Set(Object.keys(dictionary));
-    if (options?.localeFallback) {
-      validateLocaleFallback(options.localeFallback);
-      this.localeFallback = options.localeFallback;
+}
+function recordPreloadedKeysSingle(partial, preloadedKeys) {
+  for (const [key, incomingLocales] of Object.entries(partial)) {
+    if (incomingLocales === void 0 || typeof incomingLocales !== "object") {
+      continue;
+    }
+    for (const locale of Object.keys(incomingLocales)) {
+      preloadedKeys.add(preloadKeySingle(key, locale));
     }
-    this.onMissing = options?.onMissing ?? "throw";
   }
-  get(namespace, key, locale, ...args) {
-    const params = args[0];
-    return this.getWithLocale(String(namespace), String(key), locale, params);
+}
+function recordPreloadedKeysMulti(namespace, partial, preloadedKeys) {
+  for (const [key, incomingLocales] of Object.entries(partial)) {
+    if (incomingLocales === void 0 || typeof incomingLocales !== "object") {
+      continue;
+    }
+    for (const locale of Object.keys(incomingLocales)) {
+      preloadedKeys.add(preloadKeyMulti(namespace, key, locale));
+    }
   }
-  getWithLocale(namespace, key, locale, params) {
-    if (!this.loadedNamespaces.has(namespace)) {
-      throw new Error(
-        `[i18n] Namespace not loaded: "${namespace}". Register it with setNamespace() before calling .get().`
-      );
+}
+function collectLocaleMetasForKey(localeByKey, patchedLocale, patchedMeta) {
+  const localeMetas = [patchedMeta];
+  for (const [locale, template] of Object.entries(localeByKey)) {
+    if (locale === patchedLocale) {
+      continue;
+    }
+    const parsed = parseTemplate(template);
+    if (parsed.ok) {
+      localeMetas.push(parsed.meta);
     }
-    const localeByKey = this.dictionary[namespace]?.[key];
-    return resolveAndFormat({
-      localeByKey,
-      locale,
-      params,
-      getCache: (resolvedLocale) => {
-        if (!this.compiledCache[resolvedLocale]) {
-          this.compiledCache[resolvedLocale] = {};
-        }
-        if (!this.compiledCache[resolvedLocale][namespace]) {
-          this.compiledCache[resolvedLocale][namespace] = {};
-        }
-        return this.compiledCache[resolvedLocale][namespace];
-      },
-      context: {
-        namespace,
-        key,
-        locale,
-        localeFallback: this.localeFallback,
-        onMissing: this.onMissing
-      }
-    });
   }
-  forLocale(locale) {
-    return new IcuTranslationProviderMultiForLocale(this, locale);
+  return localeMetas;
+}
+function assertPatchKeySingle(key, locale, template, preloadedKeys, localeByKey) {
+  if (!preloadedKeys.has(preloadKeySingle(key, locale))) {
+    throw new Error(`[i18n] Key not preloaded: ${key} (${locale})`);
   }
-  getAll() {
-    return cloneAndFreeze(this.dictionary);
+  const parsed = parseTemplate(template);
+  if (!parsed.ok) {
+    throw new Error(`[i18n] ICU syntax error on patch: ${parsed.message}`);
   }
-  hasNamespace(namespace) {
-    return this.loadedNamespaces.has(namespace);
+  const localeMetas = collectLocaleMetasForKey(localeByKey ?? {}, locale, parsed.meta);
+  const merged = mergeVariableMetaAcrossLocales(localeMetas);
+  if (!merged.ok) {
+    throw new Error(`[i18n] ICU args mismatch on patch: ${merged.message}`);
   }
-  setAll(values) {
-    this.dictionary = structuredClone(values);
-    this.compiledCache = {};
-    this.loadedNamespaces = new Set(Object.keys(values));
+}
+function assertPatchKeyMulti(namespace, key, locale, template, preloadedKeys, localeByKey) {
+  if (!preloadedKeys.has(preloadKeyMulti(namespace, key, locale))) {
+    throw new Error(`[i18n] Key not preloaded: ${namespace}.${key} (${locale})`);
   }
-  setNamespace(namespace, values) {
-    this.dictionary = {
-      ...this.dictionary,
-      [namespace]: structuredClone(values)
-    };
-    this.loadedNamespaces.add(namespace);
-    for (const locale of Object.keys(this.compiledCache)) {
-      delete this.compiledCache[locale]?.[namespace];
-    }
+  const parsed = parseTemplate(template);
+  if (!parsed.ok) {
+    throw new Error(`[i18n] ICU syntax error on patch: ${parsed.message}`);
   }
-};
+  const localeMetas = collectLocaleMetasForKey(localeByKey ?? {}, locale, parsed.meta);
+  const merged = mergeVariableMetaAcrossLocales(localeMetas);
+  if (!merged.ok) {
+    throw new Error(`[i18n] ICU args mismatch on patch: ${merged.message}`);
+  }
+}
 
 // src/project-locales.ts
 function classifyAreaLocales(areaLocales, localeFallback) {
@@ -380,7 +682,266 @@ function projectDictionaryLocalesCore(dictionary, locales, localeFallback) {
   }
   return result;
 }
+function mergeNamespaceLocalesCore(existing, incoming) {
+  const merged = structuredClone(existing);
+  for (const [key, incomingLocales] of Object.entries(incoming)) {
+    if (incomingLocales === void 0 || typeof incomingLocales !== "object") {
+      continue;
+    }
+    merged[key] = {
+      ...merged[key] ?? {},
+      ...incomingLocales
+    };
+  }
+  return merged;
+}
+function mergeDictionaryLocalesCore(existing, incoming) {
+  const merged = structuredClone(existing);
+  for (const namespace of Object.keys(incoming)) {
+    const incomingNamespace = incoming[namespace];
+    if (incomingNamespace === void 0) {
+      continue;
+    }
+    merged[namespace] = mergeNamespaceLocalesCore(
+      merged[namespace] ?? {},
+      incomingNamespace
+    );
+  }
+  return merged;
+}
+
+// src/scope-single.ts
+var I18nScopeSingleImpl = class {
+  constructor(engine) {
+    this.engine = engine;
+  }
+  engine;
+  t = (key, locale, ...args) => {
+    const params = args[0];
+    return this.engine.getWithLocale(String(key), locale, params);
+  };
+  forLocale = (locale) => {
+    return new I18nScopeSingleForLocaleImpl(this.engine, locale);
+  };
+};
+var I18nScopeSingleForLocaleImpl = class _I18nScopeSingleForLocaleImpl {
+  constructor(engine, locale) {
+    this.engine = engine;
+    this.locale = locale;
+  }
+  engine;
+  locale;
+  t = (key, ...args) => {
+    const params = args[0];
+    return this.engine.getWithLocale(String(key), this.locale, params);
+  };
+  set = (key, template) => {
+    this.engine.patchKey(String(key), this.locale, template);
+  };
+  forLocale = (locale) => {
+    return new _I18nScopeSingleForLocaleImpl(this.engine, locale);
+  };
+};
+
+// src/IcuTranslationProviderSingle.ts
+var IcuTranslationProviderSingle = class {
+  __i18nEngineMode = "single";
+  dictionary;
+  compiledCache = {};
+  preloadedKeys = /* @__PURE__ */ new Set();
+  builderLoadRegistry = new BuilderLoadRegistry();
+  localeFallback;
+  onMissing;
+  constructor(dictionary, options) {
+    this.dictionary = structuredClone(dictionary);
+    seedPreloadedKeysSingle(this.dictionary, this.preloadedKeys);
+    if (options?.localeFallback) {
+      validateLocaleFallback(options.localeFallback);
+      this.localeFallback = options.localeFallback;
+    }
+    this.onMissing = options?.onMissing ?? "throw";
+  }
+  getWithLocale(key, locale, params) {
+    return resolveAndFormat({
+      localeByKey: this.dictionary[key],
+      locale,
+      params,
+      getCache: (resolvedLocale) => {
+        if (!this.compiledCache[resolvedLocale]) {
+          this.compiledCache[resolvedLocale] = {};
+        }
+        return this.compiledCache[resolvedLocale];
+      },
+      context: {
+        key,
+        locale,
+        localeFallback: this.localeFallback,
+        onMissing: this.onMissing
+      }
+    });
+  }
+  toScope(options) {
+    if (options?.locale !== void 0) {
+      return new I18nScopeSingleForLocaleImpl(this, options.locale);
+    }
+    return new I18nScopeSingleImpl(this);
+  }
+  getAll() {
+    return cloneAndFreeze(this.dictionary);
+  }
+  hasBuilderResourceLoaded(partition) {
+    return this.builderLoadRegistry.has(SINGLE_BUILDER_RESOURCE, partition);
+  }
+  markBuilderResourceLoaded(partition) {
+    this.builderLoadRegistry.mark(SINGLE_BUILDER_RESOURCE, partition);
+  }
+  applyLoadMergeSingle(values) {
+    this.dictionary = mergeNamespaceLocalesCore(this.dictionary, values);
+    recordPreloadedKeysSingle(values, this.preloadedKeys);
+    for (const [key, incomingLocales] of Object.entries(values)) {
+      if (incomingLocales === void 0 || typeof incomingLocales !== "object") {
+        continue;
+      }
+      for (const locale of Object.keys(incomingLocales)) {
+        delete this.compiledCache[locale]?.[key];
+      }
+    }
+  }
+  patchKey(key, locale, template) {
+    assertPatchKeySingle(key, locale, template, this.preloadedKeys, this.dictionary[key]);
+    this.dictionary = mergeNamespaceLocalesCore(this.dictionary, {
+      [key]: { [locale]: template }
+    });
+    delete this.compiledCache[locale]?.[key];
+  }
+};
+
+// src/scope-multi.ts
+var I18nScopeMultiImpl = class {
+  constructor(engine) {
+    this.engine = engine;
+  }
+  engine;
+  t = (namespace, key, locale, ...args) => {
+    const params = args[0];
+    return this.engine.getWithLocale(String(namespace), String(key), locale, params);
+  };
+  forLocale = (locale) => {
+    return new I18nScopeMultiForLocaleImpl(this.engine, locale);
+  };
+};
+var I18nScopeMultiForLocaleImpl = class _I18nScopeMultiForLocaleImpl {
+  constructor(engine, locale) {
+    this.engine = engine;
+    this.locale = locale;
+  }
+  engine;
+  locale;
+  t = (namespace, key, ...args) => {
+    const params = args[0];
+    return this.engine.getWithLocale(String(namespace), String(key), this.locale, params);
+  };
+  set = (namespace, key, template) => {
+    this.engine.patchKeyMulti(String(namespace), String(key), this.locale, template);
+  };
+  forLocale = (locale) => {
+    return new _I18nScopeMultiForLocaleImpl(this.engine, locale);
+  };
+};
+
+// src/IcuTranslationProviderMulti.ts
+var IcuTranslationProviderMulti = class {
+  __i18nEngineMode = "multi";
+  dictionary;
+  compiledCache = {};
+  preloadedKeys = /* @__PURE__ */ new Set();
+  builderLoadRegistry = new BuilderLoadRegistry();
+  localeFallback;
+  onMissing;
+  constructor(dictionary, options) {
+    this.dictionary = structuredClone(dictionary);
+    seedPreloadedKeysMulti(this.dictionary, this.preloadedKeys);
+    if (options?.localeFallback) {
+      validateLocaleFallback(options.localeFallback);
+      this.localeFallback = options.localeFallback;
+    }
+    this.onMissing = options?.onMissing ?? "throw";
+  }
+  getWithLocale(namespace, key, locale, params) {
+    const localeByKey = this.dictionary[namespace]?.[key];
+    return resolveAndFormat({
+      localeByKey,
+      locale,
+      params,
+      getCache: (resolvedLocale) => {
+        if (!this.compiledCache[resolvedLocale]) {
+          this.compiledCache[resolvedLocale] = {};
+        }
+        if (!this.compiledCache[resolvedLocale][namespace]) {
+          this.compiledCache[resolvedLocale][namespace] = {};
+        }
+        return this.compiledCache[resolvedLocale][namespace];
+      },
+      context: {
+        namespace,
+        key,
+        locale,
+        localeFallback: this.localeFallback,
+        onMissing: this.onMissing
+      }
+    });
+  }
+  toScope(options) {
+    if (options.locale !== void 0) {
+      return new I18nScopeMultiForLocaleImpl(this, options.locale);
+    }
+    return new I18nScopeMultiImpl(this);
+  }
+  getAll() {
+    return cloneAndFreeze(this.dictionary);
+  }
+  hasBuilderResourceLoaded(namespace, partition) {
+    return this.builderLoadRegistry.has(namespace, partition);
+  }
+  markBuilderResourceLoaded(namespace, partition) {
+    this.builderLoadRegistry.mark(namespace, partition);
+  }
+  applyLoadMergeNamespace(namespace, values) {
+    const existing = this.dictionary[namespace];
+    const merged = mergeNamespaceLocalesCore(existing ?? {}, values);
+    this.dictionary = {
+      ...this.dictionary,
+      [namespace]: merged
+    };
+    recordPreloadedKeysMulti(namespace, values, this.preloadedKeys);
+    for (const [key, incomingLocales] of Object.entries(values)) {
+      if (incomingLocales === void 0 || typeof incomingLocales !== "object") {
+        continue;
+      }
+      for (const locale of Object.keys(incomingLocales)) {
+        delete this.compiledCache[locale]?.[namespace]?.[key];
+      }
+    }
+  }
+  applyLoadMergeAll(values) {
+    for (const namespace of Object.keys(values)) {
+      const incoming = values[namespace];
+      if (incoming !== void 0) {
+        this.applyLoadMergeNamespace(namespace, incoming);
+      }
+    }
+  }
+  patchKeyMulti(namespace, key, locale, template) {
+    const namespaceDictionary = this.dictionary[namespace];
+    const localeByKey = namespaceDictionary?.[key];
+    assertPatchKeyMulti(namespace, key, locale, template, this.preloadedKeys, localeByKey);
+    this.applyLoadMergeNamespace(
+      namespace,
+      { [key]: { [locale]: template } }
+    );
+  }
+};
 
-export { IcuTranslationProviderMulti, IcuTranslationProviderSingle, formatLocaleFallbackChain, projectDictionaryForDeliveryAreaCore, projectDictionaryLocalesCore, projectNamespaceForDeliveryAreaCore, projectNamespaceLocalesCore, resolveLocaleTemplate, validateLocaleFallback };
+export { IcuTranslationProviderMulti, IcuTranslationProviderSingle, createI18nBuilder, createI18nMultiBuilder, createI18nSingleBuilder, formatLocaleFallbackChain, invokeNamespaceLoader, mergeDictionaryLocalesCore, mergeNamespaceLocalesCore, projectDictionaryForDeliveryAreaCore, projectDictionaryLocalesCore, projectNamespaceForDeliveryAreaCore, projectNamespaceLocalesCore, resolveLocaleTemplate, validateLocaleFallback };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map