inline-i18n-multi 0.4.0 → 0.6.0

package/dist/index.mjs

@@ -8,6 +8,156 @@ function setLocale(locale) {
 function getLocale() {
   return currentLocale;
 }
+
+// src/config.ts
+function defaultWarningHandler(warning) {
+  const parts = [`[inline-i18n] Missing translation for locale "${warning.requestedLocale}"`];
+  if (warning.key) {
+    parts.push(`key: "${warning.key}"`);
+  }
+  parts.push(`Available: [${warning.availableLocales.join(", ")}]`);
+  if (warning.fallbackUsed) {
+    parts.push(`Using fallback: "${warning.fallbackUsed}"`);
+  }
+  console.warn(parts.join(" | "));
+}
+function isDevMode() {
+  try {
+    if (typeof globalThis !== "undefined" && "process" in globalThis) {
+      const proc = globalThis.process;
+      return proc?.env?.NODE_ENV !== "production";
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+var defaultConfig = {
+  defaultLocale: "en",
+  fallbackLocale: "en",
+  autoParentLocale: true,
+  fallbackChain: {},
+  warnOnMissing: isDevMode(),
+  onMissingTranslation: defaultWarningHandler,
+  debugMode: false,
+  loader: void 0
+};
+var config = { ...defaultConfig };
+function configure(options) {
+  config = { ...config, ...options };
+}
+function getConfig() {
+  return {
+    ...defaultConfig,
+    ...config
+  };
+}
+function resetConfig() {
+  config = { ...defaultConfig };
+}
+function getParentLocale(locale) {
+  const dashIndex = locale.indexOf("-");
+  if (dashIndex > 0) {
+    return locale.substring(0, dashIndex);
+  }
+  return void 0;
+}
+function buildFallbackChain(locale) {
+  const cfg = getConfig();
+  if (cfg.fallbackChain[locale]) {
+    return [locale, ...cfg.fallbackChain[locale]];
+  }
+  const chain = [locale];
+  if (cfg.autoParentLocale) {
+    let current = locale;
+    while (true) {
+      const parent = getParentLocale(current);
+      if (parent && !chain.includes(parent)) {
+        chain.push(parent);
+        current = parent;
+      } else {
+        break;
+      }
+    }
+  }
+  const finalFallback = cfg.fallbackLocale;
+  if (finalFallback && !chain.includes(finalFallback)) {
+    chain.push(finalFallback);
+  }
+  return chain;
+}
+function emitWarning(warning) {
+  const cfg = getConfig();
+  if (cfg.warnOnMissing && cfg.onMissingTranslation) {
+    cfg.onMissingTranslation(warning);
+  }
+}
+function applyDebugFormat(output, debugInfo) {
+  const cfg = getConfig();
+  if (!cfg.debugMode) {
+    return output;
+  }
+  const options = typeof cfg.debugMode === "object" ? cfg.debugMode : { showMissingPrefix: true, showFallbackPrefix: true };
+  if (debugInfo.isMissing && options.showMissingPrefix !== false) {
+    const prefix = options.missingPrefixFormat ? options.missingPrefixFormat(debugInfo.requestedLocale, debugInfo.key) : `[MISSING: ${debugInfo.requestedLocale}] `;
+    return prefix + output;
+  }
+  if (debugInfo.isFallback && options.showFallbackPrefix !== false && debugInfo.usedLocale) {
+    const prefix = options.fallbackPrefixFormat ? options.fallbackPrefixFormat(debugInfo.requestedLocale, debugInfo.usedLocale, debugInfo.key) : `[${debugInfo.requestedLocale} -> ${debugInfo.usedLocale}] `;
+    return prefix + output;
+  }
+  return output;
+}
+function handleMissingVar(varName, locale) {
+  const cfg = getConfig();
+  if (cfg.missingVarHandler) {
+    return cfg.missingVarHandler(varName, locale);
+  }
+  return `{${varName}}`;
+}
+var customFormatters = /* @__PURE__ */ new Map();
+var RESERVED_FORMATTER_NAMES = /* @__PURE__ */ new Set([
+  "plural",
+  "select",
+  "selectordinal",
+  "number",
+  "date",
+  "time",
+  "relativeTime",
+  "list",
+  "currency"
+]);
+function registerFormatter(name, formatter) {
+  if (RESERVED_FORMATTER_NAMES.has(name)) {
+    throw new Error(`Cannot register formatter "${name}": reserved ICU type name`);
+  }
+  customFormatters.set(name, formatter);
+}
+function clearFormatters() {
+  customFormatters.clear();
+}
+function buildCustomFormatterPattern() {
+  if (customFormatters.size === 0) return null;
+  const names = [...customFormatters.keys()].map((n) => n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+  return new RegExp(`\\{(\\w+),\\s*(${names})(?:,\\s*(\\w+))?\\}`, "g");
+}
+function preprocessCustomFormatters(template) {
+  const replacements = /* @__PURE__ */ new Map();
+  const pattern = buildCustomFormatterPattern();
+  if (!pattern) return { processed: template, replacements };
+  let counter = 0;
+  const processed = template.replace(pattern, (_, variable, formatterName, style) => {
+    const placeholder = `__CUSTOM_${counter++}__`;
+    replacements.set(placeholder, { variable, formatterName, style });
+    return `{${placeholder}}`;
+  });
+  return { processed, replacements };
+}
+function hasCustomFormatter(template) {
+  const pattern = buildCustomFormatterPattern();
+  if (!pattern) return false;
+  return pattern.test(template);
+}
 var DATE_STYLES = {
   short: { dateStyle: "short" },
   medium: { dateStyle: "medium" },
@@ -49,11 +199,11 @@ function toDate(value) {
 function formatNumberElement(el, vars, locale) {
   const value = vars[el.value];
   if (value === void 0) {
-    return `{${el.value}}`;
+    return handleMissingVar(el.value, locale);
   }
   const num = typeof value === "number" ? value : Number(value);
   if (isNaN(num)) {
-    return `{${el.value}}`;
+    return handleMissingVar(el.value, locale);
   }
   let options = {};
   if (el.style) {
@@ -76,7 +226,7 @@ function formatNumberElement(el, vars, locale) {
 function formatDateElement(el, vars, locale) {
   const value = vars[el.value];
   if (value === void 0) {
-    return `{${el.value}}`;
+    return handleMissingVar(el.value, locale);
   }
   let options = {};
   if (el.style) {
@@ -90,13 +240,13 @@ function formatDateElement(el, vars, locale) {
     const date = toDate(value);
     return new Intl.DateTimeFormat(locale, options).format(date);
   } catch {
-    return `{${el.value}}`;
+    return handleMissingVar(el.value, locale);
   }
 }
 function formatTimeElement(el, vars, locale) {
   const value = vars[el.value];
   if (value === void 0) {
-    return `{${el.value}}`;
+    return handleMissingVar(el.value, locale);
   }
   let options = {};
   if (el.style) {
@@ -110,7 +260,68 @@ function formatTimeElement(el, vars, locale) {
     const date = toDate(value);
     return new Intl.DateTimeFormat(locale, options).format(date);
   } catch {
-    return `{${el.value}}`;
+    return handleMissingVar(el.value, locale);
+  }
+}
+var CURRENCY_PATTERN = /\{(\w+),\s*currency(?:,\s*(\w+))?\}/g;
+function preprocessCurrency(template) {
+  const replacements = /* @__PURE__ */ new Map();
+  let counter = 0;
+  const processed = template.replace(CURRENCY_PATTERN, (_, variable, currencyCode) => {
+    const placeholder = `__CURRENCY_${counter++}__`;
+    replacements.set(placeholder, { variable, currencyCode: currencyCode || "USD" });
+    return `{${placeholder}}`;
+  });
+  return { processed, replacements };
+}
+function formatCurrencyValue(variableName, currencyCode, vars, locale) {
+  const value = vars[variableName];
+  if (value === void 0) {
+    return handleMissingVar(variableName, locale);
+  }
+  const num = typeof value === "number" ? value : Number(value);
+  if (isNaN(num)) {
+    return handleMissingVar(variableName, locale);
+  }
+  try {
+    return new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency: currencyCode
+    }).format(num);
+  } catch {
+    return String(num);
+  }
+}
+var COMPACT_NUMBER_PATTERN = /\{(\w+),\s*number,\s*(compact|compactLong)\}/g;
+function preprocessCompactNumber(template) {
+  const replacements = /* @__PURE__ */ new Map();
+  let counter = 0;
+  const processed = template.replace(COMPACT_NUMBER_PATTERN, (_, variable, style) => {
+    const placeholder = `__COMPACT_${counter++}__`;
+    replacements.set(placeholder, {
+      variable,
+      display: style === "compactLong" ? "long" : "short"
+    });
+    return `{${placeholder}}`;
+  });
+  return { processed, replacements };
+}
+function formatCompactNumber(variableName, display, vars, locale) {
+  const value = vars[variableName];
+  if (value === void 0) {
+    return handleMissingVar(variableName, locale);
+  }
+  const num = typeof value === "number" ? value : Number(value);
+  if (isNaN(num)) {
+    return handleMissingVar(variableName, locale);
+  }
+  try {
+    return new Intl.NumberFormat(locale, {
+      notation: "compact",
+      compactDisplay: display
+    }).format(num);
+  } catch {
+    return String(num);
   }
 }
 function getRelativeTimeUnit(date, now = /* @__PURE__ */ new Date()) {
@@ -144,7 +355,7 @@ function preprocessRelativeTime(template) {
 function formatRelativeTimeValue(variableName, style, vars, locale) {
   const value = vars[variableName];
   if (value === void 0) {
-    return `{${variableName}}`;
+    return handleMissingVar(variableName, locale);
   }
   try {
     const date = toDate(value);
@@ -152,7 +363,7 @@ function formatRelativeTimeValue(variableName, style, vars, locale) {
     const options = style && RELATIVE_TIME_STYLES[style] || RELATIVE_TIME_STYLES.long;
     return new Intl.RelativeTimeFormat(locale, options).format(relValue, unit);
   } catch {
-    return `{${variableName}}`;
+    return handleMissingVar(variableName, locale);
   }
 }
 var LIST_PATTERN = /\{(\w+),\s*list(?:,\s*(\w+))?(?:,\s*(\w+))?\}/g;
@@ -179,7 +390,7 @@ function preprocessList(template) {
 function formatListValue(variableName, type, style, vars, locale) {
   const value = vars[variableName];
   if (value === void 0 || !Array.isArray(value)) {
-    return `{${variableName}}`;
+    return handleMissingVar(variableName, locale);
   }
   const options = {
     type: type || "conjunction",
@@ -192,10 +403,32 @@ function formatListValue(variableName, type, style, vars, locale) {
   }
 }
 function interpolateICU(template, vars, locale) {
-  const { processed: afterRelTime, replacements: relTimeReplacements } = preprocessRelativeTime(template);
+  const { processed: afterCustom, replacements: customReplacements } = preprocessCustomFormatters(template);
+  const { processed: afterCurrency, replacements: currencyReplacements } = preprocessCurrency(afterCustom);
+  const { processed: afterCompact, replacements: compactReplacements } = preprocessCompactNumber(afterCurrency);
+  const { processed: afterRelTime, replacements: relTimeReplacements } = preprocessRelativeTime(afterCompact);
   const { processed: afterList, replacements: listReplacements } = preprocessList(afterRelTime);
   const ast = parse(afterList);
   let result = formatElements(ast, vars, locale, null);
+  for (const [placeholder, { variable, formatterName, style }] of customReplacements) {
+    const value = vars[variable];
+    let formatted;
+    if (value === void 0) {
+      formatted = handleMissingVar(variable, locale);
+    } else {
+      const formatter = customFormatters.get(formatterName);
+      formatted = formatter ? formatter(value, locale, style) : String(value);
+    }
+    result = result.replace(`{${placeholder}}`, formatted);
+  }
+  for (const [placeholder, { variable, currencyCode }] of currencyReplacements) {
+    const formatted = formatCurrencyValue(variable, currencyCode, vars, locale);
+    result = result.replace(`{${placeholder}}`, formatted);
+  }
+  for (const [placeholder, { variable, display }] of compactReplacements) {
+    const formatted = formatCompactNumber(variable, display, vars, locale);
+    result = result.replace(`{${placeholder}}`, formatted);
+  }
   for (const [placeholder, { variable, style }] of relTimeReplacements) {
     const formatted = formatRelativeTimeValue(variable, style, vars, locale);
     result = result.replace(`{${placeholder}}`, formatted);
@@ -215,7 +448,11 @@ function formatElement(el, vars, locale, currentPluralValue) {
   }
   if (isArgumentElement(el)) {
     const value = vars[el.value];
-    return value !== void 0 ? String(value) : `{${el.value}}`;
+    if (value !== void 0) return String(value);
+    if (el.value.startsWith("__") && el.value.endsWith("__")) {
+      return `{${el.value}}`;
+    }
+    return handleMissingVar(el.value, locale);
   }
   if (isPoundElement(el)) {
     return currentPluralValue !== null ? String(currentPluralValue) : "#";
@@ -240,7 +477,7 @@ function formatElement(el, vars, locale, currentPluralValue) {
 function formatPlural(el, vars, locale) {
   const value = vars[el.value];
   if (typeof value !== "number") {
-    return `{${el.value}}`;
+    return handleMissingVar(el.value, locale);
   }
   const adjustedValue = value - el.offset;
   const pluralRules = new Intl.PluralRules(locale, { type: el.pluralType });
@@ -255,7 +492,7 @@ function formatPlural(el, vars, locale) {
   if (el.options.other) {
     return formatElements(el.options.other.value, vars, locale, adjustedValue);
   }
-  return `{${el.value}}`;
+  return handleMissingVar(el.value, locale);
 }
 function formatSelect(el, vars, locale) {
   const value = vars[el.value];
@@ -266,9 +503,9 @@ function formatSelect(el, vars, locale) {
   if (el.options.other) {
     return formatElements(el.options.other.value, vars, locale, null);
   }
-  return `{${el.value}}`;
+  return handleMissingVar(el.value, locale);
 }
-var ICU_PATTERN = /\{[^}]+,\s*(plural|select|selectordinal|number|date|time|relativeTime|list)\s*[,}]/;
+var ICU_PATTERN = /\{[^}]+,\s*(plural|select|selectordinal|number|date|time|relativeTime|list|currency)\s*[,}]/;
 function hasICUPattern(template) {
   return ICU_PATTERN.test(template);
 }
@@ -276,113 +513,35 @@ function hasICUPattern(template) {
 // src/interpolation.ts
 var VARIABLE_PATTERN = /\{(\w+)\}/g;
 function interpolate(template, vars, locale) {
-  if (!vars) return template;
-  if (hasICUPattern(template)) {
-    return interpolateICU(template, vars, locale || "en");
+  const resolvedLocale = locale || "en";
+  if (hasICUPattern(template) || hasCustomFormatter(template)) {
+    if (!vars) {
+      const cfg = getConfig();
+      if (cfg.missingVarHandler) {
+        return interpolateICU(template, {}, resolvedLocale);
+      }
+      return template;
+    }
+    return interpolateICU(template, vars, resolvedLocale);
+  }
+  if (!vars) {
+    const cfg = getConfig();
+    if (cfg.missingVarHandler) {
+      return template.replace(VARIABLE_PATTERN, (_, key) => {
+        return cfg.missingVarHandler(key, resolvedLocale);
+      });
+    }
+    return template;
   }
   return template.replace(VARIABLE_PATTERN, (_, key) => {
     const value = vars[key];
-    return value !== void 0 ? String(value) : `{${key}}`;
-  });
-}
-
-// src/config.ts
-function defaultWarningHandler(warning) {
-  const parts = [`[inline-i18n] Missing translation for locale "${warning.requestedLocale}"`];
-  if (warning.key) {
-    parts.push(`key: "${warning.key}"`);
-  }
-  parts.push(`Available: [${warning.availableLocales.join(", ")}]`);
-  if (warning.fallbackUsed) {
-    parts.push(`Using fallback: "${warning.fallbackUsed}"`);
-  }
-  console.warn(parts.join(" | "));
-}
-function isDevMode() {
-  try {
-    if (typeof globalThis !== "undefined" && "process" in globalThis) {
-      const proc = globalThis.process;
-      return proc?.env?.NODE_ENV !== "production";
+    if (value !== void 0) return String(value);
+    const cfg = getConfig();
+    if (cfg.missingVarHandler) {
+      return cfg.missingVarHandler(key, resolvedLocale);
     }
-    return false;
-  } catch {
-    return false;
-  }
-}
-var defaultConfig = {
-  defaultLocale: "en",
-  fallbackLocale: "en",
-  autoParentLocale: true,
-  fallbackChain: {},
-  warnOnMissing: isDevMode(),
-  onMissingTranslation: defaultWarningHandler,
-  debugMode: false
-};
-var config = { ...defaultConfig };
-function configure(options) {
-  config = { ...config, ...options };
-}
-function getConfig() {
-  return {
-    ...defaultConfig,
-    ...config
-  };
-}
-function resetConfig() {
-  config = { ...defaultConfig };
-}
-function getParentLocale(locale) {
-  const dashIndex = locale.indexOf("-");
-  if (dashIndex > 0) {
-    return locale.substring(0, dashIndex);
-  }
-  return void 0;
-}
-function buildFallbackChain(locale) {
-  const cfg = getConfig();
-  if (cfg.fallbackChain[locale]) {
-    return [locale, ...cfg.fallbackChain[locale]];
-  }
-  const chain = [locale];
-  if (cfg.autoParentLocale) {
-    let current = locale;
-    while (true) {
-      const parent = getParentLocale(current);
-      if (parent && !chain.includes(parent)) {
-        chain.push(parent);
-        current = parent;
-      } else {
-        break;
-      }
-    }
-  }
-  const finalFallback = cfg.fallbackLocale;
-  if (finalFallback && !chain.includes(finalFallback)) {
-    chain.push(finalFallback);
-  }
-  return chain;
-}
-function emitWarning(warning) {
-  const cfg = getConfig();
-  if (cfg.warnOnMissing && cfg.onMissingTranslation) {
-    cfg.onMissingTranslation(warning);
-  }
-}
-function applyDebugFormat(output, debugInfo) {
-  const cfg = getConfig();
-  if (!cfg.debugMode) {
-    return output;
-  }
-  const options = typeof cfg.debugMode === "object" ? cfg.debugMode : { showMissingPrefix: true, showFallbackPrefix: true };
-  if (debugInfo.isMissing && options.showMissingPrefix !== false) {
-    const prefix = options.missingPrefixFormat ? options.missingPrefixFormat(debugInfo.requestedLocale, debugInfo.key) : `[MISSING: ${debugInfo.requestedLocale}] `;
-    return prefix + output;
-  }
-  if (debugInfo.isFallback && options.showFallbackPrefix !== false && debugInfo.usedLocale) {
-    const prefix = options.fallbackPrefixFormat ? options.fallbackPrefixFormat(debugInfo.requestedLocale, debugInfo.usedLocale, debugInfo.key) : `[${debugInfo.requestedLocale} -> ${debugInfo.usedLocale}] `;
-    return prefix + output;
-  }
-  return output;
+    return `{${key}}`;
+  });
 }
 
 // src/translate.ts
@@ -519,6 +678,11 @@ var zh_es = createPair("zh", "es");
 var DEFAULT_NAMESPACE = "default";
 var NAMESPACE_SEPARATOR = ":";
 var namespacedDictionaries = {};
+var loadingState = {};
+var loadingPromises = /* @__PURE__ */ new Map();
+function getLoadingKey(locale, namespace) {
+  return `${namespace}:${locale}`;
+}
 function parseKey(fullKey) {
   const separatorIndex = fullKey.indexOf(NAMESPACE_SEPARATOR);
   if (separatorIndex > 0) {
@@ -555,10 +719,50 @@ function loadDictionary(locale, dict, namespace) {
 function clearDictionaries(namespace) {
   if (namespace) {
     delete namespacedDictionaries[namespace];
+    for (const key of Object.keys(loadingState)) {
+      if (key.startsWith(`${namespace}:`)) {
+        delete loadingState[key];
+        loadingPromises.delete(key);
+      }
+    }
   } else {
     namespacedDictionaries = {};
+    loadingState = {};
+    loadingPromises.clear();
   }
 }
+async function loadAsync(locale, namespace) {
+  const ns = namespace || DEFAULT_NAMESPACE;
+  const cfg = getConfig();
+  if (!cfg.loader) {
+    throw new Error("No loader configured. Call configure({ loader: ... }) first.");
+  }
+  const key = getLoadingKey(locale, ns);
+  if (loadingState[key] === "loaded") return;
+  if (loadingPromises.has(key)) {
+    return loadingPromises.get(key);
+  }
+  const promise = (async () => {
+    loadingState[key] = "loading";
+    try {
+      const dict = await cfg.loader(locale, ns);
+      loadDictionary(locale, dict, ns);
+      loadingState[key] = "loaded";
+    } catch (error) {
+      loadingState[key] = "error";
+      throw error;
+    } finally {
+      loadingPromises.delete(key);
+    }
+  })();
+  loadingPromises.set(key, promise);
+  return promise;
+}
+function isLoaded(locale, namespace) {
+  const ns = namespace || DEFAULT_NAMESPACE;
+  const key = getLoadingKey(locale, ns);
+  return loadingState[key] === "loaded";
+}
 function getNestedValue(dict, key) {
   const parts = key.split(".");
   let current = dict;
@@ -668,6 +872,129 @@ function getLoadedNamespaces() {
   return Object.keys(namespacedDictionaries);
 }
 
-export { __i18n_lookup, clearDictionaries, configure, en_de, en_es, en_fr, en_ja, en_zh, getConfig, getDictionary, getLoadedLocales, getLoadedNamespaces, getLocale, hasTranslation, it, it_de, it_es, it_fr, it_ja, it_zh, ja_es, ja_zh, loadDictionaries, loadDictionary, resetConfig, setLocale, t, zh_es };
+// src/detect.ts
+function matchLocale(candidate, supportedLocales) {
+  const normalized = candidate.trim().toLowerCase();
+  const exact = supportedLocales.find((l) => l.toLowerCase() === normalized);
+  if (exact) return exact;
+  const parent = getParentLocale(candidate);
+  if (parent) {
+    const parentMatch = supportedLocales.find((l) => l.toLowerCase() === parent.toLowerCase());
+    if (parentMatch) return parentMatch;
+  }
+  return void 0;
+}
+function detectFromNavigator(supportedLocales) {
+  if (typeof globalThis === "undefined") return void 0;
+  const nav = globalThis.navigator;
+  if (!nav) return void 0;
+  const languages = nav.languages || (nav.language ? [nav.language] : []);
+  for (const lang of languages) {
+    const match = matchLocale(lang, supportedLocales);
+    if (match) return match;
+  }
+  return void 0;
+}
+function detectFromCookie(supportedLocales, cookieName) {
+  if (typeof document === "undefined") return void 0;
+  const cookies = document.cookie.split(";");
+  for (const cookie of cookies) {
+    const [key, value] = cookie.split("=").map((s) => s.trim());
+    if (key === cookieName && value) {
+      return matchLocale(value, supportedLocales);
+    }
+  }
+  return void 0;
+}
+function detectFromUrl(supportedLocales) {
+  if (typeof location === "undefined") return void 0;
+  const pathname = location.pathname;
+  const match = pathname.match(/^\/([a-zA-Z]{2}(?:-[a-zA-Z]{2,})?)(?:\/|$)/);
+  if (match?.[1]) {
+    return matchLocale(match[1], supportedLocales);
+  }
+  return void 0;
+}
+function detectFromHeader(supportedLocales, headerValue) {
+  if (!headerValue) return void 0;
+  const entries = headerValue.split(",").map((part) => {
+    const parts = part.trim().split(";");
+    const lang = parts[0]?.trim() || "";
+    const qStr = parts[1];
+    const q = qStr ? parseFloat(qStr.replace(/q=/, "")) : 1;
+    return { lang, q };
+  }).sort((a, b) => b.q - a.q);
+  for (const { lang } of entries) {
+    const match = matchLocale(lang, supportedLocales);
+    if (match) return match;
+  }
+  return void 0;
+}
+function detectLocale(options) {
+  const {
+    supportedLocales,
+    defaultLocale,
+    sources = ["navigator"],
+    cookieName = "NEXT_LOCALE",
+    headerValue
+  } = options;
+  for (const source of sources) {
+    let detected;
+    switch (source) {
+      case "navigator":
+        detected = detectFromNavigator(supportedLocales);
+        break;
+      case "cookie":
+        detected = detectFromCookie(supportedLocales, cookieName);
+        break;
+      case "url":
+        detected = detectFromUrl(supportedLocales);
+        break;
+      case "header":
+        detected = detectFromHeader(supportedLocales, headerValue);
+        break;
+    }
+    if (detected) return detected;
+  }
+  return defaultLocale;
+}
+
+// src/richtext.ts
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function parseRichText(template, componentNames) {
+  if (componentNames.length === 0) {
+    return [{ type: "text", content: template }];
+  }
+  const segments = [];
+  const namesPattern = componentNames.map(escapeRegExp).join("|");
+  const regex = new RegExp(`<(${namesPattern})>(.*?)</\\1>`, "gs");
+  let lastIndex = 0;
+  let match;
+  while ((match = regex.exec(template)) !== null) {
+    if (match.index > lastIndex) {
+      segments.push({
+        type: "text",
+        content: template.slice(lastIndex, match.index)
+      });
+    }
+    segments.push({
+      type: "component",
+      content: match[2] ?? "",
+      componentName: match[1]
+    });
+    lastIndex = match.index + match[0].length;
+  }
+  if (lastIndex < template.length) {
+    segments.push({
+      type: "text",
+      content: template.slice(lastIndex)
+    });
+  }
+  return segments;
+}
+
+export { __i18n_lookup, clearDictionaries, clearFormatters, configure, detectLocale, en_de, en_es, en_fr, en_ja, en_zh, getConfig, getDictionary, getLoadedLocales, getLoadedNamespaces, getLocale, hasTranslation, isLoaded, it, it_de, it_es, it_fr, it_ja, it_zh, ja_es, ja_zh, loadAsync, loadDictionaries, loadDictionary, parseRichText, registerFormatter, resetConfig, setLocale, t, zh_es };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map