@burdenoff/be-sdk 2026.510.79

package/dist/chunk-IYE2NTRX.js

@@ -0,0 +1,764 @@
+import { logger } from './chunk-CBZNP6RF.js';
+import { __export, __name } from './chunk-XE4OXN2W.js';
+import { readdir, readFile, stat } from 'fs/promises';
+import { join, extname, basename, resolve, relative } from 'path';
+
+// src/i18n/index.ts
+var i18n_exports = {};
+__export(i18n_exports, {
+  DEFAULT_I18N_CONFIG: () => DEFAULT_I18N_CONFIG,
+  I18n: () => I18n,
+  Locales: () => Locales,
+  RTL_LANGUAGES: () => RTL_LANGUAGES,
+  clearTranslationCache: () => clearTranslationCache,
+  createI18n: () => createI18n,
+  createTranslator: () => createTranslator,
+  discoverLocales: () => discoverLocales,
+  extractLocaleFromRequest: () => extractLocaleFromRequest,
+  findBestMatch: () => findBestMatch,
+  flattenDictionary: () => flattenDictionary,
+  getCachedTranslations: () => getCachedTranslations,
+  getI18n: () => getI18n,
+  getLanguage: () => getLanguage,
+  getLanguageFromLocale: () => getLanguageFromLocale,
+  getLocale: () => getLocale,
+  getRegionFromLocale: () => getRegionFromLocale,
+  getTextDirection: () => getTextDirection,
+  hasI18n: () => hasI18n,
+  initializeI18n: () => initializeI18n,
+  loadTranslationFile: () => loadTranslationFile,
+  loadTranslationsForLocale: () => loadTranslationsForLocale,
+  normalizeLocale: () => normalizeLocale,
+  parseAcceptLanguage: () => parseAcceptLanguage,
+  parseLocaleString: () => parseLocaleString,
+  preloadAllTranslations: () => preloadAllTranslations,
+  setCachedTranslations: () => setCachedTranslations,
+  t: () => t
+});
+
+// src/i18n/types.ts
+var RTL_LANGUAGES = [
+  "ar",
+  "he"
+];
+function getTextDirection(language) {
+  return RTL_LANGUAGES.includes(language) ? "rtl" : "ltr";
+}
+__name(getTextDirection, "getTextDirection");
+
+// src/i18n/parser.ts
+function parseLocaleString(localeStr) {
+  const trimmed = localeStr.trim();
+  if (!trimmed || trimmed === "*") {
+    return null;
+  }
+  const [localePart, ...params] = trimmed.split(";");
+  let quality = 1;
+  for (const param of params) {
+    const [key, value] = param.trim().split("=");
+    if (key?.toLowerCase() === "q" && value) {
+      const parsed = parseFloat(value);
+      if (!isNaN(parsed) && parsed >= 0 && parsed <= 1) {
+        quality = parsed;
+      }
+    }
+  }
+  const locale = localePart?.trim();
+  if (!locale) {
+    return null;
+  }
+  const parts = locale.split("-");
+  const language = parts[0]?.toLowerCase();
+  const region = parts[1]?.toUpperCase();
+  const normalizedLocale = region ? `${language}-${region}` : language;
+  return {
+    locale: normalizedLocale,
+    language,
+    region,
+    quality
+  };
+}
+__name(parseLocaleString, "parseLocaleString");
+function parseAcceptLanguage(header) {
+  if (!header || header.trim() === "") {
+    return [];
+  }
+  const locales = [];
+  const parts = header.split(",");
+  for (const part of parts) {
+    const parsed = parseLocaleString(part);
+    if (parsed) {
+      locales.push(parsed);
+    }
+  }
+  locales.sort((a, b) => b.quality - a.quality);
+  return locales;
+}
+__name(parseAcceptLanguage, "parseAcceptLanguage");
+function extractLocaleFromRequest(request, defaultLocale = "en-US") {
+  const explicitLocale = request.headers.get("x-locale") || request.headers.get("x-language");
+  if (explicitLocale) {
+    const parsed = parseLocaleString(explicitLocale);
+    if (parsed) {
+      return parsed;
+    }
+  }
+  const acceptLanguage = request.headers.get("accept-language");
+  const parsedLocales = parseAcceptLanguage(acceptLanguage);
+  if (parsedLocales.length > 0) {
+    return parsedLocales[0];
+  }
+  const [language, region] = defaultLocale.split("-");
+  return {
+    locale: defaultLocale,
+    language,
+    region,
+    quality: 1
+  };
+}
+__name(extractLocaleFromRequest, "extractLocaleFromRequest");
+function normalizeLocale(locale) {
+  const parts = locale.trim().split(/[-_]/);
+  const language = parts[0]?.toLowerCase();
+  const region = parts[1]?.toUpperCase();
+  if (region) {
+    return `${language}-${region}`;
+  }
+  return language;
+}
+__name(normalizeLocale, "normalizeLocale");
+function getLanguageFromLocale(locale) {
+  return locale.split("-")[0];
+}
+__name(getLanguageFromLocale, "getLanguageFromLocale");
+function getRegionFromLocale(locale) {
+  const parts = locale.split("-");
+  return parts[1];
+}
+__name(getRegionFromLocale, "getRegionFromLocale");
+function findBestMatch(requested, available, defaultLocale) {
+  const availableSet = new Set(available.map((l) => l.toLowerCase()));
+  for (const req of requested) {
+    if (availableSet.has(req.locale.toLowerCase())) {
+      return available.find((l) => l.toLowerCase() === req.locale.toLowerCase()) || req.locale;
+    }
+    if (availableSet.has(req.language.toLowerCase())) {
+      return available.find((l) => l.toLowerCase() === req.language.toLowerCase()) || req.language;
+    }
+    const langMatch = available.find((l) => getLanguageFromLocale(l).toLowerCase() === req.language.toLowerCase());
+    if (langMatch) {
+      return langMatch;
+    }
+  }
+  return defaultLocale;
+}
+__name(findBestMatch, "findBestMatch");
+
+// src/i18n/loader.ts
+var translationCache = /* @__PURE__ */ new Map();
+function validateFilePath(filePath, baseDir) {
+  const resolvedBase = resolve(baseDir);
+  const resolvedPath = resolve(filePath);
+  const relativePath = relative(resolvedBase, resolvedPath);
+  if (relativePath.startsWith("..") || resolve(relativePath) === relativePath) {
+    throw new Error(`Invalid file path: ${filePath} is outside base directory ${baseDir}`);
+  }
+  return resolvedPath;
+}
+__name(validateFilePath, "validateFilePath");
+async function safeReadFile(filePath, baseDir) {
+  const validatedPath = validateFilePath(filePath, baseDir);
+  return readFile(validatedPath, "utf-8");
+}
+__name(safeReadFile, "safeReadFile");
+async function safeStat(filePath, baseDir) {
+  const validatedPath = validateFilePath(filePath, baseDir);
+  return stat(validatedPath).catch(() => null);
+}
+__name(safeStat, "safeStat");
+async function safeReaddir(dirPath, baseDir) {
+  const validatedPath = validateFilePath(dirPath, baseDir);
+  return readdir(validatedPath);
+}
+__name(safeReaddir, "safeReaddir");
+function flattenDictionary(obj, prefix = "") {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    if (typeof value === "string") {
+      result[fullKey] = value;
+    } else if (value !== null && typeof value === "object") {
+      Object.assign(result, flattenDictionary(value, fullKey));
+    }
+  }
+  return result;
+}
+__name(flattenDictionary, "flattenDictionary");
+async function loadTranslationFile(filePath, baseDir) {
+  try {
+    const content = await safeReadFile(filePath, baseDir);
+    const data = JSON.parse(content);
+    return data;
+  } catch (error) {
+    logger.error(`[I18n] Failed to load translation file: ${filePath}`, error);
+    return {};
+  }
+}
+__name(loadTranslationFile, "loadTranslationFile");
+function getCacheKey(namespace, locale) {
+  return namespace ? `${namespace}:${locale}` : locale;
+}
+__name(getCacheKey, "getCacheKey");
+async function loadTranslationsForLocale(config, locale) {
+  const cacheKey = getCacheKey(config.namespace, locale);
+  if (config.enableCache !== false && translationCache.has(cacheKey)) {
+    return translationCache.get(cacheKey);
+  }
+  const normalizedLocale = normalizeLocale(locale);
+  const language = getLanguageFromLocale(normalizedLocale);
+  const result = {};
+  const pathsToTry = [
+    // Most specific: full locale
+    join(config.localesPath, `${normalizedLocale}.json`),
+    // Directory format
+    join(config.localesPath, normalizedLocale),
+    // Language only fallback
+    join(config.localesPath, `${language}.json`),
+    // Language directory
+    join(config.localesPath, language)
+  ];
+  for (const path of pathsToTry) {
+    try {
+      const stats = await safeStat(path, config.localesPath);
+      if (!stats) continue;
+      if (stats.isFile() && path.endsWith(".json")) {
+        const translations = await loadTranslationFile(path, config.localesPath);
+        const flattened = flattenDictionary(translations);
+        Object.assign(result, flattened);
+        logger.debug(`[I18n] Loaded translations from ${path}`);
+        break;
+      } else if (stats.isDirectory()) {
+        const files = await safeReaddir(path, config.localesPath);
+        for (const file of files) {
+          if (extname(file) === ".json") {
+            const namespace = basename(file, ".json");
+            const filePath = join(path, file);
+            const translations = await loadTranslationFile(filePath, config.localesPath);
+            const flattened = flattenDictionary(translations, namespace);
+            Object.assign(result, flattened);
+            logger.debug(`[I18n] Loaded namespace ${namespace} from ${filePath}`);
+          }
+        }
+        break;
+      }
+    } catch {
+    }
+  }
+  if (Object.keys(result).length === 0 && config.fallbackLocale && config.fallbackLocale !== locale) {
+    logger.warn(`[I18n] No translations found for ${locale}, trying fallback ${config.fallbackLocale}`);
+    const fallbackTranslations = await loadTranslationsForLocale({
+      ...config,
+      fallbackLocale: void 0
+    }, config.fallbackLocale);
+    Object.assign(result, fallbackTranslations);
+  }
+  if (config.enableCache !== false) {
+    translationCache.set(cacheKey, result);
+  }
+  return result;
+}
+__name(loadTranslationsForLocale, "loadTranslationsForLocale");
+async function discoverLocales(localesPath) {
+  const locales = [];
+  try {
+    const validatedBasePath = resolve(localesPath);
+    const entries = await readdir(validatedBasePath);
+    for (const entry of entries) {
+      const entryPath = join(validatedBasePath, entry);
+      const stats = await safeStat(entryPath, validatedBasePath);
+      if (!stats) continue;
+      if (stats.isFile() && entry.endsWith(".json")) {
+        const locale = basename(entry, ".json");
+        locales.push(normalizeLocale(locale));
+      } else if (stats.isDirectory()) {
+        locales.push(normalizeLocale(entry));
+      }
+    }
+  } catch (error) {
+    logger.error(`[I18n] Failed to discover locales in ${localesPath}`, error);
+  }
+  return locales;
+}
+__name(discoverLocales, "discoverLocales");
+async function preloadAllTranslations(config) {
+  const locales = config.supportedLocales || await discoverLocales(config.localesPath);
+  logger.info(`[I18n] Preloading translations for ${locales.length} locales...`);
+  await Promise.all(locales.map(async (locale) => {
+    try {
+      await loadTranslationsForLocale(config, locale);
+    } catch (error) {
+      logger.error(`[I18n] Failed to preload locale ${locale}`, error);
+    }
+  }));
+  logger.info(`[I18n] Preloaded translations for: ${locales.join(", ")}`);
+}
+__name(preloadAllTranslations, "preloadAllTranslations");
+function clearTranslationCache(namespace) {
+  if (namespace) {
+    for (const key of translationCache.keys()) {
+      if (key.startsWith(`${namespace}:`)) {
+        translationCache.delete(key);
+      }
+    }
+  } else {
+    translationCache.clear();
+  }
+}
+__name(clearTranslationCache, "clearTranslationCache");
+function getCachedTranslations(namespace, locale) {
+  return translationCache.get(getCacheKey(namespace, locale));
+}
+__name(getCachedTranslations, "getCachedTranslations");
+function setCachedTranslations(namespace, locale, translations) {
+  translationCache.set(getCacheKey(namespace, locale), translations);
+}
+__name(setCachedTranslations, "setCachedTranslations");
+
+// src/i18n/i18n.ts
+function getEnglishPluralCategory(absCount) {
+  if (absCount === 1) return "one";
+  return "other";
+}
+__name(getEnglishPluralCategory, "getEnglishPluralCategory");
+function getFrenchPluralCategory(absCount) {
+  if (absCount === 0 || absCount === 1) return "one";
+  return "other";
+}
+__name(getFrenchPluralCategory, "getFrenchPluralCategory");
+function getSlavicPluralCategory(absCount) {
+  const mod10 = absCount % 10;
+  const mod100 = absCount % 100;
+  if (mod10 === 1 && mod100 !== 11) return "one";
+  if (mod10 >= 2 && mod10 <= 4 && (mod100 < 12 || mod100 > 14)) return "few";
+  if (mod10 === 0 || mod10 >= 5 && mod10 <= 9 || mod100 >= 11 && mod100 <= 14) return "many";
+  return "other";
+}
+__name(getSlavicPluralCategory, "getSlavicPluralCategory");
+function getArabicPluralCategory(absCount) {
+  if (absCount === 0) return "zero";
+  if (absCount === 1) return "one";
+  if (absCount === 2) return "two";
+  const mod100 = absCount % 100;
+  if (mod100 >= 3 && mod100 <= 10) return "few";
+  if (mod100 >= 11 && mod100 <= 99) return "many";
+  return "other";
+}
+__name(getArabicPluralCategory, "getArabicPluralCategory");
+function getPolishCzechPluralCategory(absCount) {
+  const mod10 = absCount % 10;
+  const mod100 = absCount % 100;
+  if (absCount === 1) return "one";
+  if (mod10 >= 2 && mod10 <= 4 && (mod100 < 12 || mod100 > 14)) return "few";
+  return "many";
+}
+__name(getPolishCzechPluralCategory, "getPolishCzechPluralCategory");
+function getRomanianPluralCategory(absCount) {
+  if (absCount === 1) return "one";
+  const mod100 = absCount % 100;
+  if (absCount === 0 || mod100 >= 1 && mod100 <= 19) return "few";
+  return "other";
+}
+__name(getRomanianPluralCategory, "getRomanianPluralCategory");
+function getHebrewPluralCategory(absCount) {
+  if (absCount === 1) return "one";
+  if (absCount === 2) return "two";
+  return "other";
+}
+__name(getHebrewPluralCategory, "getHebrewPluralCategory");
+function getPluralCategory(language, count) {
+  const absCount = Math.abs(count);
+  const englishLanguages = [
+    "en",
+    "de",
+    "es",
+    "it",
+    "nl",
+    "sv",
+    "da",
+    "nb",
+    "fi",
+    "pt",
+    "el",
+    "hu",
+    "tr",
+    "id",
+    "ms",
+    "th",
+    "vi",
+    "ko",
+    "zh",
+    "ja"
+  ];
+  if (englishLanguages.includes(language)) {
+    return getEnglishPluralCategory(absCount);
+  }
+  if (language === "fr") {
+    return getFrenchPluralCategory(absCount);
+  }
+  if (language === "ru" || language === "uk") {
+    return getSlavicPluralCategory(absCount);
+  }
+  if (language === "ar") {
+    return getArabicPluralCategory(absCount);
+  }
+  if (language === "pl" || language === "cs") {
+    return getPolishCzechPluralCategory(absCount);
+  }
+  if (language === "ro") {
+    return getRomanianPluralCategory(absCount);
+  }
+  if (language === "he") {
+    return getHebrewPluralCategory(absCount);
+  }
+  return getEnglishPluralCategory(absCount);
+}
+__name(getPluralCategory, "getPluralCategory");
+function interpolate(text, variables) {
+  if (!variables || !text) {
+    return text;
+  }
+  return text.replace(/\{\{\s*(\w+)\s*\}\}/g, (match, key) => {
+    const value = variables[key.trim()];
+    if (value !== void 0) {
+      return String(value);
+    }
+    return match;
+  });
+}
+__name(interpolate, "interpolate");
+var I18n = class {
+  static {
+    __name(this, "I18n");
+  }
+  config;
+  currentLocale;
+  supportedLocales = [];
+  initialized = false;
+  constructor(config) {
+    this.config = {
+      ...config,
+      fallbackLocale: config.fallbackLocale || "en-US",
+      enableCache: config.enableCache !== false,
+      returnKeyOnMissing: config.returnKeyOnMissing !== false,
+      logMissing: config.logMissing !== false
+    };
+    this.currentLocale = normalizeLocale(config.defaultLocale);
+  }
+  /**
+  * Initialize the i18n instance
+  * Discovers available locales and optionally preloads translations
+  */
+  async initialize() {
+    if (this.initialized) return;
+    if (this.config.supportedLocales && this.config.supportedLocales.length > 0) {
+      this.supportedLocales = this.config.supportedLocales;
+    } else {
+      this.supportedLocales = await discoverLocales(this.config.localesPath);
+    }
+    if (!this.config.lazyLoad) {
+      await preloadAllTranslations(this.config);
+    }
+    this.initialized = true;
+    logger.info(`[I18n] Initialized with ${this.supportedLocales.length} locales, default: ${this.currentLocale}`);
+  }
+  /**
+  * Get current locale
+  */
+  getLocale() {
+    return this.currentLocale;
+  }
+  /**
+  * Set current locale
+  */
+  setLocale(locale) {
+    this.currentLocale = normalizeLocale(locale);
+  }
+  /**
+  * Get supported locales
+  */
+  getSupportedLocales() {
+    return [
+      ...this.supportedLocales
+    ];
+  }
+  /**
+  * Check if a locale is supported
+  */
+  isSupported(locale) {
+    const normalized = normalizeLocale(locale);
+    const language = getLanguageFromLocale(normalized);
+    return this.supportedLocales.some((l) => {
+      const supportedNorm = normalizeLocale(l);
+      return supportedNorm === normalized || getLanguageFromLocale(supportedNorm) === language;
+    });
+  }
+  /**
+  * Load translations for a specific locale
+  */
+  async loadLocale(locale) {
+    await loadTranslationsForLocale(this.config, locale);
+  }
+  /**
+  * Get all translations for a locale
+  */
+  getTranslations(locale) {
+    return getCachedTranslations(this.config.namespace, locale);
+  }
+  /**
+  * Translate a key
+  */
+  t = /* @__PURE__ */ __name((key, variables, defaultValue) => {
+    return this.translate(this.currentLocale, key, variables, defaultValue);
+  }, "t");
+  /**
+  * Translate with pluralization
+  */
+  tp = /* @__PURE__ */ __name((key, count, variables) => {
+    return this.translatePlural(this.currentLocale, key, count, variables);
+  }, "tp");
+  /**
+  * Internal translate method
+  */
+  translate(locale, key, variables, defaultValue) {
+    const translations = getCachedTranslations(this.config.namespace, locale);
+    let text = translations?.[key];
+    if (!text && this.config.fallbackLocale && locale !== this.config.fallbackLocale) {
+      const fallbackTranslations = getCachedTranslations(this.config.namespace, this.config.fallbackLocale);
+      text = fallbackTranslations?.[key];
+    }
+    if (!text) {
+      const language = getLanguageFromLocale(locale);
+      if (language !== locale) {
+        const langTranslations = getCachedTranslations(this.config.namespace, language);
+        text = langTranslations?.[key];
+      }
+    }
+    if (!text) {
+      if (this.config.logMissing) {
+        logger.warn(`[I18n] Missing translation for key: ${key} in locale: ${locale}`);
+      }
+      return defaultValue ?? (this.config.returnKeyOnMissing ? key : "");
+    }
+    return interpolate(text, variables);
+  }
+  /**
+  * Internal translate with pluralization
+  */
+  translatePlural(locale, key, count, variables) {
+    const language = getLanguageFromLocale(locale);
+    const category = getPluralCategory(language, count);
+    const pluralKey = `${key}.${category}`;
+    let text = this.translate(locale, pluralKey, void 0, "");
+    if (!text && category !== "other") {
+      text = this.translate(locale, `${key}.other`, void 0, "");
+    }
+    if (!text) {
+      text = this.translate(locale, key, void 0, key);
+    }
+    return interpolate(text, {
+      ...variables,
+      count
+    });
+  }
+  /**
+  * Create an i18n context for a specific locale
+  */
+  createContext(locale) {
+    const normalizedLocale = normalizeLocale(locale);
+    const language = getLanguageFromLocale(normalizedLocale);
+    const region = getRegionFromLocale(normalizedLocale);
+    const t2 = /* @__PURE__ */ __name((key, variables, defaultValue) => {
+      return this.translate(normalizedLocale, key, variables, defaultValue);
+    }, "t");
+    const tp = /* @__PURE__ */ __name((key, count, variables) => {
+      return this.translatePlural(normalizedLocale, key, count, variables);
+    }, "tp");
+    const formatNumber = /* @__PURE__ */ __name((value, options) => {
+      return new Intl.NumberFormat(normalizedLocale, options).format(value);
+    }, "formatNumber");
+    const formatCurrency = /* @__PURE__ */ __name((value, currency) => {
+      return new Intl.NumberFormat(normalizedLocale, {
+        style: "currency",
+        currency
+      }).format(value);
+    }, "formatCurrency");
+    const formatDate = /* @__PURE__ */ __name((date, options) => {
+      const dateObj = typeof date === "string" ? new Date(date) : date;
+      return new Intl.DateTimeFormat(normalizedLocale, options).format(dateObj);
+    }, "formatDate");
+    const formatRelativeTime = /* @__PURE__ */ __name((value, unit) => {
+      return new Intl.RelativeTimeFormat(normalizedLocale, {
+        numeric: "auto"
+      }).format(value, unit);
+    }, "formatRelativeTime");
+    return {
+      locale: normalizedLocale,
+      language,
+      region,
+      t: t2,
+      tp,
+      formatNumber,
+      formatCurrency,
+      formatDate,
+      formatRelativeTime
+    };
+  }
+  /**
+  * Create context from a request
+  */
+  createContextFromRequest(request) {
+    const parsed = extractLocaleFromRequest(request, this.config.defaultLocale);
+    const bestMatch = findBestMatch([
+      parsed
+    ], this.supportedLocales, this.config.defaultLocale);
+    return this.createContext(bestMatch);
+  }
+  /**
+  * Get language metadata
+  */
+  getLanguageInfo(locale) {
+    const language = getLanguageFromLocale(locale);
+    const region = getRegionFromLocale(locale);
+    const direction = getTextDirection(language);
+    return {
+      code: language,
+      direction,
+      locale,
+      region
+    };
+  }
+};
+var globalI18n = null;
+async function initializeI18n(config) {
+  globalI18n = new I18n(config);
+  await globalI18n.initialize();
+  return globalI18n;
+}
+__name(initializeI18n, "initializeI18n");
+function getI18n() {
+  return globalI18n;
+}
+__name(getI18n, "getI18n");
+function createI18n(config) {
+  return new I18n(config);
+}
+__name(createI18n, "createI18n");
+
+// src/i18n/helpers.ts
+function interpolateVariables(text, variables) {
+  if (!variables) return text;
+  return text.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+    const value = variables[key];
+    return value !== void 0 ? String(value) : match;
+  });
+}
+__name(interpolateVariables, "interpolateVariables");
+function t(ctx, key, defaultMessage, variables) {
+  if (!ctx.i18n?.t) {
+    return interpolateVariables(defaultMessage, variables);
+  }
+  const translated = ctx.i18n.t(key, variables, defaultMessage);
+  if (translated === key) {
+    return interpolateVariables(defaultMessage, variables);
+  }
+  return translated;
+}
+__name(t, "t");
+function createTranslator(ctx) {
+  return (key, defaultMessage, variables) => {
+    return t(ctx, key, defaultMessage, variables);
+  };
+}
+__name(createTranslator, "createTranslator");
+function hasI18n(ctx) {
+  return ctx.i18n?.t !== void 0;
+}
+__name(hasI18n, "hasI18n");
+function getLocale(ctx, defaultLocale = "en-US") {
+  return ctx.i18n?.locale ?? defaultLocale;
+}
+__name(getLocale, "getLocale");
+function getLanguage(ctx, defaultLanguage = "en") {
+  return ctx.i18n?.language ?? defaultLanguage;
+}
+__name(getLanguage, "getLanguage");
+
+// src/i18n/index.ts
+var Locales = {
+  // English
+  EN_US: "en-US",
+  EN_GB: "en-GB",
+  EN_AU: "en-AU",
+  EN_CA: "en-CA",
+  EN_IN: "en-IN",
+  // Spanish
+  ES_ES: "es-ES",
+  ES_MX: "es-MX",
+  // French
+  FR_FR: "fr-FR",
+  FR_CA: "fr-CA",
+  // German
+  DE_DE: "de-DE",
+  DE_AT: "de-AT",
+  DE_CH: "de-CH",
+  // Italian
+  IT_IT: "it-IT",
+  // Portuguese
+  PT_PT: "pt-PT",
+  PT_BR: "pt-BR",
+  // Russian
+  RU_RU: "ru-RU",
+  // Chinese
+  ZH_CN: "zh-CN",
+  ZH_TW: "zh-TW",
+  ZH_HK: "zh-HK",
+  // Japanese
+  JA_JP: "ja-JP",
+  // Korean
+  KO_KR: "ko-KR",
+  // Arabic
+  AR_SA: "ar-SA",
+  AR_AE: "ar-AE",
+  // Hindi
+  HI_IN: "hi-IN",
+  // Tamil
+  TA_IN: "ta-IN",
+  // Dutch
+  NL_NL: "nl-NL",
+  // Polish
+  PL_PL: "pl-PL",
+  // Turkish
+  TR_TR: "tr-TR",
+  // Vietnamese
+  VI_VN: "vi-VN",
+  // Thai
+  TH_TH: "th-TH",
+  // Indonesian
+  ID_ID: "id-ID",
+  // Hebrew
+  HE_IL: "he-IL",
+  // Ukrainian
+  UK_UA: "uk-UA"
+};
+var DEFAULT_I18N_CONFIG = {
+  defaultLocale: "en-US",
+  fallbackLocale: "en-US",
+  enableCache: true,
+  lazyLoad: false,
+  logMissing: true,
+  returnKeyOnMissing: true
+};
+
+export { DEFAULT_I18N_CONFIG, I18n, Locales, RTL_LANGUAGES, clearTranslationCache, createI18n, createTranslator, discoverLocales, extractLocaleFromRequest, findBestMatch, flattenDictionary, getCachedTranslations, getI18n, getLanguage, getLanguageFromLocale, getLocale, getRegionFromLocale, getTextDirection, hasI18n, i18n_exports, initializeI18n, loadTranslationFile, loadTranslationsForLocale, normalizeLocale, parseAcceptLanguage, parseLocaleString, preloadAllTranslations, setCachedTranslations, t };
+//# sourceMappingURL=chunk-IYE2NTRX.js.map
+//# sourceMappingURL=chunk-IYE2NTRX.js.map