@lionrapid/core 0.3.1 → 0.5.0

package/dist/browser/lionrapid.auto.dev.js

@@ -23,6 +23,7 @@ var LionRapid = (() => {
   // src/browser/index.ts
   var index_exports = {};
   __export(index_exports, {
+    AttributeExtractor: () => AttributeExtractor,
     AutoTranslator: () => AutoTranslator,
     BlockExtractor: () => BlockExtractor,
     CacheStorageRepository: () => CacheStorageRepository,
@@ -2179,10 +2180,44 @@ var LionRapid = (() => {
   }
 
   // src/content/parser/MarkupParser.ts
+  function decodeEntities(text) {
+    const named = {
+      amp: "&",
+      lt: "<",
+      gt: ">",
+      quot: '"',
+      apos: "'",
+      nbsp: " ",
+      rsquo: "\u2019",
+      lsquo: "\u2018",
+      rdquo: "\u201D",
+      ldquo: "\u201C",
+      hellip: "\u2026",
+      mdash: "\u2014",
+      ndash: "\u2013",
+      copy: "\xA9",
+      reg: "\xAE",
+      trade: "\u2122"
+    };
+    return text.replace(/&(#x[0-9a-f]+|#[0-9]+|[a-z][a-z0-9]*);/gi, (m, body) => {
+      if (body[0] === "#") {
+        const cp = body[1] === "x" || body[1] === "X" ? parseInt(body.slice(2), 16) : parseInt(body.slice(1), 10);
+        if (Number.isFinite(cp) && cp > 0) {
+          try {
+            return String.fromCodePoint(cp);
+          } catch {
+            return m;
+          }
+        }
+        return m;
+      }
+      return named[body.toLowerCase()] ?? m;
+    });
+  }
   var MarkupParser = class {
     parse(input) {
       if (/<\/?[0-9]+>/.test(input)) {
-        return { text: input, styles: {} };
+        return { text: decodeEntities(input), styles: {} };
       }
       const styles = {};
       let tagIndex = 0;
@@ -2227,7 +2262,7 @@ var LionRapid = (() => {
         const unclosed = tagStack.pop();
         result += `</${unclosed.index}>`;
       }
-      return { text: result, styles };
+      return { text: decodeEntities(result), styles };
     }
     matchTag(input, startPos) {
       const tagStart = input.indexOf("<", startPos);
@@ -3108,6 +3143,155 @@ var LionRapid = (() => {
     }
   };
 
+  // src/repositories/memory-repository.ts
+  var MemoryRepository = class {
+    constructor(config) {
+      __publicField(this, "name", "MemoryRepository");
+      __publicField(this, "type", "memory");
+      __publicField(this, "config", {});
+      __publicField(this, "cache", /* @__PURE__ */ new Map());
+      __publicField(this, "accessOrder", /* @__PURE__ */ new Map());
+      __publicField(this, "maxSize", 1e3);
+      this.config = config;
+      this.maxSize = this.config.options?.maxSize || 1e3;
+    }
+    get(key) {
+      const value = this.cache.get(key);
+      if (value !== void 0) {
+        this.accessOrder.set(key, Date.now());
+        return value;
+      }
+      return null;
+    }
+    set(key, value) {
+      if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
+        this.evictOldest();
+      }
+      this.cache.set(key, value);
+      this.accessOrder.set(key, Date.now());
+    }
+    remove(key) {
+      this.cache.delete(key);
+      this.accessOrder.delete(key);
+    }
+    clear() {
+      this.cache.clear();
+      this.accessOrder.clear();
+    }
+    /**
+     * Clear all entries for a specific namespace
+     * Removes both the namespace cache entry and all individual translation keys
+     */
+    clearNamespace(locale, namespace) {
+      const namespaceCacheKey = createNamespaceCacheKey(locale, namespace);
+      const keyPrefix = `${locale}:${namespace}:`;
+      this.cache.delete(namespaceCacheKey);
+      this.accessOrder.delete(namespaceCacheKey);
+      for (const key of this.cache.keys()) {
+        if (key.startsWith(keyPrefix)) {
+          this.cache.delete(key);
+          this.accessOrder.delete(key);
+        }
+      }
+    }
+    getNamespace(locale, namespace) {
+      const namespaceCacheKey = createNamespaceCacheKey(locale, namespace);
+      const namespaceData = this.cache.get(namespaceCacheKey);
+      if (!namespaceData) return null;
+      try {
+        return JSON.parse(namespaceData);
+      } catch (error) {
+        this.cache.delete(namespaceCacheKey);
+        return null;
+      }
+    }
+    setNamespace(locale, namespace, translations) {
+      const namespaceCacheKey = createNamespaceCacheKey(locale, namespace);
+      this.cache.set(namespaceCacheKey, JSON.stringify(translations));
+    }
+    evictOldest() {
+      let oldestKey = "";
+      let oldestTime = Date.now();
+      for (const [key, time] of this.accessOrder.entries()) {
+        if (time < oldestTime) {
+          oldestTime = time;
+          oldestKey = key;
+        }
+      }
+      if (oldestKey) {
+        this.cache.delete(oldestKey);
+        this.accessOrder.delete(oldestKey);
+      }
+    }
+    /**
+     * Get all cache entries for debugging
+     */
+    getEntries() {
+      const entries = {};
+      for (const [key, value] of this.cache.entries()) {
+        entries[key] = value;
+      }
+      return entries;
+    }
+    getConfig() {
+      return this.config;
+    }
+  };
+
+  // src/repositories/static-repository.ts
+  var StaticRepository = class {
+    constructor(bundle, config = {}) {
+      __publicField(this, "name", "StaticRepository");
+      __publicField(this, "type", "memory");
+      __publicField(this, "config");
+      __publicField(this, "mem");
+      this.config = {
+        enabled: config.enabled ?? true,
+        priority: config.priority ?? 0.5,
+        // after the live memory (0), before storage
+        options: {
+          ttl: Number.MAX_SAFE_INTEGER,
+          maxSize: Number.MAX_SAFE_INTEGER,
+          ...config.options
+        }
+      };
+      this.mem = new MemoryRepository({ options: { maxSize: Number.MAX_SAFE_INTEGER } });
+      for (const [locale, namespaces] of Object.entries(bundle)) {
+        for (const [namespace, translations] of Object.entries(namespaces)) {
+          this.mem.setNamespace(locale, namespace, translations);
+          const flat = flattenTranslations(
+            translations,
+            "",
+            locale,
+            namespace
+          );
+          for (const [key, value] of Object.entries(flat)) this.mem.set(key, value);
+        }
+      }
+    }
+    get(key) {
+      return this.mem.get(key);
+    }
+    getNamespace(locale, namespace) {
+      return this.mem.getNamespace(locale, namespace);
+    }
+    getEntries() {
+      return this.mem.getEntries();
+    }
+    getConfig() {
+      return this.config;
+    }
+    // Read-only: the live memory layer owns fresh network data; this stays pristine.
+    set() {
+    }
+    remove() {
+    }
+    clear() {
+    }
+    setNamespace() {
+    }
+  };
+
   // src/sync/missing-translation-queue.ts
   var COOLDOWN_MS = 6e4;
   var MissingTranslationQueue = class {
@@ -3316,6 +3500,15 @@ var LionRapid = (() => {
       }
       return this;
     }
+    /**
+     * Offline resilience: seed a translation bundle (or the CLI's snapshot files)
+     * as a read-only sync layer that resolves synchronously even with the server
+     * down and nothing cached. Sits after the live memory layer (priority 0) at
+     * `priority` (default 0.5), so fresh network data always shadows it.
+     */
+    useStaticBundle(bundle, priority = 0.5) {
+      return this.use(new StaticRepository(bundle, { priority }));
+    }
     async build() {
       const eventEmitter = new EventEmitter();
       const buildBus = eventEmitter.builder();
@@ -3913,101 +4106,6 @@ var LionRapid = (() => {
   __publicField(_NetworkRepository, "VERSION_PREFIX", "lionrapid:v:");
   var NetworkRepository = _NetworkRepository;
 
-  // src/repositories/memory-repository.ts
-  var MemoryRepository = class {
-    constructor(config) {
-      __publicField(this, "name", "MemoryRepository");
-      __publicField(this, "type", "memory");
-      __publicField(this, "config", {});
-      __publicField(this, "cache", /* @__PURE__ */ new Map());
-      __publicField(this, "accessOrder", /* @__PURE__ */ new Map());
-      __publicField(this, "maxSize", 1e3);
-      this.config = config;
-      this.maxSize = this.config.options?.maxSize || 1e3;
-    }
-    get(key) {
-      const value = this.cache.get(key);
-      if (value !== void 0) {
-        this.accessOrder.set(key, Date.now());
-        return value;
-      }
-      return null;
-    }
-    set(key, value) {
-      if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
-        this.evictOldest();
-      }
-      this.cache.set(key, value);
-      this.accessOrder.set(key, Date.now());
-    }
-    remove(key) {
-      this.cache.delete(key);
-      this.accessOrder.delete(key);
-    }
-    clear() {
-      this.cache.clear();
-      this.accessOrder.clear();
-    }
-    /**
-     * Clear all entries for a specific namespace
-     * Removes both the namespace cache entry and all individual translation keys
-     */
-    clearNamespace(locale, namespace) {
-      const namespaceCacheKey = createNamespaceCacheKey(locale, namespace);
-      const keyPrefix = `${locale}:${namespace}:`;
-      this.cache.delete(namespaceCacheKey);
-      this.accessOrder.delete(namespaceCacheKey);
-      for (const key of this.cache.keys()) {
-        if (key.startsWith(keyPrefix)) {
-          this.cache.delete(key);
-          this.accessOrder.delete(key);
-        }
-      }
-    }
-    getNamespace(locale, namespace) {
-      const namespaceCacheKey = createNamespaceCacheKey(locale, namespace);
-      const namespaceData = this.cache.get(namespaceCacheKey);
-      if (!namespaceData) return null;
-      try {
-        return JSON.parse(namespaceData);
-      } catch (error) {
-        this.cache.delete(namespaceCacheKey);
-        return null;
-      }
-    }
-    setNamespace(locale, namespace, translations) {
-      const namespaceCacheKey = createNamespaceCacheKey(locale, namespace);
-      this.cache.set(namespaceCacheKey, JSON.stringify(translations));
-    }
-    evictOldest() {
-      let oldestKey = "";
-      let oldestTime = Date.now();
-      for (const [key, time] of this.accessOrder.entries()) {
-        if (time < oldestTime) {
-          oldestTime = time;
-          oldestKey = key;
-        }
-      }
-      if (oldestKey) {
-        this.cache.delete(oldestKey);
-        this.accessOrder.delete(oldestKey);
-      }
-    }
-    /**
-     * Get all cache entries for debugging
-     */
-    getEntries() {
-      const entries = {};
-      for (const [key, value] of this.cache.entries()) {
-        entries[key] = value;
-      }
-      return entries;
-    }
-    getConfig() {
-      return this.config;
-    }
-  };
-
   // src/browser/exclude-filter.ts
   var DEFAULT_PATTERNS = {
     emails: true,
@@ -4204,15 +4302,46 @@ var LionRapid = (() => {
     }
     return str;
   }
-  function str2binl(str) {
+  function utf8Bytes(str) {
+    if (typeof TextEncoder !== "undefined") {
+      return new TextEncoder().encode(str);
+    }
+    const out = [];
+    for (let i = 0; i < str.length; i++) {
+      const c = str.charCodeAt(i);
+      if (c < 128) {
+        out.push(c);
+      } else if (c < 2048) {
+        out.push(192 | c >> 6, 128 | c & 63);
+      } else if (c >= 55296 && c < 56320 && i + 1 < str.length) {
+        const c2 = str.charCodeAt(++i);
+        const cp = 65536 + (c - 55296 << 10) + (c2 - 56320);
+        out.push(
+          240 | cp >> 18,
+          128 | cp >> 12 & 63,
+          128 | cp >> 6 & 63,
+          128 | cp & 63
+        );
+      } else {
+        out.push(
+          224 | c >> 12,
+          128 | c >> 6 & 63,
+          128 | c & 63
+        );
+      }
+    }
+    return new Uint8Array(out);
+  }
+  function bytes2binl(bytes) {
     const bin = [];
-    for (let i = 0; i < str.length * 8; i += 8) {
-      bin[i >> 5] |= (str.charCodeAt(i / 8) & 255) << i % 32;
+    for (let i = 0; i < bytes.length; i++) {
+      bin[i >> 2] |= bytes[i] << i % 4 * 8;
     }
     return bin;
   }
   function md5(str) {
-    return binl2hex(binlMD5(str2binl(str), str.length * 8));
+    const bytes = utf8Bytes(str);
+    return binl2hex(binlMD5(bytes2binl(bytes), bytes.length * 8));
   }
   function generateAutoKey(text) {
     const trimmed = text.trim();
@@ -4221,6 +4350,7 @@ var LionRapid = (() => {
 
   // src/browser/block-extractor.ts
   var BLOCK_SELECTOR = "p,h1,h2,h3,h4,h5,h6,li,td,th,label,button,figcaption,dt,dd,summary,caption";
+  var INLINE_BLOCK_SELECTOR = "a";
   var SKIP_TAGS = /* @__PURE__ */ new Set([
     "SCRIPT",
     "STYLE",
@@ -4309,8 +4439,60 @@ var LionRapid = (() => {
         }
         results.push({ element: el, unit, key });
       }
+      this.extractOrphanInline(root, results, includeTranslated);
       return results;
     }
+    /**
+     * Second pass: extract inline elements (currently <a>) that have no block
+     * ancestor. These would otherwise slip through both the block pass (not in
+     * BLOCK_SELECTOR) and the inline-style capture (no parent block to host
+     * them as `<1>...</1>`). Common shape: a `<div>` action group containing
+     * only links.
+     */
+    extractOrphanInline(root, results, includeTranslated) {
+      const candidates = root.querySelectorAll(INLINE_BLOCK_SELECTOR);
+      const elements = [];
+      if (root instanceof Element && root.matches(INLINE_BLOCK_SELECTOR)) {
+        elements.push(root);
+      }
+      for (let i = 0; i < candidates.length; i++) {
+        elements.push(candidates[i]);
+      }
+      for (let i = 0; i < elements.length; i++) {
+        const el = elements[i];
+        if (this.isInsideSkipTag(el)) continue;
+        if (!includeTranslated && this.hasSkipAttribute(el)) continue;
+        if (this.matchesExcludeSelector(el)) continue;
+        if (el.getAttribute("translate") === "no") continue;
+        if (el.parentElement?.closest(BLOCK_SELECTOR)) continue;
+        if (el.parentElement?.closest(INLINE_BLOCK_SELECTOR)) continue;
+        if (el.querySelector(BLOCK_SELECTOR)) continue;
+        const lrOriginal = el.getAttribute("data-lr-original");
+        let unit;
+        if (lrOriginal) {
+          const temp = document.createElement(el.tagName);
+          temp.innerHTML = lrOriginal;
+          unit = parseBlockElement(temp);
+        } else {
+          unit = parseBlockElement(el);
+        }
+        const strippedText = unit.text.replace(/<\/?[0-9]+\/?>/g, "");
+        if (this.excludeFilter.shouldExclude(strippedText)) continue;
+        const lrBlock = el.getAttribute("data-lr-block");
+        let key;
+        if (lrBlock) {
+          key = lrBlock;
+        } else {
+          const dataI18n = el.getAttribute("data-i18n");
+          if (dataI18n) {
+            key = dataI18n.includes(":") ? dataI18n : `common:${dataI18n}`;
+          } else {
+            key = generateAutoKey(unit.text);
+          }
+        }
+        results.push({ element: el, unit, key });
+      }
+    }
     isInsideSkipTag(element) {
       let current = element.parentElement;
       while (current) {
@@ -4346,6 +4528,116 @@ var LionRapid = (() => {
     }
   };
 
+  // src/browser/attribute-extractor.ts
+  var TARGETS = [
+    { selector: 'img[alt], area[alt], input[type="image"][alt]', attr: "alt", type: "alt" },
+    { selector: "[title]", attr: "title", type: "title" },
+    { selector: "input[placeholder], textarea[placeholder]", attr: "placeholder", type: "placeholder" },
+    { selector: 'meta[name="description"][content]', attr: "content", type: "meta-description" },
+    {
+      selector: 'input[type="submit"][value], input[type="button"][value], input[type="reset"][value]',
+      attr: "value",
+      type: "input-value"
+    }
+  ];
+  var SKIP_TAGS2 = /* @__PURE__ */ new Set([
+    "SCRIPT",
+    "STYLE",
+    "CODE",
+    "PRE",
+    "NOSCRIPT",
+    "SVG"
+  ]);
+  var SKIP_ATTRIBUTES2 = [
+    "data-lionrapid-translated",
+    "data-lionrapid-client",
+    "data-no-translate"
+  ];
+  function stampAttrName(attrName) {
+    return `data-lr-attr-${attrName.toLowerCase()}`;
+  }
+  var AttributeExtractor = class {
+    constructor(excludePatterns = {}, excludeSelectors = [], minTextLength = 2) {
+      __publicField(this, "excludeFilter");
+      __publicField(this, "excludeSelectors");
+      this.excludeFilter = new ExcludeFilter(excludePatterns, minTextLength);
+      this.excludeSelectors = excludeSelectors;
+    }
+    /**
+     * Walk the DOM under `root` and return every translatable attribute.
+     *
+     * @param root           Element or Document to scan
+     * @param includeStamped When true, elements already carrying
+     *                       `data-lr-attr-{name}` are returned anyway —
+     *                       the editor uses this to surface server-handled
+     *                       attributes for inspection. The runtime keeps
+     *                       the default `false` so it doesn't re-extract
+     *                       what the server already keyed.
+     */
+    extract(root, includeStamped = false) {
+      const results = [];
+      for (const target of TARGETS) {
+        const candidates = root.querySelectorAll(target.selector);
+        const all = [];
+        if (root instanceof Element && root.matches(target.selector)) {
+          all.push(root);
+        }
+        for (let i = 0; i < candidates.length; i++) {
+          all.push(candidates[i]);
+        }
+        for (let i = 0; i < all.length; i++) {
+          const el = all[i];
+          if (this.isInsideSkipTag(el)) continue;
+          if (this.hasSkipAncestor(el)) continue;
+          if (this.matchesExcludeSelector(el)) continue;
+          if (el.getAttribute("translate") === "no") continue;
+          const rawValue = el.getAttribute(target.attr);
+          if (rawValue === null) continue;
+          const trimmed = rawValue.trim();
+          if (this.excludeFilter.shouldExclude(trimmed)) continue;
+          const stampName = stampAttrName(target.attr);
+          const stamped = el.getAttribute(stampName);
+          if (!includeStamped && stamped) {
+            continue;
+          }
+          const unit = { text: rawValue, type: target.type };
+          const key = stamped ?? generateAutoKey(rawValue);
+          results.push({ element: el, attrName: target.attr, unit, key });
+        }
+      }
+      return results;
+    }
+    isInsideSkipTag(element) {
+      let current = element.parentElement;
+      while (current) {
+        if (SKIP_TAGS2.has(current.tagName)) return true;
+        current = current.parentElement;
+      }
+      return false;
+    }
+    hasSkipAncestor(element) {
+      let current = element;
+      while (current) {
+        for (const attr of SKIP_ATTRIBUTES2) {
+          if (current.hasAttribute(attr)) return true;
+        }
+        current = current.parentElement;
+      }
+      return false;
+    }
+    matchesExcludeSelector(element) {
+      for (const selector of this.excludeSelectors) {
+        try {
+          if (element.matches(selector) || element.closest(selector)) {
+            return true;
+          }
+        } catch {
+        }
+      }
+      return false;
+    }
+  };
+
   // src/browser/dom-observer.ts
   var DOMObserver = class {
     constructor(callbacks, debounceMs = 50) {
@@ -4450,6 +4742,7 @@ var LionRapid = (() => {
     constructor(config = {}) {
       __publicField(this, "core", null);
       __publicField(this, "blockExtractor");
+      __publicField(this, "attributeExtractor");
       __publicField(this, "domObserver", null);
       __publicField(this, "locale", "");
       __publicField(this, "sourceLocale", "");
@@ -4463,6 +4756,11 @@ var LionRapid = (() => {
         config.excludeSelectors,
         config.minTextLength
       );
+      this.attributeExtractor = new AttributeExtractor(
+        config.excludePatterns,
+        config.excludeSelectors,
+        config.minTextLength
+      );
       this.debounceMs = config.debounceMs ?? 100;
     }
     /**
@@ -4511,8 +4809,9 @@ var LionRapid = (() => {
       if (!this.core) {
         return 0;
       }
-      const extracted = this.blockExtractor.extract(element);
-      return this.translateBlocks(extracted);
+      const blockCount = this.translateBlocks(this.blockExtractor.extract(element));
+      const attrCount = this.translateAttributesIn(this.attributeExtractor.extract(element));
+      return blockCount + attrCount;
     }
     /**
      * Translate the entire page
@@ -4610,12 +4909,79 @@ var LionRapid = (() => {
       }
       return count;
     }
+    /**
+     * Translate extracted attribute units against the cache.
+     *
+     * Mirrors translateBlocks but for attribute values. For each hit, the
+     * original attribute value is preserved in `data-lr-orig-{name}` so
+     * retranslate() can restore source. The element accumulates a comma-
+     * separated `data-lionrapid-client-attrs` list naming every attr the
+     * client touched — so we can find them all on retranslate without
+     * iterating a fixed selector set.
+     *
+     * Cache misses emit `translation:not-found` with empty styles, so the
+     * existing MissingTranslationQueue + NetworkRepository sync queue
+     * picks them up unchanged.
+     */
+    translateAttributesIn(extracted) {
+      if (!this.core) return 0;
+      let count = 0;
+      for (const { element, attrName, unit, key } of extracted) {
+        const fullKey = `${this.locale}:${this.namespace}:${key}`;
+        const cached = this.core.cache.get(fullKey);
+        if (cached && cached.value !== unit.text && cached.value !== key) {
+          const lower = attrName.toLowerCase();
+          const origAttr = `data-lr-orig-${lower}`;
+          if (!element.hasAttribute(origAttr)) {
+            element.setAttribute(origAttr, unit.text);
+          }
+          element.setAttribute(attrName, cached.value);
+          element.setAttribute(`data-lr-attr-${lower}`, key);
+          const existing = element.getAttribute("data-lionrapid-client-attrs") ?? "";
+          const set = new Set(existing.split(",").filter(Boolean));
+          set.add(lower);
+          element.setAttribute("data-lionrapid-client-attrs", Array.from(set).join(","));
+          count++;
+        } else {
+          this.core.bus.emit("translation:not-found", {
+            payload: {
+              key,
+              fallbackValue: unit.text,
+              locale: this.sourceLocale,
+              namespace: this.namespace,
+              status: 404,
+              styles: {}
+            }
+          });
+        }
+      }
+      return count;
+    }
     /**
      * Get translated count
      */
     getTranslatedCount() {
       return this.translatedCount;
     }
+    /**
+     * Restore every client-translated attribute on `el` from its
+     * `data-lr-orig-*` backup, then strip the stamps. Mirrors the block-side
+     * restoration in retranslate() so language switch / editor reset clears
+     * attributes too.
+     */
+    restoreClientAttributes(el) {
+      const list = el.getAttribute("data-lionrapid-client-attrs");
+      if (list === null) return;
+      for (const name of list.split(",").filter(Boolean)) {
+        const orig = el.getAttribute(`data-lr-orig-${name}`);
+        if (orig !== null) {
+          el.setAttribute(name, orig);
+          el.removeAttribute(`data-lr-orig-${name}`);
+        }
+        el.removeAttribute(`data-lr-attr-${name}`);
+      }
+      el.removeAttribute("data-lionrapid-client-attrs");
+    }
     /**
      * Re-translate a single element (for editor live preview reset)
      */
@@ -4624,14 +4990,15 @@ var LionRapid = (() => {
       if (original !== null) element.innerHTML = original;
       element.removeAttribute("data-lionrapid-client");
       element.removeAttribute("data-lr-block");
+      this.restoreClientAttributes(element);
       this.translateElement(element);
     }
     /**
      * Re-translate the page (after language change)
      */
     retranslate() {
-      const translated = document.querySelectorAll("[data-lionrapid-client]");
-      translated.forEach((el) => {
+      const translatedBlocks = document.querySelectorAll("[data-lionrapid-client]");
+      translatedBlocks.forEach((el) => {
         const original = el.getAttribute("data-lr-original");
         if (original !== null) {
           el.innerHTML = original;
@@ -4639,6 +5006,8 @@ var LionRapid = (() => {
         el.removeAttribute("data-lionrapid-client");
         el.removeAttribute("data-lr-block");
       });
+      const translatedAttrs = document.querySelectorAll("[data-lionrapid-client-attrs]");
+      translatedAttrs.forEach((el) => this.restoreClientAttributes(el));
       this.translatedCount = 0;
       if (this.locale !== this.sourceLocale) {
         this.translatePage();
@@ -5368,6 +5737,8 @@ var LionRapid = (() => {
     const switcherShowFlags = script.dataset.switcherShowFlags !== "false";
     const switcherShowNames = script.dataset.switcherShowNames === "true";
     const switcherCustomCss = script.dataset.switcherCustomCss || void 0;
+    const editorCdnUrl = script.dataset.editorCdn || void 0;
+    const offline = script.dataset.offline !== "false";
     return {
       apiKey,
       baseUrl,
@@ -5381,7 +5752,9 @@ var LionRapid = (() => {
       switcherPosition,
       switcherShowFlags,
       switcherShowNames,
-      switcherCustomCss
+      switcherCustomCss,
+      editorCdnUrl,
+      offline
     };
   }
   function readLocaleCookie(availableLanguages) {
@@ -5461,10 +5834,22 @@ var LionRapid = (() => {
       renderSwitcher();
     }
     try {
-      const core = await LionRapidBuilder.init({
+      const builder = LionRapidBuilder.init({
         defaultLocale: initialLocale,
         namespace: config.namespace
-      }).use(new MemoryRepository({ enabled: true })).use(new LocalStorageRepository({ enabled: true })).use(new CacheStorageRepository({ enabled: true })).use(
+      }).use(new MemoryRepository({ enabled: true })).use(new LocalStorageRepository({ enabled: true })).use(new CacheStorageRepository({ enabled: true }));
+      if (config.offline !== false) {
+        builder.use(
+          new CacheStorageRepository({
+            enabled: true,
+            options: {
+              ttl: Number.MAX_SAFE_INTEGER,
+              cacheName: "lionrapid-offline-v1"
+            }
+          })
+        );
+      }
+      const core = await builder.use(
         new NetworkRepository({
           enabled: true,
           options: {
@@ -5563,7 +5948,7 @@ var LionRapid = (() => {
       };
       window.LionRapid = instance;
       const editorParam = new URLSearchParams(window.location.search).get("__lr_editor");
-      if (editorParam && !document.querySelector("script[data-grant]")) {
+      if (editorParam && !document.querySelector("script[data-grant], script[data-lr-editor]")) {
         const editorScript = document.createElement("script");
         editorScript.src = config.editorCdnUrl || "https://cdn.lionrapid.com/lionrapid.editor.min.js";
         editorScript.dataset.grant = editorParam;