langie 1.9.25

package/dist/components/index.mjs

@@ -0,0 +1,2288 @@
+/**
+ * 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
+ */
+
+// 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, 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
+  }
+};
+
+// 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 = ref("");
+    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";
+
+// src/useLangie.ts
+import { watch } from "vue";
+
+// src/composables/useLangie-core.ts
+import { ref as ref2, reactive } from "vue";
+
+// src/constants.ts
+var DEFAULT_API_HOST = "https://api.langie.uk/v1";
+var API_FIELD_TEXT = "t";
+var API_FIELD_FROM = "from";
+var API_FIELD_TO = "to";
+var API_FIELD_CTX = "ctx";
+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 clearCache = (pattern) => {
+  return cacheManager.clear(pattern);
+};
+
+// src/composables/useLangie-core.ts
+var availableLanguages = ref2([]);
+var translations = reactive({});
+var uiTranslations = reactive({});
+var currentLanguage = ref2("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 = ref2(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 setLtDefaults = (defaults) => {
+    Object.assign(ltDefaults, defaults);
+  };
+  const getLtDefaults = () => ({ ...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,
+    getLtDefaults
+  };
+}
+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;
+}
+
+// vue-script:/Users/nlit/projects/langie-sdk/src/components/InterfaceLanguageSelect.vue?type=script
+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 detectBrowserLanguage(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 = detectBrowserLanguage(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 = detectBrowserLanguage(currentLanguages);
+          if (browserLang) {
+            setLanguage(browserLang);
+          }
+        }
+      } else if (!currentLanguage2.value && effectiveLanguages.value.length > 0) {
+        const browserLang = detectBrowserLanguage(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 } = 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 = getLtDefaults();
+      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";
+export {
+  InterfaceLanguageSelect_default2 as InterfaceLanguageSelect,
+  LanguageSelect_default2 as LanguageSelect,
+  lt_default2 as lt
+};
+//# sourceMappingURL=index.mjs.map