@lionrapid/core 0.4.0 → 0.6.0

package/dist/browser/lionrapid.umd.js

@@ -39,8 +39,10 @@ __export(index_exports, {
   Colors: () => Colors,
   ContentValidator: () => ContentValidator,
   EventEmitter: () => EventEmitter,
+  ExcludeFilter: () => ExcludeFilter,
   HTMLSerializer: () => HTMLSerializer,
   HandlerChain: () => HandlerChain,
+  LOCALE_TAG_REGEX: () => LOCALE_TAG_REGEX,
   LionRapidBuilder: () => LionRapidBuilder,
   LionRapidCore: () => LionRapidCore,
   LocalStorageRepository: () => LocalStorageRepository,
@@ -51,24 +53,44 @@ __export(index_exports, {
   MissingTranslationQueue: () => MissingTranslationQueue,
   NetworkError: () => NetworkError,
   NetworkRepository: () => NetworkRepository,
+  SAFE_ATTRS: () => SAFE_ATTRS,
+  SAFE_STYLE_PROPS: () => SAFE_STYLE_PROPS,
+  SAFE_TAGS: () => SAFE_TAGS,
   ServerError: () => ServerError,
+  StaticRepository: () => StaticRepository,
   TranslationError: () => TranslationError,
   TranslationLockedError: () => TranslationLockedError,
   TranslationNotFoundError: () => TranslationNotFoundError,
   VERSION: () => VERSION,
   VOID_TAGS: () => VOID_TAGS,
   createPackageLogger: () => createPackageLogger,
+  escapeHtml: () => escapeHtml,
   extractTagName: () => extractTagName,
+  generateAutoKey: () => generateAutoKey,
   isClientError: () => isClientError,
   isRetryableError: () => isRetryableError,
   isTranslationError: () => isTranslationError,
+  localeDir: () => localeDir,
   logger: () => logger,
+  matchLocale: () => matchLocale,
+  md5: () => md5,
   measure: () => measure,
+  normalizeLocale: () => normalizeLocale,
+  parseAcceptLanguage: () => parseAcceptLanguage,
   parseKeyPath: () => parseKeyPath,
   prepareTranslationRequest: () => prepareTranslationRequest,
+  primarySubtag: () => primarySubtag,
   readRawStyle: () => readRawStyle,
+  replaceBlockInners: () => replaceBlockInners,
   resolveNestedKey: () => resolveNestedKey,
-  serializeOpeningTag: () => serializeOpeningTag
+  sanitizeContentUnit: () => sanitizeContentUnit,
+  sanitizeElement: () => sanitizeElement,
+  sanitizeOpeningTag: () => sanitizeOpeningTag,
+  sanitizeStyle: () => sanitizeStyle,
+  sanitizeStyleSheetText: () => sanitizeStyleSheetText,
+  sanitizeUrl: () => sanitizeUrl,
+  serializeOpeningTag: () => serializeOpeningTag,
+  splitBlocks: () => splitBlocks
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -419,6 +441,57 @@ var measure = (name) => {
   };
 };
 
+// src/utils/locale.ts
+var LOCALE_TAG_REGEX = /^[a-z]{2,3}(?:-[a-z0-9]{2,4})*$/i;
+var RTL_LANGUAGES = /* @__PURE__ */ new Set(["ar", "fa", "he", "ur", "yi"]);
+function primarySubtag(tag) {
+  return tag.split("-")[0].toLowerCase();
+}
+function normalizeLocale(tag) {
+  const trimmed = tag.trim();
+  if (!trimmed) return trimmed;
+  const [lang, ...rest] = trimmed.split("-");
+  const out = [lang.toLowerCase()];
+  for (const sub of rest) {
+    if (sub.length === 4) {
+      out.push(sub[0].toUpperCase() + sub.slice(1).toLowerCase());
+    } else if (sub.length === 2) {
+      out.push(sub.toUpperCase());
+    } else {
+      out.push(sub.toLowerCase());
+    }
+  }
+  return out.join("-");
+}
+function matchLocale(requested, available, fallback) {
+  if (available.length === 0) return fallback;
+  const avail = available.map((raw) => ({
+    raw,
+    lower: normalizeLocale(raw).toLowerCase()
+  }));
+  for (const req of requested) {
+    if (!req) continue;
+    const reqLower = normalizeLocale(req).toLowerCase();
+    const exact = avail.find((a) => a.lower === reqLower);
+    if (exact) return exact.raw;
+    const primary = primarySubtag(req);
+    const byPrimary = avail.find((a) => a.lower === primary);
+    if (byPrimary) return byPrimary.raw;
+  }
+  return fallback;
+}
+function parseAcceptLanguage(header) {
+  return header.split(",").map((part) => {
+    const [tag, ...params] = part.trim().split(";");
+    const qParam = params.find((p) => p.trim().startsWith("q="));
+    const q = qParam ? parseFloat(qParam.trim().slice(2)) : 1;
+    return { tag: tag.trim(), q: Number.isNaN(q) ? 0 : q };
+  }).filter((x) => x.tag.length > 0 && x.tag !== "*").sort((a, b) => b.q - a.q).map((x) => x.tag);
+}
+function localeDir(tag) {
+  return RTL_LANGUAGES.has(primarySubtag(tag)) ? "rtl" : "ltr";
+}
+
 // src/base/event-emitter.ts
 var EventEmitter = class {
   constructor() {
@@ -707,7 +780,7 @@ var EventEmitter = class {
       complete: () => {
         this.emit("language:change:success", {
           context: this.createContext(requestId, [...baseTrace, "complete"]),
-          payload: { oldLocale, newLocale }
+          payload: { oldLocale, newLocale, dir: localeDir(newLocale) }
         });
       },
       error: (error) => {
@@ -1117,12 +1190,11 @@ function parseNamespaceKey(key) {
 }
 
 // src/utils/context-utils.ts
-function createTranslationContext(parsedKey, currentLocale, defaultNamespace, fallbackLocale) {
+function createTranslationContext(parsedKey, currentLocale, defaultNamespace) {
   const effectiveNamespace = parsedKey.hasExplicitNamespace ? parsedKey.namespace : defaultNamespace;
   return {
     locale: currentLocale,
-    namespace: effectiveNamespace,
-    fallbackLocale: fallbackLocale || currentLocale
+    namespace: effectiveNamespace
   };
 }
 
@@ -1239,7 +1311,7 @@ function flattenTranslations(translations, prefix = "", locale, namespace) {
 }
 
 // src/utils/translation-flow.ts
-function prepareTranslationRequest(key, currentLocale, defaultValueOrParams, paramsOrDefaultValue, defaultNamespace, fallbackLocale) {
+function prepareTranslationRequest(key, currentLocale, defaultValueOrParams, paramsOrDefaultValue, defaultNamespace) {
   const startTime = performance.now();
   const { defaultValue, params } = parseTranslationParams(
     defaultValueOrParams,
@@ -1249,8 +1321,7 @@ function prepareTranslationRequest(key, currentLocale, defaultValueOrParams, par
   const context = createTranslationContext(
     parsedKey,
     currentLocale,
-    defaultNamespace,
-    fallbackLocale
+    defaultNamespace
   );
   const individualCacheKey = createIndividualCacheKey(
     context.locale,
@@ -1272,7 +1343,6 @@ function prepareTranslationRequest(key, currentLocale, defaultValueOrParams, par
     locale: currentLocale,
     namespace: context.namespace,
     // ✅ Use effective namespace (explicit or default)
-    fallbackLocale,
     individualCacheKey,
     // ✅ Ready-to-use cache key
     namespaceCacheKey,
@@ -2388,6 +2458,183 @@ var MarkupParser = class {
   }
 };
 
+// src/content/sanitizer/HTMLSanitizer.ts
+var SAFE_TAGS = /* @__PURE__ */ new Set([
+  "a",
+  "abbr",
+  "b",
+  "bdi",
+  "bdo",
+  "br",
+  "cite",
+  "code",
+  "del",
+  "dfn",
+  "em",
+  "i",
+  "img",
+  "ins",
+  "kbd",
+  "mark",
+  "q",
+  "s",
+  "samp",
+  "small",
+  "span",
+  "strong",
+  "sub",
+  "sup",
+  "time",
+  "u",
+  "var",
+  "wbr"
+]);
+var SAFE_ATTRS = /* @__PURE__ */ new Set([
+  "alt",
+  "cite",
+  "class",
+  "datetime",
+  "dir",
+  "height",
+  "href",
+  "id",
+  "lang",
+  "loading",
+  "rel",
+  "role",
+  "src",
+  "target",
+  "title",
+  "width"
+]);
+var URL_ATTRS = /* @__PURE__ */ new Set(["href", "src", "cite"]);
+var SAFE_STYLE_PROPS = /* @__PURE__ */ new Set([
+  "color",
+  "background-color",
+  "font-family",
+  "font-size",
+  "font-style",
+  "font-weight",
+  "letter-spacing",
+  "line-height",
+  "text-decoration",
+  "text-decoration-color",
+  "text-decoration-line",
+  "text-decoration-style",
+  "text-transform",
+  "vertical-align",
+  "white-space",
+  "word-spacing"
+]);
+var DANGEROUS_CSS_VALUE = /url\s*\(|expression\s*\(|image-set\s*\(|element\s*\(|paint\s*\(|javascript:|\\|[<>{}@]/i;
+var SAFE_SCHEMES = /* @__PURE__ */ new Set(["http", "https", "mailto", "tel"]);
+var NAMED_ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: "\xA0",
+  colon: ":",
+  semi: ";",
+  sol: "/",
+  bsol: "\\",
+  Tab: "	",
+  NewLine: "\n"
+};
+function decodeEntities2(value) {
+  return value.replace(
+    /&(?:#[xX]([0-9a-fA-F]+);?|#(\d+);?|([a-zA-Z]+);)/g,
+    (full, hex, dec, name) => {
+      if (hex) return String.fromCodePoint(parseInt(hex, 16));
+      if (dec) return String.fromCodePoint(parseInt(dec, 10));
+      return NAMED_ENTITIES[name] ?? full;
+    }
+  );
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function sanitizeUrl(value) {
+  const decoded = decodeEntities2(value);
+  const probe = decoded.replace(/[\u0000-\u0020\u007f]/g, "").toLowerCase();
+  const scheme = /^([a-z][a-z0-9+.-]*):/.exec(probe);
+  if (!scheme) return value;
+  return SAFE_SCHEMES.has(scheme[1]) ? value : null;
+}
+function sanitizeStyle(value) {
+  return filterCssDeclarations(value, true);
+}
+function sanitizeCssDeclarations(value) {
+  return filterCssDeclarations(value, false);
+}
+function filterCssDeclarations(value, requirePropAllowlist) {
+  const decoded = decodeEntities2(value);
+  const kept = [];
+  for (const declaration of decoded.split(";")) {
+    const colon = declaration.indexOf(":");
+    if (colon === -1) continue;
+    const prop = declaration.slice(0, colon).trim().toLowerCase();
+    const val = declaration.slice(colon + 1).trim();
+    if (!/^[a-z-]+$/.test(prop)) continue;
+    if (requirePropAllowlist && !SAFE_STYLE_PROPS.has(prop)) continue;
+    if (val === "" || DANGEROUS_CSS_VALUE.test(val)) continue;
+    kept.push(`${prop}: ${val}`);
+  }
+  return kept.length > 0 ? kept.join("; ") : null;
+}
+var ATTR_PATTERN = /([^\s=/>"']+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]*)))?/g;
+function sanitizeOpeningTag(rawOpen) {
+  if (!rawOpen.startsWith("<")) return null;
+  const tagName = extractTagName(rawOpen);
+  if (!/^[a-z][a-z0-9-]*$/.test(tagName) || !SAFE_TAGS.has(tagName)) {
+    return null;
+  }
+  const end = rawOpen.endsWith("/>") ? rawOpen.length - 2 : rawOpen.endsWith(">") ? rawOpen.length - 1 : rawOpen.length;
+  const attrSource = rawOpen.slice(1 + tagName.length, end);
+  const attrs = {};
+  for (const match of attrSource.matchAll(ATTR_PATTERN)) {
+    const name = match[1].toLowerCase();
+    const value = match[2] ?? match[3] ?? match[4] ?? "";
+    if (name in attrs) continue;
+    if (name === "style") {
+      const cleanStyle = sanitizeStyle(value);
+      if (cleanStyle !== null) attrs[name] = cleanStyle;
+      continue;
+    }
+    const allowed = SAFE_ATTRS.has(name) || /^data-[a-z0-9-]*$/.test(name) || /^aria-[a-z0-9-]*$/.test(name);
+    if (!allowed) continue;
+    if (URL_ATTRS.has(name)) {
+      if (sanitizeUrl(value) === null) continue;
+    }
+    attrs[name] = value;
+  }
+  return serializeOpeningTag(tagName, attrs);
+}
+function sanitizeContentUnit(unit) {
+  let changed = false;
+  const styles = {};
+  for (const [index, styleList] of Object.entries(unit.styles)) {
+    const raw = readRawStyle(styleList);
+    if (raw === null) {
+      styles[index] = styleList;
+      continue;
+    }
+    const safe = sanitizeOpeningTag(raw);
+    if (safe === null) {
+      changed = true;
+      const rest = styleList.filter((s) => !s.startsWith("raw:"));
+      if (rest.length > 0) styles[index] = rest;
+    } else if (safe === raw) {
+      styles[index] = styleList;
+    } else {
+      changed = true;
+      styles[index] = styleList.map((s) => s.startsWith("raw:") ? `raw:${safe}` : s);
+    }
+  }
+  return changed ? { text: unit.text, styles } : unit;
+}
+
 // src/content/serializer/HTMLSerializer.ts
 var HTMLSerializer = class {
   serialize(unit) {
@@ -2397,24 +2644,25 @@ var HTMLSerializer = class {
     let lastIndex = 0;
     let match;
     while ((match = tagPattern.exec(text)) !== null) {
-      result += text.slice(lastIndex, match.index);
+      result += escapeHtml(text.slice(lastIndex, match.index));
       const [fullMatch, closingSlash, indexStr] = match;
       const styleList = styles[indexStr] ?? [];
       const rawOpen = readRawStyle(styleList);
-      if (rawOpen) {
+      const safeOpen = rawOpen === null ? null : sanitizeOpeningTag(rawOpen);
+      if (rawOpen && safeOpen !== null) {
         const tagName = extractTagName(rawOpen);
         const isVoid = VOID_TAGS.has(tagName);
         if (closingSlash) {
           if (!isVoid) result += `</${tagName}>`;
         } else {
-          result += rawOpen;
+          result += safeOpen;
         }
       } else {
         result += fullMatch;
       }
       lastIndex = match.index + fullMatch.length;
     }
-    result += text.slice(lastIndex);
+    result += escapeHtml(text.slice(lastIndex));
     return result;
   }
 };
@@ -2653,10 +2901,9 @@ var CacheManager = class {
 var INDEXED_TAG_REGEX = /<\/?[0-9]+\/?>/;
 var HTML_TAG_REGEX = /<[a-z][a-z0-9]*(?:\s+[^>]*)?\/?>/i;
 var LionRapidCore = class {
-  constructor(eventEmitter, handlerChain, defaultLocale = "en", fallbackLocale = "en", defaultNamespace) {
+  constructor(eventEmitter, handlerChain, defaultLocale = "en", defaultNamespace) {
     __publicField(this, "handlerChain");
     __publicField(this, "currentLocale");
-    __publicField(this, "fallbackLocale");
     __publicField(this, "defaultNamespace");
     __publicField(this, "pendingTranslations", /* @__PURE__ */ new Map());
     __publicField(this, "bus");
@@ -2674,7 +2921,6 @@ var LionRapidCore = class {
     this.bus = eventEmitter;
     this.handlerChain = handlerChain;
     this.currentLocale = defaultLocale;
-    this.fallbackLocale = fallbackLocale;
     this.defaultNamespace = defaultNamespace;
     this.cache = new CacheManager(
       this.handlerChain,
@@ -2739,8 +2985,7 @@ var LionRapidCore = class {
       this.currentLocale,
       firstArg,
       secondArg,
-      this.defaultNamespace,
-      this.fallbackLocale
+      this.defaultNamespace
     );
     logger.debug(`Translation requested: ${request.cleanKey}`);
     const translateBus = this.bus.translation(request);
@@ -2790,8 +3035,7 @@ var LionRapidCore = class {
       this.currentLocale,
       firstArg,
       secondArg,
-      this.defaultNamespace,
-      this.fallbackLocale
+      this.defaultNamespace
     );
     logger.debug(`HTML translation requested: ${request.cleanKey}`);
     const translateBus = this.bus.translation(request);
@@ -2999,8 +3243,7 @@ var LionRapidCore = class {
       this.currentLocale,
       params,
       defaultValue,
-      this.defaultNamespace,
-      this.fallbackLocale
+      this.defaultNamespace
     );
     const syncResult = this.handlerChain.handleSync(request);
     const rawValue = syncResult && syncResult.status === 200 ? syncResult.value : request.parsedDefaultValue || request.cleanKey;
@@ -3121,8 +3364,7 @@ var LionRapidCore = class {
       this.currentLocale,
       void 0,
       void 0,
-      this.defaultNamespace,
-      this.fallbackLocale
+      this.defaultNamespace
     );
     return this.handlerChain.isCached(request);
   }
@@ -3232,6 +3474,155 @@ var LionRapidCore = class {
   }
 };
 
+// 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 {
@@ -3394,6 +3785,9 @@ var MissingTranslationQueue = class {
 };
 
 // src/builder.ts
+function isLoudPreloadFailure(error) {
+  return !(error instanceof TranslationNotFoundError || error instanceof TranslationLockedError);
+}
 var LionRapidBuilder = class _LionRapidBuilder {
   constructor(config) {
     __publicField(this, "config");
@@ -3404,7 +3798,6 @@ var LionRapidBuilder = class _LionRapidBuilder {
     __publicField(this, "syncQueue", null);
     this.config = {
       defaultLocale: config.defaultLocale || "en",
-      fallbackLocale: config.fallbackLocale || "en",
       namespace: config.namespace || "app"
     };
   }
@@ -3440,6 +3833,15 @@ var LionRapidBuilder = class _LionRapidBuilder {
     }
     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();
@@ -3496,7 +3898,6 @@ var LionRapidBuilder = class _LionRapidBuilder {
       eventEmitter,
       handlerChain,
       this.config.defaultLocale,
-      this.config.fallbackLocale,
       this.config.namespace
     );
     for (const plugin of this.plugins) {
@@ -3527,7 +3928,17 @@ var LionRapidBuilder = class _LionRapidBuilder {
     logger.debug("Preload targets", {
       namespaces: eagerPreloads.map((c) => `${c.locale}:${c.namespace}`)
     });
+    let warnedLoudly = false;
+    const warnLoudlyOnce = (namespaceKey, error) => {
+      if (!isLoudPreloadFailure(error) || warnedLoudly) return;
+      warnedLoudly = true;
+      console.warn(
+        `[LionRapid] Could not load translations for ${namespaceKey} \u2014 the page stays untranslated until the server is reachable.`,
+        error
+      );
+    };
     const promises = eagerPreloads.map(async (preloadConfig) => {
+      const namespaceKey = `${preloadConfig.locale}:${preloadConfig.namespace}`;
       try {
         const result = await networkHandler.loadNamespace(
           preloadConfig.locale,
@@ -3536,19 +3947,19 @@ var LionRapidBuilder = class _LionRapidBuilder {
         if (result && result.data && result.status === 200) {
           const context = {
             locale: preloadConfig.locale,
-            namespace: preloadConfig.namespace,
-            fallbackLocale: this.config.fallbackLocale
+            namespace: preloadConfig.namespace
           };
           await handlerChain.saveNamespaceToHandlers(result.data, context);
-          logger.debug(
-            `Preloaded: ${preloadConfig.locale}:${preloadConfig.namespace}`
-          );
+          logger.debug(`Preloaded: ${namespaceKey}`);
+          return;
+        }
+        if (result?.error) {
+          warnLoudlyOnce(namespaceKey, result.error);
+          logger.warn(`Preload failed: ${namespaceKey}`, result.error);
         }
       } catch (error) {
-        logger.warn(
-          `Preload failed: ${preloadConfig.locale}:${preloadConfig.namespace}`,
-          error
-        );
+        warnLoudlyOnce(namespaceKey, error);
+        logger.warn(`Preload failed: ${namespaceKey}`, error);
       }
     });
     await Promise.allSettled(promises);
@@ -3562,8 +3973,16 @@ var _NetworkRepository = class _NetworkRepository {
     __publicField(this, "name", "NetworkRepository");
     __publicField(this, "type", "network");
     __publicField(this, "config", {});
-    /** Cached version (opaque string from server) per namespace key "locale:namespace" */
-    __publicField(this, "namespaceVersions", /* @__PURE__ */ new Map());
+    /**
+     * Namespace snapshot per key "locale:namespace": the server version TOGETHER
+     * with the payload it describes, persisted as ONE localStorage entry.
+     *
+     * Canonical 304 contract (same as edge KV bundle + WP transient cache):
+     * never claim freshness you can't back. If-None-Match is only sent when the
+     * snapshot is in hand; a 304 answers with that snapshot's payload; version
+     * and payload can never desync because they live and die together.
+     */
+    __publicField(this, "namespaceSnapshots", /* @__PURE__ */ new Map());
     /**
      * Default endpoint templates with placeholder support
      * Placeholders: :key, :locale, :namespace
@@ -3676,36 +4095,50 @@ var _NetworkRepository = class _NetworkRepository {
       logger.debug("API base URL is not set");
       throw new NetworkError("API base URL is not set");
     }
+    try {
+      return await this.fetchNamespaceRaw(locale, namespace);
+    } catch (error) {
+      this.handleCaughtError(error);
+    }
+  }
+  /**
+   * Shared namespace fetch with the canonical 304 contract:
+   * - If-None-Match is sent ONLY when a snapshot (version + payload) is in hand.
+   * - 304 answers with that snapshot's payload — never with "nothing".
+   * - A 304 with no snapshot (server/proxy surprise) refetches unconditionally.
+   * - A 200 stores version + payload atomically before either is trusted.
+   */
+  async fetchNamespaceRaw(locale, namespace, allowConditional = true) {
     const url = this.buildUrl("getNamespace", { locale, namespace });
     logger.debug(`API GET Namespace: ${url}`);
     const namespaceKey = `${locale}:${namespace}`;
-    try {
-      const extraHeaders = {};
-      const cachedVersion = this.getVersion(namespaceKey);
-      if (cachedVersion) {
-        extraHeaders["If-None-Match"] = `W/"${cachedVersion}"`;
-      }
-      const response = await this.makeRequest(url, "GET", void 0, extraHeaders);
-      if (response.status === 304) {
-        logger.debug(`Namespace ${namespaceKey}: 304 Not Modified`);
-        return null;
-      }
-      if (!response.ok) {
-        this.handleHttpError(response, namespaceKey);
-      }
-      const data = await response.json();
-      logger.debug("API response data:", data);
-      if (!data.translations) {
-        throw new TranslationNotFoundError(namespaceKey);
-      }
-      const version = data.meta?.version != null ? String(data.meta.version) : null;
-      if (version) {
-        this.setVersion(namespaceKey, version);
+    const snapshot = allowConditional ? this.getSnapshot(namespaceKey) : void 0;
+    const extraHeaders = {};
+    if (snapshot) {
+      extraHeaders["If-None-Match"] = `W/"${snapshot.version}"`;
+    }
+    const response = await this.makeRequest(url, "GET", void 0, extraHeaders);
+    if (response.status === 304) {
+      if (snapshot) {
+        logger.debug(`Namespace ${namespaceKey}: 304 Not Modified (snapshot served)`);
+        return snapshot.translations;
       }
-      return data.translations;
-    } catch (error) {
-      this.handleCaughtError(error);
+      logger.debug(`Namespace ${namespaceKey}: unexpected 304 with no snapshot \u2014 refetching`);
+      return this.fetchNamespaceRaw(locale, namespace, false);
+    }
+    if (!response.ok) {
+      this.handleHttpError(response, namespaceKey);
     }
+    const data = await response.json();
+    logger.debug("API response data:", data);
+    if (!data.translations) {
+      throw new TranslationNotFoundError(namespaceKey);
+    }
+    const version = data.meta?.version != null ? String(data.meta.version) : null;
+    if (version) {
+      this.setSnapshot(namespaceKey, { version, translations: data.translations });
+    }
+    return data.translations;
   }
   /**
    * Save translation to API (if supported)
@@ -3790,33 +4223,8 @@ var _NetworkRepository = class _NetworkRepository {
       logger.debug("API base URL is not set");
       throw new NetworkError("API base URL is not set");
     }
-    const url = this.buildUrl("getNamespace", { locale, namespace });
-    logger.debug(`API GET Namespace ContentUnits: ${url}`);
-    const namespaceKey = `${locale}:${namespace}`;
     try {
-      const extraHeaders = {};
-      const cachedVersion = this.getVersion(namespaceKey);
-      if (cachedVersion) {
-        extraHeaders["If-None-Match"] = `W/"${cachedVersion}"`;
-      }
-      const response = await this.makeRequest(url, "GET", void 0, extraHeaders);
-      if (response.status === 304) {
-        logger.debug(`Namespace ContentUnits ${namespaceKey}: 304 Not Modified`);
-        return null;
-      }
-      if (!response.ok) {
-        this.handleHttpError(response, namespaceKey);
-      }
-      const data = await response.json();
-      logger.debug("API response data:", data);
-      if (!data.translations) {
-        throw new TranslationNotFoundError(namespaceKey);
-      }
-      const version = data.meta?.version != null ? String(data.meta.version) : null;
-      if (version) {
-        this.setVersion(namespaceKey, version);
-      }
-      return data.translations;
+      return await this.fetchNamespaceRaw(locale, namespace);
     } catch (error) {
       this.handleCaughtError(error);
     }
@@ -3926,25 +4334,37 @@ var _NetworkRepository = class _NetworkRepository {
   getConfig() {
     return this.config;
   }
-  /** Read persisted version from localStorage, falling back to in-memory map */
-  getVersion(namespaceKey) {
-    const mem = this.namespaceVersions.get(namespaceKey);
+  /** Read a persisted snapshot (version + payload), falling back to memory.
+   *  Legacy bare-version entries and corrupt snapshots are deleted on sight —
+   *  a version without its payload must never drive a conditional request. */
+  getSnapshot(namespaceKey) {
+    const mem = this.namespaceSnapshots.get(namespaceKey);
     if (mem) return mem;
     try {
-      const stored = localStorage.getItem(_NetworkRepository.VERSION_PREFIX + namespaceKey);
-      if (stored) {
-        this.namespaceVersions.set(namespaceKey, stored);
-        return stored;
+      localStorage.removeItem(_NetworkRepository.LEGACY_VERSION_PREFIX + namespaceKey);
+      const raw = localStorage.getItem(_NetworkRepository.SNAPSHOT_PREFIX + namespaceKey);
+      if (raw) {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed.version === "string" && parsed.version.length > 0 && parsed.translations && typeof parsed.translations === "object") {
+          this.namespaceSnapshots.set(namespaceKey, parsed);
+          return parsed;
+        }
+        localStorage.removeItem(_NetworkRepository.SNAPSHOT_PREFIX + namespaceKey);
       }
     } catch {
     }
     return void 0;
   }
-  /** Persist version to both in-memory map and localStorage */
-  setVersion(namespaceKey, version) {
-    this.namespaceVersions.set(namespaceKey, version);
+  /** Persist version + payload as ONE entry (memory + localStorage). On quota
+   *  failure the previous stored snapshot stays — still a consistent pair. */
+  setSnapshot(namespaceKey, snapshot) {
+    this.namespaceSnapshots.set(namespaceKey, snapshot);
     try {
-      localStorage.setItem(_NetworkRepository.VERSION_PREFIX + namespaceKey, version);
+      localStorage.setItem(
+        _NetworkRepository.SNAPSHOT_PREFIX + namespaceKey,
+        JSON.stringify(snapshot)
+      );
+      localStorage.removeItem(_NetworkRepository.LEGACY_VERSION_PREFIX + namespaceKey);
     } catch {
     }
   }
@@ -4033,105 +4453,13 @@ var _NetworkRepository = class _NetworkRepository {
     }
   }
 };
-/** localStorage key prefix for persisted versions */
-__publicField(_NetworkRepository, "VERSION_PREFIX", "lionrapid:v:");
+/** localStorage key prefix for persisted snapshots (version + payload) */
+__publicField(_NetworkRepository, "SNAPSHOT_PREFIX", "lionrapid:ns:");
+/** Legacy bare-version prefix — a version WITHOUT its payload is exactly the
+ *  desync the snapshot store exists to prevent; entries are deleted on sight. */
+__publicField(_NetworkRepository, "LEGACY_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/content/validator/ContentValidator.ts
 var ContentValidator = class {
   /**
@@ -4285,6 +4613,433 @@ var ContentValidator = class {
   }
 };
 
+// src/content/splitter/BlockSplitter.ts
+var BLOCK_TAGS = /* @__PURE__ */ new Set([
+  "title",
+  "p",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "li",
+  "td",
+  "th",
+  "label",
+  "button",
+  "figcaption",
+  "dt",
+  "dd",
+  "summary",
+  "caption"
+]);
+var INLINE_BLOCK_TAGS = /* @__PURE__ */ new Set(["a"]);
+var SKIP_TAGS = /* @__PURE__ */ new Set([
+  "script",
+  "style",
+  "code",
+  "pre",
+  "textarea",
+  "noscript",
+  "svg"
+]);
+var TAG_REGEX = /<(\/?)([a-zA-Z][a-zA-Z0-9]*)((?:\s+[a-zA-Z][a-zA-Z0-9-]*(?:=(?:"[^"]*"|'[^']*'|[^\s>]*))?)*)\s*(\/?)>/g;
+function hasNoTranslateAttr(attrsString) {
+  if (attrsString.includes("data-no-translate")) return true;
+  return /translate\s*=\s*["']no["']/.test(attrsString);
+}
+function containsBlockTag(innerHTML) {
+  TAG_REGEX.lastIndex = 0;
+  let match;
+  while ((match = TAG_REGEX.exec(innerHTML)) !== null) {
+    const [, closingSlash, tagName, , selfClosingSlash] = match;
+    if (!closingSlash && !selfClosingSlash && BLOCK_TAGS.has(tagName.toLowerCase())) {
+      return true;
+    }
+  }
+  return false;
+}
+function findCloseTag(html, pos, tagName) {
+  const lowerTag = tagName.toLowerCase();
+  let depth = 1;
+  TAG_REGEX.lastIndex = pos;
+  let match;
+  while ((match = TAG_REGEX.exec(html)) !== null) {
+    const [, closingSlash, matchedTag, , selfClosingSlash] = match;
+    if (matchedTag.toLowerCase() !== lowerTag) continue;
+    if (closingSlash) {
+      depth--;
+      if (depth === 0) return match.index;
+    } else if (!selfClosingSlash) {
+      depth++;
+    }
+  }
+  return -1;
+}
+function splitBlocks(html) {
+  const blocks = [];
+  let pos = 0;
+  let skipDepth = 0;
+  let iter = 0;
+  const maxIter = 1e5;
+  const noTranslateEnds = [];
+  while (pos < html.length && iter < maxIter) {
+    iter++;
+    const ltPos = html.indexOf("<", pos);
+    if (ltPos === -1) break;
+    if (html.startsWith("<!--", ltPos)) {
+      const commentEnd = html.indexOf("-->", ltPos + 4);
+      if (commentEnd === -1) break;
+      pos = commentEnd + 3;
+      continue;
+    }
+    TAG_REGEX.lastIndex = ltPos;
+    const match = TAG_REGEX.exec(html);
+    if (!match || match.index !== ltPos) {
+      pos = ltPos + 1;
+      continue;
+    }
+    const [fullMatch, closingSlash, tagName, attrsString, selfClosingSlash] = match;
+    const tag = tagName.toLowerCase();
+    const afterMatch = match.index + fullMatch.length;
+    if (SKIP_TAGS.has(tag)) {
+      if (closingSlash) {
+        if (skipDepth > 0) skipDepth--;
+      } else if (!selfClosingSlash) {
+        skipDepth++;
+      }
+      pos = afterMatch;
+      continue;
+    }
+    if (skipDepth > 0) {
+      pos = afterMatch;
+      continue;
+    }
+    while (noTranslateEnds.length && pos >= noTranslateEnds[noTranslateEnds.length - 1]) {
+      noTranslateEnds.pop();
+    }
+    if (!closingSlash && !selfClosingSlash && hasNoTranslateAttr(attrsString)) {
+      const regionEnd = findCloseTag(html, afterMatch, tagName);
+      if (regionEnd !== -1) {
+        noTranslateEnds.push(regionEnd);
+      }
+    }
+    if (noTranslateEnds.length > 0) {
+      pos = afterMatch;
+      continue;
+    }
+    if ((BLOCK_TAGS.has(tag) || INLINE_BLOCK_TAGS.has(tag)) && !closingSlash && !selfClosingSlash) {
+      const closeTagStart = findCloseTag(html, afterMatch, tagName);
+      if (closeTagStart === -1) {
+        pos = afterMatch;
+        continue;
+      }
+      const innerHTML = html.slice(afterMatch, closeTagStart);
+      if (containsBlockTag(innerHTML)) {
+        pos = afterMatch;
+        continue;
+      }
+      blocks.push({
+        tag,
+        openTag: fullMatch,
+        attrs: attrsString,
+        inner: innerHTML,
+        innerStart: afterMatch,
+        innerEnd: closeTagStart
+      });
+      TAG_REGEX.lastIndex = closeTagStart;
+      const closeMatch = TAG_REGEX.exec(html);
+      pos = closeMatch ? closeMatch.index + closeMatch[0].length : closeTagStart + 1;
+      continue;
+    }
+    pos = afterMatch;
+  }
+  return { blocks };
+}
+function replaceBlockInners(html, replacements) {
+  const ordered = [...replacements].sort((a, b) => b.block.innerStart - a.block.innerStart);
+  let result = html;
+  for (const { block, inner } of ordered) {
+    result = result.slice(0, block.innerStart) + inner + result.slice(block.innerEnd);
+  }
+  return result;
+}
+
+// src/browser/md5.ts
+function safeAdd(x, y) {
+  const lsw = (x & 65535) + (y & 65535);
+  const msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+  return msw << 16 | lsw & 65535;
+}
+function bitRotateLeft(num, cnt) {
+  return num << cnt | num >>> 32 - cnt;
+}
+function md5cmn(q, a, b, x, s, t) {
+  return safeAdd(bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b);
+}
+function md5ff(a, b, c, d, x, s, t) {
+  return md5cmn(b & c | ~b & d, a, b, x, s, t);
+}
+function md5gg(a, b, c, d, x, s, t) {
+  return md5cmn(b & d | c & ~d, a, b, x, s, t);
+}
+function md5hh(a, b, c, d, x, s, t) {
+  return md5cmn(b ^ c ^ d, a, b, x, s, t);
+}
+function md5ii(a, b, c, d, x, s, t) {
+  return md5cmn(c ^ (b | ~d), a, b, x, s, t);
+}
+function binlMD5(x, len) {
+  x[len >> 5] |= 128 << len % 32;
+  x[(len + 64 >>> 9 << 4) + 14] = len;
+  let a = 1732584193;
+  let b = -271733879;
+  let c = -1732584194;
+  let d = 271733878;
+  for (let i = 0; i < x.length; i += 16) {
+    const olda = a;
+    const oldb = b;
+    const oldc = c;
+    const oldd = d;
+    a = md5ff(a, b, c, d, x[i], 7, -680876936);
+    d = md5ff(d, a, b, c, x[i + 1], 12, -389564586);
+    c = md5ff(c, d, a, b, x[i + 2], 17, 606105819);
+    b = md5ff(b, c, d, a, x[i + 3], 22, -1044525330);
+    a = md5ff(a, b, c, d, x[i + 4], 7, -176418897);
+    d = md5ff(d, a, b, c, x[i + 5], 12, 1200080426);
+    c = md5ff(c, d, a, b, x[i + 6], 17, -1473231341);
+    b = md5ff(b, c, d, a, x[i + 7], 22, -45705983);
+    a = md5ff(a, b, c, d, x[i + 8], 7, 1770035416);
+    d = md5ff(d, a, b, c, x[i + 9], 12, -1958414417);
+    c = md5ff(c, d, a, b, x[i + 10], 17, -42063);
+    b = md5ff(b, c, d, a, x[i + 11], 22, -1990404162);
+    a = md5ff(a, b, c, d, x[i + 12], 7, 1804603682);
+    d = md5ff(d, a, b, c, x[i + 13], 12, -40341101);
+    c = md5ff(c, d, a, b, x[i + 14], 17, -1502002290);
+    b = md5ff(b, c, d, a, x[i + 15], 22, 1236535329);
+    a = md5gg(a, b, c, d, x[i + 1], 5, -165796510);
+    d = md5gg(d, a, b, c, x[i + 6], 9, -1069501632);
+    c = md5gg(c, d, a, b, x[i + 11], 14, 643717713);
+    b = md5gg(b, c, d, a, x[i], 20, -373897302);
+    a = md5gg(a, b, c, d, x[i + 5], 5, -701558691);
+    d = md5gg(d, a, b, c, x[i + 10], 9, 38016083);
+    c = md5gg(c, d, a, b, x[i + 15], 14, -660478335);
+    b = md5gg(b, c, d, a, x[i + 4], 20, -405537848);
+    a = md5gg(a, b, c, d, x[i + 9], 5, 568446438);
+    d = md5gg(d, a, b, c, x[i + 14], 9, -1019803690);
+    c = md5gg(c, d, a, b, x[i + 3], 14, -187363961);
+    b = md5gg(b, c, d, a, x[i + 8], 20, 1163531501);
+    a = md5gg(a, b, c, d, x[i + 13], 5, -1444681467);
+    d = md5gg(d, a, b, c, x[i + 2], 9, -51403784);
+    c = md5gg(c, d, a, b, x[i + 7], 14, 1735328473);
+    b = md5gg(b, c, d, a, x[i + 12], 20, -1926607734);
+    a = md5hh(a, b, c, d, x[i + 5], 4, -378558);
+    d = md5hh(d, a, b, c, x[i + 8], 11, -2022574463);
+    c = md5hh(c, d, a, b, x[i + 11], 16, 1839030562);
+    b = md5hh(b, c, d, a, x[i + 14], 23, -35309556);
+    a = md5hh(a, b, c, d, x[i + 1], 4, -1530992060);
+    d = md5hh(d, a, b, c, x[i + 4], 11, 1272893353);
+    c = md5hh(c, d, a, b, x[i + 7], 16, -155497632);
+    b = md5hh(b, c, d, a, x[i + 10], 23, -1094730640);
+    a = md5hh(a, b, c, d, x[i + 13], 4, 681279174);
+    d = md5hh(d, a, b, c, x[i + 0], 11, -358537222);
+    c = md5hh(c, d, a, b, x[i + 3], 16, -722521979);
+    b = md5hh(b, c, d, a, x[i + 6], 23, 76029189);
+    a = md5hh(a, b, c, d, x[i + 9], 4, -640364487);
+    d = md5hh(d, a, b, c, x[i + 12], 11, -421815835);
+    c = md5hh(c, d, a, b, x[i + 15], 16, 530742520);
+    b = md5hh(b, c, d, a, x[i + 2], 23, -995338651);
+    a = md5ii(a, b, c, d, x[i], 6, -198630844);
+    d = md5ii(d, a, b, c, x[i + 7], 10, 1126891415);
+    c = md5ii(c, d, a, b, x[i + 14], 15, -1416354905);
+    b = md5ii(b, c, d, a, x[i + 5], 21, -57434055);
+    a = md5ii(a, b, c, d, x[i + 12], 6, 1700485571);
+    d = md5ii(d, a, b, c, x[i + 3], 10, -1894986606);
+    c = md5ii(c, d, a, b, x[i + 10], 15, -1051523);
+    b = md5ii(b, c, d, a, x[i + 1], 21, -2054922799);
+    a = md5ii(a, b, c, d, x[i + 8], 6, 1873313359);
+    d = md5ii(d, a, b, c, x[i + 15], 10, -30611744);
+    c = md5ii(c, d, a, b, x[i + 6], 15, -1560198380);
+    b = md5ii(b, c, d, a, x[i + 13], 21, 1309151649);
+    a = md5ii(a, b, c, d, x[i + 4], 6, -145523070);
+    d = md5ii(d, a, b, c, x[i + 11], 10, -1120210379);
+    c = md5ii(c, d, a, b, x[i + 2], 15, 718787259);
+    b = md5ii(b, c, d, a, x[i + 9], 21, -343485551);
+    a = safeAdd(a, olda);
+    b = safeAdd(b, oldb);
+    c = safeAdd(c, oldc);
+    d = safeAdd(d, oldd);
+  }
+  return [a, b, c, d];
+}
+function binl2hex(binarray) {
+  const hexTab = "0123456789abcdef";
+  let str = "";
+  for (let i = 0; i < binarray.length * 4; i++) {
+    str += hexTab.charAt(binarray[i >> 2] >> i % 4 * 8 + 4 & 15) + hexTab.charAt(binarray[i >> 2] >> i % 4 * 8 & 15);
+  }
+  return 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 < bytes.length; i++) {
+    bin[i >> 2] |= bytes[i] << i % 4 * 8;
+  }
+  return bin;
+}
+function md5(str) {
+  const bytes = utf8Bytes(str);
+  return binl2hex(binlMD5(bytes2binl(bytes), bytes.length * 8));
+}
+function generateAutoKey(text) {
+  const trimmed = text.trim();
+  return "auto_" + md5(trimmed).substring(0, 12);
+}
+
+// src/browser/exclude-filter.ts
+var DEFAULT_PATTERNS = {
+  emails: true,
+  urls: true,
+  numbers: true,
+  phones: true
+};
+var PATTERNS = {
+  email: /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/,
+  url: /^(https?:\/\/|www\.)[^\s]+$/i,
+  number: /^[\d\s.,+-]+$/,
+  phone: /^[+\d][\d\s().-]{6,}$/
+};
+var ExcludeFilter = class {
+  constructor(patterns = {}, minTextLength = 2) {
+    __publicField(this, "patterns");
+    __publicField(this, "minTextLength");
+    this.patterns = { ...DEFAULT_PATTERNS, ...patterns };
+    this.minTextLength = minTextLength;
+  }
+  /**
+   * Check if text should be excluded from translation
+   */
+  shouldExclude(text) {
+    const trimmed = text.trim();
+    if (trimmed.length < this.minTextLength) {
+      return true;
+    }
+    if (this.patterns.emails && PATTERNS.email.test(trimmed)) {
+      return true;
+    }
+    if (this.patterns.urls && PATTERNS.url.test(trimmed)) {
+      return true;
+    }
+    if (this.patterns.numbers && PATTERNS.number.test(trimmed)) {
+      return true;
+    }
+    if (this.patterns.phones && PATTERNS.phone.test(trimmed)) {
+      return true;
+    }
+    return false;
+  }
+};
+
+// src/browser/sanitizer.ts
+var REMOVE_TAGS = /* @__PURE__ */ new Set([
+  "script",
+  "iframe",
+  "frame",
+  "frameset",
+  "object",
+  "embed",
+  "applet",
+  "base",
+  "meta",
+  "link",
+  "template",
+  "portal"
+]);
+var URL_ATTRS2 = /* @__PURE__ */ new Set([
+  "href",
+  "src",
+  "action",
+  "formaction",
+  "poster",
+  "data",
+  "xlink:href"
+]);
+function sanitizeElement(root) {
+  const all = [root, ...Array.from(root.querySelectorAll("*"))];
+  for (const el of all) {
+    const tag = el.tagName.toLowerCase();
+    if (REMOVE_TAGS.has(tag)) {
+      el.remove();
+      continue;
+    }
+    for (const name of el.getAttributeNames()) {
+      const lower = name.toLowerCase();
+      if (lower.startsWith("on") || lower === "srcdoc") {
+        el.removeAttribute(name);
+        continue;
+      }
+      if (URL_ATTRS2.has(lower)) {
+        if (sanitizeUrl(el.getAttribute(name) ?? "") === null) {
+          el.removeAttribute(name);
+        }
+        continue;
+      }
+      if (lower === "style") {
+        const clean = sanitizeCssDeclarations(el.getAttribute(name) ?? "");
+        if (clean === null) el.removeAttribute(name);
+        else el.setAttribute(name, clean);
+      }
+    }
+  }
+}
+function sanitizeStyleSheetText(css, baseHref) {
+  let out = css.replace(/@import[^;]*(;|$)/gi, "");
+  out = out.replace(
+    /url\(\s*(['"]?)([^'")]*)\1\s*\)/gi,
+    (full, _quote, target) => {
+      try {
+        const resolved = new URL(target, baseHref);
+        if (resolved.protocol === "data:") return full;
+        if (resolved.origin === new URL(baseHref).origin) return full;
+      } catch {
+      }
+      return 'url("")';
+    }
+  );
+  return out.replace(/expression\s*\(/gi, "blocked(");
+}
+
 // src/browser/storage/localstorage-repository.ts
 var STORAGE_PREFIX = "lionrapid:";
 var VERSION_KEY = `${STORAGE_PREFIX}version`;