langie 1.9.25

package/dist/index.mjs

@@ -0,0 +1,2826 @@
+/**
+ * langie v1.9.25
+ * (c) 2026 nlit
+ * @license Apache-2.0
+ * 
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+// src/useLangie.ts
+import { watch } from "vue";
+
+// src/composables/useLangie-core.ts
+import { ref, reactive } from "vue";
+
+// src/constants.ts
+var DEFAULT_API_HOST = "https://api.langie.uk/v1";
+var DEV_API_HOST = "http://localhost:8081/v1";
+var API_FIELD_TEXT = "t";
+var API_FIELD_FROM = "from";
+var API_FIELD_TO = "to";
+var API_FIELD_CTX = "ctx";
+var API_FIELD_TRANSLATED = "t";
+var API_FIELD_TRANSLATIONS = "translations";
+var API_FIELD_ERROR = "error";
+
+// src/utils/debug.ts
+function devDebug(...args) {
+  if (import.meta.env && import.meta.env.DEV) {
+    console.debug(...args);
+  }
+}
+
+// src/utils/getCountryCode.ts
+import * as ct from "countries-and-timezones";
+async function getCountryCode() {
+  const localeCountry = getCountryCodeFromBrowser();
+  if (localeCountry) return localeCountry;
+  const timezoneCountry = getCountryFromTimezone();
+  if (timezoneCountry) return timezoneCountry;
+  return await getCountryFromIP();
+}
+function getCountryFromTimezone() {
+  try {
+    const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    return getCountryFromTimezoneString(timezone);
+  } catch (error) {
+    return null;
+  }
+}
+function getCountryFromTimezoneString(timezone) {
+  try {
+    const country = ct.getCountryForTimezone(timezone);
+    return country?.id || null;
+  } catch (error) {
+    return null;
+  }
+}
+async function getCountryFromIP() {
+  try {
+    const response = await fetch("https://ipapi.co/json/");
+    const data = await response.json();
+    return data.country_code || null;
+  } catch (error) {
+    return null;
+  }
+}
+function getCountryCodeFromBrowser() {
+  const langs = navigator.languages || [navigator.language];
+  for (const locale of langs) {
+    const parts = locale.split("-");
+    if (parts.length > 1) {
+      return parts[1].toUpperCase();
+    }
+  }
+  return null;
+}
+
+// src/utils/cache.ts
+var DEFAULT_TTL = 7 * 24 * 60 * 60 * 1e3;
+var DEFAULT_MAX_SIZE = 2 * 1024 * 1024;
+var DEFAULT_MAX_ITEMS = 1e3;
+var CacheManager = class {
+  options;
+  constructor(options = {}) {
+    this.options = {
+      ttl: options.ttl || DEFAULT_TTL,
+      maxSize: options.maxSize || DEFAULT_MAX_SIZE,
+      maxItems: options.maxItems || DEFAULT_MAX_ITEMS
+    };
+  }
+  set(key, data, ttl) {
+    if (typeof window === "undefined") return false;
+    try {
+      const item = {
+        data,
+        timestamp: Date.now(),
+        ttl: ttl || this.options.ttl
+      };
+      const serialized = JSON.stringify(item);
+      const size = new Blob([serialized]).size;
+      if (size > this.options.maxSize) {
+        console.warn(`[CacheManager] Item size ${size} exceeds max size ${this.options.maxSize}`);
+        return false;
+      }
+      this.cleanup();
+      const currentSize = this.getCurrentSize();
+      if (currentSize + size > this.options.maxSize) {
+        console.warn(`[CacheManager] Cache would exceed max size after adding item`);
+        return false;
+      }
+      localStorage.setItem(key, serialized);
+      return true;
+    } catch (error) {
+      console.warn(`[CacheManager] Failed to set cache item ${key}:`, error);
+      return false;
+    }
+  }
+  get(key) {
+    if (typeof window === "undefined") return null;
+    try {
+      const item = localStorage.getItem(key);
+      if (!item) return null;
+      const cacheItem = JSON.parse(item);
+      const now = Date.now();
+      if (now - cacheItem.timestamp > cacheItem.ttl) {
+        localStorage.removeItem(key);
+        return null;
+      }
+      return cacheItem.data;
+    } catch (error) {
+      console.warn(`[CacheManager] Failed to get cache item ${key}:`, error);
+      localStorage.removeItem(key);
+      return null;
+    }
+  }
+  remove(key) {
+    if (typeof window === "undefined") return false;
+    try {
+      localStorage.removeItem(key);
+      return true;
+    } catch (error) {
+      console.warn(`[CacheManager] Failed to remove cache item ${key}:`, error);
+      return false;
+    }
+  }
+  clear(pattern) {
+    if (typeof window === "undefined") return;
+    try {
+      if (pattern) {
+        Object.keys(localStorage).forEach((key) => {
+          if (key.includes(pattern)) {
+            localStorage.removeItem(key);
+          }
+        });
+      } else {
+        Object.keys(localStorage).forEach((key) => {
+          if (key.startsWith("langie_")) {
+            localStorage.removeItem(key);
+          }
+        });
+      }
+    } catch (error) {
+      console.warn("[CacheManager] Failed to clear cache:", error);
+    }
+  }
+  cleanup() {
+    if (typeof window === "undefined") return;
+    try {
+      const now = Date.now();
+      const items = [];
+      Object.keys(localStorage).forEach((key) => {
+        if (key.startsWith("langie_")) {
+          try {
+            const item = localStorage.getItem(key);
+            if (item) {
+              const cacheItem = JSON.parse(item);
+              const size = new Blob([item]).size;
+              if (now - cacheItem.timestamp > cacheItem.ttl) {
+                localStorage.removeItem(key);
+                return;
+              }
+              items.push({
+                key,
+                size,
+                timestamp: cacheItem.timestamp
+              });
+            }
+          } catch (error) {
+            localStorage.removeItem(key);
+          }
+        }
+      });
+      items.sort((a, b) => a.timestamp - b.timestamp);
+      while (items.length > this.options.maxItems) {
+        const oldest = items.shift();
+        if (oldest) {
+          localStorage.removeItem(oldest.key);
+        }
+      }
+      let totalSize = items.reduce((sum, item) => sum + item.size, 0);
+      while (totalSize > this.options.maxSize && items.length > 0) {
+        const oldest = items.shift();
+        if (oldest) {
+          localStorage.removeItem(oldest.key);
+          totalSize -= oldest.size;
+        }
+      }
+    } catch (error) {
+      console.warn("[CacheManager] Failed to cleanup cache:", error);
+    }
+  }
+  getCurrentSize() {
+    if (typeof window === "undefined") return 0;
+    try {
+      let totalSize = 0;
+      Object.keys(localStorage).forEach((key) => {
+        if (key.startsWith("langie_")) {
+          const item = localStorage.getItem(key);
+          if (item) {
+            totalSize += new Blob([item]).size;
+          }
+        }
+      });
+      return totalSize;
+    } catch (error) {
+      console.warn("[CacheManager] Failed to calculate cache size:", error);
+      return 0;
+    }
+  }
+  getStats() {
+    if (typeof window === "undefined") {
+      return { size: 0, items: 0, maxSize: this.options.maxSize, maxItems: this.options.maxItems };
+    }
+    try {
+      let totalSize = 0;
+      let itemCount = 0;
+      Object.keys(localStorage).forEach((key) => {
+        if (key.startsWith("langie_")) {
+          const item = localStorage.getItem(key);
+          if (item) {
+            totalSize += new Blob([item]).size;
+            itemCount++;
+          }
+        }
+      });
+      return {
+        size: totalSize,
+        items: itemCount,
+        maxSize: this.options.maxSize,
+        maxItems: this.options.maxItems
+      };
+    } catch (error) {
+      console.warn("[CacheManager] Failed to get cache stats:", error);
+      return { size: 0, items: 0, maxSize: this.options.maxSize, maxItems: this.options.maxItems };
+    }
+  }
+};
+var cacheManager = new CacheManager();
+var setCache = (key, data, ttl) => {
+  return cacheManager.set(key, data, ttl);
+};
+var getCache = (key) => {
+  return cacheManager.get(key);
+};
+var removeCache = (key) => {
+  return cacheManager.remove(key);
+};
+var clearCache = (pattern) => {
+  return cacheManager.clear(pattern);
+};
+var getCacheStats = () => {
+  return cacheManager.getStats();
+};
+
+// src/composables/useLangie-core.ts
+var availableLanguages = ref([]);
+var translations = reactive({});
+var uiTranslations = reactive({});
+var currentLanguage = ref("en");
+var _translatorHost = DEFAULT_API_HOST;
+var _autoSelected = false;
+var _languagesCache = null;
+var _languagesPromise = null;
+function useLangieCore(options = {}) {
+  if (options.translatorHost) {
+    _translatorHost = options.translatorHost;
+  }
+  const translatorHost = _translatorHost;
+  const defaultLanguage = options.defaultLanguage || "en";
+  const isLoading = ref(false);
+  if (defaultLanguage !== "en" && currentLanguage.value === "en") {
+    currentLanguage.value = defaultLanguage;
+  }
+  if (typeof window !== "undefined" && currentLanguage.value === "en") {
+    const savedLanguage = localStorage.getItem("interface_language");
+    if (savedLanguage) {
+      currentLanguage.value = savedLanguage;
+    }
+  }
+  if (typeof window !== "undefined") {
+    const cachedLanguages = getCache("langie_languages_cache");
+    if (cachedLanguages && availableLanguages.value.length === 0) {
+      availableLanguages.value = cachedLanguages;
+      _languagesCache = cachedLanguages;
+      devDebug("[useLangie] Loaded languages from cache:", cachedLanguages.length);
+    } else if (cachedLanguages) {
+      devDebug(
+        "[useLangie] Cache exists but languages already loaded:",
+        availableLanguages.value.length
+      );
+    } else {
+      devDebug("[useLangie] No cached languages found");
+    }
+  }
+  const setLanguage = (lang) => {
+    if (lang && lang !== currentLanguage.value) {
+    }
+    currentLanguage.value = lang;
+    if (typeof window !== "undefined") {
+      localStorage.setItem("interface_language", lang);
+    }
+  };
+  const fetchLanguages = async (opts = {}) => {
+    const { force = false, country: explicitCountry } = opts;
+    devDebug("[useLangie] fetchLanguages called:", {
+      force,
+      hasCache: !!_languagesCache,
+      hasPromise: !!_languagesPromise,
+      availableLanguagesLength: availableLanguages.value.length
+    });
+    if (!force) {
+      if (_languagesCache) {
+        devDebug("[useLangie] Returning cached languages:", _languagesCache.length);
+        return _languagesCache;
+      }
+      if (_languagesPromise) {
+        devDebug("[useLangie] Returning existing promise");
+        return _languagesPromise;
+      }
+    }
+    try {
+      let countryHint = explicitCountry || null;
+      if (!countryHint && !_languagesCache && availableLanguages.value && availableLanguages.value.length) {
+        const currentLang = currentLanguage.value;
+        const entry = availableLanguages.value.find(
+          (l) => l.code === currentLang
+        );
+        if (entry) {
+          const c = Array.isArray(entry.flag_country) ? entry.flag_country[0] : typeof entry.flag_country === "string" ? entry.flag_country.split(",")[0] : null;
+          if (c) countryHint = c.toUpperCase();
+        }
+      }
+      if (!countryHint && !_languagesCache && typeof window !== "undefined") {
+        const cc = await getCountryCode();
+        countryHint = cc;
+      }
+      let url = "/languages";
+      const language = typeof navigator !== "undefined" && navigator.languages && navigator.languages[0] || typeof navigator !== "undefined" && navigator.language || "";
+      const timezone = typeof Intl !== "undefined" && Intl.DateTimeFormat().resolvedOptions().timeZone || "";
+      const params = new URLSearchParams();
+      if (countryHint) params.append("country", countryHint);
+      if (language) params.append("language", language);
+      if (timezone) params.append("timezone", timezone);
+      if (Array.from(params).length > 0) url += `?${params.toString()}`;
+      _languagesPromise = fetch(`${translatorHost}${url}`).then((res) => res.json());
+      const response = await _languagesPromise;
+      const rawList = Array.isArray(response) ? response : response.languages || [];
+      const mapped = rawList.map(
+        (lang) => {
+          let flag = lang.flag_country || lang.code;
+          if (Array.isArray(flag)) {
+            flag = flag[0];
+          }
+          return {
+            ...lang,
+            value: lang.code,
+            flag_country: flag
+          };
+        }
+      );
+      const filtered = mapped.filter((l) => {
+        if (l.code.startsWith("sr")) {
+          return l.code === "sr-latn" || l.code === "sr-cyrl";
+        }
+        return true;
+      });
+      availableLanguages.value = filtered;
+      devDebug("[useLangie] Set availableLanguages:", filtered.length);
+      if (typeof window !== "undefined") {
+        const saved = setCache("langie_languages_cache", filtered, 7 * 24 * 60 * 60 * 1e3);
+        devDebug(
+          "[useLangie] Saved languages to cache:",
+          saved ? "success" : "failed",
+          filtered.length
+        );
+      }
+      if (!_autoSelected && !localStorage.getItem("interface_language")) {
+        const locale = typeof navigator !== "undefined" ? navigator.languages?.[0] || navigator.language || "" : "";
+        const browserCode = locale.split("-")[0];
+        if (browserCode) {
+          let pick = void 0;
+          if (browserCode === "sr") {
+            const isLatin = /latn/i.test(locale) || locale === "sr";
+            const target = isLatin ? "sr-latn" : "sr-cyrl";
+            pick = mapped.find((l) => l.value === target);
+          } else if (browserCode === "sh") {
+            pick = mapped.find((l) => l.value === "sr-latn") || mapped.find((l) => l.code.startsWith("sr"));
+          } else {
+            pick = mapped.find((l) => l.value === browserCode);
+            if (!pick) {
+              pick = mapped.find((l) => l.code.startsWith(browserCode));
+            }
+          }
+          if (pick && pick.value) {
+            setLanguage(pick.value);
+          }
+        }
+        _autoSelected = true;
+      }
+      _languagesCache = filtered;
+      _languagesPromise = null;
+      return filtered;
+    } catch (error) {
+      devDebug("[useLangie] Language fetch error:", { error });
+      return [];
+    }
+  };
+  const clearTranslations = () => {
+    Object.keys(translations).forEach((key) => delete translations[key]);
+    Object.keys(uiTranslations).forEach((key) => delete uiTranslations[key]);
+    if (typeof window !== "undefined") {
+      clearCache("translations_cache");
+      clearCache("ui_translations_cache");
+    }
+  };
+  return {
+    availableLanguages,
+    translations,
+    uiTranslations,
+    currentLanguage,
+    isLoading,
+    setLanguage,
+    fetchLanguages,
+    clearTranslations,
+    translatorHost
+  };
+}
+
+// src/composables/useLangie-batching.ts
+var TranslationBatching = class {
+  constructor(options = {}, translatorHost, currentLanguage2, onBatchComplete) {
+    this.options = options;
+    this.translatorHost = translatorHost;
+    this.currentLanguage = currentLanguage2;
+    this.onBatchComplete = onBatchComplete;
+  }
+  pendingRequests = /* @__PURE__ */ new Set();
+  queueMap = /* @__PURE__ */ new Map();
+  flushTimeout = null;
+  queuedThisTick = /* @__PURE__ */ new Set();
+  clearQueuedThisTickScheduled = false;
+  firstItemTime = null;
+  get initialBatchDelay() {
+    return this.options.initialBatchDelay ?? 50;
+  }
+  get followupBatchDelay() {
+    return this.options.followupBatchDelay ?? 10;
+  }
+  get maxBatchSize() {
+    return this.options.maxBatchSize ?? 50;
+  }
+  get maxWaitTime() {
+    return this.options.maxWaitTime ?? 1e3;
+  }
+  scheduleClearQueuedThisTick() {
+    if (this.clearQueuedThisTickScheduled) return;
+    this.clearQueuedThisTickScheduled = true;
+    queueMicrotask(() => {
+      this.queuedThisTick.clear();
+      this.clearQueuedThisTickScheduled = false;
+    });
+  }
+  flushQueues = async () => {
+    const allRequests = [];
+    for (const [batchKey, map] of Array.from(this.queueMap.entries())) {
+      if (!map || map.size === 0) {
+        this.queueMap.delete(batchKey);
+        continue;
+      }
+      const [from, to] = batchKey.split("|");
+      for (const [cacheKey, item] of map.entries()) {
+        allRequests.push({
+          [API_FIELD_TEXT]: item[API_FIELD_TEXT],
+          [API_FIELD_CTX]: item[API_FIELD_CTX],
+          [API_FIELD_FROM]: from,
+          [API_FIELD_TO]: to,
+          cacheKey,
+          __explicitToLang: item.__explicitToLang
+        });
+      }
+      this.queueMap.delete(batchKey);
+    }
+    if (allRequests.length > 0) {
+      devDebug(
+        "[TranslationBatching] Sending batch:",
+        allRequests.length,
+        "translation items",
+        allRequests
+      );
+      const chunks = this.chunkArray(allRequests, this.maxBatchSize);
+      for (const chunk of chunks) {
+        try {
+          await this.fetchAndCacheBatchMixed(chunk);
+        } catch (error) {
+          devDebug("[TranslationBatching] Batch translation error:", error);
+          chunk.forEach((req) => this.pendingRequests.delete(req.cacheKey));
+        }
+      }
+    }
+    this.firstItemTime = null;
+  };
+  chunkArray(array, size) {
+    const chunks = [];
+    for (let i = 0; i < array.length; i += size) {
+      chunks.push(array.slice(i, i + size));
+    }
+    return chunks;
+  }
+  scheduleFlush = () => {
+    if (this.flushTimeout) {
+      clearTimeout(this.flushTimeout);
+    }
+    let totalItems = 0;
+    for (const map of this.queueMap.values()) {
+      totalItems += map.size;
+    }
+    if (this.firstItemTime && Date.now() - this.firstItemTime >= this.maxWaitTime) {
+      devDebug("[TranslationBatching] Flushing due to maximum wait time:", totalItems, "items");
+      this.flushQueues();
+      return;
+    }
+    const delay = this.queueMap.size === 1 ? this.initialBatchDelay : this.followupBatchDelay;
+    devDebug(
+      "[TranslationBatching] Scheduling flush in",
+      delay,
+      "ms",
+      Array.from(this.queueMap.entries())
+    );
+    this.flushTimeout = setTimeout(() => {
+      this.flushQueues();
+      this.flushTimeout = null;
+    }, delay);
+  };
+  queueTranslation(text, ctx, from, to, cacheKey, explicitToLang) {
+    if (this.pendingRequests.has(cacheKey) || this.queuedThisTick.has(cacheKey)) {
+      devDebug("[TranslationBatching] Skipping duplicate:", cacheKey);
+      return;
+    }
+    if (this.firstItemTime === null) {
+      this.firstItemTime = Date.now();
+    }
+    this.queuedThisTick.add(cacheKey);
+    this.scheduleClearQueuedThisTick();
+    this.pendingRequests.add(cacheKey);
+    const batchKey = `${from}|${to}`;
+    if (!this.queueMap.has(batchKey)) {
+      this.queueMap.set(batchKey, /* @__PURE__ */ new Map());
+    }
+    this.queueMap.get(batchKey).set(cacheKey, {
+      [API_FIELD_TEXT]: text,
+      [API_FIELD_CTX]: ctx,
+      __explicitToLang: explicitToLang
+    });
+    devDebug("[TranslationBatching] Queued translation:", {
+      text,
+      ctx,
+      from,
+      to,
+      cacheKey,
+      batchKey,
+      explicitToLang
+    });
+    this.scheduleFlush();
+  }
+  async fetchAndCacheBatchMixed(requests) {
+    const grouped = {};
+    requests.forEach((req) => {
+      const key = `${req.from}|${req.to}`;
+      if (!grouped[key]) grouped[key] = [];
+      grouped[key].push(req);
+    });
+    const allResults = [];
+    const allRequests = [];
+    for (const [langPair, batchRequests] of Object.entries(grouped)) {
+      const [from, to] = langPair.split("|");
+      try {
+        const contexts = [...new Set(batchRequests.map((req) => req[API_FIELD_CTX]))];
+        const useGlobalContext = contexts.length === 1 && contexts[0] === "ui";
+        devDebug(
+          "[TranslationBatching] Sending batch for",
+          langPair,
+          "with",
+          batchRequests.length,
+          "items",
+          batchRequests
+        );
+        const response = await fetch(`${this.translatorHost}/translate`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            translations: batchRequests.map((req) => ({
+              [API_FIELD_TEXT]: req[API_FIELD_TEXT],
+              ...useGlobalContext ? {} : { [API_FIELD_CTX]: req[API_FIELD_CTX] }
+            })),
+            [API_FIELD_FROM]: from,
+            [API_FIELD_TO]: to,
+            ...useGlobalContext ? { [API_FIELD_CTX]: "ui" } : {}
+          })
+        });
+        let result;
+        try {
+          result = await response.json();
+        } catch (parseError) {
+          devDebug("[TranslationBatching] Failed to parse response as JSON:", parseError);
+          throw new Error(`Translation request failed: ${response.status}`);
+        }
+        if (!response.ok) {
+          devDebug(
+            "[TranslationBatching] Translation request failed:",
+            response.status,
+            response.statusText
+          );
+          if (result && result[API_FIELD_ERROR]) {
+            devDebug(
+              "[TranslationBatching] HTTP error with API error message:",
+              result[API_FIELD_ERROR]
+            );
+            const errorResponses = batchRequests.map((req) => ({
+              [API_FIELD_TEXT]: req[API_FIELD_TEXT],
+              [API_FIELD_ERROR]: result[API_FIELD_ERROR]
+            }));
+            allResults.push({ [API_FIELD_TRANSLATIONS]: errorResponses });
+            allRequests.push(...batchRequests);
+            batchRequests.forEach((req) => {
+              this.pendingRequests.delete(req.cacheKey);
+            });
+            this.onBatchComplete(allResults, allRequests);
+            return;
+          }
+          throw new Error(`Translation request failed: ${response.status}`);
+        }
+        if (result[API_FIELD_ERROR]) {
+          devDebug("[TranslationBatching] Top-level API error:", result[API_FIELD_ERROR]);
+          const errorResponses = batchRequests.map((req) => ({
+            [API_FIELD_TEXT]: req[API_FIELD_TEXT],
+            [API_FIELD_ERROR]: result[API_FIELD_ERROR]
+          }));
+          allResults.push({ [API_FIELD_TRANSLATIONS]: errorResponses });
+          allRequests.push(...batchRequests);
+          batchRequests.forEach((req) => {
+            this.pendingRequests.delete(req.cacheKey);
+          });
+        } else {
+          if (result[API_FIELD_TRANSLATIONS]) {
+            result[API_FIELD_TRANSLATIONS].forEach((translation, index) => {
+              if (translation[API_FIELD_ERROR]) {
+                const originalText = batchRequests[index]?.[API_FIELD_TEXT];
+                devDebug(
+                  "[TranslationBatching] Translation error for",
+                  originalText,
+                  ":",
+                  translation[API_FIELD_ERROR]
+                );
+              }
+            });
+          }
+          allResults.push(result);
+          allRequests.push(...batchRequests);
+          batchRequests.forEach((req) => {
+            this.pendingRequests.delete(req.cacheKey);
+          });
+        }
+      } catch (error) {
+        devDebug("[TranslationBatching] Batch request failed for", langPair, ":", error);
+        batchRequests.forEach((req) => {
+          this.pendingRequests.delete(req.cacheKey);
+        });
+        throw error;
+      }
+    }
+    this.onBatchComplete(allResults, allRequests);
+  }
+  clearPending(cacheKey) {
+    this.pendingRequests.delete(cacheKey);
+  }
+  clearAllPending() {
+    this.pendingRequests.clear();
+  }
+  cleanup() {
+    this.clearAllPending();
+    this.queueMap.clear();
+    this.queuedThisTick.clear();
+    if (this.flushTimeout) {
+      clearTimeout(this.flushTimeout);
+      this.flushTimeout = null;
+    }
+    this.clearQueuedThisTickScheduled = false;
+    this.firstItemTime = null;
+  }
+  getStats() {
+    return {
+      pendingRequests: this.pendingRequests.size,
+      queuedBatches: this.queueMap.size,
+      queuedThisTick: this.queuedThisTick.size,
+      hasFlushTimeout: !!this.flushTimeout
+    };
+  }
+};
+
+// src/useLangie.ts
+var globalLangieInstance = null;
+if (typeof window !== "undefined" && window.__LANGIE_SINGLETON__) {
+  globalLangieInstance = window.__LANGIE_SINGLETON__;
+}
+function safeLocalStorageAccess(operation) {
+  if (typeof window === "undefined") return void 0;
+  try {
+    return operation();
+  } catch (e) {
+    devDebug("[useLangie] localStorage error:", e);
+    return void 0;
+  }
+}
+if (!globalLangieInstance && typeof window !== "undefined") {
+  const stored = safeLocalStorageAccess(() => localStorage.getItem("__LANGIE_SINGLETON_URL__"));
+  if (stored) {
+    const storedOptions = { translatorHost: stored };
+    globalLangieInstance = createLangieInstance(storedOptions);
+  }
+}
+function createLangieInstance(options = {}) {
+  const core = useLangieCore(options);
+  const {
+    availableLanguages: availableLanguages2,
+    translations: translations2,
+    uiTranslations: uiTranslations2,
+    currentLanguage: currentLanguage2,
+    isLoading,
+    setLanguage,
+    fetchLanguages,
+    translatorHost,
+    clearTranslations
+  } = core;
+  const ltDefaults = {
+    ctx: "ui",
+    orig: ""
+  };
+  const setLtDefaults2 = (defaults) => {
+    Object.assign(ltDefaults, defaults);
+  };
+  const getLtDefaults2 = () => ({ ...ltDefaults });
+  const CACHE_KEY = "langie_translations_cache";
+  const UI_CACHE_KEY = "langie_ui_translations_cache";
+  const LANGUAGES_CACHE_KEY = "langie_languages_cache";
+  const loadCachedTranslations = () => {
+    if (typeof window === "undefined") return;
+    const cachedTranslations = getCache(CACHE_KEY);
+    const cachedUiTranslations = getCache(UI_CACHE_KEY);
+    if (cachedTranslations) {
+      const currentLang = currentLanguage2.value;
+      const langTranslations = cachedTranslations[currentLang] || {};
+      Object.assign(translations2, langTranslations);
+    }
+    if (cachedUiTranslations) {
+      const currentLang = currentLanguage2.value;
+      const langUiTranslations = cachedUiTranslations[currentLang] || {};
+      Object.assign(uiTranslations2, langUiTranslations);
+    }
+  };
+  const saveCachedTranslations = () => {
+    if (typeof window === "undefined") return;
+    const existingTranslations = getCache(CACHE_KEY) || {};
+    const existingUiTranslations = getCache(UI_CACHE_KEY) || {};
+    const currentLang = currentLanguage2.value;
+    existingTranslations[currentLang] = { ...translations2 };
+    existingUiTranslations[currentLang] = { ...uiTranslations2 };
+    setCache(CACHE_KEY, existingTranslations, 7 * 24 * 60 * 60 * 1e3);
+    setCache(UI_CACHE_KEY, existingUiTranslations, 7 * 24 * 60 * 60 * 1e3);
+  };
+  const loadCachedLanguages = () => {
+    if (typeof window === "undefined") return;
+    const cachedLanguages = getCache(LANGUAGES_CACHE_KEY);
+    if (cachedLanguages) {
+      availableLanguages2.value = cachedLanguages;
+    }
+  };
+  loadCachedTranslations();
+  loadCachedLanguages();
+  watch(currentLanguage2, () => {
+    Object.keys(translations2).forEach((key) => delete translations2[key]);
+    Object.keys(uiTranslations2).forEach((key) => delete uiTranslations2[key]);
+    loadCachedTranslations();
+  });
+  const batching = new TranslationBatching(
+    {
+      initialBatchDelay: options.initialBatchDelay,
+      followupBatchDelay: options.followupBatchDelay,
+      maxBatchSize: options.maxBatchSize,
+      maxWaitTime: options.maxWaitTime
+    },
+    translatorHost,
+    () => currentLanguage2.value,
+    (results, requests) => {
+      requests.forEach((req) => {
+        const cacheKey = `${req[API_FIELD_TEXT]}|${req[API_FIELD_CTX]}`;
+        const languageCacheKey = `${cacheKey}|${req[API_FIELD_FROM]}|${req[API_FIELD_TO]}`;
+        recentlyQueued.delete(languageCacheKey);
+      });
+      let translationsArray = [];
+      results.forEach((result) => {
+        if (Array.isArray(result)) {
+          translationsArray = translationsArray.concat(result);
+        } else if (result.translations && Array.isArray(result.translations)) {
+          translationsArray = translationsArray.concat(result.translations);
+        }
+      });
+      translationsArray.forEach((translation, idx) => {
+        const request = requests[idx];
+        if (!request) {
+          devDebug("[useLangie] No matching request for translation:", translation);
+          return;
+        }
+        const originalText = request[API_FIELD_TEXT];
+        const originalCtx = request[API_FIELD_CTX] ?? (ltDefaults.ctx || "ui");
+        if (translation[API_FIELD_ERROR]) {
+          devDebug(
+            "[useLangie] Translation error for",
+            originalText,
+            ":",
+            translation[API_FIELD_ERROR]
+          );
+          const errorKey = `${originalText}|${originalCtx}|${request[API_FIELD_FROM]}|${request[API_FIELD_TO]}`;
+          translationErrors.set(errorKey, translation[API_FIELD_ERROR]);
+          return;
+        }
+        if (translation[API_FIELD_FROM] && !translation[API_FIELD_TEXT]) {
+          return;
+        }
+        const translatedText = translation[API_FIELD_TEXT];
+        if (translatedText) {
+          const requestedLanguage = request[API_FIELD_TO];
+          const explicitToLang = request.__explicitToLang;
+          if (!explicitToLang && requestedLanguage !== currentLanguage2.value) {
+            devDebug("[useLangie] Skipping outdated translation:", {
+              original: originalText,
+              translated: translatedText,
+              requestedLanguage,
+              currentLanguage: currentLanguage2.value
+            });
+            return;
+          }
+          if (translatedText === originalText) {
+            devDebug("[useLangie] Skipping cache for identical translation:", {
+              original: originalText,
+              translated: translatedText,
+              context: originalCtx
+            });
+            return;
+          }
+          const effectiveCtx = originalCtx;
+          const cacheKey = `${originalText}|${effectiveCtx}`;
+          const cache = effectiveCtx === "ui" ? uiTranslations2 : translations2;
+          cache[cacheKey] = translatedText;
+          devDebug("[useLangie] Cached translation:", {
+            original: originalText,
+            translated: translatedText,
+            context: effectiveCtx,
+            cacheKey,
+            language: requestedLanguage
+          });
+          saveCachedTranslations();
+        }
+      });
+    }
+  );
+  const recentlyQueued = /* @__PURE__ */ new Set();
+  const pendingTimeouts = /* @__PURE__ */ new Set();
+  const translationErrors = /* @__PURE__ */ new Map();
+  const translateInternal = (text, ctx, originalLang, toLang, reactive2 = false) => {
+    if (reactive2) {
+      void currentLanguage2.value;
+    }
+    const from = originalLang || ltDefaults.orig || "";
+    const to = toLang || currentLanguage2.value;
+    if (from === to) {
+      return text;
+    }
+    const effectiveCtx = ctx !== void 0 ? ctx : ltDefaults.ctx || "ui";
+    const cacheKey = `${text}|${effectiveCtx}`;
+    const cache = effectiveCtx === "ui" ? uiTranslations2 : translations2;
+    if (cache[cacheKey]) {
+      return cache[cacheKey];
+    }
+    const errorKey = `${text}|${effectiveCtx}|${from}|${to}`;
+    if (translationErrors.has(errorKey)) {
+      return text;
+    }
+    const languageCacheKey = `${cacheKey}|${from}|${to}`;
+    if (recentlyQueued.has(languageCacheKey)) {
+      return text;
+    }
+    batching.queueTranslation(text, effectiveCtx, from, to, cacheKey, toLang !== void 0);
+    recentlyQueued.add(languageCacheKey);
+    const clearDelay = 100;
+    const timeoutId = setTimeout(() => {
+      recentlyQueued.delete(languageCacheKey);
+      pendingTimeouts.delete(timeoutId);
+    }, clearDelay);
+    pendingTimeouts.add(timeoutId);
+    return text;
+  };
+  const l = (text, ctx, originalLang, toLang) => translateInternal(text, ctx, originalLang, toLang, false);
+  const lr = (text, ctx, originalLang, toLang) => translateInternal(text, ctx, originalLang, toLang, true);
+  const fetchAndCacheBatch = async (items, from, to = currentLanguage2.value, globalCtx) => {
+    if (items.length === 0) return;
+    const effectiveFrom = from || ltDefaults.orig || "";
+    if (effectiveFrom === to) {
+      return;
+    }
+    isLoading.value = true;
+    try {
+      const effectiveCtx = globalCtx || ltDefaults.ctx || "ui";
+      const response = await fetch(`${translatorHost}/translate`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          translations: items.map((item) => ({
+            [API_FIELD_TEXT]: item[API_FIELD_TEXT],
+            [API_FIELD_CTX]: item[API_FIELD_CTX] || effectiveCtx
+          })),
+          [API_FIELD_FROM]: effectiveFrom,
+          [API_FIELD_TO]: to
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`Translation request failed: ${response.status}`);
+      }
+      const result = await response.json();
+      if (result[API_FIELD_ERROR]) {
+        devDebug("[useLangie] Top-level API error:", result[API_FIELD_ERROR]);
+        const errorResponses = items.map((item) => ({
+          [API_FIELD_TEXT]: item[API_FIELD_TEXT],
+          [API_FIELD_ERROR]: result[API_FIELD_ERROR]
+        }));
+        errorResponses.forEach((translation, index) => {
+          const item = items[index];
+          const originalText = item?.[API_FIELD_TEXT];
+          if (!originalText) {
+            return;
+          }
+          if (translation[API_FIELD_ERROR]) {
+            devDebug(
+              "[useLangie] Translation error for",
+              originalText,
+              ":",
+              translation[API_FIELD_ERROR]
+            );
+            const errorKey = `${originalText}|${item[API_FIELD_CTX] || effectiveCtx}|${effectiveFrom}|${to}`;
+            translationErrors.set(errorKey, translation[API_FIELD_ERROR]);
+            return;
+          }
+        });
+        return;
+      }
+      if (result[API_FIELD_TRANSLATIONS]) {
+        result[API_FIELD_TRANSLATIONS].forEach(
+          (translation, index) => {
+            const item = items[index];
+            const originalText = item?.[API_FIELD_TEXT];
+            if (!originalText) {
+              return;
+            }
+            if (translation[API_FIELD_ERROR]) {
+              devDebug(
+                "[useLangie] Translation error for",
+                originalText,
+                ":",
+                translation[API_FIELD_ERROR]
+              );
+              return;
+            }
+            if (translation[API_FIELD_FROM] && !translation[API_FIELD_TEXT]) {
+              return;
+            }
+            const translatedText = translation[API_FIELD_TEXT];
+            if (translatedText) {
+              if (to !== currentLanguage2.value) {
+                devDebug("[useLangie] Skipping outdated translation (batch):", {
+                  original: originalText,
+                  translated: translatedText,
+                  requestedLanguage: to,
+                  currentLanguage: currentLanguage2.value
+                });
+                return;
+              }
+              if (translatedText === originalText) {
+                devDebug("[useLangie] Skipping cache for identical translation (batch):", {
+                  original: originalText,
+                  translated: translatedText,
+                  context: item[API_FIELD_CTX] || effectiveCtx
+                });
+                return;
+              }
+              const originalCtx = item[API_FIELD_CTX];
+              const translationCtx = originalCtx !== void 0 ? originalCtx : effectiveCtx;
+              const cacheKey = `${originalText}|${translationCtx}`;
+              const cache = translationCtx === "ui" ? uiTranslations2 : translations2;
+              cache[cacheKey] = translatedText;
+              devDebug("[useLangie] Cached translation (batch):", {
+                original: originalText,
+                translated: translatedText,
+                context: translationCtx,
+                cacheKey,
+                language: to
+              });
+              saveCachedTranslations();
+            }
+          }
+        );
+      }
+    } catch (error) {
+      console.error("[useLangie] Translation error:", error);
+    } finally {
+      isLoading.value = false;
+    }
+  };
+  watch(currentLanguage2, () => {
+    recentlyQueued.clear();
+    loadCachedTranslations();
+    batching.cleanup();
+  });
+  return {
+    // Core functionality
+    availableLanguages: availableLanguages2,
+    translations: translations2,
+    uiTranslations: uiTranslations2,
+    currentLanguage: currentLanguage2,
+    isLoading,
+    setLanguage,
+    fetchLanguages,
+    translatorHost,
+    // Translation functions
+    l,
+    lr,
+    fetchAndCacheBatch,
+    // Error handling
+    getTranslationError: (text, ctx, from, to) => {
+      const effectiveCtx = ctx !== void 0 ? ctx : ltDefaults.ctx || "ui";
+      const effectiveFrom = from || ltDefaults.orig || "";
+      const effectiveTo = to || currentLanguage2.value;
+      const errorKey = `${text}|${effectiveCtx}|${effectiveFrom}|${effectiveTo}`;
+      return translationErrors.get(errorKey) || null;
+    },
+    // Utility functions
+    cleanup: () => {
+      clearTranslations();
+      batching.cleanup();
+      pendingTimeouts.forEach((id) => clearTimeout(id));
+      pendingTimeouts.clear();
+      translationErrors.clear();
+    },
+    getBatchingStats: () => batching.getStats(),
+    // lt component defaults management
+    setLtDefaults: setLtDefaults2,
+    getLtDefaults: getLtDefaults2
+  };
+}
+function getGlobalLangieInstance() {
+  if (typeof window !== "undefined") {
+    return window.__LANGIE_SINGLETON__ || null;
+  }
+  return globalLangieInstance;
+}
+function setGlobalLangieInstance(instance, options) {
+  if (typeof window !== "undefined") {
+    ;
+    window.__LANGIE_SINGLETON__ = instance;
+    if (options && options.translatorHost) {
+      safeLocalStorageAccess(
+        () => localStorage.setItem("__LANGIE_SINGLETON_URL__", options.translatorHost)
+      );
+    }
+  }
+  globalLangieInstance = instance;
+}
+function useLangie(options = {}) {
+  const globalInstance = getGlobalLangieInstance();
+  if (globalInstance) {
+    const currentHost = globalInstance.translatorHost;
+    const newHost = options.translatorHost;
+    if (!options.translatorHost || currentHost === newHost) {
+      return globalInstance;
+    }
+  }
+  const instance = createLangieInstance(options);
+  setGlobalLangieInstance(instance, options);
+  return instance;
+}
+function setLtDefaults(defaults) {
+  const instance = getGlobalLangieInstance();
+  if (instance && instance.setLtDefaults) {
+    instance.setLtDefaults(defaults);
+  }
+}
+function getLtDefaults() {
+  const instance = getGlobalLangieInstance();
+  if (instance && instance.getLtDefaults) {
+    return instance.getLtDefaults();
+  }
+  return { ctx: "ui", orig: "" };
+}
+
+// src/core.ts
+var DEFAULT_TRANSLATOR_HOST = "http://localhost:8081";
+var translationCache = /* @__PURE__ */ new Map();
+function getTranslationCacheKey(serviceTranslations, options) {
+  return JSON.stringify({
+    translations: serviceTranslations.map((t) => ({
+      [API_FIELD_TEXT]: t[API_FIELD_TEXT],
+      [API_FIELD_FROM]: t[API_FIELD_FROM],
+      [API_FIELD_TO]: t[API_FIELD_TO],
+      [API_FIELD_CTX]: t[API_FIELD_CTX] || options[API_FIELD_CTX] || "ui"
+    })),
+    host: options.translatorHost || DEFAULT_TRANSLATOR_HOST,
+    context: options[API_FIELD_CTX] || "ui"
+  });
+}
+async function translateBatch(translations2 = [], options = {}) {
+  if (!Array.isArray(translations2) || translations2.length === 0) {
+    throw new Error("translations must be a non-empty array");
+  }
+  const translatorHost = options.translatorHost || DEFAULT_TRANSLATOR_HOST;
+  const apiKey = options.apiKey || process.env.TRANSLATOR_API_KEY;
+  const serviceTranslations = [];
+  const indexMap = [];
+  translations2.forEach((tr, idx) => {
+    const from = (tr[API_FIELD_FROM] || "").toLowerCase();
+    const to = (tr[API_FIELD_TO] || "").toLowerCase();
+    if (from === to) {
+      return;
+    }
+    serviceTranslations.push(tr);
+    indexMap.push(idx);
+  });
+  let serviceResults = [];
+  if (serviceTranslations.length > 0) {
+    const cacheKey = getTranslationCacheKey(serviceTranslations, options);
+    if (translationCache.has(cacheKey)) {
+      serviceResults = await translationCache.get(cacheKey);
+    } else {
+      const translationPromise = (async () => {
+        try {
+          const controller = new AbortController();
+          const timeoutId = setTimeout(() => controller.abort(), 5e3);
+          const resp = await fetch(`${translatorHost}/translate`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              ...apiKey ? { Authorization: `Bearer ${apiKey}`, "X-Api-Key": apiKey } : {}
+            },
+            body: JSON.stringify({
+              [API_FIELD_TRANSLATIONS]: serviceTranslations.map((t) => ({
+                [API_FIELD_TEXT]: t[API_FIELD_TEXT],
+                [API_FIELD_FROM]: t[API_FIELD_FROM],
+                [API_FIELD_TO]: t[API_FIELD_TO],
+                [API_FIELD_CTX]: t[API_FIELD_CTX] || options[API_FIELD_CTX] || "ui"
+              })),
+              [API_FIELD_CTX]: options[API_FIELD_CTX] || "ui"
+            }),
+            signal: controller.signal
+          });
+          clearTimeout(timeoutId);
+          if (!resp.ok) {
+            console.error(
+              "[translator-sdk] Translator error response:",
+              resp.status,
+              resp.statusText
+            );
+            throw new Error(`Translator service error: ${resp.status} ${resp.statusText}`);
+          }
+          let parsed;
+          try {
+            parsed = await resp.clone().json();
+          } catch (jsonErr) {
+            console.error("[translator-sdk] Failed to parse JSON response:", jsonErr);
+            throw new Error(`Failed to parse JSON response: ${jsonErr}`);
+          }
+          const data = parsed || {};
+          if (data[API_FIELD_ERROR]) {
+            console.warn(`[translator-sdk] Top-level API error:`, data[API_FIELD_ERROR]);
+            return serviceTranslations.map((translation) => ({
+              [API_FIELD_TEXT]: translation[API_FIELD_TEXT],
+              [API_FIELD_ERROR]: data[API_FIELD_ERROR]
+            }));
+          }
+          const results = Array.isArray(data[API_FIELD_TRANSLATIONS]) ? data[API_FIELD_TRANSLATIONS].map((translation, index) => {
+            const originalText = serviceTranslations[index]?.[API_FIELD_TEXT] || "";
+            if (translation[API_FIELD_ERROR]) {
+              console.warn(
+                `[translator-sdk] Translation error for "${originalText}":`,
+                translation[API_FIELD_ERROR]
+              );
+              return {
+                [API_FIELD_TEXT]: originalText,
+                // Return original text on error
+                [API_FIELD_ERROR]: translation[API_FIELD_ERROR]
+              };
+            }
+            if (translation[API_FIELD_FROM] && !translation[API_FIELD_TEXT]) {
+              return {
+                [API_FIELD_TEXT]: originalText,
+                // For detection, return original text
+                [API_FIELD_FROM]: translation[API_FIELD_FROM]
+              };
+            }
+            return {
+              [API_FIELD_TEXT]: translation[API_FIELD_TEXT] || originalText
+            };
+          }) : data[API_FIELD_TEXT] ? [{ [API_FIELD_TEXT]: data[API_FIELD_TEXT] }] : [];
+          return results;
+        } catch (error) {
+          translationCache.delete(cacheKey);
+          if (error instanceof Error && error.name === "AbortError") {
+            const message2 = `Translator request to ${translatorHost} timed out after 5 seconds.`;
+            console.error(message2);
+            throw new Error(message2);
+          }
+          const message = `Failed to connect to translator at ${translatorHost}. Is the service running?`;
+          console.error(message);
+          throw new Error(message);
+        }
+      })();
+      translationCache.set(cacheKey, translationPromise);
+      serviceResults = await translationPromise;
+    }
+  }
+  const final = translations2.map((tr, idx) => {
+    const from = (tr[API_FIELD_FROM] || "").toLowerCase();
+    const to = (tr[API_FIELD_TO] || "").toLowerCase();
+    if (from === to) return { [API_FIELD_TEXT]: tr[API_FIELD_TEXT] };
+    const svcIdx = indexMap.indexOf(idx);
+    if (svcIdx !== -1) return serviceResults[svcIdx] || { [API_FIELD_TEXT]: tr[API_FIELD_TEXT] };
+    return { [API_FIELD_TEXT]: tr[API_FIELD_TEXT] };
+  });
+  return final;
+}
+function clearTranslationCache() {
+  translationCache.clear();
+}
+function getTranslationCacheSize() {
+  return translationCache.size;
+}
+async function fetchAvailableLanguages(options = {}) {
+  const translatorHost = options.translatorHost || DEFAULT_TRANSLATOR_HOST;
+  const apiKey = options.apiKey || process.env.TRANSLATOR_API_KEY;
+  const minPop = options.minPopularity !== void 0 ? Number(options.minPopularity) : Number.parseFloat(process.env.MIN_LANGUAGE_POPULARITY || "0.1");
+  const queryParams = [];
+  if (options.country) queryParams.push(`country=${encodeURIComponent(options.country)}`);
+  if (options.region) queryParams.push(`region=${encodeURIComponent(options.region)}`);
+  const queryStr = queryParams.length ? `?${queryParams.join("&")}` : "";
+  const requestUrl = `${translatorHost}/languages${queryStr}`;
+  try {
+    const resp = await fetch(requestUrl, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        ...apiKey ? { Authorization: `Bearer ${apiKey}`, "X-Api-Key": apiKey } : {}
+      }
+    });
+    if (!resp.ok) {
+      throw new Error(`Translator languages error: ${resp.status}`);
+    }
+    const data = await resp.json();
+    const languages = Array.isArray(data) ? data : data.languages || [];
+    const filtered = languages.filter((lang) => {
+      if (lang.popularity === void 0 || lang.popularity === null) return true;
+      return Number(lang.popularity) >= minPop;
+    });
+    return filtered;
+  } catch (error) {
+    console.error("[translator-sdk] Languages fetch error:", error);
+    throw error;
+  }
+}
+
+// vue-script:/Users/nlit/projects/langie-sdk/src/components/LanguageSelect.vue?type=script
+import { useCssVars as _useCssVars, defineComponent as _defineComponent } from "vue";
+import { createCommentVNode as _createCommentVNode, openBlock as _openBlock, createElementBlock as _createElementBlock, toDisplayString as _toDisplayString, createElementVNode as _createElementVNode, createTextVNode as _createTextVNode, unref as _unref, withCtx as _withCtx, createBlock as _createBlock, Fragment as _Fragment, normalizeClass as _normalizeClass } from "vue";
+import "@vueform/multiselect/themes/default.css";
+import { ref as ref2, computed, nextTick } from "vue";
+import Multiselect from "@vueform/multiselect";
+import Fuse from "fuse.js";
+
+// src/language-aliases/european.ts
+var EUROPEAN_LANGUAGES = [
+  // Major European Languages
+  {
+    lang: "english",
+    match: [
+      "eng",
+      "en",
+      "united states",
+      "united states of america",
+      "usa",
+      "us",
+      "great britain",
+      "britain",
+      "british",
+      "england",
+      "united kingdom",
+      "uk"
+    ],
+    suggest: ["irish", "scottish", "welsh"]
+  },
+  {
+    lang: "spanish",
+    match: [
+      "spa",
+      "es",
+      "esp",
+      "spain",
+      "espa\xF1ol",
+      "mexico",
+      "mexican",
+      "argentina",
+      "colombia",
+      "venezuela"
+    ],
+    suggest: ["catalan", "galician", "basque"]
+  },
+  {
+    lang: "french",
+    match: [
+      "fra",
+      "fr",
+      "fre",
+      "france",
+      "fran\xE7ais",
+      "canada",
+      "canadian",
+      "quebec",
+      "belgium",
+      "swiss"
+    ],
+    suggest: ["occitan", "breton", "corsican"]
+  },
+  {
+    lang: "german",
+    match: [
+      "ger",
+      "de",
+      "deu",
+      "germany",
+      "deutsch",
+      "austria",
+      "austrian",
+      "switzerland",
+      "swiss"
+    ],
+    suggest: ["bavarian", "saxon", "luxembourgish"]
+  },
+  {
+    lang: "italian",
+    match: ["ita", "it", "italy", "italiano", "swiss italian"],
+    suggest: ["sardinian", "neapolitan", "venetian"]
+  },
+  {
+    lang: "portuguese",
+    match: ["por", "pt", "portugal", "brazil", "brazilian", "braz", "mozambique", "angola"],
+    suggest: ["galician", "mirandese"]
+  },
+  {
+    lang: "dutch",
+    match: ["dut", "nl", "nld", "netherlands", "holland", "flemish", "belgium"],
+    suggest: ["frisian", "afrikaans"]
+  },
+  // Slavic Languages
+  {
+    lang: "russian",
+    match: ["rus", "ru", "russia", "belarus"],
+    suggest: ["kazakh", "tatar", "belarusian", "tajik", "uzbek", "moldovan"]
+  },
+  {
+    lang: "ukrainian",
+    match: ["ukr", "uk", "ukraine"],
+    suggest: ["russian", "belarusian"]
+  },
+  {
+    lang: "polish",
+    match: ["pol", "pl", "poland"],
+    suggest: ["silesian", "kashubian"]
+  },
+  {
+    lang: "czech",
+    match: ["ces", "cs", "cze", "czech republic", "czechia"],
+    suggest: ["slovak", "moravian"]
+  },
+  {
+    lang: "slovak",
+    match: ["slk", "sk", "slovakia"],
+    suggest: ["czech", "rusyn"]
+  },
+  {
+    lang: "croatian",
+    match: ["hrv", "hr", "croatia"],
+    suggest: ["serbian", "bosnian", "montenegrin"]
+  },
+  {
+    lang: "serbian",
+    match: ["srp", "sr", "ser", "serbia", "serbian", "srpski", "\u0441\u0440\u0431\u0438\u0458\u0430", "\u0441\u0440\u043F\u0441\u043A\u0438"],
+    suggest: ["croatian", "bosnian", "montenegrin"]
+  },
+  {
+    lang: "bulgarian",
+    match: ["bul", "bg", "bulgaria"],
+    suggest: ["macedonian"]
+  },
+  {
+    lang: "slovenian",
+    match: ["slv", "sl", "slovenia"],
+    suggest: ["croatian"]
+  },
+  // Nordic Languages
+  {
+    lang: "swedish",
+    match: ["swe", "sv", "sweden"],
+    suggest: ["norwegian", "danish", "finnish"]
+  },
+  {
+    lang: "norwegian",
+    match: ["nor", "no", "norway"],
+    suggest: ["swedish", "danish"]
+  },
+  {
+    lang: "danish",
+    match: ["dan", "da", "denmark"],
+    suggest: ["norwegian", "swedish"]
+  },
+  {
+    lang: "finnish",
+    match: ["fin", "fi", "finland"],
+    suggest: ["estonian", "swedish"]
+  },
+  {
+    lang: "icelandic",
+    match: ["isl", "is", "iceland"],
+    suggest: ["faroese", "norwegian"]
+  },
+  // Other European Languages
+  {
+    lang: "greek",
+    match: ["ell", "el", "gre", "greece", "hellenic"],
+    suggest: ["macedonian", "albanian"]
+  },
+  {
+    lang: "romanian",
+    match: ["ron", "ro", "rum", "romania"],
+    suggest: ["moldovan", "hungarian"]
+  },
+  {
+    lang: "hungarian",
+    match: ["hun", "hu", "hungary", "magyar"],
+    suggest: ["romanian", "slovak"]
+  },
+  {
+    lang: "albanian",
+    match: ["sqi", "sq", "alb", "albania", "kosovo"],
+    suggest: ["greek", "macedonian"]
+  },
+  {
+    lang: "lithuanian",
+    match: ["lit", "lt", "lithuania"],
+    suggest: ["latvian", "polish"]
+  },
+  {
+    lang: "latvian",
+    match: ["lav", "lv", "latvia"],
+    suggest: ["lithuanian", "estonian"]
+  },
+  {
+    lang: "estonian",
+    match: ["est", "et", "estonia"],
+    suggest: ["finnish", "latvian"]
+  },
+  // Celtic Languages
+  {
+    lang: "irish",
+    match: ["gle", "ga", "ireland", "gaelic"],
+    suggest: ["scottish", "welsh"]
+  },
+  {
+    lang: "welsh",
+    match: ["cym", "cy", "wales", "cymru"],
+    suggest: ["irish", "cornish"]
+  },
+  {
+    lang: "scottish",
+    match: ["gla", "gd", "scotland", "scots gaelic"],
+    suggest: ["irish", "english"]
+  },
+  // Additional Languages
+  {
+    lang: "esperanto",
+    match: ["epo", "eo", "esperanto"],
+    suggest: []
+  },
+  {
+    lang: "latin",
+    match: ["lat", "la", "latin"],
+    suggest: ["italian", "spanish", "french"]
+  }
+];
+
+// src/language-aliases/asian.ts
+var ASIAN_LANGUAGES = [
+  // Asian Languages
+  {
+    lang: "chinese",
+    match: [
+      "chi",
+      "zh",
+      "zho",
+      "zh-cn",
+      "cn",
+      "china",
+      "mandarin",
+      "zhongwen",
+      "simplified",
+      "traditional"
+    ],
+    suggest: ["cantonese", "taiwanese", "hakka"]
+  },
+  {
+    lang: "japanese",
+    match: ["jpn", "ja", "jp", "japan", "nihongo"],
+    suggest: ["okinawan"]
+  },
+  {
+    lang: "korean",
+    match: ["kor", "ko", "kr", "korea", "hangul", "south korea", "north korea"],
+    suggest: ["jeju"]
+  },
+  {
+    lang: "hindi",
+    match: ["hin", "hi", "india", "indian", "devanagari"],
+    suggest: ["urdu", "punjabi", "gujarati", "marathi", "bengali"]
+  },
+  {
+    lang: "arabic",
+    match: ["ara", "ar", "arab", "saudi", "egypt", "egyptian", "gulf", "levantine", "maghreb"],
+    suggest: ["persian", "hebrew", "urdu"]
+  },
+  {
+    lang: "thai",
+    match: ["tha", "th", "thailand", "siam"],
+    suggest: ["lao", "khmer"]
+  },
+  {
+    lang: "vietnamese",
+    match: ["vie", "vi", "vietnam"],
+    suggest: ["khmer", "lao"]
+  },
+  {
+    lang: "indonesian",
+    match: ["ind", "id", "indonesia", "bahasa"],
+    suggest: ["malay", "javanese", "sundanese"]
+  },
+  {
+    lang: "malay",
+    match: ["msa", "ms", "malaysia", "brunei"],
+    suggest: ["indonesian"]
+  },
+  // Central Asian & Turkic Languages
+  {
+    lang: "kazakh",
+    match: ["kaz", "kk", "kazakh", "kazakhstan"],
+    suggest: ["russian", "kyrgyz", "uzbek"]
+  },
+  {
+    lang: "turkish",
+    match: ["tur", "tr", "turkey"],
+    suggest: ["kurdish", "azerbaijani"]
+  },
+  {
+    lang: "uzbek",
+    match: ["uzb", "uz", "uzbekistan"],
+    suggest: ["tajik", "kazakh", "kyrgyz"]
+  },
+  {
+    lang: "kyrgyz",
+    match: ["kir", "ky", "kyrgyzstan"],
+    suggest: ["kazakh", "uzbek"]
+  },
+  {
+    lang: "tajik",
+    match: ["tgk", "tg", "tajikistan"],
+    suggest: ["persian", "uzbek"]
+  },
+  {
+    lang: "azerbaijani",
+    match: ["aze", "az", "azerbaijan"],
+    suggest: ["turkish", "persian"]
+  },
+  // Middle Eastern Languages
+  {
+    lang: "persian",
+    match: ["fas", "fa", "per", "iran", "farsi", "dari", "afghanistan"],
+    suggest: ["tajik", "kurdish", "pashto"]
+  },
+  {
+    lang: "hebrew",
+    match: ["heb", "he", "israel", "israeli"],
+    suggest: ["arabic", "yiddish"]
+  },
+  {
+    lang: "kurdish",
+    match: ["kur", "ku", "kurdistan", "kurmanji", "sorani"],
+    suggest: ["turkish", "persian", "arabic"]
+  },
+  // South Asian Languages
+  {
+    lang: "urdu",
+    match: ["urd", "ur", "pakistan", "pakistani"],
+    suggest: ["hindi", "punjabi"]
+  },
+  {
+    lang: "bengali",
+    match: ["ben", "bn", "bangladesh", "bengal"],
+    suggest: ["hindi", "assamese"]
+  },
+  {
+    lang: "punjabi",
+    match: ["pan", "pa", "punjab"],
+    suggest: ["hindi", "urdu"]
+  },
+  {
+    lang: "gujarati",
+    match: ["guj", "gu", "gujarat"],
+    suggest: ["hindi", "marathi"]
+  },
+  {
+    lang: "marathi",
+    match: ["mar", "mr", "maharashtra"],
+    suggest: ["hindi", "gujarati"]
+  },
+  {
+    lang: "tamil",
+    match: ["tam", "ta", "tamil nadu", "sri lanka"],
+    suggest: ["malayalam", "telugu", "kannada"]
+  },
+  {
+    lang: "telugu",
+    match: ["tel", "te", "andhra pradesh"],
+    suggest: ["tamil", "kannada"]
+  },
+  {
+    lang: "kannada",
+    match: ["kan", "kn", "karnataka"],
+    suggest: ["tamil", "telugu", "malayalam"]
+  },
+  {
+    lang: "malayalam",
+    match: ["mal", "ml", "kerala"],
+    suggest: ["tamil", "kannada"]
+  },
+  {
+    lang: "nepali",
+    match: ["nep", "ne", "nepal"],
+    suggest: ["hindi"]
+  },
+  {
+    lang: "sinhala",
+    match: ["sin", "si", "sri lanka", "ceylon"],
+    suggest: ["tamil"]
+  },
+  // Southeast Asian Languages
+  {
+    lang: "burmese",
+    match: ["mya", "my", "myanmar", "burma"],
+    suggest: ["thai"]
+  },
+  {
+    lang: "khmer",
+    match: ["khm", "km", "cambodia", "cambodian"],
+    suggest: ["vietnamese", "thai"]
+  },
+  {
+    lang: "lao",
+    match: ["lao", "lo", "laos"],
+    suggest: ["thai", "vietnamese"]
+  },
+  {
+    lang: "tagalog",
+    match: ["tgl", "tl", "philippines", "filipino"],
+    suggest: ["cebuano", "ilocano"]
+  }
+];
+
+// src/language-aliases/african.ts
+var AFRICAN_LANGUAGES = [
+  // African Languages
+  {
+    lang: "swahili",
+    match: ["swa", "sw", "kiswahili", "tanzania", "kenya"],
+    suggest: ["arabic"]
+  },
+  {
+    lang: "amharic",
+    match: ["amh", "am", "ethiopia", "ethiopian"],
+    suggest: ["tigrinya", "oromo"]
+  },
+  {
+    lang: "yoruba",
+    match: ["yor", "yo", "nigeria", "benin"],
+    suggest: ["igbo", "hausa"]
+  },
+  {
+    lang: "zulu",
+    match: ["zul", "zu", "south africa"],
+    suggest: ["xhosa", "afrikaans"]
+  }
+];
+
+// src/language-aliases/index.ts
+var LANGUAGE_ALIAS_TABLE = [
+  ...EUROPEAN_LANGUAGES,
+  ...ASIAN_LANGUAGES,
+  ...AFRICAN_LANGUAGES
+];
+
+// src/search-utils.ts
+function applyLanguageAlias(term = "") {
+  const s = term.toLowerCase().trim();
+  if (!s) return { primary: term, suggestions: [] };
+  const isMatch = (alias, input) => {
+    if (input === alias) return true;
+    if (alias.length >= 3 && input.length >= alias.length && input.startsWith(alias)) return true;
+    if (input.length >= 2 && alias.startsWith(input)) return true;
+    return false;
+  };
+  const hits = /* @__PURE__ */ new Set();
+  const suggestions = /* @__PURE__ */ new Set();
+  for (const { lang, match, suggest } of LANGUAGE_ALIAS_TABLE) {
+    for (const m of match) {
+      if (isMatch(m, s)) {
+        hits.add(lang);
+        if (suggest) {
+          suggest.forEach((sug) => suggestions.add(sug));
+        }
+      }
+    }
+  }
+  let primary;
+  if (hits.size === 0) {
+    primary = term;
+  } else if (hits.size === 1) {
+    primary = Array.from(hits)[0];
+  } else {
+    primary = Array.from(hits);
+  }
+  return { primary, suggestions: Array.from(suggestions) };
+}
+
+// src/constants/colors.ts
+var COLORS = {
+  // Primary colors
+  primary: {
+    blue: "#3b82f6",
+    blueLight: "#60a5fa",
+    blueDark: "#2563eb",
+    blueAlpha30: "#3b82f630",
+    blueAlpha50: "#3b82f650"
+  },
+  // Neutral colors
+  neutral: {
+    white: "#fff",
+    gray50: "#f9fafb",
+    gray100: "#f3f4f6",
+    gray200: "#e5e7eb",
+    gray300: "#d1d5db",
+    gray400: "#9ca3af",
+    gray500: "#6b7280",
+    gray600: "#4b5563",
+    gray700: "#374151",
+    gray800: "#1f2937",
+    gray900: "#111827"
+  },
+  // Border colors
+  border: {
+    light: "#d1d5db",
+    dark: "#4b5563",
+    flag: "#eee"
+  },
+  // Text colors
+  text: {
+    primary: "#1f2937",
+    secondary: "#6b7280",
+    placeholder: "#9ca3af",
+    inverse: "#f9fafb"
+  }
+};
+var THEME_COLORS = {
+  light: {
+    background: COLORS.neutral.white,
+    backgroundDisabled: COLORS.neutral.gray100,
+    border: COLORS.border.light,
+    placeholder: COLORS.text.placeholder,
+    ring: COLORS.primary.blueAlpha30,
+    optionPointed: COLORS.neutral.gray100,
+    optionPointedText: COLORS.text.primary,
+    optionSelected: COLORS.primary.blue,
+    optionSelectedText: COLORS.neutral.white,
+    dropdownBackground: COLORS.neutral.white,
+    dropdownBorder: COLORS.border.light,
+    dropdownText: COLORS.text.primary,
+    tagBackground: COLORS.primary.blue
+  },
+  dark: {
+    background: COLORS.neutral.gray800,
+    backgroundDisabled: COLORS.neutral.gray700,
+    border: COLORS.border.dark,
+    placeholder: COLORS.text.placeholder,
+    ring: COLORS.primary.blueAlpha50,
+    optionPointed: COLORS.neutral.gray700,
+    optionPointedText: COLORS.neutral.gray50,
+    optionSelected: COLORS.primary.blue,
+    optionSelectedText: COLORS.neutral.white,
+    dropdownBackground: COLORS.neutral.gray800,
+    dropdownBorder: COLORS.border.dark,
+    dropdownText: COLORS.neutral.gray50,
+    tagBackground: COLORS.primary.blue
+  }
+};
+var CSS_VARS = {
+  // Multiselect variables
+  multiselect: {
+    bg: "--ms-bg",
+    bgDisabled: "--ms-bg-disabled",
+    borderColor: "--ms-border-color",
+    placeholderColor: "--ms-placeholder-color",
+    ringColor: "--ms-ring-color",
+    optionBgPointed: "--ms-option-bg-pointed",
+    optionColorPointed: "--ms-option-color-pointed",
+    optionBgSelected: "--ms-option-bg-selected",
+    optionColorSelected: "--ms-option-color-selected",
+    dropdownBg: "--ms-dropdown-bg",
+    dropdownBorderColor: "--ms-dropdown-border-color",
+    dropdownColor: "--ms-dropdown-color",
+    tagBg: "--ms-tag-bg"
+  }
+};
+
+// vue-script:/Users/nlit/projects/langie-sdk/src/components/LanguageSelect.vue?type=script
+var _hoisted_1 = {
+  key: 0,
+  class: "multiselect-single-label"
+};
+var _hoisted_2 = ["src", "alt"];
+var _hoisted_3 = { class: "language-text" };
+var _hoisted_4 = { class: "native-name" };
+var _hoisted_5 = ["data-lang-code"];
+var _hoisted_6 = ["src", "alt"];
+var _hoisted_7 = { class: "language-text" };
+var _hoisted_8 = { class: "native-name" };
+var _hoisted_9 = { class: "multiselect-no-options" };
+var LanguageSelect_default = /* @__PURE__ */ _defineComponent({
+  __name: "LanguageSelect",
+  props: {
+    modelValue: {
+      type: Object,
+      default: void 0
+    },
+    languages: {
+      type: Array,
+      default: () => []
+    },
+    placeholder: {
+      type: String,
+      default: "Select language"
+    },
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    isDark: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit: __emit }) {
+    _useCssVars((_ctx) => ({
+      "25bc3fde-THEME_COLORS.light.background": _unref(THEME_COLORS).light.background,
+      "25bc3fde-THEME_COLORS.light.backgroundDisabled": _unref(THEME_COLORS).light.backgroundDisabled,
+      "25bc3fde-THEME_COLORS.light.border": _unref(THEME_COLORS).light.border,
+      "25bc3fde-THEME_COLORS.light.ring": _unref(THEME_COLORS).light.ring,
+      "25bc3fde-THEME_COLORS.light.placeholder": _unref(THEME_COLORS).light.placeholder,
+      "25bc3fde-THEME_COLORS.light.optionPointed": _unref(THEME_COLORS).light.optionPointed,
+      "25bc3fde-THEME_COLORS.light.optionPointedText": _unref(THEME_COLORS).light.optionPointedText,
+      "25bc3fde-THEME_COLORS.light.optionSelected": _unref(THEME_COLORS).light.optionSelected,
+      "25bc3fde-THEME_COLORS.light.optionSelectedText": _unref(THEME_COLORS).light.optionSelectedText,
+      "25bc3fde-THEME_COLORS.light.dropdownBackground": _unref(THEME_COLORS).light.dropdownBackground,
+      "25bc3fde-THEME_COLORS.light.dropdownBorder": _unref(THEME_COLORS).light.dropdownBorder,
+      "25bc3fde-THEME_COLORS.light.dropdownText": _unref(THEME_COLORS).light.dropdownText,
+      "25bc3fde-THEME_COLORS.light.tagBackground": _unref(THEME_COLORS).light.tagBackground,
+      "25bc3fde-THEME_COLORS.dark.background": _unref(THEME_COLORS).dark.background,
+      "25bc3fde-THEME_COLORS.dark.backgroundDisabled": _unref(THEME_COLORS).dark.backgroundDisabled,
+      "25bc3fde-THEME_COLORS.dark.border": _unref(THEME_COLORS).dark.border,
+      "25bc3fde-THEME_COLORS.dark.placeholder": _unref(THEME_COLORS).dark.placeholder,
+      "25bc3fde-THEME_COLORS.dark.ring": _unref(THEME_COLORS).dark.ring,
+      "25bc3fde-THEME_COLORS.dark.optionPointed": _unref(THEME_COLORS).dark.optionPointed,
+      "25bc3fde-THEME_COLORS.dark.optionPointedText": _unref(THEME_COLORS).dark.optionPointedText,
+      "25bc3fde-THEME_COLORS.dark.optionSelected": _unref(THEME_COLORS).dark.optionSelected,
+      "25bc3fde-THEME_COLORS.dark.optionSelectedText": _unref(THEME_COLORS).dark.optionSelectedText,
+      "25bc3fde-THEME_COLORS.dark.dropdownBackground": _unref(THEME_COLORS).dark.dropdownBackground,
+      "25bc3fde-THEME_COLORS.dark.dropdownBorder": _unref(THEME_COLORS).dark.dropdownBorder,
+      "25bc3fde-THEME_COLORS.dark.dropdownText": _unref(THEME_COLORS).dark.dropdownText,
+      "25bc3fde-COLORS.border.flag": _unref(COLORS).border.flag,
+      "25bc3fde-COLORS.border.dark": _unref(COLORS).border.dark,
+      "25bc3fde-COLORS.text.secondary": _unref(COLORS).text.secondary,
+      "25bc3fde-COLORS.neutral.gray400": _unref(COLORS).neutral.gray400
+    }));
+    const getFlagCode = (lang) => {
+      const flagCode = lang.flag_country || lang.code;
+      return flagCode;
+    };
+    const getFlagImageUrl = (lang) => {
+      const flagCode = getFlagCode(lang);
+      return `/flags/${flagCode}.svg`;
+    };
+    const props = __props;
+    const emit = __emit;
+    const isLoading = computed(() => {
+      return props.languages.length <= 0;
+    });
+    const searchQuery = ref2("");
+    const validLanguages = computed(() => {
+      return props.languages.filter((lang) => lang && lang.code && lang.name && lang.native_name);
+    });
+    const fuse = computed(() => {
+      if (!validLanguages.value.length) return null;
+      return new Fuse(validLanguages.value, {
+        keys: ["name", "native_name", "code"],
+        includeScore: true,
+        threshold: 0.6,
+        // Use highest threshold to catch all cases
+        isCaseSensitive: false,
+        minMatchCharLength: 1
+        // Allow single character matches
+      });
+    });
+    const multiselectKey = computed(() => {
+      const hasApiData = props.languages.length > 0 && props.languages[0].flag_country !== null;
+      return hasApiData ? "api-data" : "fallback-data";
+    });
+    const selectedLanguageKey = computed(() => {
+      if (!props.modelValue || !props.modelValue.code) return "no-selection";
+      const key = `${props.modelValue.code}-${props.modelValue.flag_country || "fallback"}`;
+      return key;
+    });
+    const selectedLanguage = computed({
+      get: () => props.modelValue || null,
+      set: (value) => {
+        if (value && value.code) {
+          emit("update:modelValue", value);
+        }
+      }
+    });
+    const filteredLanguages = computed(() => {
+      const query = searchQuery.value.trim();
+      let results;
+      if (!query) {
+        results = validLanguages.value;
+      } else {
+        if (!fuse.value) return [];
+        const aliasResult = applyLanguageAlias(query);
+        const searchTerm = Array.isArray(aliasResult.primary) ? aliasResult.primary[0] : aliasResult.primary;
+        const fuseResults = fuse.value.search(searchTerm);
+        results = fuseResults.map((result) => result.item);
+        if (searchTerm !== query) {
+          const originalResults = fuse.value.search(query);
+          originalResults.forEach((result) => {
+            if (!results.some((r) => r.code === result.item.code)) {
+              results.push(result.item);
+            }
+          });
+        }
+        if (aliasResult.suggestions.length > 0) {
+          aliasResult.suggestions.forEach((suggestion) => {
+            const suggestedLang = validLanguages.value.find((lang) => {
+              const langName = lang.name.toLowerCase();
+              const suggestion_lower = suggestion.toLowerCase();
+              return langName === suggestion_lower || // Exact match
+              langName.includes(suggestion_lower) || // Contains match
+              lang.code.toLowerCase() === suggestion_lower || // Code match
+              langName.startsWith(suggestion_lower) || // Starts with match
+              // Handle common variations
+              suggestion_lower === "tatar" && langName.includes("tatar") || suggestion_lower === "belarusian" && (langName.includes("belarus") || langName.includes("belarusian")) || suggestion_lower === "moldovan" && (langName.includes("moldov") || langName.includes("moldova"));
+            });
+            if (suggestedLang && !results.some((r) => r.code === suggestedLang.code)) {
+              results.push(suggestedLang);
+            }
+          });
+        }
+        if (query.length === 2) {
+          const lowerQuery = query.toLowerCase();
+          const manualResults = validLanguages.value.filter(
+            (lang) => lang.name.toLowerCase().startsWith(lowerQuery) || lang.native_name.toLowerCase().startsWith(lowerQuery)
+          );
+          manualResults.forEach((lang) => {
+            if (!results.some((r) => r.code === lang.code)) {
+              results.push(lang);
+            }
+          });
+        }
+      }
+      const filtered = results.filter(
+        (lang) => !props.modelValue || !props.modelValue.code || lang.code !== props.modelValue.code
+      );
+      return filtered;
+    });
+    function handleSearch(query) {
+      searchQuery.value = query;
+      if (query.trim()) {
+        nextTick(() => {
+          const dropdown = document.querySelector(".multiselect-dropdown");
+          const firstOption = dropdown?.querySelector(".multiselect-option");
+          if (firstOption) {
+            firstOption.scrollIntoView({ behavior: "smooth", block: "nearest" });
+            firstOption.classList.add("multiselect-option-is-pointed");
+          }
+        });
+      }
+    }
+    function handleKeydown(event) {
+      const keyboardEvent = event;
+      if (keyboardEvent.key === "Tab" || keyboardEvent.key === "Enter") {
+        const dropdown = document.querySelector(".multiselect-dropdown");
+        const firstOption = dropdown?.querySelector(".multiselect-option");
+        if (firstOption && searchQuery.value.trim()) {
+          const langCode = firstOption.getAttribute("data-lang-code");
+          if (langCode) {
+            const language = validLanguages.value.find((lang) => lang.code === langCode);
+            if (language) {
+              selectedLanguage.value = language;
+              searchQuery.value = "";
+              keyboardEvent.preventDefault();
+            }
+          }
+        }
+      }
+    }
+    const onFlagError = (event) => {
+      const target = event.target;
+      const currentSrc = target.src;
+      if (currentSrc && currentSrc.includes("/flags/")) {
+        const match = currentSrc.match(/\/flags\/([a-z]{2})\.svg/);
+        if (match) {
+          const countryCode = match[1];
+          target.src = `https://flagcdn.com/${countryCode}.svg`;
+          target.onerror = () => {
+            target.style.display = "none";
+          };
+          return;
+        }
+      }
+      target.style.display = "none";
+    };
+    return (_ctx, _cache) => {
+      return _openBlock(), _createElementBlock(
+        "div",
+        {
+          class: _normalizeClass(["language-select", { "is-dark": __props.isDark }])
+        },
+        [
+          _createCommentVNode(" Show multiselect when we have languages OR when not loading "),
+          validLanguages.value.length > 0 || !isLoading.value ? (_openBlock(), _createBlock(_unref(Multiselect), {
+            key: multiselectKey.value,
+            modelValue: selectedLanguage.value,
+            "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => selectedLanguage.value = $event),
+            options: filteredLanguages.value,
+            searchable: true,
+            onSearchChange: handleSearch,
+            "can-clear": false,
+            "allow-empty": false,
+            object: true,
+            placeholder: validLanguages.value.length === 0 ? "No languages available" : __props.placeholder,
+            disabled: props.disabled || validLanguages.value.length === 0,
+            loading: isLoading.value,
+            "track-by": "name",
+            label: "name",
+            "value-prop": "code",
+            "filter-results": false,
+            onKeydown: handleKeydown
+          }, {
+            singlelabel: _withCtx(({ value }) => [
+              value ? (_openBlock(), _createElementBlock("div", _hoisted_1, [
+                value.code ? (_openBlock(), _createElementBlock("img", {
+                  key: selectedLanguageKey.value,
+                  src: getFlagImageUrl(value),
+                  class: "lang-flag",
+                  alt: `${value.native_name || value.name} flag`,
+                  onError: onFlagError
+                }, null, 40, _hoisted_2)) : _createCommentVNode("v-if", true),
+                _createElementVNode("span", _hoisted_3, [
+                  _createTextVNode(
+                    _toDisplayString(value.name) + " ",
+                    1
+                    /* TEXT */
+                  ),
+                  _createElementVNode(
+                    "span",
+                    _hoisted_4,
+                    "(" + _toDisplayString(value.native_name || value.name) + ")",
+                    1
+                    /* TEXT */
+                  )
+                ])
+              ])) : _createCommentVNode("v-if", true)
+            ]),
+            option: _withCtx(({ option }) => [
+              _createElementVNode("div", {
+                class: "multiselect-option",
+                "data-lang-code": option.code
+              }, [
+                (_openBlock(), _createElementBlock("img", {
+                  key: `${option.code}-${option.flag_country || "fallback"}`,
+                  src: getFlagImageUrl(option),
+                  class: "lang-flag",
+                  alt: `${option.name} flag`,
+                  onError: onFlagError
+                }, null, 40, _hoisted_6)),
+                _createElementVNode("span", _hoisted_7, [
+                  _createTextVNode(
+                    _toDisplayString(option.name) + " ",
+                    1
+                    /* TEXT */
+                  ),
+                  _createElementVNode(
+                    "span",
+                    _hoisted_8,
+                    "(" + _toDisplayString(option.native_name || option.name) + ")",
+                    1
+                    /* TEXT */
+                  )
+                ])
+              ], 8, _hoisted_5)
+            ]),
+            noresults: _withCtx(() => _cache[1] || (_cache[1] = [
+              _createElementVNode(
+                "div",
+                { class: "multiselect-no-results" },
+                "No languages found.",
+                -1
+                /* CACHED */
+              )
+            ])),
+            nooptions: _withCtx(() => [
+              _createElementVNode(
+                "div",
+                _hoisted_9,
+                _toDisplayString(validLanguages.value.length === 0 ? "Please provide languages via the :languages prop" : "No languages available."),
+                1
+                /* TEXT */
+              )
+            ]),
+            _: 1
+            /* STABLE */
+          }, 8, ["modelValue", "options", "placeholder", "disabled", "loading"])) : isLoading.value && validLanguages.value.length === 0 ? (_openBlock(), _createElementBlock(
+            _Fragment,
+            { key: 1 },
+            [
+              _createCommentVNode(" Only show skeleton loader when actually loading AND we have no languages yet "),
+              _cache[2] || (_cache[2] = _createElementVNode(
+                "div",
+                { class: "skeleton-loader" },
+                null,
+                -1
+                /* CACHED */
+              ))
+            ],
+            2112
+            /* STABLE_FRAGMENT, DEV_ROOT_FRAGMENT */
+          )) : _createCommentVNode("v-if", true)
+        ],
+        2
+        /* CLASS */
+      );
+    };
+  }
+});
+
+// src/components/LanguageSelect.vue
+var LanguageSelect_default2 = LanguageSelect_default;
+LanguageSelect_default.__scopeId = "data-v-25bc3fde";
+
+// vue-script:/Users/nlit/projects/langie-sdk/src/components/InterfaceLanguageSelect.vue?type=script
+import { defineComponent as _defineComponent2 } from "vue";
+import { openBlock as _openBlock2, createBlock as _createBlock2, createCommentVNode as _createCommentVNode2, createElementVNode as _createElementVNode2, unref as _unref2, toDisplayString as _toDisplayString2, normalizeClass as _normalizeClass2, createElementBlock as _createElementBlock2 } from "vue";
+import { computed as computed2, watch as watch2, onMounted, ref as ref3 } from "vue";
+var _hoisted_12 = { class: "interface-language-select-wrapper" };
+var _hoisted_22 = { class: "loader-text" };
+var InterfaceLanguageSelect_default = /* @__PURE__ */ _defineComponent2({
+  __name: "InterfaceLanguageSelect",
+  props: {
+    placeholder: {
+      type: String,
+      default: "Select interface language"
+    },
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    isDark: {
+      type: Boolean,
+      default: false
+    },
+    translatorHost: {
+      type: String,
+      default: ""
+    },
+    apiKey: {
+      type: String,
+      default: ""
+    },
+    languages: {
+      type: Array,
+      default: () => []
+    }
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit: __emit }) {
+    const isChangingLanguage = ref3(false);
+    const props = __props;
+    const emit = __emit;
+    const { availableLanguages: availableLanguages2, currentLanguage: currentLanguage2, setLanguage, fetchLanguages, lr } = useLangie();
+    const effectiveLanguages = computed2(() => {
+      const languages = props.languages && props.languages.length > 0 ? props.languages : availableLanguages2.value;
+      const processed = languages.map((lang) => ({
+        ...lang,
+        native_name: lang.native_name || lang.name,
+        flag_country: lang.flag_country || lang.code
+      }));
+      return processed;
+    });
+    const currentLanguageObject = computed2(() => {
+      if (!currentLanguage2.value) return null;
+      return effectiveLanguages.value.find((lang) => lang.code === currentLanguage2.value) || null;
+    });
+    function detectBrowserLanguage2(languages) {
+      if (languages.length === 0) return null;
+      const browserLanguages = navigator.languages || [navigator.language || "en"];
+      for (const browserLang of browserLanguages) {
+        const langCode = browserLang.toLowerCase().split("-")[0];
+        const exactMatch = languages.find((lang) => lang.code.toLowerCase() === langCode);
+        if (exactMatch) {
+          return exactMatch.code;
+        }
+      }
+      for (const browserLang of browserLanguages) {
+        const fullLangCode = browserLang.toLowerCase();
+        const localeMatch = languages.find((lang) => lang.code.toLowerCase() === fullLangCode);
+        if (localeMatch) {
+          return localeMatch.code;
+        }
+      }
+      return null;
+    }
+    async function handleLanguageChange(selectedLanguage) {
+      if (selectedLanguage) {
+        isChangingLanguage.value = true;
+        try {
+          setLanguage(selectedLanguage.code);
+          localStorage.setItem("interface_language", selectedLanguage.code);
+          emit("update:modelValue", selectedLanguage);
+        } finally {
+          isChangingLanguage.value = false;
+        }
+      }
+    }
+    watch2(currentLanguage2, (newLangCode) => {
+      if (newLangCode) {
+        localStorage.setItem("interface_language", newLangCode);
+      }
+    });
+    watch2(
+      () => effectiveLanguages.value,
+      (newLanguages) => {
+        if (newLanguages.length > 0 && !currentLanguage2.value) {
+          const savedLanguageCode = localStorage.getItem("interface_language");
+          if (savedLanguageCode) {
+            const savedLangExists = newLanguages.find((lang) => lang.code === savedLanguageCode);
+            if (savedLangExists) {
+              setLanguage(savedLanguageCode);
+              return;
+            }
+          }
+          const browserLang = detectBrowserLanguage2(newLanguages);
+          if (browserLang) {
+            setLanguage(browserLang);
+          }
+        }
+      },
+      { immediate: true }
+    );
+    onMounted(async () => {
+      if (!props.languages || props.languages.length === 0) {
+        const countryCode = await getCountryCode();
+        await fetchLanguages({ country: countryCode || void 0 });
+      }
+      const savedLanguageCode = localStorage.getItem("interface_language");
+      if (savedLanguageCode && savedLanguageCode !== currentLanguage2.value) {
+        const currentLanguages = effectiveLanguages.value;
+        const savedLangExists = currentLanguages.find((lang) => lang.code === savedLanguageCode);
+        if (savedLangExists) {
+          setLanguage(savedLanguageCode);
+        } else if (currentLanguages.length > 0) {
+          const browserLang = detectBrowserLanguage2(currentLanguages);
+          if (browserLang) {
+            setLanguage(browserLang);
+          }
+        }
+      } else if (!currentLanguage2.value && effectiveLanguages.value.length > 0) {
+        const browserLang = detectBrowserLanguage2(effectiveLanguages.value);
+        if (browserLang) {
+          setLanguage(browserLang);
+        }
+      }
+    });
+    watch2(
+      currentLanguageObject,
+      (newValue) => {
+        if (newValue) {
+          emit("update:modelValue", newValue);
+        }
+      },
+      { immediate: true }
+    );
+    return (_ctx, _cache) => {
+      return _openBlock2(), _createElementBlock2("div", _hoisted_12, [
+        (_openBlock2(), _createBlock2(LanguageSelect_default2, {
+          key: `interface-lang-${effectiveLanguages.value.length}-${effectiveLanguages.value[0]?.code || "empty"}`,
+          "model-value": currentLanguageObject.value,
+          languages: effectiveLanguages.value,
+          placeholder: props.placeholder,
+          disabled: props.disabled || isChangingLanguage.value,
+          "is-dark": props.isDark,
+          "onUpdate:modelValue": handleLanguageChange
+        }, null, 8, ["model-value", "languages", "placeholder", "disabled", "is-dark"])),
+        _createCommentVNode2(" Loading overlay "),
+        isChangingLanguage.value ? (_openBlock2(), _createElementBlock2(
+          "div",
+          {
+            key: 0,
+            class: _normalizeClass2(["language-change-loader", { "is-dark": props.isDark }])
+          },
+          [
+            _cache[0] || (_cache[0] = _createElementVNode2(
+              "div",
+              { class: "loader-spinner" },
+              null,
+              -1
+              /* CACHED */
+            )),
+            _createElementVNode2(
+              "span",
+              _hoisted_22,
+              _toDisplayString2(_unref2(lr)("Changing language...", "ui")),
+              1
+              /* TEXT */
+            )
+          ],
+          2
+          /* CLASS */
+        )) : _createCommentVNode2("v-if", true)
+      ]);
+    };
+  }
+});
+
+// src/components/InterfaceLanguageSelect.vue
+var InterfaceLanguageSelect_default2 = InterfaceLanguageSelect_default;
+InterfaceLanguageSelect_default.__scopeId = "data-v-7192f8c0";
+
+// vue-script:/Users/nlit/projects/langie-sdk/src/components/lt.vue?type=script
+import { defineComponent as _defineComponent3 } from "vue";
+import { toDisplayString as _toDisplayString3, openBlock as _openBlock3, createElementBlock as _createElementBlock3, Transition as _Transition, withCtx as _withCtx2, createBlock as _createBlock3 } from "vue";
+import { computed as computed3, useSlots, watch as watch3 } from "vue";
+import { ref as ref4, nextTick as nextTick2 } from "vue";
+var lt_default = /* @__PURE__ */ _defineComponent3({
+  __name: "lt",
+  props: {
+    // Message key (optional, otherwise slot content is used)
+    msg: {
+      type: String,
+      default: void 0
+    },
+    // Translation context shorthand
+    ctx: {
+      type: String,
+      required: false,
+      default: "ui"
+    },
+    // Original language shorthand
+    orig: {
+      type: String,
+      required: false,
+      default: void 0
+    }
+  },
+  setup(__props) {
+    const isNuxt = computed3(() => {
+      if (typeof window !== "undefined") {
+        return !!window.__NUXT__;
+      }
+      if (typeof process !== "undefined") {
+        return !!process.env.NUXT_SSR_BASE || !!process.env.NUXT_PUBLIC_BASE_URL;
+      }
+      return false;
+    });
+    const props = __props;
+    const slots = useSlots();
+    const { lr, currentLanguage: currentLanguage2, uiTranslations: uiTranslations2, translations: translations2, getLtDefaults: getLtDefaults2 } = useLangie();
+    const keyStr = computed3(() => {
+      if (props.msg) return props.msg;
+      const slotContent = slots.default ? slots.default().map((n) => n.children).join("") : "";
+      return (slotContent || "").trim();
+    });
+    const forceUpdate = ref4(0);
+    watch3(
+      [uiTranslations2, translations2],
+      () => {
+        nextTick2(() => {
+          forceUpdate.value++;
+        });
+      },
+      { deep: true }
+    );
+    const translated = computed3(() => {
+      if (isNuxt.value && typeof window === "undefined") {
+        return keyStr.value;
+      }
+      const globalDefaults = getLtDefaults2();
+      const effectiveCtx = props.ctx ?? globalDefaults.ctx;
+      const effectiveOrig = props.orig ?? globalDefaults.orig;
+      void currentLanguage2.value;
+      void forceUpdate.value;
+      const cacheKey = `${keyStr.value}|${effectiveCtx}`;
+      const cache = effectiveCtx === "ui" ? uiTranslations2 : translations2;
+      void cache[cacheKey];
+      const result = lr(keyStr.value, effectiveCtx, effectiveOrig);
+      return result;
+    });
+    return (_ctx, _cache) => {
+      return _openBlock3(), _createBlock3(_Transition, {
+        name: "fade",
+        mode: "out-in"
+      }, {
+        default: _withCtx2(() => [
+          (_openBlock3(), _createElementBlock3(
+            "span",
+            { key: translated.value },
+            _toDisplayString3(translated.value),
+            1
+            /* TEXT */
+          ))
+        ]),
+        _: 1
+        /* STABLE */
+      });
+    };
+  }
+});
+
+// src/components/lt.vue
+var lt_default2 = lt_default;
+lt_default.__scopeId = "data-v-14a7b6f6";
+
+// src/utils/theme.ts
+function setThemeColors() {
+  const root = document.documentElement;
+  root.style.setProperty("--langie-flag-border", COLORS.border.flag);
+  root.style.setProperty("--langie-flag-border-dark", COLORS.border.dark);
+  root.style.setProperty("--langie-text-secondary", COLORS.text.secondary);
+  root.style.setProperty("--langie-text-secondary-dark", COLORS.neutral.gray400);
+  root.style.setProperty("--langie-primary-blue", COLORS.primary.blue);
+  root.style.setProperty("--langie-primary-blue-alpha-30", COLORS.primary.blueAlpha30);
+  root.style.setProperty("--langie-primary-blue-alpha-50", COLORS.primary.blueAlpha50);
+}
+function clearThemeColors() {
+  const root = document.documentElement;
+  const properties = [
+    "--langie-flag-border",
+    "--langie-flag-border-dark",
+    "--langie-text-secondary",
+    "--langie-text-secondary-dark",
+    "--langie-primary-blue",
+    "--langie-primary-blue-alpha-30",
+    "--langie-primary-blue-alpha-50"
+  ];
+  properties.forEach((prop) => root.style.removeProperty(prop));
+}
+
+// src/utils/languageMapping.ts
+var BROWSER_LANGUAGE_MAP = {
+  // Chinese variants
+  "zh": "zh-cn",
+  // Chinese (Simplified)
+  // Serbian variants
+  "sr": "sr-latn",
+  // Serbian (default to Latin)
+  "me": "sr-latn",
+  // Montenegrin
+  "sh": "sr-latn",
+  // Serbo-Croatian
+  // Kazakh variants
+  "kaz": "kk",
+  // Kazakh (browser 'kaz' or 'kk' → 'kk')
+  "kk": "kk"
+};
+function detectBrowserLanguage() {
+  if (typeof navigator === "undefined") {
+    return "en";
+  }
+  const locale = navigator.languages?.[0] || navigator.language || "";
+  const browserCode = locale.split("-")[0];
+  const mappedLanguage = BROWSER_LANGUAGE_MAP[browserCode];
+  if (mappedLanguage) {
+    return mappedLanguage;
+  }
+  return browserCode || "en";
+}
+
+// src/utils/regionMapping.ts
+var COUNTRY_TO_REGION = {
+  // EU
+  DE: "EU",
+  AT: "EU",
+  CH: "EU",
+  NL: "EU",
+  BE: "EU",
+  LU: "EU",
+  DK: "EU",
+  SE: "EU",
+  NO: "EU",
+  IS: "EU",
+  GB: "EU",
+  IE: "EU",
+  FR: "EU",
+  IT: "EU",
+  ES: "EU",
+  PT: "EU",
+  RO: "EU",
+  MT: "EU",
+  PL: "EU",
+  CZ: "EU",
+  SK: "EU",
+  SI: "EU",
+  HR: "EU",
+  BA: "EU",
+  RS: "EU",
+  ME: "EU",
+  MK: "EU",
+  BG: "EU",
+  RU: "EU",
+  BY: "EU",
+  UA: "EU",
+  LT: "EU",
+  LV: "EU",
+  EE: "EU",
+  FI: "EU",
+  HU: "EU",
+  GR: "EU",
+  CY: "EU",
+  AL: "EU",
+  MD: "EU",
+  LI: "EU",
+  AD: "EU",
+  SM: "EU",
+  VA: "EU",
+  MC: "EU",
+  // NA
+  US: "NA",
+  CA: "NA",
+  MX: "NA",
+  GT: "NA",
+  BZ: "NA",
+  SV: "NA",
+  HN: "NA",
+  NI: "NA",
+  CR: "NA",
+  PA: "NA",
+  HT: "NA",
+  JM: "NA",
+  CU: "NA",
+  DO: "NA",
+  TT: "NA",
+  BB: "NA",
+  BS: "NA",
+  GD: "NA",
+  LC: "NA",
+  VC: "NA",
+  AG: "NA",
+  DM: "NA",
+  KN: "NA",
+  // SA
+  AR: "SA",
+  CL: "SA",
+  PE: "SA",
+  CO: "SA",
+  VE: "SA",
+  EC: "SA",
+  BO: "SA",
+  PY: "SA",
+  UY: "SA",
+  BR: "SA",
+  GY: "SA",
+  SR: "SA",
+  GF: "SA",
+  // EA
+  CN: "EA",
+  TW: "EA",
+  HK: "EA",
+  MO: "EA",
+  SG: "EA",
+  JP: "EA",
+  KR: "EA",
+  KP: "EA",
+  MN: "EA",
+  // SEA
+  VN: "SEA",
+  KH: "SEA",
+  TH: "SEA",
+  LA: "SEA",
+  MM: "SEA",
+  ID: "SEA",
+  MY: "SEA",
+  PH: "SEA",
+  BN: "SEA",
+  TL: "SEA",
+  // SAS
+  IN: "SAS",
+  PK: "SAS",
+  BD: "SAS",
+  LK: "SAS",
+  NP: "SAS",
+  BT: "SAS",
+  MV: "SAS",
+  AF: "SAS",
+  // CAS
+  KZ: "CAS",
+  KG: "CAS",
+  UZ: "CAS",
+  TM: "CAS",
+  TR: "CAS",
+  AZ: "CAS",
+  TJ: "CAS",
+  IR: "CAS",
+  // ME
+  SA: "ME",
+  AE: "ME",
+  QA: "ME",
+  KW: "ME",
+  BH: "ME",
+  OM: "ME",
+  YE: "ME",
+  JO: "ME",
+  LB: "ME",
+  SY: "ME",
+  IQ: "ME",
+  PS: "ME",
+  IL: "ME",
+  GE: "ME",
+  AM: "ME",
+  // NAF
+  EG: "NAF",
+  LY: "NAF",
+  TN: "NAF",
+  DZ: "NAF",
+  MA: "NAF",
+  SD: "NAF",
+  SS: "NAF",
+  ET: "NAF",
+  ER: "NAF",
+  DJ: "NAF",
+  SO: "NAF",
+  // WAF
+  NG: "WAF",
+  GH: "WAF",
+  CI: "WAF",
+  BF: "WAF",
+  ML: "WAF",
+  SN: "WAF",
+  GN: "WAF",
+  SL: "WAF",
+  LR: "WAF",
+  GM: "WAF",
+  GW: "WAF",
+  NE: "WAF",
+  TD: "WAF",
+  CF: "WAF",
+  CM: "WAF",
+  MR: "WAF",
+  CV: "WAF",
+  // EAF
+  KE: "EAF",
+  TZ: "EAF",
+  UG: "EAF",
+  RW: "EAF",
+  BI: "EAF",
+  MZ: "EAF",
+  MW: "EAF",
+  ZM: "EAF",
+  ZW: "EAF",
+  MG: "EAF",
+  MU: "EAF",
+  KM: "EAF",
+  SC: "EAF",
+  // SAF
+  ZA: "SAF",
+  NA: "SAF",
+  BW: "SAF",
+  LS: "SAF",
+  SZ: "SAF",
+  AO: "SAF",
+  // CAF
+  CD: "CAF",
+  CG: "CAF",
+  GA: "CAF",
+  GQ: "CAF",
+  ST: "CAF",
+  // OC
+  AU: "OC",
+  NZ: "OC",
+  PG: "OC",
+  FJ: "OC",
+  SB: "OC",
+  VU: "OC",
+  NC: "OC",
+  PF: "OC",
+  WS: "OC",
+  TO: "OC",
+  TV: "OC",
+  KI: "OC",
+  NR: "OC",
+  PW: "OC",
+  MH: "OC",
+  FM: "OC",
+  // CAR
+  PR: "CAR",
+  GP: "CAR",
+  MQ: "CAR",
+  AW: "CAR",
+  CW: "CAR"
+};
+function getRegionForCountry(country) {
+  if (!country) return "";
+  return COUNTRY_TO_REGION[country.toUpperCase()] || "";
+}
+function getGeoRequestParams(country, language, timezone) {
+  const params = {};
+  if (country) {
+    params.country = country;
+    const region = getRegionForCountry(country);
+    if (region) {
+      params.region = region;
+    }
+  }
+  if (language) params.language = language;
+  if (timezone) params.timezone = timezone;
+  return params;
+}
+export {
+  API_FIELD_CTX,
+  API_FIELD_FROM,
+  API_FIELD_TEXT,
+  API_FIELD_TO,
+  API_FIELD_TRANSLATED,
+  API_FIELD_TRANSLATIONS,
+  BROWSER_LANGUAGE_MAP,
+  COLORS,
+  CSS_VARS,
+  DEFAULT_API_HOST,
+  DEV_API_HOST,
+  InterfaceLanguageSelect_default2 as InterfaceLanguageSelect,
+  LANGUAGE_ALIAS_TABLE,
+  LanguageSelect_default2 as LanguageSelect,
+  THEME_COLORS,
+  cacheManager,
+  clearCache,
+  clearThemeColors,
+  clearTranslationCache,
+  detectBrowserLanguage,
+  fetchAvailableLanguages,
+  getCache,
+  getCacheStats,
+  getCountryCode,
+  getGeoRequestParams,
+  getLtDefaults,
+  getRegionForCountry,
+  getTranslationCacheSize,
+  lt_default2 as lt,
+  removeCache,
+  setCache,
+  setLtDefaults,
+  setThemeColors,
+  translateBatch,
+  useLangie,
+  useLangie as useTranslator
+};
+//# sourceMappingURL=index.mjs.map