@hkonda/loco-translate 1.0.0

package/public/loco.js

@@ -0,0 +1,2386 @@
+var Loco = function() {
+  "use strict";
+  var state = {
+    apiKey: null,
+    apiBase: null,
+    phrases: [],
+    translations: {},
+    observer: null,
+    fileMode: false,
+    fileData: null,
+    fileReadyResolve: null,
+    fileReady: null,
+    fileUrl: null,
+    fileUrls: [],
+    scanStopped: false,
+    loadedFromCache: false,
+    screenshotsEnabled: true,
+    widgetPosition: null
+  };
+  var DEFAULT_BLOCKED_TAGS = [
+    "SCRIPT",
+    "STYLE",
+    "NOSCRIPT",
+    "IFRAME",
+    "CODE",
+    "SVG",
+    "AUDIO",
+    "VIDEO",
+    "LINK"
+  ];
+  var DEFAULT_INLINE_TAGS = [
+    "VAR",
+    "STRONG",
+    "EM",
+    "B",
+    "I",
+    "SPAN",
+    "A",
+    "ABBR",
+    "MARK",
+    "SMALL",
+    "SUB",
+    "SUP",
+    "U",
+    "S",
+    "TIME"
+  ];
+  var DEFAULT_DOM_CONTEXT_SELECTORS = [
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "label",
+    "legend",
+    "caption",
+    "figcaption",
+    "nav",
+    "header",
+    "footer",
+    "main",
+    "section",
+    "article",
+    "form"
+  ];
+  var BLOCKED_TAGS = new Set(DEFAULT_BLOCKED_TAGS);
+  var INLINE_TAGS = new Set(DEFAULT_INLINE_TAGS);
+  var DOM_CONTEXT_SELECTORS = [].concat(DEFAULT_DOM_CONTEXT_SELECTORS);
+  var CONTEXT_DEPTH = 0;
+  var DOM_CONTEXT_ENABLED = true;
+  var MAX_TEXT_LENGTH = 1e3;
+  var MAX_STRING_LENGTH = 1e4;
+  var STORAGE_KEY = "loco-lang";
+  function getSavedLang() {
+    try {
+      return localStorage.getItem(STORAGE_KEY);
+    } catch (e) {
+      return null;
+    }
+  }
+  function saveLang(code) {
+    try {
+      if (code) localStorage.setItem(STORAGE_KEY, code);
+      else localStorage.removeItem(STORAGE_KEY);
+    } catch (e) {
+    }
+  }
+  function applyConfig(cfg) {
+    if (cfg.blockedTags) {
+      var disabled = cfg.blockedTags.disabled || [];
+      var custom = cfg.blockedTags.custom || [];
+      BLOCKED_TAGS = new Set(DEFAULT_BLOCKED_TAGS.filter(function(t) {
+        return disabled.indexOf(t) < 0;
+      }));
+      custom.forEach(function(t) {
+        BLOCKED_TAGS.add(t.toUpperCase());
+      });
+    }
+    if (cfg.inlineTags) {
+      var disabled = cfg.inlineTags.disabled || [];
+      var custom = cfg.inlineTags.custom || [];
+      INLINE_TAGS = new Set(DEFAULT_INLINE_TAGS.filter(function(t) {
+        return disabled.indexOf(t) < 0;
+      }));
+      custom.forEach(function(t) {
+        INLINE_TAGS.add(t.toUpperCase());
+      });
+    }
+    if (cfg.domContextSelectors) {
+      var disabled = cfg.domContextSelectors.disabled || [];
+      var custom = cfg.domContextSelectors.custom || [];
+      DOM_CONTEXT_SELECTORS = DEFAULT_DOM_CONTEXT_SELECTORS.filter(function(s) {
+        return disabled.indexOf(s) < 0;
+      }).concat(custom);
+    }
+    if (cfg.screenshotsEnabled === false) {
+      state.screenshotsEnabled = false;
+    }
+    if (typeof cfg.contextDepth === "number") {
+      CONTEXT_DEPTH = cfg.contextDepth;
+    }
+    if (cfg.domContextEnabled === false) {
+      DOM_CONTEXT_ENABLED = false;
+    }
+  }
+  function normalize(text) {
+    return text.trim().replace(/\s+/g, " ");
+  }
+  function isOnlySymbolsOrNumbers(text) {
+    return !/[a-zA-Z\u00C0-\u024F\u0900-\u097F\u0600-\u06FF]/.test(text);
+  }
+  function isMixedKeyOnlySeparators(key) {
+    var literal = key.replace(/\{\{(?:text|number|decimal|date):\d+\}\}/g, "");
+    return !literal.trim() || isOnlySymbolsOrNumbers(literal);
+  }
+  function escapeHTML(str) {
+    return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+  }
+  function shouldSkipElement(el) {
+    var _a;
+    if (!el || el.nodeType !== 1) return false;
+    const tag = (_a = el.tagName) == null ? void 0 : _a.toUpperCase();
+    return BLOCKED_TAGS.has(tag) || el.hasAttribute("notranslate") || el.hasAttribute("data-notranslate") || el.getAttribute("translate") === "no" || el.isContentEditable;
+  }
+  function isAncestorBlocked(node) {
+    let el = node.parentElement;
+    while (el && el !== document.body) {
+      if (shouldSkipElement(el)) return true;
+      el = el.parentElement;
+    }
+    return false;
+  }
+  const HEADING_TAGS = /* @__PURE__ */ new Set(["H1", "H2", "H3", "H4", "H5", "H6"]);
+  const LABEL_SKIP_TAGS = /* @__PURE__ */ new Set(["SCRIPT", "STYLE", "NOSCRIPT", "CODE"]);
+  let _traceCache = /* @__PURE__ */ new WeakMap();
+  let _labelCache = /* @__PURE__ */ new WeakMap();
+  let _allContextElements = null;
+  function prepareContextScan() {
+    if (!DOM_CONTEXT_ENABLED) return;
+    _allContextElements = /* @__PURE__ */ new Set();
+    var selectors = DOM_CONTEXT_SELECTORS.slice();
+    try {
+      var combined = selectors.join(",");
+      document.querySelectorAll(combined).forEach(function(el) {
+        _allContextElements.add(el);
+      });
+    } catch (e) {
+      selectors.forEach(function(sel) {
+        try {
+          document.querySelectorAll(sel).forEach(function(el) {
+            _allContextElements.add(el);
+          });
+        } catch (e2) {
+        }
+      });
+    }
+    _allContextElements.forEach(function(el) {
+      if (!_labelCache.has(el)) getLabel(el);
+    });
+  }
+  function isContextElement(el) {
+    if (_allContextElements) return _allContextElements.has(el);
+    if (HEADING_TAGS.has(el.tagName)) return true;
+    return DOM_CONTEXT_SELECTORS.some(function(sel) {
+      try {
+        return el.matches(sel);
+      } catch (e) {
+        return false;
+      }
+    });
+  }
+  function getDirectText(el) {
+    let text = "";
+    for (const child of el.childNodes) {
+      if (child.nodeType === Node.TEXT_NODE) {
+        const t = child.textContent.trim();
+        if (t) text += (text ? " " : "") + t;
+      }
+    }
+    return text;
+  }
+  function getVisibleText(el, maxLen) {
+    var text = "";
+    var walker = document.createTreeWalker(el, NodeFilter.SHOW_ALL, {
+      acceptNode: function(node2) {
+        if (node2.nodeType === Node.ELEMENT_NODE) {
+          if (LABEL_SKIP_TAGS.has(node2.tagName)) return NodeFilter.FILTER_REJECT;
+          return NodeFilter.FILTER_SKIP;
+        }
+        return NodeFilter.FILTER_ACCEPT;
+      }
+    });
+    var node;
+    while (node = walker.nextNode()) {
+      if (node.nodeType === Node.TEXT_NODE) {
+        text += node.textContent;
+        if (text.length >= maxLen) break;
+      }
+    }
+    return text.trim();
+  }
+  function getLabel(el) {
+    if (_labelCache.has(el)) return _labelCache.get(el);
+    let result = null;
+    const direct = getDirectText(el);
+    if (direct) {
+      result = direct.substring(0, 60);
+      _labelCache.set(el, result);
+      return result;
+    }
+    if (HEADING_TAGS.has(el.tagName)) {
+      const full = (el.textContent || "").trim().replace(/\s+/g, " ");
+      if (full) {
+        result = full.substring(0, 60);
+        _labelCache.set(el, result);
+        return result;
+      }
+    }
+    var visible = getVisibleText(el, 200);
+    if (visible) {
+      const firstLine = visible.split(/\n/)[0].trim().replace(/\s+/g, " ");
+      if (firstLine.length >= 2 && !isOnlySymbolsOrNumbers(firstLine)) {
+        result = firstLine.substring(0, 60);
+      }
+    }
+    _labelCache.set(el, result);
+    return result;
+  }
+  function buildContextTrace(el) {
+    if (!el || !DOM_CONTEXT_ENABLED) return "";
+    if (_traceCache.has(el)) return _traceCache.get(el);
+    const trail = [];
+    const seen = /* @__PURE__ */ new Set();
+    let current = el;
+    let steps = 0;
+    if (el && el.tagName === "TD") {
+      var table = el.closest("table");
+      if (table) {
+        var th = table.querySelector(
+          "thead tr th:nth-child(" + (el.cellIndex + 1) + ")"
+        );
+        if (th) {
+          var lbl = getLabel(th);
+          if (lbl) {
+            seen.add(lbl);
+            trail.push(lbl);
+          }
+        }
+      }
+    }
+    while (current && current !== document.body) {
+      if (CONTEXT_DEPTH > 0 && steps >= CONTEXT_DEPTH) break;
+      steps++;
+      let sib = current.previousElementSibling;
+      while (sib) {
+        var sibTag = sib.tagName.toUpperCase();
+        if (BLOCKED_TAGS.has(sibTag)) {
+          sib = sib.previousElementSibling;
+          continue;
+        }
+        if (sibTag === "ARTICLE" || sibTag === "MAIN") {
+          sib = sib.previousElementSibling;
+          continue;
+        }
+        if (isContextElement(sib)) {
+          const lbl2 = getLabel(sib);
+          if (lbl2 && !seen.has(lbl2)) {
+            seen.add(lbl2);
+            trail.unshift(lbl2);
+          }
+          break;
+        }
+        let nested = null;
+        for (const child of sib.children) {
+          if (isContextElement(child)) {
+            nested = child;
+            break;
+          }
+        }
+        if (!nested) {
+          for (const child of sib.children) {
+            for (const gc of child.children) {
+              if (isContextElement(gc)) {
+                nested = gc;
+                break;
+              }
+            }
+            if (nested) break;
+          }
+        }
+        if (nested) {
+          const lbl2 = getLabel(nested);
+          if (lbl2 && !seen.has(lbl2)) {
+            seen.add(lbl2);
+            trail.unshift(lbl2);
+          }
+          break;
+        }
+        sib = sib.previousElementSibling;
+      }
+      if (isContextElement(current)) {
+        const lbl2 = getLabel(current);
+        if (lbl2 && !seen.has(lbl2)) {
+          seen.add(lbl2);
+          trail.unshift(lbl2);
+        }
+      }
+      var tag = current.tagName;
+      if (tag === "ARTICLE" || tag === "MAIN") break;
+      current = current.parentElement;
+    }
+    const result = trail.join(" > ");
+    _traceCache.set(el, result);
+    return result;
+  }
+  function detectSlotType(value) {
+    if (/^\d+$/.test(value)) return "number";
+    if (/^\d+\.\d+$/.test(value)) return "decimal";
+    return "text";
+  }
+  function extractVarSlots(rawKey, patternKey) {
+    var tokens = patternKey.split(/(\{\{(?:text|number|decimal|date):\d+\}\})/);
+    var slots = [];
+    var remaining = rawKey;
+    for (var i = 0; i < tokens.length; i++) {
+      var token = tokens[i];
+      var m = token.match(/^\{\{(text|number|decimal|date):(\d+)\}\}$/);
+      if (m) {
+        if (remaining.indexOf(token) === 0) {
+          slots.push({ type: m[1], index: parseInt(m[2]), originalText: token });
+          remaining = remaining.substring(token.length);
+        } else {
+          var suffix = "";
+          for (var j = i + 1; j < tokens.length; j++) {
+            var nextTok = tokens[j];
+            if (!/^\{\{(?:text|number|decimal|date):\d+\}\}$/.test(nextTok)) {
+              if (nextTok !== "") {
+                suffix = nextTok;
+                break;
+              }
+            } else if (remaining.indexOf(nextTok) >= 0) {
+              suffix = nextTok;
+              break;
+            }
+          }
+          var value;
+          if (suffix === "") {
+            value = remaining;
+            remaining = "";
+          } else {
+            var sepIdx = remaining.indexOf(suffix);
+            if (sepIdx >= 0) {
+              value = remaining.substring(0, sepIdx);
+              remaining = remaining.substring(sepIdx);
+            } else {
+              value = remaining;
+              remaining = "";
+            }
+          }
+          slots.push({ type: m[1], index: parseInt(m[2]), originalText: value });
+        }
+      } else {
+        if (remaining.indexOf(token) === 0) remaining = remaining.substring(token.length);
+      }
+    }
+    return slots;
+  }
+  function applyKeyMap(phraseList, keyMap) {
+    phraseList.forEach(function(p) {
+      if (p.varSlots && p.varSlots.length > 0) return;
+      var mapped = keyMap[p.key];
+      if (!mapped) return;
+      p.varSlots = extractVarSlots(p.key, mapped);
+      p.key = mapped;
+    });
+  }
+  function isStaticVarMatch(key, pattern) {
+    var parts = pattern.split(/\{\{(?:text|number|decimal|date):\d+\}\}/g);
+    var remaining = key;
+    var values = [];
+    for (var i = 0; i < parts.length; i++) {
+      if (i === 0) {
+        if (remaining.indexOf(parts[i]) === 0) remaining = remaining.substring(parts[i].length);
+      } else {
+        if (parts[i] === "" && i === parts.length - 1) {
+          values.push(remaining);
+          remaining = "";
+        } else {
+          var idx = remaining.indexOf(parts[i]);
+          if (idx >= 0) {
+            values.push(remaining.substring(0, idx));
+            remaining = remaining.substring(idx + parts[i].length);
+          }
+        }
+      }
+    }
+    return values.length > 0 && values.every(function(v) {
+      return /^[a-zA-Z\s]+$/.test(v.trim());
+    });
+  }
+  function patternSpecificity(patternKey) {
+    var score = 0;
+    var re = /\{\{(text|number|decimal|date):\d+\}\}/g;
+    var m;
+    while ((m = re.exec(patternKey)) !== null) {
+      switch (m[1]) {
+        case "number":
+          score += 3;
+          break;
+        case "decimal":
+          score += 3;
+          break;
+        case "date":
+          score += 2;
+          break;
+        default:
+          score += 1;
+          break;
+      }
+    }
+    return score;
+  }
+  function buildFileVarKeyMap(phraseList, translationKeys) {
+    var slotPatterns = [];
+    for (var i = 0; i < translationKeys.length; i++) {
+      var k = translationKeys[i];
+      if (k.indexOf("{{text:") < 0 && k.indexOf("{{number:") < 0 && k.indexOf("{{decimal:") < 0 && k.indexOf("{{date:") < 0) continue;
+      var literals = [];
+      var slotTypes = [];
+      var lastIdx = 0;
+      var re = /\{\{(text|number|decimal|date):\d+\}\}/g;
+      var m;
+      while ((m = re.exec(k)) !== null) {
+        literals.push(k.substring(lastIdx, m.index));
+        slotTypes.push(m[1]);
+        lastIdx = re.lastIndex;
+      }
+      literals.push(k.substring(lastIdx));
+      var regexStr = "";
+      for (var j = 0; j < literals.length; j++) {
+        regexStr += literals[j].replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        if (j < slotTypes.length) {
+          switch (slotTypes[j]) {
+            case "number":
+              regexStr += "\\d+";
+              break;
+            case "decimal":
+              regexStr += "\\d+\\.\\d+";
+              break;
+            default:
+              regexStr += ".+";
+              break;
+          }
+        }
+      }
+      slotPatterns.push({ pattern: k, regex: new RegExp("^" + regexStr + "$"), specificity: patternSpecificity(k) });
+    }
+    if (slotPatterns.length === 0) return;
+    slotPatterns.sort(function(a, b) {
+      return b.specificity - a.specificity;
+    });
+    var keyMap = {};
+    var translationKeySet = {};
+    for (var i = 0; i < translationKeys.length; i++) translationKeySet[translationKeys[i]] = true;
+    phraseList.forEach(function(p) {
+      if (translationKeySet[p.key]) return;
+      if (p.key.length > MAX_TEXT_LENGTH) return;
+      for (var j2 = 0; j2 < slotPatterns.length; j2++) {
+        if (slotPatterns[j2].regex.test(p.key) && !isStaticVarMatch(p.key, slotPatterns[j2].pattern)) {
+          keyMap[p.key] = slotPatterns[j2].pattern;
+          break;
+        }
+      }
+    });
+    applyKeyMap(phraseList, keyMap);
+    return keyMap;
+  }
+  function hasMixedContent(el) {
+    let hasText = false;
+    let hasSpecial = false;
+    for (const child of el.childNodes) {
+      if (child.nodeType === Node.TEXT_NODE && child.textContent.trim()) {
+        hasText = true;
+      }
+      if (child.nodeType === Node.ELEMENT_NODE) {
+        const tag = child.tagName.toUpperCase();
+        if (tag === "BR") return false;
+        if (tag === "VAR" || tag === "TIME" && child.hasAttribute("datetime") || INLINE_TAGS.has(tag)) {
+          hasSpecial = true;
+        }
+      }
+    }
+    return hasText && hasSpecial;
+  }
+  function extractMixedContent(parentEl) {
+    let key = "";
+    const slots = [];
+    for (const child of parentEl.childNodes) {
+      if (child.nodeType === Node.TEXT_NODE) {
+        const text = normalize(child.textContent);
+        if (text) key += text;
+        continue;
+      }
+      if (child.nodeType === Node.ELEMENT_NODE) {
+        const tag = child.tagName.toUpperCase();
+        if (tag === "TIME" && child.hasAttribute("datetime")) {
+          const index = slots.length;
+          slots.push({ type: "date", index, raw: child.getAttribute("datetime"), display: child.textContent, node: child });
+          key += `{{date:${index}}}`;
+          continue;
+        }
+        if (tag === "VAR" || INLINE_TAGS.has(tag)) {
+          const text = normalize(child.textContent);
+          if (text) {
+            const index = slots.length;
+            const slotType = detectSlotType(text);
+            slots.push({ type: slotType, index, tag, value: text, node: child });
+            key += `{{${slotType}:${index}}}`;
+          }
+          continue;
+        }
+      }
+    }
+    return { key: normalize(key), slots };
+  }
+  var INPUT_TRANSLATABLE_ATTRS = ["title", "placeholder", "aria-label"];
+  function collectPhrases(root) {
+    const phrases = [];
+    const seen = /* @__PURE__ */ new Set();
+    if (root.nodeType === Node.ELEMENT_NODE && !shouldSkipElement(root) && hasMixedContent(root)) {
+      const { key, slots } = extractMixedContent(root);
+      if (key && key.length <= MAX_TEXT_LENGTH) {
+        if (isMixedKeyOnlySeparators(key)) {
+          slots.forEach(function(slot) {
+            if (slot.type === "text" && slot.value && slot.value.length >= 2 && !isOnlySymbolsOrNumbers(slot.value)) {
+              var slotCtx = buildContextTrace(slot.node || root);
+              var sc = slot.value + "\0" + slotCtx;
+              if (!seen.has(sc)) {
+                seen.add(sc);
+                phrases.push({ type: "text", key: slot.value, slots: [], textNode: slot.node ? slot.node.firstChild : null, element: slot.node || root, context: slotCtx, original: slot.value });
+              }
+            }
+          });
+        } else {
+          var ctx = buildContextTrace(root);
+          var compositeKey = key + "\0" + ctx;
+          if (!seen.has(compositeKey)) seen.add(compositeKey);
+          const type = slots.some((s) => s.type === "date") ? "mixed-date" : slots.some((s) => s.type === "text") ? "mixed-text" : "mixed";
+          phrases.push({
+            type,
+            key,
+            slots,
+            element: root,
+            context: ctx,
+            original: key,
+            originalHTML: root.innerHTML
+          });
+        }
+      }
+    }
+    const walker = document.createTreeWalker(
+      root,
+      NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT,
+      {
+        acceptNode(node2) {
+          var _a, _b, _c;
+          if (node2.nodeType === Node.TEXT_NODE) {
+            const text = normalize(node2.textContent);
+            if (!text || text.length < 2) return NodeFilter.FILTER_SKIP;
+            if (text.length > MAX_TEXT_LENGTH) return NodeFilter.FILTER_SKIP;
+            if (isOnlySymbolsOrNumbers(text)) return NodeFilter.FILTER_SKIP;
+            if (/\{\{(?:text|number|decimal|date):\d+\}\}/.test(text)) return NodeFilter.FILTER_SKIP;
+            if (isAncestorBlocked(node2)) return NodeFilter.FILTER_SKIP;
+            const parentTag = (_b = (_a = node2.parentElement) == null ? void 0 : _a.tagName) == null ? void 0 : _b.toUpperCase();
+            if (BLOCKED_TAGS.has(parentTag)) return NodeFilter.FILTER_SKIP;
+            if (hasMixedContent(node2.parentElement)) return NodeFilter.FILTER_SKIP;
+            var ancestor = node2.parentElement;
+            while (ancestor) {
+              var aTag = (_c = ancestor.tagName) == null ? void 0 : _c.toUpperCase();
+              if (aTag === "VAR" || aTag === "TIME" || INLINE_TAGS.has(aTag)) {
+                if (ancestor.parentElement && hasMixedContent(ancestor.parentElement)) return NodeFilter.FILTER_SKIP;
+              }
+              ancestor = ancestor.parentElement;
+            }
+            return NodeFilter.FILTER_ACCEPT;
+          }
+          if (node2.nodeType === Node.ELEMENT_NODE) {
+            const tag = node2.tagName.toUpperCase();
+            if (BLOCKED_TAGS.has(tag)) return NodeFilter.FILTER_REJECT;
+            if (shouldSkipElement(node2)) return NodeFilter.FILTER_REJECT;
+            if (tag === "INPUT") {
+              var itype2 = (node2.getAttribute("type") || "").toLowerCase();
+              if (itype2 === "button" || itype2 === "submit" || itype2 === "reset") {
+                var val2 = normalize(node2.value);
+                if (val2 && val2.length >= 2 && !isOnlySymbolsOrNumbers(val2)) return NodeFilter.FILTER_ACCEPT;
+              }
+              var hasTranslatableAttr = INPUT_TRANSLATABLE_ATTRS.some(function(a) {
+                var v = normalize(node2.getAttribute(a) || "");
+                return v && v.length >= 2 && !isOnlySymbolsOrNumbers(v);
+              });
+              if (hasTranslatableAttr) return NodeFilter.FILTER_ACCEPT;
+              return NodeFilter.FILTER_SKIP;
+            }
+            if (hasMixedContent(node2)) return NodeFilter.FILTER_ACCEPT;
+            return NodeFilter.FILTER_SKIP;
+          }
+          return NodeFilter.FILTER_SKIP;
+        }
+      }
+    );
+    let node;
+    while (node = walker.nextNode()) {
+      if (node.nodeType === Node.TEXT_NODE) {
+        const text = normalize(node.textContent);
+        if (!text) continue;
+        var ctx = buildContextTrace(node.parentElement);
+        var compositeKey = text + "\0" + ctx;
+        if (!seen.has(compositeKey)) seen.add(compositeKey);
+        phrases.push({
+          type: "text",
+          key: text,
+          slots: [],
+          textNode: node,
+          element: node.parentElement,
+          context: ctx,
+          original: text
+        });
+        continue;
+      }
+      if (node.nodeType === Node.ELEMENT_NODE && node.tagName.toUpperCase() === "INPUT") {
+        var itype = (node.getAttribute("type") || "").toLowerCase();
+        var ctx = buildContextTrace(node);
+        if (itype === "button" || itype === "submit" || itype === "reset") {
+          var val = normalize(node.value);
+          if (val && val.length >= 2 && !isOnlySymbolsOrNumbers(val)) {
+            var compositeKey = val + "\0" + ctx;
+            if (!seen.has(compositeKey)) seen.add(compositeKey);
+            phrases.push({
+              type: "input-value",
+              key: val,
+              slots: [],
+              element: node,
+              context: ctx,
+              original: val
+            });
+          }
+        }
+        INPUT_TRANSLATABLE_ATTRS.forEach(function(attr) {
+          var attrVal = normalize(node.getAttribute(attr) || "");
+          if (!attrVal || attrVal.length < 2 || isOnlySymbolsOrNumbers(attrVal)) return;
+          var attrKey = attrVal + "\0" + ctx + "\0" + attr;
+          if (seen.has(attrKey)) return;
+          seen.add(attrKey);
+          phrases.push({
+            type: "input-attr",
+            key: attrVal,
+            attr,
+            slots: [],
+            element: node,
+            context: ctx,
+            original: attrVal
+          });
+        });
+        continue;
+      }
+      if (node.nodeType === Node.ELEMENT_NODE) {
+        const { key, slots } = extractMixedContent(node);
+        if (!key || key.length > MAX_TEXT_LENGTH) continue;
+        if (isMixedKeyOnlySeparators(key)) {
+          slots.forEach(function(slot) {
+            if (slot.type === "text" && slot.value && slot.value.length >= 2 && !isOnlySymbolsOrNumbers(slot.value)) {
+              var slotCtx = buildContextTrace(slot.node || node);
+              var sc = slot.value + "\0" + slotCtx;
+              if (!seen.has(sc)) {
+                seen.add(sc);
+                phrases.push({ type: "text", key: slot.value, slots: [], textNode: slot.node ? slot.node.firstChild : null, element: slot.node || node, context: slotCtx, original: slot.value });
+              }
+            }
+          });
+          continue;
+        }
+        var ctx = buildContextTrace(node);
+        var compositeKey = key + "\0" + ctx;
+        if (!seen.has(compositeKey)) seen.add(compositeKey);
+        const type = slots.some((s) => s.type === "date") ? "mixed-date" : slots.some((s) => s.type === "text") ? "mixed-text" : "mixed";
+        phrases.push({
+          type,
+          key,
+          slots,
+          element: node,
+          context: ctx,
+          original: key,
+          originalHTML: node.innerHTML
+        });
+      }
+    }
+    return phrases;
+  }
+  async function collectPhrasesAsync(root, yieldEvery) {
+    if (!yieldEvery) yieldEvery = 100;
+    const phrases = [];
+    const seen = /* @__PURE__ */ new Set();
+    if (root.nodeType === Node.ELEMENT_NODE && !shouldSkipElement(root) && hasMixedContent(root)) {
+      const { key, slots } = extractMixedContent(root);
+      if (key && key.length <= MAX_TEXT_LENGTH) {
+        if (isMixedKeyOnlySeparators(key)) {
+          slots.forEach(function(slot) {
+            if (slot.type === "text" && slot.value && slot.value.length >= 2 && !isOnlySymbolsOrNumbers(slot.value)) {
+              var slotCtx = buildContextTrace(slot.node || root);
+              var sc = slot.value + "\0" + slotCtx;
+              if (!seen.has(sc)) {
+                seen.add(sc);
+                phrases.push({ type: "text", key: slot.value, slots: [], textNode: slot.node ? slot.node.firstChild : null, element: slot.node || root, context: slotCtx, original: slot.value });
+              }
+            }
+          });
+        } else {
+          var ctx = buildContextTrace(root);
+          var compositeKey = key + "\0" + ctx;
+          if (!seen.has(compositeKey)) seen.add(compositeKey);
+          const type = slots.some((s) => s.type === "date") ? "mixed-date" : slots.some((s) => s.type === "text") ? "mixed-text" : "mixed";
+          phrases.push({
+            type,
+            key,
+            slots,
+            element: root,
+            context: ctx,
+            original: key,
+            originalHTML: root.innerHTML
+          });
+        }
+      }
+    }
+    const nodes = [];
+    const walker = document.createTreeWalker(
+      root,
+      NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT,
+      {
+        acceptNode(node2) {
+          var _a, _b, _c;
+          if (node2.nodeType === Node.TEXT_NODE) {
+            const text = normalize(node2.textContent);
+            if (!text || text.length < 2) return NodeFilter.FILTER_SKIP;
+            if (text.length > MAX_TEXT_LENGTH) return NodeFilter.FILTER_SKIP;
+            if (isOnlySymbolsOrNumbers(text)) return NodeFilter.FILTER_SKIP;
+            if (/\{\{(?:text|number|decimal|date):\d+\}\}/.test(text)) return NodeFilter.FILTER_SKIP;
+            if (isAncestorBlocked(node2)) return NodeFilter.FILTER_SKIP;
+            const parentTag = (_b = (_a = node2.parentElement) == null ? void 0 : _a.tagName) == null ? void 0 : _b.toUpperCase();
+            if (BLOCKED_TAGS.has(parentTag)) return NodeFilter.FILTER_SKIP;
+            if (hasMixedContent(node2.parentElement)) return NodeFilter.FILTER_SKIP;
+            var ancestor = node2.parentElement;
+            while (ancestor) {
+              var aTag = (_c = ancestor.tagName) == null ? void 0 : _c.toUpperCase();
+              if (aTag === "VAR" || aTag === "TIME" || INLINE_TAGS.has(aTag)) {
+                if (ancestor.parentElement && hasMixedContent(ancestor.parentElement)) return NodeFilter.FILTER_SKIP;
+              }
+              ancestor = ancestor.parentElement;
+            }
+            return NodeFilter.FILTER_ACCEPT;
+          }
+          if (node2.nodeType === Node.ELEMENT_NODE) {
+            const tag = node2.tagName.toUpperCase();
+            if (BLOCKED_TAGS.has(tag)) return NodeFilter.FILTER_REJECT;
+            if (shouldSkipElement(node2)) return NodeFilter.FILTER_REJECT;
+            if (tag === "INPUT") {
+              var itype2 = (node2.getAttribute("type") || "").toLowerCase();
+              if (itype2 === "button" || itype2 === "submit" || itype2 === "reset") {
+                var val2 = normalize(node2.value);
+                if (val2 && val2.length >= 2 && !isOnlySymbolsOrNumbers(val2)) return NodeFilter.FILTER_ACCEPT;
+              }
+              var hasTranslatableAttr = INPUT_TRANSLATABLE_ATTRS.some(function(a) {
+                var v = normalize(node2.getAttribute(a) || "");
+                return v && v.length >= 2 && !isOnlySymbolsOrNumbers(v);
+              });
+              if (hasTranslatableAttr) return NodeFilter.FILTER_ACCEPT;
+              return NodeFilter.FILTER_SKIP;
+            }
+            if (hasMixedContent(node2)) return NodeFilter.FILTER_ACCEPT;
+            return NodeFilter.FILTER_SKIP;
+          }
+          return NodeFilter.FILTER_SKIP;
+        }
+      }
+    );
+    var n;
+    while (n = walker.nextNode()) nodes.push(n);
+    for (var i = 0; i < nodes.length; i++) {
+      if (i > 0 && i % yieldEvery === 0) {
+        await new Promise(function(resolve) {
+          setTimeout(resolve, 0);
+        });
+      }
+      var node = nodes[i];
+      if (node.nodeType === Node.TEXT_NODE) {
+        const text = normalize(node.textContent);
+        if (!text) continue;
+        var ctx = buildContextTrace(node.parentElement);
+        var compositeKey = text + "\0" + ctx;
+        if (!seen.has(compositeKey)) seen.add(compositeKey);
+        phrases.push({
+          type: "text",
+          key: text,
+          slots: [],
+          textNode: node,
+          element: node.parentElement,
+          context: ctx,
+          original: text
+        });
+        continue;
+      }
+      if (node.nodeType === Node.ELEMENT_NODE && node.tagName.toUpperCase() === "INPUT") {
+        var itype = (node.getAttribute("type") || "").toLowerCase();
+        var ctx = buildContextTrace(node);
+        if (itype === "button" || itype === "submit" || itype === "reset") {
+          var val = normalize(node.value);
+          if (val && val.length >= 2 && !isOnlySymbolsOrNumbers(val)) {
+            var compositeKey = val + "\0" + ctx;
+            if (!seen.has(compositeKey)) seen.add(compositeKey);
+            phrases.push({
+              type: "input-value",
+              key: val,
+              slots: [],
+              element: node,
+              context: ctx,
+              original: val
+            });
+          }
+        }
+        INPUT_TRANSLATABLE_ATTRS.forEach(function(attr) {
+          var attrVal = normalize(node.getAttribute(attr) || "");
+          if (!attrVal || attrVal.length < 2 || isOnlySymbolsOrNumbers(attrVal)) return;
+          var attrKey = attrVal + "\0" + ctx + "\0" + attr;
+          if (seen.has(attrKey)) return;
+          seen.add(attrKey);
+          phrases.push({
+            type: "input-attr",
+            key: attrVal,
+            attr,
+            slots: [],
+            element: node,
+            context: ctx,
+            original: attrVal
+          });
+        });
+        continue;
+      }
+      if (node.nodeType === Node.ELEMENT_NODE) {
+        const { key, slots } = extractMixedContent(node);
+        if (!key || key.length > MAX_TEXT_LENGTH) continue;
+        if (isMixedKeyOnlySeparators(key)) {
+          slots.forEach(function(slot) {
+            if (slot.type === "text" && slot.value && slot.value.length >= 2 && !isOnlySymbolsOrNumbers(slot.value)) {
+              var slotCtx = buildContextTrace(slot.node || node);
+              var sc = slot.value + "\0" + slotCtx;
+              if (!seen.has(sc)) {
+                seen.add(sc);
+                phrases.push({ type: "text", key: slot.value, slots: [], textNode: slot.node ? slot.node.firstChild : null, element: slot.node || node, context: slotCtx, original: slot.value });
+              }
+            }
+          });
+          continue;
+        }
+        var ctx = buildContextTrace(node);
+        var compositeKey = key + "\0" + ctx;
+        if (!seen.has(compositeKey)) seen.add(compositeKey);
+        const type = slots.some((s) => s.type === "date") ? "mixed-date" : slots.some((s) => s.type === "text") ? "mixed-text" : "mixed";
+        phrases.push({
+          type,
+          key,
+          slots,
+          element: node,
+          context: ctx,
+          original: key,
+          originalHTML: node.innerHTML
+        });
+      }
+    }
+    return phrases;
+  }
+  function postKeys(phrases) {
+    if (state.scanStopped) return Promise.resolve({ ok: true, registered: 0, keyMap: {} });
+    var sentKeys = /* @__PURE__ */ new Set();
+    var keys = [];
+    phrases.forEach(function(p) {
+      var composite = p.key + "\0" + (p.context || "");
+      if (sentKeys.has(composite)) return;
+      if (p.varSlots && p.varSlots.length > 0 && /\{\{(?:text|number|decimal|date):\d+\}\}/.test(p.key)) return;
+      sentKeys.add(composite);
+      keys.push({ key: p.key, context: p.context || "" });
+      if (p.slots && p.slots.length > 0) {
+        p.slots.forEach(function(slot) {
+          if (slot.type === "text" && slot.value && !isOnlySymbolsOrNumbers(slot.value)) {
+            var slotComposite = slot.value + "\0";
+            if (!sentKeys.has(slotComposite)) {
+              sentKeys.add(slotComposite);
+              keys.push({ key: slot.value, context: "" });
+            }
+          }
+        });
+      }
+    });
+    return fetch(state.apiBase + "/api/textnodes", {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-API-Key": state.apiKey },
+      body: JSON.stringify({ keys, url: window.location.href })
+    }).then(function(r) {
+      return r.json();
+    });
+  }
+  function fetchTranslations(langCode) {
+    var url = state.apiBase + "/api/translations?lang=" + encodeURIComponent(langCode);
+    return fetch(url, {
+      headers: { "X-API-Key": state.apiKey }
+    }).then(function(r) {
+      return r.json();
+    }).then(function(data) {
+      var map = {};
+      if (Array.isArray(data)) {
+        data.forEach(function(r) {
+          map[r.key + "\0" + (r.context || "")] = r.value;
+          if (!map.hasOwnProperty(r.key)) map[r.key] = r.value;
+        });
+      } else {
+        map = data;
+      }
+      return map;
+    });
+  }
+  function captureScreenshot() {
+    if (state.fileMode || !state.screenshotsEnabled) return;
+    var script = document.createElement("script");
+    script.src = state.apiBase + "/cdn/html2canvas.min.js";
+    script.onload = function() {
+      if (typeof html2canvas !== "function") return;
+      html2canvas(document.body, {
+        scale: 0.35,
+        logging: false,
+        useCORS: true,
+        allowTaint: true,
+        width: window.innerWidth,
+        height: window.innerHeight,
+        windowWidth: window.innerWidth,
+        windowHeight: window.innerHeight
+      }).then(function(canvas) {
+        var data = canvas.toDataURL("image/jpeg", 0.5);
+        var base64 = data.split(",")[1];
+        if (!base64 || base64.length > 5e5) return;
+        fetch(state.apiBase + "/api/screenshots", {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "X-API-Key": state.apiKey },
+          body: JSON.stringify({ url: window.location.href, screenshot: base64 })
+        }).catch(function() {
+        });
+      }).catch(function() {
+      });
+    };
+    script.onerror = function() {
+    };
+    document.head.appendChild(script);
+  }
+  function rehydrate(translation, slots) {
+    return translation.replace(
+      /\{\{(text|number|decimal|date):(\d+)\}\}/g,
+      (match, type, i) => {
+        const slot = slots[parseInt(i)];
+        if (!slot) return match;
+        if (type === "date") return slot.display;
+        return slot.value;
+      }
+    );
+  }
+  function normalizeTranslationMap(raw) {
+    if (!Array.isArray(raw)) return raw;
+    var map = {};
+    raw.forEach(function(r) {
+      map[r.key + "\0" + (r.context || "")] = r.value;
+      if (!map.hasOwnProperty(r.key)) map[r.key] = r.value;
+    });
+    return map;
+  }
+  function applyTranslations(phrases, translations) {
+    let applied = 0;
+    let skipped = 0;
+    phrases.forEach((p) => {
+      const ctxKey = p.key + "\0" + (p.context || "");
+      var translation = translations[ctxKey] || translations[p.key];
+      if (!translation && p.slots && p.slots.length > 0) {
+        var hasSlotTranslation = p.slots.some(function(slot) {
+          if (slot.type !== "text" || !slot.value) return false;
+          var slotCtxKey = slot.value + "\0" + (p.context || "");
+          var slotEmptyCtx = slot.value + "\0";
+          return translations.hasOwnProperty(slotCtxKey) || translations.hasOwnProperty(slotEmptyCtx) || translations.hasOwnProperty(slot.value);
+        });
+        if (hasSlotTranslation) translation = p.key;
+      }
+      if (!translation) {
+        skipped++;
+        return;
+      }
+      if (p.type === "input-value" && p.element) {
+        try {
+          p.element.value = translation;
+          applied++;
+          return;
+        } catch (e) {
+          console.warn("[translate] Could not write to input value", e);
+          skipped++;
+          return;
+        }
+      }
+      if (p.type === "input-attr" && p.element && p.attr) {
+        try {
+          p.element.setAttribute(p.attr, translation);
+          applied++;
+          return;
+        } catch (e) {
+          console.warn("[translate] Could not write to input attr", e);
+          skipped++;
+          return;
+        }
+      }
+      if (p.type === "text" && p.textNode) {
+        try {
+          var translated = translation;
+          if (p.varSlots && p.varSlots.length > 0) {
+            translated = translated.replace(/\{\{(text|number|decimal|date):(\d+)\}\}/g, function(match, type, i) {
+              var slot = p.varSlots.find(function(s) {
+                return (s.type || "text") === type && s.index === +i;
+              });
+              if (!slot) {
+                slot = p.varSlots[+i];
+              }
+              return slot ? slot.originalText : match;
+            });
+          }
+          translated = translated.replace(/\{\{(?:text|number|decimal|date):\d+\}\}/g, "");
+          p.textNode.nodeValue = translated;
+          applied++;
+          return;
+        } catch (e) {
+          console.warn("[translate] Could not write to text node", e);
+          skipped++;
+          return;
+        }
+      }
+      if (p.element) {
+        try {
+          const rehydrated = rehydrate(translation, p.slots);
+          let html = translation;
+          var slotReplacements = {};
+          p.slots.forEach((slot) => {
+            const placeholder = `{{${slot.type}:${slot.index}}}`;
+            if (slot.type === "date" && slot.node) {
+              slot.node.textContent = slot.display;
+              slotReplacements[placeholder] = slot.node.outerHTML;
+            } else if (slot.node) {
+              if (slot.type === "text" && slot.value) {
+                var slotCtxKey = slot.value + "\0" + (p.context || "");
+                var slotEmptyCtx = slot.value + "\0";
+                var slotTranslation = translations[slotCtxKey] || translations[slotEmptyCtx] || translations[slot.value];
+                if (slotTranslation) {
+                  slot.node.textContent = slotTranslation;
+                }
+              }
+              slotReplacements[placeholder] = slot.node.outerHTML;
+            }
+          });
+          if (p.varSlots && p.varSlots.length > 0) {
+            p.varSlots.forEach(function(vs) {
+              var ph = "{{" + vs.type + ":" + vs.index + "}}";
+              if (!slotReplacements.hasOwnProperty(ph)) {
+                slotReplacements[ph] = escapeHTML(vs.originalText);
+              }
+            });
+          }
+          var parts = html.split(/(\{\{(?:text|number|decimal|date):\d+\}\})/g);
+          html = parts.map(function(part) {
+            if (slotReplacements.hasOwnProperty(part)) return slotReplacements[part];
+            if (/^\{\{(?:text|number|decimal|date):\d+\}\}$/.test(part)) return "";
+            return escapeHTML(part);
+          }).join("");
+          p.element.innerHTML = html;
+          applied++;
+        } catch (e) {
+          console.warn("[translate] Could not apply mixed translation", e);
+          skipped++;
+        }
+        return;
+      }
+      skipped++;
+    });
+    return { applied, skipped };
+  }
+  async function applyTranslationsAsync(phrases, translations, yieldEvery) {
+    if (!yieldEvery) yieldEvery = 100;
+    var applied = 0;
+    var skipped = 0;
+    for (var i = 0; i < phrases.length; i += yieldEvery) {
+      if (i > 0) {
+        await new Promise(function(resolve) {
+          setTimeout(resolve, 0);
+        });
+      }
+      var batch = phrases.slice(i, i + yieldEvery);
+      var result = applyTranslations(batch, translations);
+      applied += result.applied;
+      skipped += result.skipped;
+    }
+    return { applied, skipped };
+  }
+  function untranslate(phrases) {
+    let restored = 0;
+    phrases.forEach((p) => {
+      try {
+        if (p.type === "input-value" && p.element) {
+          p.element.value = p.original;
+          restored++;
+        } else if (p.type === "input-attr" && p.element && p.attr) {
+          p.element.setAttribute(p.attr, p.original);
+          restored++;
+        } else if (p.type === "text" && p.textNode) {
+          p.textNode.nodeValue = p.original;
+          restored++;
+        }
+      } catch (e) {
+        console.warn("[translate] Could not restore text node", e);
+      }
+    });
+    phrases.forEach((p) => {
+      if (p.type === "text") return;
+      try {
+        if (p.element && p.originalHTML !== void 0) {
+          p.element.innerHTML = p.originalHTML;
+          restored++;
+        }
+      } catch (e) {
+        console.warn("[translate] Could not restore node", e);
+      }
+    });
+    console.log("[loco] untranslated " + restored + " phrase(s)");
+  }
+  function watchAndTranslate(existingKeys, translations) {
+    const seenKeys = new Set(existingKeys);
+    const translatedPatterns = [];
+    Object.values(translations).forEach(function(v) {
+      if (!v) return;
+      seenKeys.add(v);
+      if (/\{\{(text|number|decimal|date):\d+\}\}/.test(v)) {
+        var parts = v.split(/\{\{(?:text|number|decimal|date):\d+\}\}/g);
+        var escaped = parts.map(function(p) {
+          return p.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        });
+        translatedPatterns.push(new RegExp("^" + escaped.join(".+") + "$"));
+      }
+    });
+    function isTranslatedPhrase(key) {
+      if (seenKeys.has(key)) return true;
+      for (var i = 0; i < translatedPatterns.length; i++) {
+        if (translatedPatterns[i].test(key)) return true;
+      }
+      return false;
+    }
+    let pending = [];
+    let flushTimer = null;
+    let rafId = null;
+    let rescanTargets = /* @__PURE__ */ new Set();
+    let observer = null;
+    let applying = false;
+    function flushPending() {
+      if (pending.length === 0) return;
+      var batch = pending.splice(0);
+      if (!state.fileMode) {
+        postKeys(batch).then(function(result) {
+          if (result && result.keyMap) {
+            applyKeyMap(batch, result.keyMap);
+            applying = true;
+            applyTranslations(batch, translations);
+            if (observer) observer.takeRecords();
+            applying = false;
+          }
+        }).catch(function() {
+        });
+      }
+    }
+    function processNode(node) {
+      const newPhrases = collectPhrases(node);
+      newPhrases.forEach((p) => {
+        var compositeKey = p.key + "\0" + (p.context || "");
+        if (isTranslatedPhrase(p.key) || seenKeys.has(compositeKey)) return;
+        seenKeys.add(compositeKey);
+        seenKeys.add(p.key);
+        pending.push(p);
+        state.phrases.push(p);
+      });
+      buildFileVarKeyMap(newPhrases, Object.keys(translations));
+      applying = true;
+      applyTranslations(newPhrases, translations);
+      if (observer) observer.takeRecords();
+      applying = false;
+      if (!state.fileMode) {
+        clearTimeout(flushTimer);
+        flushTimer = setTimeout(flushPending, 500);
+      }
+    }
+    function scheduleRescan(node) {
+      rescanTargets.add(node);
+      if (!rafId) {
+        rafId = requestAnimationFrame(function() {
+          rafId = null;
+          var targets = Array.from(rescanTargets);
+          rescanTargets.clear();
+          targets.forEach(function(t) {
+            if (t.isConnected) processNode(t);
+          });
+        });
+      }
+    }
+    observer = new MutationObserver((mutations) => {
+      if (applying) return;
+      var elementNodes = [];
+      var textParents = /* @__PURE__ */ new Set();
+      for (const mutation of mutations) {
+        for (const node of mutation.addedNodes) {
+          if (node.nodeType === Node.ELEMENT_NODE) {
+            elementNodes.push(node);
+          } else if (node.nodeType === Node.TEXT_NODE) {
+            var parent = node.parentElement;
+            if (parent && parent.isConnected) textParents.add(parent);
+          }
+        }
+      }
+      elementNodes.forEach(function(n) {
+        processNode(n);
+      });
+      textParents.forEach(function(p) {
+        scheduleRescan(p);
+      });
+    });
+    observer.observe(document.body, {
+      childList: true,
+      subtree: true
+    });
+    return observer;
+  }
+  var LOCO_DB_NAME = "loco";
+  var LOCO_DB_VERSION = 2;
+  function openLocoDB() {
+    return new Promise(function(resolve, reject) {
+      try {
+        var req = indexedDB.open(LOCO_DB_NAME, LOCO_DB_VERSION);
+        req.onupgradeneeded = function(e) {
+          var db = e.target.result;
+          if (db.objectStoreNames.contains("meta") && e.oldVersion < 2) {
+            db.deleteObjectStore("meta");
+          }
+          if (!db.objectStoreNames.contains("meta")) {
+            db.createObjectStore("meta", { keyPath: "key" });
+          }
+          if (!db.objectStoreNames.contains("translations")) {
+            db.createObjectStore("translations", { keyPath: "lang" });
+          }
+        };
+        req.onsuccess = function(e) {
+          resolve(e.target.result);
+        };
+        req.onerror = function() {
+          reject(req.error);
+        };
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
+  function getLanguageRegistry() {
+    return openLocoDB().then(function(db) {
+      return new Promise(function(resolve, reject) {
+        var tx = db.transaction("meta", "readonly");
+        var req = tx.objectStore("meta").get("registry");
+        req.onsuccess = function() {
+          db.close();
+          var row = req.result;
+          resolve(row ? { languages: row.languages || [], languageNames: row.languageNames || {} } : null);
+        };
+        req.onerror = function() {
+          db.close();
+          reject(req.error);
+        };
+      });
+    });
+  }
+  function getSourceMeta(url) {
+    var metaKey = "source:" + url;
+    return openLocoDB().then(function(db) {
+      return new Promise(function(resolve, reject) {
+        var tx = db.transaction("meta", "readonly");
+        var req = tx.objectStore("meta").get(metaKey);
+        req.onsuccess = function() {
+          db.close();
+          var row = req.result;
+          resolve(row ? { url: row.url, timestamp: row.timestamp, storedAt: row.storedAt } : null);
+        };
+        req.onerror = function() {
+          db.close();
+          reject(req.error);
+        };
+      });
+    });
+  }
+  function loadLangFromDb(lang) {
+    return openLocoDB().then(function(db) {
+      return new Promise(function(resolve, reject) {
+        var tx = db.transaction("translations", "readonly");
+        var req = tx.objectStore("translations").get(lang);
+        req.onsuccess = function() {
+          db.close();
+          var row = req.result;
+          resolve(row ? row.data : null);
+        };
+        req.onerror = function() {
+          db.close();
+          reject(req.error);
+        };
+      });
+    });
+  }
+  function getCachedData() {
+    return openLocoDB().then(function(db) {
+      return new Promise(function(resolve, reject) {
+        var tx = db.transaction(["meta", "translations"], "readonly");
+        var metaStore = tx.objectStore("meta");
+        var regReq = metaStore.get("registry");
+        regReq.onsuccess = function() {
+          var registry = regReq.result;
+          if (!registry || !registry.languages || registry.languages.length === 0) {
+            db.close();
+            resolve(null);
+            return;
+          }
+          var activeLang = getSavedLang();
+          var lang = activeLang || registry.languages[0];
+          var langReq = tx.objectStore("translations").get(lang);
+          langReq.onsuccess = function() {
+            db.close();
+            var row = langReq.result;
+            if (!row || !row.data) {
+              resolve(null);
+              return;
+            }
+            var translations = {};
+            translations[lang] = row.data;
+            resolve({
+              languages: registry.languages,
+              languageNames: registry.languageNames || {},
+              translations
+            });
+          };
+          langReq.onerror = function() {
+            db.close();
+            reject(langReq.error);
+          };
+        };
+        regReq.onerror = function() {
+          db.close();
+          reject(regReq.error);
+        };
+      });
+    });
+  }
+  function setCachedData(url, data, merge) {
+    var languages = data.languages || [];
+    var languageNames = data.languageNames || {};
+    var tMap = data.translations || {};
+    var timestamp = data.timestamp || 0;
+    return openLocoDB().then(function(db) {
+      return new Promise(function(resolve, reject) {
+        var tx = db.transaction(["meta", "translations"], "readwrite");
+        var metaStore = tx.objectStore("meta");
+        var transStore = tx.objectStore("translations");
+        var regReq = metaStore.get("registry");
+        regReq.onsuccess = function() {
+          var existing = regReq.result;
+          var newLangs, newNames;
+          if (merge && existing) {
+            var existingLangs = existing.languages || [];
+            newLangs = existingLangs.slice();
+            for (var i = 0; i < languages.length; i++) {
+              if (newLangs.indexOf(languages[i]) === -1) {
+                newLangs.push(languages[i]);
+              }
+            }
+            newNames = {};
+            var oldNames = existing.languageNames || {};
+            var k;
+            for (k in oldNames) {
+              newNames[k] = oldNames[k];
+            }
+            for (k in languageNames) {
+              newNames[k] = languageNames[k];
+            }
+          } else {
+            newLangs = languages;
+            newNames = languageNames;
+          }
+          metaStore.put({ key: "registry", languages: newLangs, languageNames: newNames });
+          metaStore.put({ key: "source:" + url, url, timestamp, storedAt: Date.now() });
+          for (var j = 0; j < languages.length; j++) {
+            if (!tMap[languages[j]]) continue;
+            if (merge && Array.isArray(tMap[languages[j]])) {
+              (function(lang) {
+                var getReq = transStore.get(lang);
+                getReq.onsuccess = function() {
+                  var row = getReq.result;
+                  var existingArr = row && Array.isArray(row.data) ? row.data : null;
+                  var incomingArr = tMap[lang];
+                  if (existingArr) {
+                    var SEP = "\0";
+                    var map = {};
+                    var order = [];
+                    for (var a = 0; a < existingArr.length; a++) {
+                      var ek = existingArr[a].key + SEP + (existingArr[a].context || "");
+                      if (!map.hasOwnProperty(ek)) order.push(ek);
+                      map[ek] = existingArr[a];
+                    }
+                    for (var b = 0; b < incomingArr.length; b++) {
+                      var nk = incomingArr[b].key + SEP + (incomingArr[b].context || "");
+                      if (!map.hasOwnProperty(nk)) order.push(nk);
+                      map[nk] = incomingArr[b];
+                    }
+                    var merged = [];
+                    for (var c = 0; c < order.length; c++) {
+                      merged.push(map[order[c]]);
+                    }
+                    transStore.put({ lang, data: merged });
+                  } else {
+                    transStore.put({ lang, data: incomingArr });
+                  }
+                };
+              })(languages[j]);
+            } else {
+              transStore.put({ lang: languages[j], data: tMap[languages[j]] });
+            }
+          }
+        };
+        tx.oncomplete = function() {
+          db.close();
+          resolve();
+        };
+        tx.onerror = function() {
+          db.close();
+          reject(tx.error);
+        };
+      });
+    });
+  }
+  function clearLocoCache() {
+    return new Promise(function(resolve) {
+      var req = indexedDB.deleteDatabase(LOCO_DB_NAME);
+      req.onsuccess = function() {
+        resolve();
+      };
+      req.onerror = function() {
+        resolve();
+      };
+      req.onblocked = function() {
+        resolve();
+      };
+    });
+  }
+  var PARROT_ICON = '<svg viewBox="0 0 200 200" xmlns="http://www.w3.org/2000/svg" width="32" height="32"><defs><clipPath id="loco-wc"><circle cx="100" cy="100" r="90"/></clipPath></defs><circle cx="100" cy="100" r="90" fill="#1a1f2e"/><g clip-path="url(#loco-wc)"><g transform="translate(100,108) scale(0.72) translate(-334,-198)"><ellipse cx="310" cy="318" rx="10" ry="38" fill="#2ECC88" transform="rotate(-18 310 318)"/><ellipse cx="326" cy="326" rx="9" ry="42" fill="#34D99A" transform="rotate(-6 326 326)"/><ellipse cx="342" cy="328" rx="9" ry="42" fill="#7BC74A" transform="rotate(6 342 328)"/><ellipse cx="357" cy="320" rx="9" ry="36" fill="#F07040" transform="rotate(18 357 320)"/><ellipse cx="334" cy="240" rx="62" ry="80" fill="#2ECC88"/><ellipse cx="334" cy="252" rx="36" ry="52" fill="#D4F4B0"/><path d="M275 220 Q228 190 232 265 Q248 295 280 285 Q268 255 275 220Z" fill="#3A8FE0"/><path d="M277 225 Q238 208 240 262 Q252 285 278 277 Q268 252 277 225Z" fill="#6BB3FF" opacity="0.7"/><path d="M393 220 Q440 190 436 265 Q420 295 388 285 Q400 255 393 220Z" fill="#3A8FE0"/><path d="M391 225 Q430 208 428 262 Q416 285 390 277 Q400 252 391 225Z" fill="#6BB3FF" opacity="0.7"/><ellipse cx="334" cy="172" rx="38" ry="30" fill="#2ECC88"/><circle cx="334" cy="148" r="52" fill="#2ECC88"/><ellipse cx="334" cy="118" rx="30" ry="18" fill="#FFB833"/><circle cx="312" cy="138" r="14" fill="white"/><circle cx="315" cy="140" r="9" fill="#2C2C2A"/><circle cx="315" cy="140" r="4" fill="#04342C"/><circle cx="319" cy="136" r="3.5" fill="white"/><circle cx="356" cy="138" r="14" fill="white"/><circle cx="353" cy="140" r="9" fill="#2C2C2A"/><circle cx="353" cy="140" r="4" fill="#04342C"/><circle cx="357" cy="136" r="3.5" fill="white"/><path d="M326 155 Q334 144 342 155 Q342 170 334 173 Q326 170 326 155Z" fill="#E8A020"/><path d="M328 165 Q334 158 340 165 Q340 174 334 176 Q328 174 328 165Z" fill="#A06010"/><ellipse cx="302" cy="152" rx="12" ry="8" fill="#F07040" opacity="0.8"/><ellipse cx="366" cy="152" rx="12" ry="8" fill="#F07040" opacity="0.8"/><path d="M320 100 Q316 68 308 52" stroke="#FFB833" stroke-width="6" fill="none" stroke-linecap="round"/><path d="M334 97 Q334 64 334 46" stroke="#7BC74A" stroke-width="6" fill="none" stroke-linecap="round"/><path d="M348 100 Q352 68 360 52" stroke="#F07040" stroke-width="6" fill="none" stroke-linecap="round"/><circle cx="308" cy="50" r="8" fill="#FFB833"/><circle cx="334" cy="44" r="8" fill="#7BC74A"/><circle cx="360" cy="50" r="8" fill="#F07040"/><rect x="260" y="330" width="168" height="10" rx="5" fill="#8B5E20"/><path d="M310 330 L300 350 M310 330 L315 352 M310 330 L325 348" stroke="#A07030" stroke-width="4" fill="none" stroke-linecap="round"/><path d="M360 330 L350 350 M360 330 L365 352 M360 330 L375 348" stroke="#A07030" stroke-width="4" fill="none" stroke-linecap="round"/></g></g></svg>';
+  var _widgetPosition = null;
+  function renderWidget(langs, position) {
+    _widgetPosition = position;
+    var existing = document.getElementById("loco-lang-widget");
+    if (existing) existing.remove();
+    var customLabels = {};
+    var langCodes = langs.map(function(l) {
+      if (typeof l === "object" && l.code) {
+        if (l.name) customLabels[l.code] = l.name;
+        return l.code;
+      }
+      return l;
+    });
+    function getLabel2(code) {
+      return customLabels[code] || code;
+    }
+    var currentLang = getSavedLang() || null;
+    var container = document.createElement("div");
+    container.id = "loco-lang-widget";
+    container.setAttribute("data-notranslate", "");
+    var posStyles = {
+      "bottom-right": "bottom:20px;right:20px;",
+      "bottom-left": "bottom:20px;left:20px;",
+      "top-right": "top:20px;right:20px;",
+      "top-left": "top:20px;left:20px;"
+    };
+    container.style.cssText = 'position:fixed;z-index:2147483647;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,sans-serif;font-size:14px;' + (posStyles[position] || posStyles["bottom-right"]);
+    var btn = document.createElement("button");
+    btn.innerHTML = PARROT_ICON;
+    btn.style.cssText = "width:52px;height:52px;border-radius:50%;border:none;background:#1a1f2e;color:#fff;font-size:22px;cursor:pointer;box-shadow:0 4px 14px rgba(0,0,0,0.25);display:flex;align-items:center;justify-content:center;transition:transform 0.2s,box-shadow 0.2s;overflow:hidden;padding:0;";
+    btn.onmouseenter = function() {
+      btn.style.transform = "scale(1.1)";
+      btn.style.boxShadow = "0 6px 20px rgba(0,0,0,0.35)";
+    };
+    btn.onmouseleave = function() {
+      btn.style.transform = "scale(1)";
+      btn.style.boxShadow = "0 4px 14px rgba(0,0,0,0.25)";
+    };
+    var panel = document.createElement("div");
+    panel.style.cssText = "display:none;position:absolute;" + (position.indexOf("bottom") === 0 ? "bottom:56px;" : "top:56px;") + (position.indexOf("right") >= 0 ? "right:0;" : "left:0;") + "background:#fff;border-radius:12px;box-shadow:0 8px 30px rgba(0,0,0,0.18);min-width:200px;max-height:320px;overflow-y:auto;padding:6px 0;";
+    var origItem = document.createElement("div");
+    origItem.textContent = "Original";
+    origItem.style.cssText = "padding:10px 16px;cursor:pointer;color:#333;transition:background 0.15s;font-weight:600;border-bottom:1px solid #eee;";
+    origItem.onmouseenter = function() {
+      origItem.style.background = "#f5f5f5";
+    };
+    origItem.onmouseleave = function() {
+      origItem.style.background = "transparent";
+    };
+    origItem.onclick = function() {
+      currentLang = null;
+      window.Loco.restore();
+      updateActive();
+      panel.style.display = "none";
+    };
+    panel.appendChild(origItem);
+    var items = [];
+    langCodes.forEach(function(code) {
+      var item = document.createElement("div");
+      item.textContent = getLabel2(code);
+      item.setAttribute("data-lang", code);
+      item.style.cssText = "padding:10px 16px;cursor:pointer;color:#333;transition:background 0.15s;";
+      item.onmouseenter = function() {
+        item.style.background = "#f5f5f5";
+      };
+      item.onmouseleave = function() {
+        item.style.background = currentLang === code ? "#e8f0fe" : "transparent";
+      };
+      item.onclick = function() {
+        currentLang = code;
+        window.Loco.apply(code);
+        updateActive();
+        panel.style.display = "none";
+      };
+      panel.appendChild(item);
+      items.push({ el: item, code });
+    });
+    function updateActive() {
+      origItem.style.background = currentLang === null ? "#e8f0fe" : "transparent";
+      origItem.style.fontWeight = currentLang === null ? "600" : "400";
+      items.forEach(function(it) {
+        it.el.style.background = currentLang === it.code ? "#e8f0fe" : "transparent";
+        it.el.style.fontWeight = currentLang === it.code ? "600" : "400";
+      });
+    }
+    btn.onclick = function(e) {
+      e.stopPropagation();
+      panel.style.display = panel.style.display === "none" ? "block" : "none";
+    };
+    document.addEventListener("click", function(e) {
+      if (!container.contains(e.target)) {
+        panel.style.display = "none";
+      }
+    });
+    updateActive();
+    container.appendChild(panel);
+    container.appendChild(btn);
+    document.body.appendChild(container);
+  }
+  function refreshWidget(langs) {
+    if (!_widgetPosition) return;
+    if (!langs || langs.length === 0) return;
+    renderWidget(langs, _widgetPosition);
+  }
+  var DANGEROUS_KEYS = { "__proto__": 1, "constructor": 1, "prototype": 1 };
+  function isAllowedUrl(url) {
+    if (!url || typeof url !== "string") return false;
+    if (url.charAt(0) === "/" || url.charAt(0) === ".") return true;
+    try {
+      var parsed = new URL(url, window.location.origin);
+      return parsed.protocol === "http:" || parsed.protocol === "https:";
+    } catch (e) {
+      return false;
+    }
+  }
+  function validateFileData(data) {
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
+      return null;
+    }
+    if (Array.isArray(data._raw)) {
+      var langSet = {};
+      var translations = {};
+      for (var ri = 0; ri < data._raw.length; ri++) {
+        var row = data._raw[ri];
+        if (!row || typeof row.l !== "string" || typeof row.k !== "string" || typeof row.v !== "string") continue;
+        if (!langSet[row.l]) {
+          langSet[row.l] = true;
+          translations[row.l] = [];
+        }
+        translations[row.l].push({ key: row.k, context: typeof row.c === "string" ? row.c : "", value: row.v });
+      }
+      data = {
+        languages: Object.keys(langSet).sort(),
+        languageNames: {},
+        translations,
+        timestamp: 0
+      };
+    }
+    var result = {};
+    if (!Array.isArray(data.languages)) return null;
+    result.languages = [];
+    for (var i = 0; i < data.languages.length; i++) {
+      if (typeof data.languages[i] !== "string" || data.languages[i].length > 20) return null;
+      result.languages.push(data.languages[i]);
+    }
+    result.timestamp = typeof data.timestamp === "number" && isFinite(data.timestamp) ? data.timestamp : 0;
+    result.languageNames = {};
+    if (data.languageNames && typeof data.languageNames === "object" && !Array.isArray(data.languageNames)) {
+      for (var code in data.languageNames) {
+        if (!data.languageNames.hasOwnProperty(code) || DANGEROUS_KEYS[code]) continue;
+        if (typeof data.languageNames[code] === "string" && data.languageNames[code].length <= 100) {
+          result.languageNames[code] = data.languageNames[code];
+        }
+      }
+    }
+    result.translations = {};
+    if (data.translations && typeof data.translations === "object" && !Array.isArray(data.translations)) {
+      for (var lang in data.translations) {
+        if (!data.translations.hasOwnProperty(lang) || DANGEROUS_KEYS[lang]) continue;
+        if (result.languages.indexOf(lang) === -1) continue;
+        var langData = data.translations[lang];
+        if (Array.isArray(langData)) {
+          var sanitized = [];
+          for (var j = 0; j < langData.length; j++) {
+            var entry = langData[j];
+            if (!entry || typeof entry !== "object") continue;
+            if (typeof entry.key !== "string" || typeof entry.value !== "string") continue;
+            if (entry.key.length > MAX_STRING_LENGTH || entry.value.length > MAX_STRING_LENGTH) continue;
+            if (DANGEROUS_KEYS[entry.key]) continue;
+            sanitized.push({ key: entry.key, value: entry.value, context: typeof entry.context === "string" ? entry.context : "" });
+          }
+          result.translations[lang] = sanitized;
+        } else if (typeof langData === "object") {
+          var sanitizedMap = {};
+          for (var key in langData) {
+            if (!langData.hasOwnProperty(key) || DANGEROUS_KEYS[key]) continue;
+            if (typeof langData[key] !== "string") continue;
+            if (key.length > MAX_STRING_LENGTH || langData[key].length > MAX_STRING_LENGTH) continue;
+            sanitizedMap[key] = langData[key];
+          }
+          result.translations[lang] = sanitizedMap;
+        }
+      }
+    }
+    return result;
+  }
+  async function init() {
+    try {
+      var res = await fetch(state.apiBase + "/api/project/crawler-config", {
+        headers: { "X-API-Key": state.apiKey }
+      });
+      if (res.ok) applyConfig(await res.json());
+    } catch (e) {
+    }
+    prepareContextScan();
+    state.phrases = await collectPhrasesAsync(document.body);
+    postKeys(state.phrases).then(function(result) {
+      if (result && result.keyMap) applyKeyMap(state.phrases, result.keyMap);
+    }).catch(function(e) {
+      console.warn("[loco] Failed to register keys:", e);
+    });
+    if (!state.scanStopped && state.screenshotsEnabled) setTimeout(captureScreenshot, 3e3);
+    console.log("[loco] " + state.phrases.length + " text nodes discovered");
+    console.log(
+      '  Loco.textnodes()       — list all discovered text nodes\n  Loco.apply("zh-Hans")  — apply translations for a language\n  Loco.restore()         — revert to original text\n  Loco.rescan()          — re-scan DOM for new nodes'
+    );
+    var saved = getSavedLang();
+    if (saved) {
+      Loco2.apply(saved);
+    } else {
+      state.observer = watchAndTranslate(state.phrases.map(function(p) {
+        return p.key + "\0" + (p.context || "");
+      }), {});
+    }
+  }
+  function mergeTranslationArrays(existing, incoming) {
+    var SEP = "\0";
+    var map = {};
+    var order = [];
+    for (var i = 0; i < existing.length; i++) {
+      var e = existing[i];
+      var k = e.key + SEP + (e.context || "");
+      if (!map.hasOwnProperty(k)) order.push(k);
+      map[k] = e;
+    }
+    for (var j = 0; j < incoming.length; j++) {
+      var n = incoming[j];
+      var nk = n.key + SEP + (n.context || "");
+      if (!map.hasOwnProperty(nk)) order.push(nk);
+      map[nk] = n;
+    }
+    var merged = [];
+    for (var m = 0; m < order.length; m++) {
+      merged.push(map[order[m]]);
+    }
+    return merged;
+  }
+  async function applyFileData(source) {
+    state.screenshotsEnabled = false;
+    prepareContextScan();
+    state.phrases = await collectPhrasesAsync(document.body);
+    var allTransKeys = [];
+    var tMap = state.fileData.translations || {};
+    var firstLang = (state.fileData.languages || [])[0];
+    if (firstLang && tMap[firstLang]) {
+      tMap[firstLang] = normalizeTranslationMap(tMap[firstLang]);
+      allTransKeys = Object.keys(tMap[firstLang]);
+    }
+    var fileKeyMap = buildFileVarKeyMap(state.phrases, allTransKeys);
+    var remapped = fileKeyMap ? Object.keys(fileKeyMap).length : 0;
+    var langCount = (state.fileData.languages || []).length;
+    console.log("[loco] (file mode) " + state.phrases.length + " text nodes discovered, " + langCount + " language(s) available" + (remapped ? ", " + remapped + " var-remapped" : "") + " [" + source + "]");
+    console.log("  Languages: " + (state.fileData.languages || []).join(", "));
+    var saved = getSavedLang();
+    if (saved) {
+      Loco2.apply(saved);
+    } else {
+      state.observer = watchAndTranslate(state.phrases.map(function(p) {
+        return p.key + "\0" + (p.context || "");
+      }), {});
+    }
+  }
+  async function initFileMode(urls) {
+    try {
+      indexedDB.deleteDatabase("loco-translations");
+    } catch (e) {
+    }
+    try {
+      indexedDB.deleteDatabase("loco-meta");
+    } catch (e) {
+    }
+    try {
+      if (indexedDB.databases) {
+        indexedDB.databases().then(function(dbs) {
+          dbs.forEach(function(d) {
+            if (d.name && d.name.indexOf("loco-tr-") === 0) {
+              try {
+                indexedDB.deleteDatabase(d.name);
+              } catch (e) {
+              }
+            }
+          });
+        }).catch(function() {
+        });
+      }
+    } catch (e) {
+    }
+    state.fileUrls = urls;
+    var cached = null;
+    try {
+      cached = await getCachedData();
+    } catch (e) {
+    }
+    if (cached && cached.translations) {
+      state.fileData = { languages: cached.languages, languageNames: cached.languageNames || {}, translations: cached.translations, timestamp: 0 };
+      state.loadedFromCache = true;
+      await applyFileData("cache");
+      if (state.fileReadyResolve) {
+        state.fileReadyResolve();
+        state.fileReadyResolve = null;
+      }
+      backgroundRefreshFiles(urls);
+    } else {
+      await fetchAndCacheFiles(urls);
+      await applyFileData("network");
+      if (state.fileReadyResolve) {
+        state.fileReadyResolve();
+        state.fileReadyResolve = null;
+      }
+    }
+  }
+  async function fetchAndCacheFiles(urls) {
+    var fetches = urls.map(function(url2) {
+      return fetch(url2).then(function(res) {
+        if (!res.ok) throw new Error("HTTP " + res.status + " for " + url2);
+        return res.text();
+      }).then(function(text) {
+        if (!text || !text.trim()) return null;
+        var data2;
+        try {
+          data2 = JSON.parse(text);
+        } catch (e) {
+          return null;
+        }
+        var validated = validateFileData(data2);
+        if (!validated) {
+          console.warn("[loco] File rejected (invalid schema): " + url2);
+          return null;
+        }
+        return { url: url2, data: validated };
+      }).catch(function(e) {
+        console.warn("[loco] Failed to load " + url2 + ":", e);
+        return null;
+      });
+    });
+    var results = await Promise.all(fetches);
+    var isFirst = true;
+    for (var i = 0; i < results.length; i++) {
+      if (!results[i]) continue;
+      var url = results[i].url;
+      var data = results[i].data;
+      var shouldMerge = !isFirst || (data.languages || []).length === 1;
+      mergeIntoFileData(data, isFirst);
+      isFirst = false;
+      try {
+        await setCachedData(url, data, shouldMerge);
+      } catch (e) {
+      }
+    }
+    state.loadedFromCache = false;
+  }
+  function mergeIntoFileData(data, isFirst) {
+    if (!state.fileData || isFirst) {
+      state.fileData = {
+        languages: (data.languages || []).slice(),
+        languageNames: Object.assign({}, data.languageNames || {}),
+        translations: Object.assign({}, data.translations || {}),
+        timestamp: data.timestamp || 0
+      };
+      return;
+    }
+    var langs = data.languages || [];
+    for (var i = 0; i < langs.length; i++) {
+      if (state.fileData.languages.indexOf(langs[i]) === -1) {
+        state.fileData.languages.push(langs[i]);
+      }
+    }
+    var names = data.languageNames || {};
+    if (!state.fileData.languageNames) state.fileData.languageNames = {};
+    for (var k in names) {
+      if (!names.hasOwnProperty(k) || DANGEROUS_KEYS[k]) continue;
+      state.fileData.languageNames[k] = names[k];
+    }
+    var tMap = data.translations || {};
+    if (!state.fileData.translations) state.fileData.translations = {};
+    for (var lang in tMap) {
+      if (!tMap.hasOwnProperty(lang) || DANGEROUS_KEYS[lang]) continue;
+      var existing = state.fileData.translations[lang];
+      var incoming = tMap[lang];
+      if (!existing || !Array.isArray(existing) || !Array.isArray(incoming)) {
+        state.fileData.translations[lang] = incoming;
+      } else {
+        state.fileData.translations[lang] = mergeTranslationArrays(existing, incoming);
+      }
+    }
+    if (data.timestamp && data.timestamp > state.fileData.timestamp) {
+      state.fileData.timestamp = data.timestamp;
+    }
+  }
+  function backgroundRefreshFiles(urls) {
+    var refreshPromises = urls.map(function(url) {
+      return Promise.all([
+        getSourceMeta(url).catch(function() {
+          return null;
+        }),
+        fetch(url).then(function(res) {
+          if (!res.ok) return null;
+          return res.text();
+        }).catch(function() {
+          return null;
+        })
+      ]).then(function(results) {
+        var sourceMeta = results[0];
+        var text = results[1];
+        if (!text || !text.trim()) return null;
+        var freshData;
+        try {
+          freshData = JSON.parse(text);
+        } catch (e) {
+          return null;
+        }
+        freshData = validateFileData(freshData);
+        if (!freshData) return null;
+        var freshTs = freshData.timestamp || 0;
+        var cachedTs = sourceMeta && sourceMeta.timestamp || 0;
+        if (freshTs !== cachedTs) {
+          var shouldMerge = urls.length > 1 || (freshData.languages || []).length === 1;
+          setCachedData(url, freshData, shouldMerge).catch(function() {
+          });
+          return freshData;
+        }
+        return null;
+      });
+    });
+    Promise.all(refreshPromises).then(function(results) {
+      var anyUpdated = false;
+      for (var i = 0; i < results.length; i++) {
+        if (results[i]) {
+          mergeIntoFileData(results[i], false);
+          anyUpdated = true;
+        }
+      }
+      if (anyUpdated) {
+        state.loadedFromCache = false;
+        if (state.observer) {
+          state.observer.disconnect();
+          state.observer = null;
+        }
+        untranslate(state.phrases);
+        applyFileData("network — updated").then(function() {
+          refreshWidgetFromDb();
+        });
+        console.log("[loco] translations refreshed from file(s) (timestamp changed)");
+      }
+    }).catch(function() {
+      console.log("[loco] using cached translations (network unavailable)");
+    });
+  }
+  function refreshWidgetFromDb() {
+    if (!state.widgetPosition) return;
+    getLanguageRegistry().then(function(reg) {
+      if (!reg) return;
+      var langs = buildWidgetLangs(reg.languages, reg.languageNames);
+      refreshWidget(langs);
+    }).catch(function() {
+    });
+  }
+  function buildWidgetLangs(languages, languageNames) {
+    languages = languages || [];
+    languageNames = languageNames || {};
+    return languages.map(function(c) {
+      return languageNames[c] ? { code: c, name: languageNames[c] } : c;
+    });
+  }
+  var Loco2 = {
+    init: function(config) {
+      if (!config) {
+        console.warn("[loco] Loco.init() requires a config object");
+        return;
+      }
+      if (config.file || config.files) {
+        state.fileMode = true;
+        state.fileReady = new Promise(function(resolve) {
+          state.fileReadyResolve = resolve;
+        });
+        var urls = config.files ? config.files.slice() : [config.file];
+        for (var i = 0; i < urls.length; i++) {
+          if (!isAllowedUrl(urls[i])) {
+            console.warn("[loco] Blocked unsafe URL: " + urls[i]);
+            return;
+          }
+        }
+        state.fileUrl = urls[0];
+        if (document.readyState === "loading") {
+          document.addEventListener("DOMContentLoaded", function() {
+            initFileMode(urls);
+          });
+        } else {
+          initFileMode(urls);
+        }
+        return;
+      }
+      if (!config.apiKey) {
+        console.warn("[loco] Loco.init() requires { apiKey } or { file }");
+        return;
+      }
+      if (!config.apiUrl) {
+        console.warn("[loco] Loco.init() requires { apiUrl }");
+        return;
+      }
+      state.apiKey = config.apiKey;
+      state.apiBase = config.apiUrl.replace(/\/+$/, "");
+      if (document.readyState === "loading") {
+        document.addEventListener("DOMContentLoaded", init);
+      } else {
+        init();
+      }
+    },
+    apply: async function(langCode) {
+      if (!langCode) {
+        console.warn('[loco] Loco.apply() requires a language code, e.g. Loco.apply("zh-Hans")');
+        return;
+      }
+      if (typeof langCode !== "string" || langCode.length > 20 || !/^[a-zA-Z0-9\-_]+$/.test(langCode)) {
+        console.warn("[loco] Invalid language code: " + langCode);
+        return;
+      }
+      if (state.fileMode) {
+        if (!state.fileData) {
+          console.warn("[loco] File not loaded yet. Call Loco.init({ file }) first.");
+          return;
+        }
+        if (!state.fileData.translations || !state.fileData.translations[langCode]) {
+          try {
+            var transMap = await loadLangFromDb(langCode);
+            if (!transMap || Object.keys(transMap).length === 0) {
+              console.warn('[loco] No translations for "' + langCode + '" in file data or cache');
+              return;
+            }
+            if (!state.fileData.translations) state.fileData.translations = {};
+            state.fileData.translations[langCode] = transMap;
+            if (state.fileData.languages.indexOf(langCode) === -1) {
+              state.fileData.languages.push(langCode);
+            }
+            return Loco2.apply(langCode);
+          } catch (e) {
+            console.warn('[loco] Failed to load translations for "' + langCode + '" from cache:', e);
+            return;
+          }
+        }
+        if (state.observer) {
+          state.observer.disconnect();
+          state.observer = null;
+        }
+        untranslate(state.phrases);
+        state.translations = normalizeTranslationMap(state.fileData.translations[langCode]);
+        state.fileData.translations[langCode] = state.translations;
+        state.phrases = await collectPhrasesAsync(document.body);
+        var allTransKeys = Object.keys(state.translations);
+        buildFileVarKeyMap(state.phrases, allTransKeys);
+        var result = await applyTranslationsAsync(state.phrases, state.translations);
+        state.observer = watchAndTranslate(state.phrases.map(function(p) {
+          return p.key + "\0" + (p.context || "");
+        }), state.translations);
+        saveLang(langCode);
+        console.log("[loco] (file) applied " + result.applied + " translation(s), " + result.skipped + " pending");
+        return result;
+      }
+      if (!state.apiKey || !state.apiBase) {
+        console.warn("[loco] Call Loco.init() first");
+        return;
+      }
+      if (state.observer) {
+        state.observer.disconnect();
+        state.observer = null;
+      }
+      untranslate(state.phrases);
+      try {
+        var map = await fetchTranslations(langCode);
+        state.translations = map || {};
+        state.phrases = await collectPhrasesAsync(document.body);
+        buildFileVarKeyMap(state.phrases, Object.keys(state.translations));
+        postKeys(state.phrases).then(function(result2) {
+          if (result2 && result2.keyMap) {
+            applyKeyMap(state.phrases, result2.keyMap);
+            applyTranslationsAsync(state.phrases, state.translations);
+          }
+        }).catch(function() {
+        });
+        var result = await applyTranslationsAsync(state.phrases, state.translations);
+        state.observer = watchAndTranslate(state.phrases.map(function(p) {
+          return p.key + "\0" + (p.context || "");
+        }), state.translations);
+        saveLang(langCode);
+        console.log("[loco] applied " + result.applied + " translation(s), " + result.skipped + " pending");
+        return result;
+      } catch (e) {
+        console.warn("[loco] Failed to fetch translations:", e);
+      }
+    },
+    restore: function() {
+      untranslate(state.phrases);
+      if (state.observer) state.observer.disconnect();
+      saveLang(null);
+    },
+    rescan: async function() {
+      var hadTranslations = Object.keys(state.translations).length > 0;
+      if (hadTranslations) untranslate(state.phrases);
+      state.phrases = await collectPhrasesAsync(document.body);
+      if (!state.fileMode) {
+        postKeys(state.phrases).catch(function() {
+        });
+      }
+      if (hadTranslations) {
+        buildFileVarKeyMap(state.phrases, Object.keys(state.translations));
+        await applyTranslationsAsync(state.phrases, state.translations);
+      }
+    },
+    textnodes: function() {
+      return state.phrases.map(function(p) {
+        return { key: p.key, context: p.context || "", element: p.element };
+      });
+    },
+    stopScan: function() {
+      state.scanStopped = true;
+      if (state.observer) {
+        state.observer.disconnect();
+        state.observer = null;
+      }
+      console.log("[loco] scanning stopped, no further nodes will be sent to dashboard");
+    },
+    startScan: function() {
+      state.scanStopped = false;
+      console.log("[loco] scanning resumed");
+    },
+    isFileMode: function() {
+      return state.fileMode;
+    },
+    languages: function() {
+      if (state.fileMode) {
+        var fromMemory = function() {
+          var codes = state.fileData ? state.fileData.languages || [] : [];
+          var names = state.fileData && state.fileData.languageNames || {};
+          return codes.map(function(c) {
+            return { code: c, name: names[c] || c };
+          });
+        };
+        if (!state.fileData && state.fileReady) {
+          return state.fileReady.then(function() {
+            return getLanguageRegistry().then(function(reg) {
+              if (reg && reg.languages && reg.languages.length > 0) {
+                return buildWidgetLangs(reg.languages, reg.languageNames);
+              }
+              return fromMemory();
+            }).catch(function() {
+              return fromMemory();
+            });
+          });
+        }
+        return getLanguageRegistry().then(function(reg) {
+          if (reg && reg.languages && reg.languages.length > 0) {
+            return buildWidgetLangs(reg.languages, reg.languageNames);
+          }
+          return fromMemory();
+        }).catch(function() {
+          return fromMemory();
+        });
+      }
+      if (!state.apiKey || !state.apiBase) {
+        return Promise.resolve([]);
+      }
+      return fetch(state.apiBase + "/api/languages", {
+        headers: { "X-API-Key": state.apiKey }
+      }).then(function(r) {
+        return r.json();
+      }).then(function(langs) {
+        return Array.isArray(langs) ? langs : [];
+      }).catch(function() {
+        return [];
+      });
+    },
+    widget: function(opts) {
+      opts = opts || {};
+      var position = opts.position || "bottom-right";
+      state.widgetPosition = position;
+      if (state.fileMode) {
+        let doRenderWidget = function() {
+          getLanguageRegistry().then(function(reg) {
+            var langs;
+            if (reg && reg.languages && reg.languages.length > 0) {
+              langs = buildWidgetLangs(reg.languages, reg.languageNames);
+            } else {
+              langs = fileModeLangs();
+            }
+            if (langs.length === 0) {
+              console.warn("[loco] No languages found in translation file or cache");
+              return;
+            }
+            renderWidget(langs, position);
+          }).catch(function() {
+            var langs = fileModeLangs();
+            if (langs.length === 0) {
+              console.warn("[loco] No languages found in translation file");
+              return;
+            }
+            renderWidget(langs, position);
+          });
+        }, fileModeLangs = function() {
+          var codes = state.fileData ? state.fileData.languages || [] : [];
+          var names = state.fileData && state.fileData.languageNames || {};
+          return codes.map(function(c) {
+            return names[c] ? { code: c, name: names[c] } : c;
+          });
+        };
+        if (!state.fileData && state.fileReady) {
+          state.fileReady.then(doRenderWidget);
+          return;
+        }
+        doRenderWidget();
+        return;
+      }
+      if (!state.apiKey || !state.apiBase) {
+        console.warn("[loco] Call Loco.init() first");
+        return;
+      }
+      fetch(state.apiBase + "/api/languages", {
+        headers: { "X-API-Key": state.apiKey }
+      }).then(function(r) {
+        return r.json();
+      }).then(function(langs) {
+        if (!Array.isArray(langs) || langs.length === 0) {
+          console.warn("[loco] No languages found — add translations in the dashboard first");
+          return;
+        }
+        renderWidget(langs, position);
+      }).catch(function(e) {
+        console.warn("[loco] Failed to fetch languages:", e);
+      });
+    },
+    clearCache: function() {
+      if (!state.fileMode) {
+        console.warn("[loco] clearCache() is only available in file mode");
+        return Promise.resolve();
+      }
+      return clearLocoCache().then(function() {
+        if (state.fileData) {
+          state.fileData.translations = {};
+          state.fileData.timestamp = 0;
+        }
+        state.loadedFromCache = false;
+        saveLang(null);
+        untranslate(state.phrases);
+        if (state.observer) {
+          state.observer.disconnect();
+          state.observer = null;
+        }
+        console.log("[loco] IndexedDB cache cleared — call pullLatest() to re-fetch");
+      }).catch(function(e) {
+        console.warn("[loco] Failed to clear cache:", e);
+      });
+    },
+    addFile: function(url) {
+      if (!state.fileMode) {
+        console.warn("[loco] addFile() is only available in file mode");
+        return Promise.resolve({ status: "error", reason: "not in file mode" });
+      }
+      if (!url) {
+        return Promise.resolve({ status: "error", reason: "no URL provided" });
+      }
+      if (!isAllowedUrl(url)) {
+        console.warn("[loco] Blocked unsafe URL: " + url);
+        return Promise.resolve({ status: "error", reason: "unsafe URL" });
+      }
+      if (state.fileUrls.indexOf(url) === -1) {
+        state.fileUrls.push(url);
+      }
+      return fetch(url).then(function(res) {
+        if (!res.ok) throw new Error("HTTP " + res.status);
+        return res.text();
+      }).then(function(text) {
+        if (!text || !text.trim()) throw new Error("Empty file");
+        var data;
+        try {
+          data = JSON.parse(text);
+        } catch (e) {
+          throw new Error("Invalid JSON");
+        }
+        data = validateFileData(data);
+        if (!data) throw new Error("Invalid file schema");
+        var isFirst = !state.fileData || !state.fileData.languages || state.fileData.languages.length === 0;
+        var shouldMerge = !isFirst || (data.languages || []).length === 1;
+        mergeIntoFileData(data, isFirst);
+        setCachedData(url, data, shouldMerge).catch(function() {
+        });
+        refreshWidgetFromDb();
+        console.log("[loco] added file: " + url + " (" + (data.languages || []).join(", ") + ")");
+        return { status: "added", languages: data.languages || [] };
+      }).catch(function(e) {
+        console.warn("[loco] addFile() failed:", e);
+        return { status: "error", reason: e.message };
+      });
+    },
+    pullLatest: function() {
+      if (!state.fileMode) {
+        console.warn("[loco] pullLatest() is only available in file mode");
+        return Promise.resolve({ status: "skipped", reason: "not in file mode" });
+      }
+      var urls = state.fileUrls.length > 0 ? state.fileUrls : state.fileUrl ? [state.fileUrl] : [];
+      if (urls.length === 0) {
+        console.warn("[loco] No file URL(s) configured. Call Loco.init({ file }) first.");
+        return Promise.resolve({ status: "error", reason: "no file URLs" });
+      }
+      var pullPromises = urls.map(function(url) {
+        return Promise.all([
+          getSourceMeta(url).catch(function() {
+            return null;
+          }),
+          fetch(url).then(function(res) {
+            if (!res.ok) throw new Error("HTTP " + res.status);
+            return res.text();
+          })
+        ]).then(function(results) {
+          var sourceMeta = results[0];
+          var text = results[1];
+          if (!text || !text.trim()) return { url, status: "current", reason: "empty" };
+          var freshData;
+          try {
+            freshData = JSON.parse(text);
+          } catch (e) {
+            throw new Error("Invalid JSON in " + url);
+          }
+          freshData = validateFileData(freshData);
+          if (!freshData) throw new Error("Invalid file schema in " + url);
+          var freshTs = freshData.timestamp || 0;
+          var cachedTs = sourceMeta && sourceMeta.timestamp || 0;
+          if (freshTs === cachedTs && cachedTs !== 0) {
+            var hasData = state.fileData && state.fileData.translations;
+            var fileLangs = freshData.languages || [];
+            var needsData = !hasData || fileLangs.some(function(l) {
+              return !state.fileData.translations[l];
+            });
+            if (!needsData) {
+              return { url, status: "current", timestamp: cachedTs };
+            }
+          }
+          var isFirst = !state.fileData || !state.fileData.languages || state.fileData.languages.length === 0;
+          var shouldMerge = !isFirst || (freshData.languages || []).length === 1;
+          mergeIntoFileData(freshData, isFirst);
+          setCachedData(url, freshData, shouldMerge).catch(function() {
+          });
+          return { url, status: "updated", timestamp: freshTs, previousTimestamp: cachedTs };
+        }).catch(function(e) {
+          return { url, status: "error", reason: e.message };
+        });
+      });
+      return Promise.all(pullPromises).then(async function(results) {
+        var anyUpdated = results.some(function(r2) {
+          return r2.status === "updated";
+        });
+        if (anyUpdated) {
+          state.loadedFromCache = false;
+          var currentLang = getSavedLang();
+          if (currentLang) {
+            if (state.observer) {
+              state.observer.disconnect();
+              state.observer = null;
+            }
+            untranslate(state.phrases);
+            await applyFileData("pullLatest");
+          } else {
+            state.phrases = collectPhrases(document.body);
+            var tMap = state.fileData.translations || {};
+            var firstLang = (state.fileData.languages || [])[0];
+            if (firstLang && tMap[firstLang]) {
+              buildFileVarKeyMap(state.phrases, Object.keys(tMap[firstLang]));
+            }
+          }
+          refreshWidgetFromDb();
+        }
+        if (results.length === 1) {
+          var r = results[0];
+          console.log("[loco] pullLatest: " + r.status + (r.timestamp ? " (timestamp: " + r.timestamp + ")" : ""));
+          return r;
+        }
+        var updated = results.filter(function(r2) {
+          return r2.status === "updated";
+        }).map(function(r2) {
+          return r2.url;
+        });
+        var current = results.filter(function(r2) {
+          return r2.status === "current";
+        }).map(function(r2) {
+          return r2.url;
+        });
+        console.log("[loco] pullLatest: " + updated.length + " updated, " + current.length + " current");
+        return { status: anyUpdated ? "updated" : "current", results };
+      }).catch(function(e) {
+        console.warn("[loco] pullLatest() failed:", e);
+        return { status: "error", reason: e.message };
+      });
+    }
+  };
+  window.Loco = Loco2;
+  Object.defineProperty(Loco2, "_state", { value: state, writable: false, enumerable: false, configurable: false });
+  return Loco2;
+}();