@lovalingo/lovalingo 0.5.28 → 0.6.0

package/dist/core.js

@@ -0,0 +1,3561 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core.tsx
+var core_exports = {};
+__export(core_exports, {
+  LanguageSwitcher: () => LanguageSwitcher,
+  LovalingoProvider: () => LovalingoProvider,
+  VERSION: () => VERSION,
+  useLovalingo: () => useLovalingo,
+  useLovalingoEdit: () => useLovalingoEdit,
+  useLovalingoTranslate: () => useLovalingoTranslate
+});
+module.exports = __toCommonJS(core_exports);
+
+// src/components/LovalingoProvider.tsx
+var import_react15 = __toESM(require("react"));
+
+// src/context/AixsterContext.tsx
+var import_react = require("react");
+var LovalingoContext = (0, import_react.createContext)(null);
+
+// src/context/LangRoutingContext.ts
+var import_react2 = require("react");
+var LangRoutingContext = (0, import_react2.createContext)({
+  defaultLang: "",
+  nonLocalizedPaths: [],
+  inactivePages: [],
+  status: "unknown"
+});
+
+// src/utils/logger.ts
+function isDebugEnabled() {
+  if (typeof globalThis === "undefined") return false;
+  const value = globalThis.__lovalingoDebug;
+  if (value === true || value === "true" || value === 1) return true;
+  try {
+    const params = typeof window !== "undefined" ? new URLSearchParams(window.location.search) : null;
+    const query = params?.get("lovalingoDebug") || params?.get("lovalingo_debug") || "";
+    if (query === "1" || query === "true") return true;
+  } catch {
+  }
+  try {
+    const stored = typeof window !== "undefined" ? window.localStorage?.getItem("Lovalingo_debug") : null;
+    if (stored === "1" || stored === "true") return true;
+  } catch {
+  }
+  return false;
+}
+function logDebug(...args) {
+  if (!isDebugEnabled()) return;
+  console.log(...args);
+}
+function warnDebug(...args) {
+  if (!isDebugEnabled()) return;
+  console.warn(...args);
+}
+function errorDebug(...args) {
+  if (!isDebugEnabled()) return;
+  console.error(...args);
+}
+
+// src/utils/apiUtils.ts
+var OK_HTTP_STATUSES = /* @__PURE__ */ new Set([200, 201]);
+var NOT_FOUND_TITLE_HINTS = /404|not found|page not found|page missing|does not exist|error 404/i;
+function getNavigationResponseStatus() {
+  if (typeof performance === "undefined" || typeof performance.getEntriesByType !== "function") return null;
+  const entries = performance.getEntriesByType("navigation");
+  if (!entries || entries.length === 0) return null;
+  const entry = entries[0];
+  const rawStatus = entry?.responseStatus;
+  const status = typeof rawStatus === "number" ? Math.floor(rawStatus) : NaN;
+  if (!Number.isFinite(status) || status <= 0) return null;
+  return status;
+}
+function isOkHttpStatus(status) {
+  if (typeof status !== "number") return true;
+  return OK_HTTP_STATUSES.has(status);
+}
+function looksLikeNotFoundDocument() {
+  if (typeof document === "undefined") return false;
+  const title = (document.title || "").toString().trim().toLowerCase();
+  if (title && NOT_FOUND_TITLE_HINTS.test(title)) return true;
+  const bodyText = (document.body?.textContent || "").toString().slice(0, 2e3).toLowerCase();
+  if (!bodyText) return false;
+  const has404 = /\b404\b/.test(bodyText);
+  const hasNotFound = /not found|page not found|page missing|does not exist|error 404/.test(bodyText);
+  return has404 && hasNotFound;
+}
+function normalizeApiBase(raw) {
+  const input = (raw || "").toString().trim();
+  if (!input) return "https://cdn.lovalingo.com";
+  let base = input.replace(/\/functions\/v1\/?$/i, "").replace(/\/$/, "");
+  try {
+    const parsed = new URL(base);
+    const host = parsed.hostname.toLowerCase();
+    if (host.endsWith(".supabase.co")) {
+      warnDebug("LovalingoAPI", `apiBase points to Supabase (${host}); falling back to https://cdn.lovalingo.com`);
+      return "https://cdn.lovalingo.com";
+    }
+  } catch {
+  }
+  return base;
+}
+
+// src/utils/api.ts
+var LovalingoAPI = class {
+  constructor(apiKey, apiBase, pathConfig, editKey) {
+    this.entitlements = null;
+    this.apiKey = apiKey;
+    this.apiBase = normalizeApiBase(apiBase);
+    this.pathConfig = pathConfig;
+    this.editKey = editKey;
+  }
+  hasApiKey() {
+    return typeof this.apiKey === "string" && this.apiKey.trim().length > 0;
+  }
+  buildPathParam(pathOrUrl) {
+    if (typeof window === "undefined") return "/";
+    const input = (pathOrUrl || "").toString().trim();
+    if (!input) return window.location.pathname + window.location.search;
+    try {
+      if (/^https?:\/\//i.test(input)) {
+        const url = new URL(input);
+        return url.pathname + url.search;
+      }
+    } catch {
+    }
+    return input;
+  }
+  warnMissingApiKey(action) {
+    warnDebug(
+      `[Lovalingo] Missing public project key: ${action} was skipped. Pass publicAnonKey to <LovalingoProvider ...> (or set VITE_LOVALINGO_PUBLIC_ANON_KEY).`
+    );
+  }
+  warnMissingEditKey(action) {
+    warnDebug(`[Lovalingo] Missing edit key: ${action} was skipped. Open the edit link from the dashboard to continue.`);
+  }
+  logActivationRequired(context, response) {
+    errorDebug(
+      `[Lovalingo] ${context} blocked (HTTP ${response.status}). This project is not activated yet. Publish a public manifest at "/.well-known/lovalingo.json" on your domain, then verify it in the Lovalingo dashboard to activate translations + SEO.`
+    );
+  }
+  isActivationRequiredPayload(data) {
+    if (!data || typeof data !== "object") return false;
+    const record = data;
+    const status = record["status"];
+    const errorCode = record["error_code"];
+    return status === "activation_required" || errorCode === "PROJECT_NOT_ACTIVATED";
+  }
+  isActivationRequiredResponse(response, data) {
+    if (response.status === 403) return true;
+    if (response.headers.get("X-Lovalingo-Status") === "activation_required") return true;
+    return typeof data !== "undefined" ? this.isActivationRequiredPayload(data) : false;
+  }
+  getEntitlements() {
+    return this.entitlements;
+  }
+  async fetchEntitlements(localeHint) {
+    try {
+      if (!this.hasApiKey()) {
+        this.warnMissingApiKey("fetchEntitlements");
+        return null;
+      }
+      const pathParam = this.buildPathParam();
+      const response = await fetch(
+        `${this.apiBase}/functions/v1/bundle?key=${this.apiKey}&locale=${encodeURIComponent(localeHint)}&path=${encodeURIComponent(pathParam)}&scoped=1`
+      );
+      if (this.isActivationRequiredResponse(response)) {
+        this.logActivationRequired("fetchEntitlements", response);
+        return null;
+      }
+      if (!response.ok) return null;
+      const data = await response.json();
+      if (this.isActivationRequiredResponse(response, data)) {
+        this.logActivationRequired("fetchEntitlements", response);
+        return null;
+      }
+      if (data?.entitlements) {
+        this.entitlements = {
+          ...data.entitlements,
+          seoEnabled: typeof data?.seoEnabled === "boolean" ? data.seoEnabled : void 0
+        };
+        return this.entitlements;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  async fetchSeoBundle(localeHint) {
+    try {
+      if (!this.hasApiKey()) {
+        this.warnMissingApiKey("fetchSeoBundle");
+        return null;
+      }
+      const pathParam = this.buildPathParam();
+      const requestUrl = `${this.apiBase}/functions/v1/seo-bundle?key=${this.apiKey}&locale=${encodeURIComponent(localeHint)}&path=${encodeURIComponent(pathParam)}`;
+      const response = await fetch(requestUrl);
+      if (this.isActivationRequiredResponse(response)) {
+        this.logActivationRequired("fetchSeoBundle", response);
+        return null;
+      }
+      const resolvedResponse = response.status === 304 ? await fetch(requestUrl, { cache: "force-cache" }) : response;
+      if (resolvedResponse !== response && this.isActivationRequiredResponse(resolvedResponse)) {
+        this.logActivationRequired("fetchSeoBundle", resolvedResponse);
+        return null;
+      }
+      if (!resolvedResponse.ok) return null;
+      const data = await resolvedResponse.json();
+      if (this.isActivationRequiredResponse(resolvedResponse, data)) {
+        this.logActivationRequired("fetchSeoBundle", resolvedResponse);
+        return null;
+      }
+      return data || null;
+    } catch {
+      return null;
+    }
+  }
+  async trackPageview(pathOrUrl, opts) {
+    try {
+      if (!this.hasApiKey()) return;
+      const status = getNavigationResponseStatus();
+      if (!isOkHttpStatus(status)) return;
+      if (looksLikeNotFoundDocument()) return;
+      const params = new URLSearchParams();
+      params.set("key", this.apiKey);
+      params.set("path", pathOrUrl);
+      const count = opts?.critical_count;
+      const hash = (opts?.critical_hash || "").toString().trim().toLowerCase();
+      if (typeof count === "number" && Number.isFinite(count) && count > 0 && count <= 5e3 && /^[a-z0-9]{1,40}$/.test(hash)) {
+        params.set("critical_count", String(Math.floor(count)));
+        params.set("critical_hash", hash);
+      }
+      const response = await fetch(`${this.apiBase}/functions/v1/pageview?${params.toString()}`, {
+        method: "GET",
+        keepalive: true
+      });
+      if (response.status === 403) {
+        this.logActivationRequired("trackPageview", response);
+      }
+    } catch {
+    }
+  }
+  async reportStringMisses(targetLocale, misses, opts) {
+    try {
+      if (!this.hasApiKey()) return null;
+      if (!Array.isArray(misses) || misses.length === 0) return null;
+      const status = getNavigationResponseStatus();
+      if (!isOkHttpStatus(status)) {
+        return { ignored: true, reason: "http_status" };
+      }
+      if (looksLikeNotFoundDocument()) {
+        return { ignored: true, reason: "soft_404" };
+      }
+      const pathParam = this.buildPathParam(opts?.pathOrUrl);
+      const response = await fetch(`${this.apiBase}/functions/v1/misses`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          key: this.apiKey,
+          locale: targetLocale,
+          path: pathParam,
+          source_locale: opts?.sourceLocale,
+          locales: Array.isArray(opts?.locales) ? opts?.locales : void 0,
+          page_status: typeof status === "number" ? status : void 0,
+          misses
+        })
+      });
+      if (this.isActivationRequiredResponse(response)) {
+        this.logActivationRequired("reportStringMisses", response);
+        return null;
+      }
+      if (!response.ok) return null;
+      const data = await response.json();
+      if (this.isActivationRequiredResponse(response, data)) {
+        this.logActivationRequired("reportStringMisses", response);
+        return null;
+      }
+      return data;
+    } catch {
+      return null;
+    }
+  }
+  async fetchTranslations(sourceLocale, targetLocale) {
+    try {
+      if (!this.hasApiKey()) {
+        this.warnMissingApiKey("fetchTranslations");
+        return [];
+      }
+      const bundle = await this.fetchBundle(targetLocale);
+      if (!bundle) return [];
+      return Object.entries(bundle.map).map(([source_text, translated_text]) => ({
+        source_text,
+        translated_text,
+        source_locale: sourceLocale,
+        target_locale: targetLocale
+      }));
+    } catch (error) {
+      errorDebug("Error fetching translations:", error);
+      return [];
+    }
+  }
+  async fetchBundle(localeHint, pathOrUrl) {
+    try {
+      if (!this.hasApiKey()) {
+        this.warnMissingApiKey("fetchBundle");
+        return null;
+      }
+      const pathParam = this.buildPathParam(pathOrUrl);
+      const requestUrl = `${this.apiBase}/functions/v1/bundle?key=${this.apiKey}&locale=${encodeURIComponent(localeHint)}&path=${encodeURIComponent(pathParam)}&scoped=1`;
+      const response = await fetch(requestUrl);
+      if (this.isActivationRequiredResponse(response)) {
+        this.logActivationRequired("fetchBundle", response);
+        return null;
+      }
+      const resolvedResponse = response.status === 304 ? await fetch(requestUrl, { cache: "force-cache" }) : response;
+      if (resolvedResponse !== response && this.isActivationRequiredResponse(resolvedResponse)) {
+        this.logActivationRequired("fetchBundle", resolvedResponse);
+        return null;
+      }
+      if (!resolvedResponse.ok) return null;
+      const data = await resolvedResponse.json();
+      if (this.isActivationRequiredResponse(resolvedResponse, data)) {
+        this.logActivationRequired("fetchBundle", resolvedResponse);
+        return null;
+      }
+      if (data?.entitlements) {
+        this.entitlements = {
+          ...data.entitlements,
+          seoEnabled: typeof data?.seoEnabled === "boolean" ? data.seoEnabled : void 0
+        };
+      }
+      const map = data?.map && typeof data.map === "object" ? data.map : {};
+      const hashMap = data?.hashMap && typeof data.hashMap === "object" ? data.hashMap : {};
+      return { map, hashMap };
+    } catch {
+      return null;
+    }
+  }
+  async fetchBootstrap(localeHint, pathOrUrl) {
+    try {
+      if (!this.hasApiKey()) {
+        this.warnMissingApiKey("fetchBootstrap");
+        return null;
+      }
+      const pathParam = this.buildPathParam(pathOrUrl);
+      const requestUrl = `${this.apiBase}/functions/v1/bootstrap?key=${this.apiKey}&locale=${encodeURIComponent(localeHint)}&path=${encodeURIComponent(pathParam)}`;
+      const response = await fetch(requestUrl);
+      if (this.isActivationRequiredResponse(response)) {
+        this.logActivationRequired("fetchBootstrap", response);
+        return null;
+      }
+      const resolvedResponse = response.status === 304 ? await fetch(requestUrl, { cache: "force-cache" }) : response;
+      if (resolvedResponse !== response && this.isActivationRequiredResponse(resolvedResponse)) {
+        this.logActivationRequired("fetchBootstrap", resolvedResponse);
+        return null;
+      }
+      if (!resolvedResponse.ok) return null;
+      const data = await resolvedResponse.json();
+      if (this.isActivationRequiredResponse(resolvedResponse, data)) {
+        this.logActivationRequired("fetchBootstrap", resolvedResponse);
+        return null;
+      }
+      return data || null;
+    } catch {
+      return null;
+    }
+  }
+  async fetchExclusions() {
+    try {
+      if (!this.hasApiKey()) {
+        this.warnMissingApiKey("fetchExclusions");
+        return [];
+      }
+      const response = await fetch(
+        `${this.apiBase}/functions/v1/exclusions?key=${this.apiKey}`
+      );
+      if (response.status === 403) {
+        this.logActivationRequired("fetchExclusions", response);
+        return [];
+      }
+      if (!response.ok) throw new Error("Failed to fetch exclusions");
+      const data = await response.json();
+      const rows = Array.isArray(data.exclusions) ? data.exclusions : [];
+      const out = [];
+      for (const row of rows) {
+        if (!row || typeof row !== "object") continue;
+        const record = row;
+        const selector = (typeof record.selector === "string" ? record.selector : "") || (typeof record.selector_value === "string" ? record.selector_value : "") || (typeof record.selectorValue === "string" ? record.selectorValue : "");
+        const type = (typeof record.type === "string" ? record.type : "") || (typeof record.selector_type === "string" ? record.selector_type : "") || (typeof record.selectorType === "string" ? record.selectorType : "");
+        const trimmedSelector = selector.trim();
+        const trimmedType = type.trim();
+        if (!trimmedSelector) continue;
+        if (trimmedType !== "css" && trimmedType !== "xpath") continue;
+        out.push({ selector: trimmedSelector, type: trimmedType });
+      }
+      return out;
+    } catch (error) {
+      errorDebug("Error fetching exclusions:", error);
+      return [];
+    }
+  }
+  async fetchDomRules(targetLocale) {
+    try {
+      if (!this.hasApiKey()) {
+        this.warnMissingApiKey("fetchDomRules");
+        return [];
+      }
+      const pathParam = this.buildPathParam();
+      const response = await fetch(
+        `${this.apiBase}/functions/v1/dom-rules?key=${this.apiKey}&locale=${encodeURIComponent(targetLocale)}&path=${encodeURIComponent(pathParam)}`
+      );
+      if (this.isActivationRequiredResponse(response)) {
+        this.logActivationRequired("fetchDomRules", response);
+        return [];
+      }
+      if (!response.ok) return [];
+      const data = await response.json();
+      if (this.isActivationRequiredResponse(response, data)) {
+        this.logActivationRequired("fetchDomRules", response);
+        return [];
+      }
+      return Array.isArray(data?.rules) ? data.rules : [];
+    } catch (error) {
+      errorDebug("Error fetching DOM rules:", error);
+      return [];
+    }
+  }
+  async saveExclusion(args) {
+    try {
+      if (!this.hasApiKey()) {
+        this.warnMissingApiKey("saveExclusion");
+        return;
+      }
+      const editKey = (args.editKey || this.editKey || "").trim();
+      if (!editKey) {
+        this.warnMissingEditKey("saveExclusion");
+        return;
+      }
+      const pagePath = (args.pagePath || this.buildPathParam()).toString();
+      const response = await fetch(`${this.apiBase}/functions/v1/exclusions?key=${this.apiKey}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          key: this.apiKey,
+          edit_key: editKey,
+          page_path: pagePath,
+          selector_type: args.type,
+          selector_value: args.selector,
+          description: args.description
+        })
+      });
+      if (response.status === 403) {
+        this.logActivationRequired("saveExclusion", response);
+      }
+    } catch (error) {
+      errorDebug("Error saving exclusion:", error);
+      throw error;
+    }
+  }
+};
+
+// src/utils/markerEngineConstants.ts
+var DEFAULT_THROTTLE_MS = 150;
+var DEFAULT_CRITICAL_BUFFER_PX = 200;
+var DEFAULT_CRITICAL_MAX = 800;
+var EXCLUDE_SELECTOR = "[data-lovalingo-exclude],[data-notranslate],[translate-no],[data-no-translate]";
+var UNSAFE_CONTAINER_TAGS = /* @__PURE__ */ new Set(["script", "style", "noscript", "template", "svg", "canvas"]);
+var ATTRIBUTE_MARKS = [
+  { attr: "title", marker: "data-lovalingo-title-original" },
+  { attr: "aria-label", marker: "data-lovalingo-aria-label-original" },
+  { attr: "placeholder", marker: "data-lovalingo-placeholder-original" }
+];
+var unsafeSelector = Array.from(UNSAFE_CONTAINER_TAGS).join(",");
+
+// src/utils/markerEngineState.ts
+var customExcludeSelector = null;
+var activeTranslationMap = null;
+function getCustomExcludeSelector() {
+  return customExcludeSelector;
+}
+function setCustomExcludeSelector(value) {
+  customExcludeSelector = value;
+}
+function getActiveTranslationMap() {
+  return activeTranslationMap;
+}
+function setActiveTranslationMap(value) {
+  activeTranslationMap = value;
+}
+
+// src/utils/markerEngineFilters.ts
+function isExcludedElement(el) {
+  if (!el) return false;
+  if (el.closest(EXCLUDE_SELECTOR)) return true;
+  const customExcludeSelector2 = getCustomExcludeSelector();
+  if (customExcludeSelector2) {
+    try {
+      if (el.closest(customExcludeSelector2)) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function findUnsafeContainer(el) {
+  if (!el) return null;
+  if (!unsafeSelector) return null;
+  return el.closest(unsafeSelector);
+}
+
+// src/utils/hash.ts
+function hashContent(text) {
+  if (!text || text.length === 0) {
+    return "0";
+  }
+  let hash = 5381;
+  for (let i = 0; i < text.length; i++) {
+    hash = (hash << 5) + hash + text.charCodeAt(i);
+  }
+  return Math.abs(hash).toString(36);
+}
+
+// src/utils/markerEngineDomUtils.ts
+function getStableKey(el) {
+  const owner = el.closest("[data-lovalingo-key]");
+  const key = owner?.getAttribute("data-lovalingo-key") || "";
+  return key.trim();
+}
+function getElementIndex(el) {
+  const parent = el.parentElement;
+  if (!parent) return 0;
+  const children = Array.from(parent.children);
+  const idx = children.indexOf(el);
+  return idx >= 0 ? idx : 0;
+}
+function getTextNodeIndex(node) {
+  let index = 0;
+  let prev = node.previousSibling;
+  while (prev) {
+    if (prev.nodeType === Node.TEXT_NODE) index += 1;
+    prev = prev.previousSibling;
+  }
+  return index;
+}
+function buildElementPath(el) {
+  const parts = [];
+  let current = el;
+  while (current && current.tagName && current !== document.body) {
+    const tag = current.tagName.toLowerCase();
+    const idx = getElementIndex(current);
+    parts.push(`${tag}[${idx}]`);
+    current = current.parentElement;
+  }
+  parts.push("body");
+  return parts.reverse().join("/");
+}
+function normalizeWhitespace(value) {
+  return (value || "").toString().replace(/\s+/g, " ").trim();
+}
+function isTranslatableText(text) {
+  if (!text || text.trim().length < 2) return false;
+  if (/^(__[A-Z0-9_]+__\s*)+$/.test(text)) return false;
+  if (/^\d+(\.\d+)?$/.test(text)) return false;
+  if (!/[a-zA-Z\u00C0-\u024F\u1E00-\u1EFF]/.test(text)) return false;
+  return true;
+}
+function buildStableId(el, text, textIndex) {
+  const key = getStableKey(el);
+  const path = buildElementPath(el);
+  const raw = `${path}#text[${textIndex}]|${text.trim()}|${key}`;
+  return hashContent(raw);
+}
+function buildSelector(el) {
+  const id = el.id;
+  if (id) return `#${id.replace(/[^a-zA-Z0-9_-]/g, "\\$&")}`;
+  const className = el.className;
+  if (typeof className === "string" && className.trim()) {
+    const classes = className.split(/\s+/).map((c) => c.trim()).filter(Boolean).slice(0, 3).map((c) => `.${c.replace(/[^a-zA-Z0-9_-]/g, "\\$&")}`).join("");
+    if (classes) return classes;
+  }
+  return null;
+}
+
+// src/utils/markerEngineOriginals.ts
+var originalTextByNode = /* @__PURE__ */ new WeakMap();
+var originalAttrByEl = /* @__PURE__ */ new WeakMap();
+function getOrInitTextOriginal(node, parent) {
+  const existing = originalTextByNode.get(node);
+  if (existing) return existing;
+  const raw = node.nodeValue || "";
+  const leading = raw.match(/^\s*/)?.[0] ?? "";
+  const trailing = raw.match(/\s*$/)?.[0] ?? "";
+  const trimmed = raw.trim();
+  const id = buildStableId(parent, trimmed, getTextNodeIndex(node));
+  const created = { raw, trimmed, leading, trailing, id };
+  originalTextByNode.set(node, created);
+  return created;
+}
+function getOrInitAttrOriginal(el, attr) {
+  let map = originalAttrByEl.get(el);
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+    originalAttrByEl.set(el, map);
+  }
+  const existing = map.get(attr);
+  if (existing != null) return existing;
+  const value = (el.getAttribute(attr) || "").toString();
+  map.set(attr, value);
+  return value;
+}
+
+// src/utils/markerEngineApply.ts
+function applyTranslationMap(bundle, root) {
+  if (!root) return 0;
+  const map = /* @__PURE__ */ new Map();
+  for (const [k, v] of Object.entries(bundle || {})) {
+    const source = normalizeWhitespace((k || "").toString());
+    const translated = (v ?? "").toString();
+    if (!source || !translated) continue;
+    map.set(source, translated);
+  }
+  setActiveTranslationMap(map);
+  return applyActiveTranslations(root);
+}
+function applyActiveTranslations(root = document.body) {
+  const map = getActiveTranslationMap();
+  if (!root || !map || map.size === 0) return 0;
+  let applied = 0;
+  const walk = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+  const nodes = [];
+  let node = walk.nextNode();
+  while (node) {
+    if (node.nodeType === Node.TEXT_NODE) nodes.push(node);
+    node = walk.nextNode();
+  }
+  for (const textNode of nodes) {
+    const parent = textNode.parentElement;
+    if (!parent) continue;
+    const raw = textNode.nodeValue || "";
+    const trimmed = raw.trim();
+    if (!trimmed) continue;
+    if (isExcludedElement(parent)) continue;
+    if (findUnsafeContainer(parent)) continue;
+    if (!isTranslatableText(trimmed)) continue;
+    const original = getOrInitTextOriginal(textNode, parent);
+    const key = normalizeWhitespace(original.trimmed);
+    const translation = map.get(key);
+    if (!translation) continue;
+    const next = `${original.leading}${translation}${original.trailing}`;
+    if (textNode.nodeValue === next) continue;
+    try {
+      textNode.nodeValue = next;
+      applied += 1;
+    } catch {
+    }
+  }
+  if (root instanceof HTMLElement) {
+    const elements = root.querySelectorAll("[title],[aria-label],[placeholder]");
+    elements.forEach((el) => {
+      if (isExcludedElement(el)) return;
+      if (findUnsafeContainer(el)) return;
+      for (const { attr } of ATTRIBUTE_MARKS) {
+        const current = el.getAttribute(attr);
+        if (!current) continue;
+        const trimmed = current.trim();
+        if (!trimmed || !isTranslatableText(trimmed)) continue;
+        const original = normalizeWhitespace(getOrInitAttrOriginal(el, attr));
+        const translation = map.get(original);
+        if (!translation) continue;
+        if (el.getAttribute(attr) === translation) continue;
+        try {
+          el.setAttribute(attr, translation);
+          applied += 1;
+        } catch {
+        }
+      }
+    });
+  }
+  return applied;
+}
+function restoreDom(root = document.body) {
+  if (!root) return;
+  const walk = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+  let node = walk.nextNode();
+  while (node) {
+    if (node.nodeType === Node.TEXT_NODE) {
+      const textNode = node;
+      const original = originalTextByNode.get(textNode);
+      if (original && textNode.nodeValue !== original.raw) {
+        try {
+          textNode.nodeValue = original.raw;
+        } catch {
+        }
+      }
+    }
+    node = walk.nextNode();
+  }
+  if (root instanceof HTMLElement) {
+    const elements = root.querySelectorAll("[title],[aria-label],[placeholder]");
+    elements.forEach((el) => {
+      const originals = originalAttrByEl.get(el);
+      if (!originals) return;
+      for (const { attr } of ATTRIBUTE_MARKS) {
+        const original = originals.get(attr);
+        if (original == null) continue;
+        if (el.getAttribute(attr) === original) continue;
+        try {
+          el.setAttribute(attr, original);
+        } catch {
+        }
+      }
+    });
+  }
+}
+
+// src/utils/markerEngineViewport.ts
+function isInViewport(rect, viewportHeight, bufferPx) {
+  if (!rect) return false;
+  if (!Number.isFinite(rect.top) || !Number.isFinite(rect.bottom)) return false;
+  if (rect.width <= 0 || rect.height <= 0) return false;
+  return rect.bottom > -bufferPx && rect.top < viewportHeight + bufferPx;
+}
+function getTextNodeRect(node) {
+  try {
+    const range = document.createRange();
+    range.selectNodeContents(node);
+    const rect = range.getBoundingClientRect();
+    if (rect && rect.width > 0 && rect.height > 0) return rect;
+  } catch {
+  }
+  try {
+    return node.parentElement ? node.parentElement.getBoundingClientRect() : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/utils/markerEngineCritical.ts
+function scanCriticalTexts() {
+  const root = document.body;
+  const viewportHeight = Math.max(0, Math.floor(window.innerHeight || 0));
+  const viewportWidth = Math.max(0, Math.floor(window.innerWidth || 0));
+  const viewport = { width: viewportWidth, height: viewportHeight };
+  if (!root || viewportHeight <= 0) return { texts: [], viewport };
+  const seen = /* @__PURE__ */ new Set();
+  const texts = [];
+  const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+  let node = walker.nextNode();
+  while (node && texts.length < DEFAULT_CRITICAL_MAX) {
+    if (node.nodeType !== Node.TEXT_NODE) {
+      node = walker.nextNode();
+      continue;
+    }
+    const textNode = node;
+    const raw = textNode.nodeValue || "";
+    const trimmed = raw.trim();
+    if (!trimmed || !isTranslatableText(trimmed)) {
+      node = walker.nextNode();
+      continue;
+    }
+    const parent = textNode.parentElement;
+    if (!parent || isExcludedElement(parent) || findUnsafeContainer(parent)) {
+      node = walker.nextNode();
+      continue;
+    }
+    const original = getOrInitTextOriginal(textNode, parent);
+    const originalText = normalizeWhitespace(original.trimmed);
+    if (!originalText || seen.has(originalText)) {
+      node = walker.nextNode();
+      continue;
+    }
+    const rect = getTextNodeRect(textNode);
+    if (!isInViewport(rect, viewportHeight, DEFAULT_CRITICAL_BUFFER_PX)) {
+      node = walker.nextNode();
+      continue;
+    }
+    seen.add(originalText);
+    texts.push(originalText);
+    node = walker.nextNode();
+  }
+  if (texts.length < DEFAULT_CRITICAL_MAX) {
+    const nodes = root.querySelectorAll("[title],[aria-label],[placeholder]");
+    nodes.forEach((el) => {
+      if (texts.length >= DEFAULT_CRITICAL_MAX) return;
+      if (isExcludedElement(el) || findUnsafeContainer(el)) return;
+      let rect = null;
+      try {
+        rect = el.getBoundingClientRect();
+      } catch {
+        rect = null;
+      }
+      if (!isInViewport(rect, viewportHeight, DEFAULT_CRITICAL_BUFFER_PX)) return;
+      for (const { attr } of ATTRIBUTE_MARKS) {
+        if (texts.length >= DEFAULT_CRITICAL_MAX) break;
+        const value = el.getAttribute(attr);
+        if (!value) continue;
+        const trimmed = value.trim();
+        if (!trimmed || !isTranslatableText(trimmed)) continue;
+        const original = normalizeWhitespace(getOrInitAttrOriginal(el, attr));
+        if (!original || seen.has(original)) continue;
+        seen.add(original);
+        texts.push(original);
+      }
+    });
+  }
+  return { texts, viewport };
+}
+function getCriticalFingerprint() {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return { critical_count: 0, critical_hash: "0", viewport: { width: 0, height: 0 } };
+  }
+  const { texts, viewport } = scanCriticalTexts();
+  const normalized = texts.map((t) => normalizeWhitespace(t)).filter(Boolean);
+  normalized.sort((a, b) => a.localeCompare(b));
+  return {
+    critical_count: normalized.length,
+    critical_hash: hashContent(normalized.join("\n")),
+    viewport
+  };
+}
+
+// src/utils/markerEngineStats.ts
+function buildEmptyStats() {
+  return {
+    totalTextNodes: 0,
+    markedNodes: 0,
+    skippedUnsafeNodes: 0,
+    skippedExcludedNodes: 0,
+    skippedNonTranslatableNodes: 0,
+    totalChars: 0,
+    markedChars: 0,
+    skippedUnsafeChars: 0,
+    skippedExcludedChars: 0,
+    skippedNonTranslatableChars: 0,
+    coverageRatio: 0,
+    coverageRatioChars: 0
+  };
+}
+function finalizeStats(stats) {
+  const eligibleNodes = stats.totalTextNodes - stats.skippedUnsafeNodes - stats.skippedExcludedNodes - stats.skippedNonTranslatableNodes;
+  const eligibleChars = stats.totalChars - stats.skippedUnsafeChars - stats.skippedExcludedChars - stats.skippedNonTranslatableChars;
+  stats.coverageRatio = eligibleNodes > 0 ? stats.markedNodes / eligibleNodes : 1;
+  stats.coverageRatioChars = eligibleChars > 0 ? stats.markedChars / eligibleChars : 1;
+}
+
+// src/utils/markerEngineScan.ts
+function considerTextNode(node, stats, segments, occurrences, seen, maxSegments, critical) {
+  const raw = node.nodeValue || "";
+  if (!raw) return;
+  const trimmed = raw.trim();
+  if (!trimmed) return;
+  stats.totalTextNodes += 1;
+  stats.totalChars += raw.length;
+  const parent = node.parentElement;
+  if (!parent) return;
+  if (isExcludedElement(parent)) {
+    stats.skippedExcludedNodes += 1;
+    stats.skippedExcludedChars += raw.length;
+    return;
+  }
+  const unsafe = findUnsafeContainer(parent);
+  if (unsafe) {
+    stats.skippedUnsafeNodes += 1;
+    stats.skippedUnsafeChars += raw.length;
+    return;
+  }
+  if (!isTranslatableText(trimmed)) {
+    stats.skippedNonTranslatableNodes += 1;
+    stats.skippedNonTranslatableChars += raw.length;
+    return;
+  }
+  const original = getOrInitTextOriginal(node, parent);
+  stats.markedNodes += 1;
+  stats.markedChars += raw.length;
+  if (segments.length < maxSegments) {
+    const originalText = normalizeWhitespace(original.trimmed) || null;
+    const currentText = normalizeWhitespace(node.nodeValue || "") || null;
+    segments.push({
+      kind: "text",
+      selector: buildSelector(parent),
+      original: originalText,
+      current: currentText,
+      html: null
+    });
+    if (originalText && !seen.has(originalText)) {
+      seen.add(originalText);
+      occurrences.push({ source_text: originalText, semantic_context: "text" });
+    }
+    if (critical?.enabled && originalText && !critical.seen.has(originalText)) {
+      const rect = getTextNodeRect(node);
+      if (isInViewport(rect, critical.viewportHeight, critical.bufferPx)) {
+        critical.seen.add(originalText);
+        critical.occurrences.push({ source_text: originalText, semantic_context: "critical:text" });
+      }
+    }
+  }
+}
+function considerAttributes(root, segments, occurrences, seen, maxSegments, critical) {
+  const nodes = root.querySelectorAll("[title],[aria-label],[placeholder]");
+  nodes.forEach((el) => {
+    if (isExcludedElement(el)) return;
+    if (findUnsafeContainer(el)) return;
+    for (const { attr } of ATTRIBUTE_MARKS) {
+      const value = el.getAttribute(attr);
+      if (!value) continue;
+      const trimmed = value.trim();
+      if (!trimmed || !isTranslatableText(trimmed)) continue;
+      const original = normalizeWhitespace(getOrInitAttrOriginal(el, attr)) || null;
+      const current = normalizeWhitespace(el.getAttribute(attr) || "") || null;
+      const kind = attr === "title" ? "title" : attr === "aria-label" ? "aria-label" : "placeholder";
+      if (segments.length < maxSegments) {
+        segments.push({
+          kind,
+          selector: buildSelector(el),
+          original,
+          current,
+          html: null
+        });
+      }
+      if (original && !seen.has(original)) {
+        seen.add(original);
+        occurrences.push({ source_text: original, semantic_context: `attr:${attr}` });
+      }
+      if (critical?.enabled && original && !critical.seen.has(original)) {
+        let rect = null;
+        try {
+          rect = el.getBoundingClientRect();
+        } catch {
+          rect = null;
+        }
+        if (isInViewport(rect, critical.viewportHeight, critical.bufferPx)) {
+          critical.seen.add(original);
+          critical.occurrences.push({ source_text: original, semantic_context: `critical:attr:${attr}` });
+        }
+      }
+    }
+  });
+}
+function scanDom(opts) {
+  const root = document.body;
+  if (!root) {
+    const empty = buildEmptyStats();
+    return { version: 1, stats: empty, segments: [], occurrences: [], truncated: false };
+  }
+  const stats = buildEmptyStats();
+  const maxSegments = Math.max(0, Math.floor(opts.maxSegments || 0)) || 2e4;
+  const includeCritical = opts.includeCritical === true;
+  const viewportHeight = includeCritical ? Math.max(0, Math.floor(window.innerHeight || 0)) : 0;
+  const viewportWidth = includeCritical ? Math.max(0, Math.floor(window.innerWidth || 0)) : 0;
+  const critical = includeCritical ? {
+    enabled: true,
+    viewportHeight,
+    bufferPx: DEFAULT_CRITICAL_BUFFER_PX,
+    max: DEFAULT_CRITICAL_MAX,
+    seen: /* @__PURE__ */ new Set(),
+    occurrences: []
+  } : null;
+  const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+  const nodes = [];
+  const segments = [];
+  const occurrences = [];
+  const seen = /* @__PURE__ */ new Set();
+  let node = walker.nextNode();
+  while (node) {
+    if (node.nodeType === Node.TEXT_NODE) nodes.push(node);
+    node = walker.nextNode();
+  }
+  nodes.forEach((textNode) => {
+    if (critical?.enabled && critical.occurrences.length >= critical.max) {
+      critical.enabled = false;
+    }
+    considerTextNode(textNode, stats, segments, occurrences, seen, maxSegments, critical);
+  });
+  considerAttributes(root, segments, occurrences, seen, maxSegments, critical);
+  finalizeStats(stats);
+  const truncated = segments.length >= maxSegments;
+  return {
+    version: 1,
+    stats,
+    segments,
+    occurrences,
+    ...includeCritical ? {
+      critical_occurrences: critical?.occurrences ?? [],
+      viewport: { width: viewportWidth, height: viewportHeight }
+    } : {},
+    truncated
+  };
+}
+
+// src/utils/markerEngineMisses.ts
+function scanDomForMisses(opts) {
+  const root = document.body;
+  const misses = [];
+  if (!root) {
+    return { misses };
+  }
+  const translationMap = getActiveTranslationMap();
+  const hasTranslations = Boolean(translationMap && translationMap.size > 0);
+  const max = Math.max(0, Math.floor(opts.max || 0));
+  if (max <= 0) return { misses };
+  const ignore = opts.ignore || /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
+  const recordMiss = (text, context) => {
+    if (!text || seen.has(text) || ignore.has(text)) return;
+    if (hasTranslations && translationMap.has(text)) return;
+    if (misses.length >= max) return;
+    seen.add(text);
+    misses.push({ source_text: text, semantic_context: context });
+  };
+  const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+  let node = walker.nextNode();
+  while (node && misses.length < max) {
+    if (node.nodeType !== Node.TEXT_NODE) {
+      node = walker.nextNode();
+      continue;
+    }
+    const textNode = node;
+    const parent = textNode.parentElement;
+    if (!parent || isExcludedElement(parent) || findUnsafeContainer(parent)) {
+      node = walker.nextNode();
+      continue;
+    }
+    const raw = textNode.nodeValue || "";
+    const trimmed = raw.trim();
+    if (!trimmed || !isTranslatableText(trimmed)) {
+      node = walker.nextNode();
+      continue;
+    }
+    const original = getOrInitTextOriginal(textNode, parent);
+    const key = normalizeWhitespace(original.trimmed);
+    if (key) {
+      recordMiss(key, "text");
+    }
+    node = walker.nextNode();
+  }
+  if (misses.length < max) {
+    const nodes = root.querySelectorAll("[title],[aria-label],[placeholder]");
+    nodes.forEach((el) => {
+      if (misses.length >= max) return;
+      if (isExcludedElement(el) || findUnsafeContainer(el)) return;
+      for (const { attr } of ATTRIBUTE_MARKS) {
+        if (misses.length >= max) break;
+        const value = el.getAttribute(attr);
+        if (!value) continue;
+        const trimmed = value.trim();
+        if (!trimmed || !isTranslatableText(trimmed)) continue;
+        const original = normalizeWhitespace(getOrInitAttrOriginal(el, attr));
+        if (!original) continue;
+        const context = attr === "title" ? "attr:title" : attr === "aria-label" ? "attr:aria-label" : "attr:placeholder";
+        recordMiss(original, context);
+      }
+    });
+  }
+  return { misses };
+}
+
+// src/utils/markerEngineTranslations.ts
+function setActiveTranslations(translations) {
+  if (!translations || translations.length === 0) {
+    setActiveTranslationMap(null);
+    return;
+  }
+  const map = /* @__PURE__ */ new Map();
+  for (const t of translations) {
+    const source = normalizeWhitespace((t?.source_text || "").toString());
+    const translated = (t?.translated_text ?? "").toString();
+    if (!source || !translated) continue;
+    map.set(source, translated);
+  }
+  setActiveTranslationMap(map);
+}
+function addActiveTranslations(translations) {
+  if (!translations) return 0;
+  const map = getActiveTranslationMap() ?? /* @__PURE__ */ new Map();
+  let added = 0;
+  if (Array.isArray(translations)) {
+    for (const t of translations) {
+      const source = normalizeWhitespace((t?.source_text || "").toString());
+      const translated = (t?.translated_text ?? "").toString();
+      if (!source || !translated) continue;
+      if (map.get(source) === translated) continue;
+      map.set(source, translated);
+      added += 1;
+    }
+  } else {
+    for (const [keyRaw, valueRaw] of Object.entries(translations || {})) {
+      const source = normalizeWhitespace((keyRaw || "").toString());
+      const translated = (valueRaw ?? "").toString();
+      if (!source || !translated) continue;
+      if (map.get(source) === translated) continue;
+      map.set(source, translated);
+      added += 1;
+    }
+  }
+  setActiveTranslationMap(map);
+  return added;
+}
+
+// src/utils/markerEngine.ts
+var observer = null;
+var scheduled = null;
+var running = false;
+var lastStats = buildEmptyStats();
+var throttleMs = DEFAULT_THROTTLE_MS;
+var applying = false;
+function scanDomWithGlobals(opts) {
+  const result = scanDom(opts);
+  setGlobalStats(result.stats);
+  return result;
+}
+function setGlobalStats(stats) {
+  lastStats = stats;
+  if (typeof window === "undefined") return;
+  window.__lovalingoMarkersReady = true;
+  window.__lovalingoMarkerStats = stats;
+  const g = window;
+  if (!g.__lovalingo) g.__lovalingo = {};
+  if (!g.__lovalingo.dom) g.__lovalingo.dom = {};
+  g.__lovalingo.dom.getStats = () => lastStats;
+  g.__lovalingo.dom.scan = () => scanDomWithGlobals({ maxSegments: 2e4, includeCritical: true });
+  g.__lovalingo.dom.getCriticalFingerprint = () => getCriticalFingerprint();
+  g.__lovalingo.dom.apply = (bundle) => ({ applied: applyTranslationMap(bundle, document.body) });
+  g.__lovalingo.dom.restore = () => restoreDom(document.body);
+}
+function scheduleScan() {
+  if (!running) return;
+  if (scheduled != null) return;
+  scheduled = window.setTimeout(() => {
+    scheduled = null;
+    try {
+      scanDomWithGlobals({ maxSegments: 2e4 });
+      if (getActiveTranslationMap()) {
+        applying = true;
+        applyActiveTranslations(document.body);
+      }
+    } finally {
+      applying = false;
+    }
+  }, throttleMs);
+}
+function startMarkerEngine(options = {}) {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return () => void 0;
+  }
+  stopMarkerEngine();
+  running = true;
+  throttleMs = Math.max(20, options.throttleMs ?? DEFAULT_THROTTLE_MS);
+  const startObserver = () => {
+    if (!running) return;
+    if (!document.body) {
+      window.setTimeout(startObserver, 50);
+      return;
+    }
+    observer = new MutationObserver(() => {
+      if (applying) return;
+      scheduleScan();
+    });
+    observer.observe(document.body, {
+      childList: true,
+      subtree: true,
+      characterData: true
+    });
+    scanDomWithGlobals({ maxSegments: 2e4 });
+  };
+  startObserver();
+  return stopMarkerEngine;
+}
+function stopMarkerEngine() {
+  running = false;
+  if (scheduled != null) {
+    window.clearTimeout(scheduled);
+    scheduled = null;
+  }
+  if (observer) {
+    observer.disconnect();
+    observer = null;
+  }
+}
+function setMarkerEngineExclusions(exclusions) {
+  if (!exclusions || exclusions.length === 0) {
+    setCustomExcludeSelector(null);
+    return;
+  }
+  const selectors = exclusions.filter((e) => e && e.type === "css" && typeof e.selector === "string" && e.selector.trim()).map((e) => e.selector.trim());
+  setCustomExcludeSelector(selectors.length ? selectors.join(",") : null);
+}
+
+// src/utils/nonLocalizedPaths.ts
+var GLOBAL_NON_LOCALIZED_APP_PATHS = /* @__PURE__ */ new Set(["/robots.txt", "/sitemap.xml"]);
+function isGlobalNonLocalizedPath(pathname) {
+  const input = (pathname || "").toString();
+  if (!input.startsWith("/")) return false;
+  if (GLOBAL_NON_LOCALIZED_APP_PATHS.has(input)) return true;
+  if (input.startsWith("/.well-known/")) return true;
+  return /\.(?:png|jpg|jpeg|gif|svg|webp|avif|ico|css|js|map|json|xml|txt|pdf|zip|gz|br|woff2?|ttf|eot)$/i.test(input);
+}
+function matchesNonLocalizedRules(pathname, rules) {
+  const input = (pathname || "").toString();
+  if (!input.startsWith("/")) return false;
+  if (!Array.isArray(rules) || rules.length === 0) return false;
+  for (const rule of rules) {
+    const pattern = typeof rule?.pattern === "string" ? rule.pattern : "";
+    const matchType = rule?.match_type;
+    if (!pattern) continue;
+    if (matchType === "exact") {
+      if (input === pattern) return true;
+      continue;
+    }
+    if (matchType === "prefix") {
+      if (input === pattern) return true;
+      const normalizedPrefix = pattern.endsWith("/") ? pattern.slice(0, -1) : pattern;
+      if (!normalizedPrefix || normalizedPrefix === "/") return true;
+      if (input.startsWith(`${normalizedPrefix}/`)) return true;
+      continue;
+    }
+    if (matchType === "regex") {
+      try {
+        if (new RegExp(pattern).test(input)) return true;
+      } catch {
+      }
+    }
+  }
+  return false;
+}
+function isNonLocalizedPath(pathname, rules) {
+  return isGlobalNonLocalizedPath(pathname) || matchesNonLocalizedRules(pathname, rules);
+}
+function stripLocalePrefix(pathname, locales) {
+  const input = (pathname || "").toString();
+  if (!input.startsWith("/")) return input;
+  const parts = input.split("/").filter(Boolean);
+  if (parts.length === 0) return "/";
+  const first = parts[0] || "";
+  if (!first || !Array.isArray(locales) || !locales.includes(first)) return input;
+  const rest = `/${parts.slice(1).join("/")}`;
+  return rest === "" ? "/" : rest;
+}
+
+// src/utils/pathNormalizer.ts
+var UUID_PATTERN = /[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}/gi;
+var NUMERIC_ID_PATTERN = /\/\d+(?=\/|$)/g;
+var HASH_PATTERN = /\/[a-f0-9]{32,}(?=\/|$)/gi;
+var ALPHANUMERIC_ID_PATTERN = /\/[a-z0-9]{20,}(?=\/|$)/gi;
+function normalizePath(path, config) {
+  if (config?.enabled === false) {
+    return path;
+  }
+  let normalized = path;
+  let shouldIncludeSubpaths = false;
+  normalized = normalized.replace(UUID_PATTERN, ":id");
+  normalized = normalized.replace(HASH_PATTERN, ":hash");
+  normalized = normalized.replace(ALPHANUMERIC_ID_PATTERN, ":id");
+  normalized = normalized.replace(NUMERIC_ID_PATTERN, "/:id");
+  if (config?.rules) {
+    for (const rule of config.rules) {
+      try {
+        const regex = new RegExp(rule.pattern, "gi");
+        const beforeReplace = normalized;
+        normalized = normalized.replace(regex, rule.replacement);
+        if (beforeReplace !== normalized && rule.includeSubpaths) {
+          shouldIncludeSubpaths = true;
+        }
+      } catch (error) {
+        warnDebug("[PathNormalizer] Invalid pattern:", rule.pattern, error);
+      }
+    }
+  }
+  normalized = normalized.replace(/\/:id(\/):id/g, "/:id$1*");
+  if (shouldIncludeSubpaths) {
+    const placeholderMatch = normalized.match(/(:[a-z]+)/);
+    if (placeholderMatch) {
+      const placeholderIndex = normalized.indexOf(placeholderMatch[0]);
+      const beforePlaceholder = normalized.substring(0, placeholderIndex + placeholderMatch[0].length);
+      normalized = beforePlaceholder + "/*";
+    }
+  }
+  return normalized;
+}
+function cleanPath(path, supportedLocales) {
+  let cleaned = path;
+  if (supportedLocales && supportedLocales.length > 0) {
+    const segments = cleaned.split("/").filter(Boolean);
+    if (segments.length > 0 && supportedLocales.includes(segments[0])) {
+      cleaned = "/" + segments.slice(1).join("/");
+      if (cleaned === "") cleaned = "/";
+    }
+  }
+  if (cleaned !== "/" && cleaned.endsWith("/")) {
+    cleaned = cleaned.slice(0, -1);
+  }
+  return cleaned;
+}
+function processPath(path, config) {
+  const cleaned = cleanPath(path, config?.supportedLocales);
+  const normalized = normalizePath(cleaned, config);
+  return normalized;
+}
+
+// src/hooks/provider/useBundleLoading.ts
+var import_react5 = require("react");
+
+// src/utils/mergeEntitlements.ts
+function mergeEntitlementsSeoEnabled(entitlements, seoEnabled) {
+  if (!entitlements) return null;
+  if (typeof seoEnabled !== "boolean") return entitlements;
+  return { ...entitlements, seoEnabled };
+}
+
+// src/hooks/provider/useDomRules.ts
+var import_react3 = require("react");
+
+// src/utils/domRules.ts
+var DEFAULT_MATCH_SELECTOR = 'button,a,label,summary,[role="button"],[role="link"],[role="tab"]';
+function ensureStyleTag(id, css) {
+  const existing = document.querySelector(`style[data-lovalingo-rule="${id}"]`);
+  if (existing) return;
+  const style = document.createElement("style");
+  style.setAttribute("data-lovalingo-rule", id);
+  style.textContent = css;
+  document.head.appendChild(style);
+}
+function ensureScriptTag(id, script) {
+  const existing = document.querySelector(`script[data-lovalingo-rule="${id}"]`);
+  if (existing) return;
+  const el = document.createElement("script");
+  el.setAttribute("data-lovalingo-rule", id);
+  el.textContent = script;
+  document.head.appendChild(el);
+}
+function shouldSkipElement(el, ruleId) {
+  return el.hasAttribute(`data-lovalingo-rule-${ruleId}`);
+}
+function markElement(el, ruleId) {
+  el.setAttribute(`data-lovalingo-rule-${ruleId}`, "1");
+}
+function collectElements(rule, matchText) {
+  if (rule.selector) return Array.from(document.querySelectorAll(rule.selector));
+  if (matchText) return Array.from(document.querySelectorAll(DEFAULT_MATCH_SELECTOR));
+  return [];
+}
+function applyDomRules(rules) {
+  if (!Array.isArray(rules) || rules.length === 0) return 0;
+  let applied = 0;
+  for (const rule of rules) {
+    if (!rule || !rule.id) continue;
+    const payload = rule.payload || {};
+    const matchText = payload.matchText?.trim() || null;
+    switch (rule.rule_type) {
+      case "css": {
+        const css = payload.css || "";
+        if (css.trim().length > 0) {
+          ensureStyleTag(rule.id, css);
+          applied += 1;
+        }
+        break;
+      }
+      case "script": {
+        const script = payload.script || "";
+        if (script.trim().length > 0) {
+          ensureScriptTag(rule.id, script);
+          applied += 1;
+        }
+        break;
+      }
+      case "remove": {
+        const elements = collectElements(rule, matchText);
+        for (const el of elements) {
+          if (shouldSkipElement(el, rule.id)) continue;
+          el.remove();
+          applied += 1;
+        }
+        break;
+      }
+      case "add_class": {
+        const className = payload.className || payload.value || "";
+        if (!className.trim()) break;
+        const elements = collectElements(rule, matchText);
+        for (const el of elements) {
+          if (shouldSkipElement(el, rule.id)) continue;
+          if (matchText) {
+            const current = (el.textContent || "").trim();
+            if (current !== matchText) continue;
+          }
+          className.split(/\s+/).forEach((cls) => cls && el.classList.add(cls));
+          markElement(el, rule.id);
+          applied += 1;
+        }
+        break;
+      }
+      case "set_attribute": {
+        const attribute = payload.attribute || "";
+        const value = payload.value || payload.text || "";
+        if (!attribute || !value) break;
+        const elements = collectElements(rule, matchText);
+        for (const el of elements) {
+          if (shouldSkipElement(el, rule.id)) continue;
+          if (matchText) {
+            const current = (el.textContent || "").trim();
+            if (current !== matchText) continue;
+          }
+          el.setAttribute(attribute, value);
+          markElement(el, rule.id);
+          applied += 1;
+        }
+        break;
+      }
+      case "set_html": {
+        const html = payload.html || "";
+        if (!html) break;
+        const elements = collectElements(rule, matchText);
+        for (const el of elements) {
+          if (shouldSkipElement(el, rule.id)) continue;
+          if (matchText) {
+            const current = (el.textContent || "").trim();
+            if (current !== matchText) continue;
+          }
+          el.innerHTML = html;
+          markElement(el, rule.id);
+          applied += 1;
+        }
+        break;
+      }
+      case "replace_text":
+      default: {
+        const replacement = payload.text || payload.value || "";
+        if (!replacement) break;
+        const elements = collectElements(rule, matchText);
+        for (const el of elements) {
+          if (shouldSkipElement(el, rule.id)) continue;
+          if (matchText) {
+            const current = (el.textContent || "").trim();
+            if (current !== matchText) continue;
+          }
+          el.textContent = replacement;
+          markElement(el, rule.id);
+          applied += 1;
+        }
+        break;
+      }
+    }
+  }
+  return applied;
+}
+
+// src/hooks/provider/useDomRules.ts
+function useDomRules({ apiRef, autoApplyRules }) {
+  const domRulesCacheRef = (0, import_react3.useRef)(/* @__PURE__ */ new Map());
+  const getCachedDomRules = (0, import_react3.useCallback)((cacheKey) => {
+    return domRulesCacheRef.current.get(cacheKey);
+  }, []);
+  const applyCachedDomRules = (0, import_react3.useCallback)(
+    (cacheKey, fallbackRules) => {
+      if (!autoApplyRules) return 0;
+      const rules = domRulesCacheRef.current.get(cacheKey) || fallbackRules || [];
+      return applyDomRules(rules);
+    },
+    [autoApplyRules]
+  );
+  const setCachedDomRules = (0, import_react3.useCallback)((cacheKey, rules) => {
+    domRulesCacheRef.current.set(cacheKey, rules);
+  }, []);
+  const setAndApplyDomRules = (0, import_react3.useCallback)(
+    (cacheKey, rules) => {
+      domRulesCacheRef.current.set(cacheKey, rules);
+      if (!autoApplyRules) return 0;
+      return applyDomRules(rules);
+    },
+    [autoApplyRules]
+  );
+  const fetchAndApplyDomRules = (0, import_react3.useCallback)(
+    async (cacheKey, targetLocale) => {
+      if (!autoApplyRules) return [];
+      const rules = await apiRef.current.fetchDomRules(targetLocale);
+      domRulesCacheRef.current.set(cacheKey, rules);
+      applyDomRules(rules);
+      return rules;
+    },
+    [apiRef, autoApplyRules]
+  );
+  return {
+    applyCachedDomRules,
+    fetchAndApplyDomRules,
+    getCachedDomRules,
+    setAndApplyDomRules,
+    setCachedDomRules
+  };
+}
+
+// src/hooks/provider/usePrehide.ts
+var import_react4 = require("react");
+var PREHIDE_FAILSAFE_MS = 900;
+function usePrehide() {
+  const prehideStateRef = (0, import_react4.useRef)({
+    active: false,
+    timeoutId: null,
+    startedAtMs: null,
+    prevHtmlVisibility: "",
+    prevBodyVisibility: "",
+    prevHtmlBg: "",
+    prevBodyBg: ""
+  });
+  const forceDisablePrehide = (0, import_react4.useCallback)(() => {
+    if (typeof document === "undefined") return;
+    const html = document.documentElement;
+    const body = document.body;
+    if (!html || !body) return;
+    const state = prehideStateRef.current;
+    if (state.timeoutId != null) {
+      window.clearTimeout(state.timeoutId);
+      state.timeoutId = null;
+    }
+    if (!state.active) return;
+    state.active = false;
+    state.startedAtMs = null;
+    html.style.visibility = state.prevHtmlVisibility;
+    body.style.visibility = state.prevBodyVisibility;
+    html.style.backgroundColor = state.prevHtmlBg;
+    body.style.backgroundColor = state.prevBodyBg;
+  }, []);
+  const enablePrehide = (0, import_react4.useCallback)(
+    (bgColor) => {
+      if (typeof document === "undefined") return;
+      const html = document.documentElement;
+      const body = document.body;
+      if (!html || !body) return;
+      const state = prehideStateRef.current;
+      if (state.active && state.startedAtMs != null && Date.now() - state.startedAtMs > PREHIDE_FAILSAFE_MS * 3) {
+        forceDisablePrehide();
+      }
+      if (!state.active) {
+        state.active = true;
+        state.startedAtMs = Date.now();
+        state.prevHtmlVisibility = html.style.visibility || "";
+        state.prevBodyVisibility = body.style.visibility || "";
+        state.prevHtmlBg = html.style.backgroundColor || "";
+        state.prevBodyBg = body.style.backgroundColor || "";
+      }
+      html.style.visibility = "hidden";
+      body.style.visibility = "hidden";
+      if (bgColor) {
+        html.style.backgroundColor = bgColor;
+        body.style.backgroundColor = bgColor;
+      }
+      if (state.timeoutId != null) {
+        return;
+      }
+      state.timeoutId = window.setTimeout(() => forceDisablePrehide(), PREHIDE_FAILSAFE_MS);
+    },
+    [forceDisablePrehide]
+  );
+  const disablePrehide = forceDisablePrehide;
+  (0, import_react4.useEffect)(() => {
+    return () => disablePrehide();
+  }, [disablePrehide]);
+  return { enablePrehide, disablePrehide };
+}
+
+// src/hooks/provider/useBundleLoading.ts
+var CRITICAL_CACHE_PREFIX = "Lovalingo_critical_v0_3";
+function useBundleLoading({
+  apiRef,
+  resolvedApiKey,
+  defaultLocale,
+  routing,
+  allLocales,
+  nonLocalizedPaths,
+  enhancedPathConfig,
+  mode,
+  autoApplyRules,
+  seoProp,
+  isSeoActive,
+  applySeoBundle: applySeoBundle2,
+  setEntitlements,
+  setBrandingEnabled,
+  setCachedBrandingEnabled,
+  setCachedLoadingBgColor,
+  getCachedLoadingBgColor
+}) {
+  const [isLoading, setIsLoading] = (0, import_react5.useState)(false);
+  const retryTimeoutRef = (0, import_react5.useRef)(null);
+  const loadingFailsafeTimeoutRef = (0, import_react5.useRef)(null);
+  const isNavigatingRef = (0, import_react5.useRef)(false);
+  const inFlightLoadKeyRef = (0, import_react5.useRef)(null);
+  const translationCacheRef = (0, import_react5.useRef)(/* @__PURE__ */ new Map());
+  const exclusionsCacheRef = (0, import_react5.useRef)(null);
+  const { enablePrehide, disablePrehide } = usePrehide();
+  const { applyCachedDomRules, fetchAndApplyDomRules, getCachedDomRules, setAndApplyDomRules } = useDomRules({
+    apiRef,
+    autoApplyRules
+  });
+  const buildCriticalCacheKey = (0, import_react5.useCallback)(
+    (targetLocale, normalizedPath) => {
+      const key = `${resolvedApiKey || "anonymous"}:${targetLocale}:${normalizedPath || "/"}`;
+      return `${CRITICAL_CACHE_PREFIX}:${hashContent(key)}`;
+    },
+    [resolvedApiKey]
+  );
+  const readCriticalCache = (0, import_react5.useCallback)(
+    (targetLocale, normalizedPath) => {
+      const key = buildCriticalCacheKey(targetLocale, normalizedPath);
+      try {
+        const raw = localStorage.getItem(key);
+        if (!raw) return null;
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object") return null;
+        const record = parsed;
+        const map = record.map && typeof record.map === "object" && !Array.isArray(record.map) ? record.map : null;
+        const exclusionsRaw = Array.isArray(record.exclusions) ? record.exclusions : [];
+        const exclusions = exclusionsRaw.map((row) => {
+          if (!row || typeof row !== "object") return null;
+          const r = row;
+          const selector = typeof r.selector === "string" ? r.selector.trim() : "";
+          const type = typeof r.type === "string" ? r.type.trim() : "";
+          if (!selector) return null;
+          if (type !== "css" && type !== "xpath") return null;
+          return { selector, type };
+        }).filter(Boolean);
+        const bg = typeof record.loading_bg_color === "string" ? record.loading_bg_color.trim() : "";
+        return {
+          map: map || {},
+          exclusions,
+          loading_bg_color: /^#[0-9a-fA-F]{6}$/.test(bg) ? bg : null
+        };
+      } catch {
+        return null;
+      }
+    },
+    [buildCriticalCacheKey]
+  );
+  const writeCriticalCache = (0, import_react5.useCallback)(
+    (targetLocale, normalizedPath, entry) => {
+      const key = buildCriticalCacheKey(targetLocale, normalizedPath);
+      try {
+        localStorage.setItem(
+          key,
+          JSON.stringify({
+            stored_at: Date.now(),
+            map: entry.map || {},
+            exclusions: entry.exclusions || [],
+            loading_bg_color: entry.loading_bg_color
+          })
+        );
+      } catch {
+      }
+    },
+    [buildCriticalCacheKey]
+  );
+  const toTranslations = (0, import_react5.useCallback)(
+    (map, targetLocale) => {
+      const out = [];
+      for (const [source_text, translated_text] of Object.entries(map || {})) {
+        if (!source_text || !translated_text) continue;
+        out.push({
+          source_text,
+          translated_text,
+          source_locale: defaultLocale,
+          target_locale: targetLocale
+        });
+      }
+      return out;
+    },
+    [defaultLocale]
+  );
+  const loadData = (0, import_react5.useCallback)(
+    async (targetLocale, previousLocale) => {
+      if (retryTimeoutRef.current) {
+        clearTimeout(retryTimeoutRef.current);
+        retryTimeoutRef.current = null;
+      }
+      if (loadingFailsafeTimeoutRef.current != null) {
+        window.clearTimeout(loadingFailsafeTimeoutRef.current);
+        loadingFailsafeTimeoutRef.current = null;
+      }
+      if (targetLocale === defaultLocale) {
+        disablePrehide();
+        setActiveTranslations(null);
+        restoreDom(document.body);
+        isNavigatingRef.current = false;
+        return;
+      }
+      if (routing === "path") {
+        const stripped = stripLocalePrefix(window.location.pathname, allLocales);
+        if (isNonLocalizedPath(stripped, nonLocalizedPaths)) {
+          disablePrehide();
+          setActiveTranslations(null);
+          restoreDom(document.body);
+          isNavigatingRef.current = false;
+          return;
+        }
+      }
+      const currentPath = window.location.pathname + window.location.search;
+      const normalizedPath = processPath(window.location.pathname, enhancedPathConfig);
+      const cacheKey = `${targetLocale}:${normalizedPath}`;
+      if (inFlightLoadKeyRef.current === cacheKey) {
+        return;
+      }
+      inFlightLoadKeyRef.current = cacheKey;
+      const cachedEntry = translationCacheRef.current.get(cacheKey);
+      const cachedExclusions = exclusionsCacheRef.current;
+      const cachedDomRules = getCachedDomRules(cacheKey);
+      if (cachedEntry && cachedExclusions) {
+        logDebug(`[Lovalingo] Using cached translations for ${targetLocale} on ${normalizedPath}`);
+        enablePrehide(getCachedLoadingBgColor());
+        setActiveTranslations(cachedEntry.translations);
+        setMarkerEngineExclusions(cachedExclusions);
+        if (mode === "dom") {
+          applyActiveTranslations(document.body);
+        }
+        if (autoApplyRules) {
+          applyCachedDomRules(cacheKey, cachedDomRules);
+          void fetchAndApplyDomRules(cacheKey, targetLocale);
+        }
+        retryTimeoutRef.current = setTimeout(() => {
+          if (isNavigatingRef.current) {
+            return;
+          }
+          logDebug(`[Lovalingo] \u{1F504} Retry scan for late-rendering content`);
+          if (mode === "dom") {
+            applyActiveTranslations(document.body);
+          }
+          if (autoApplyRules) {
+            applyCachedDomRules(cacheKey, cachedDomRules);
+          }
+        }, 500);
+        disablePrehide();
+        isNavigatingRef.current = false;
+        if (inFlightLoadKeyRef.current === cacheKey) {
+          inFlightLoadKeyRef.current = null;
+        }
+        return;
+      }
+      logDebug(`[Lovalingo] Fetching translations for ${targetLocale} on ${normalizedPath}`);
+      setIsLoading(true);
+      enablePrehide(getCachedLoadingBgColor());
+      let revealedEarly = false;
+      const revealNow = () => {
+        if (revealedEarly) return;
+        revealedEarly = true;
+        disablePrehide();
+        setIsLoading(false);
+        if (loadingFailsafeTimeoutRef.current != null) {
+          window.clearTimeout(loadingFailsafeTimeoutRef.current);
+          loadingFailsafeTimeoutRef.current = null;
+        }
+      };
+      loadingFailsafeTimeoutRef.current = window.setTimeout(() => {
+        disablePrehide();
+        setIsLoading(false);
+      }, PREHIDE_FAILSAFE_MS);
+      try {
+        if (previousLocale && previousLocale !== defaultLocale) {
+          logDebug(`[Lovalingo] Switching from ${previousLocale} to ${targetLocale}`);
+        }
+        let revealedViaCachedCritical = false;
+        const cachedCritical = readCriticalCache(targetLocale, normalizedPath);
+        if (cachedCritical?.loading_bg_color) {
+          setCachedLoadingBgColor(cachedCritical.loading_bg_color);
+          enablePrehide(cachedCritical.loading_bg_color);
+        }
+        if (cachedCritical?.exclusions && cachedCritical.exclusions.length > 0) {
+          exclusionsCacheRef.current = cachedCritical.exclusions;
+          setMarkerEngineExclusions(cachedCritical.exclusions);
+        }
+        if (cachedCritical?.map && Object.keys(cachedCritical.map).length > 0) {
+          setActiveTranslations(toTranslations(cachedCritical.map, targetLocale));
+          if (mode === "dom") {
+            applyActiveTranslations(document.body);
+          }
+          revealNow();
+          revealedViaCachedCritical = true;
+        }
+        const bootstrap = await apiRef.current.fetchBootstrap(targetLocale, currentPath);
+        const entitlementsBase = bootstrap?.entitlements || apiRef.current.getEntitlements();
+        const nextEntitlements = mergeEntitlementsSeoEnabled(entitlementsBase, bootstrap?.seoEnabled);
+        if (nextEntitlements) setEntitlements(nextEntitlements);
+        if (bootstrap?.loading_bg_color) {
+          setCachedLoadingBgColor(bootstrap.loading_bg_color);
+          enablePrehide(bootstrap.loading_bg_color);
+        }
+        if ((bootstrap?.entitlements || nextEntitlements)?.brandingRequired) {
+          setBrandingEnabled(true);
+          setCachedBrandingEnabled(true);
+        } else if (typeof bootstrap?.branding_enabled === "boolean") {
+          setBrandingEnabled(bootstrap.branding_enabled);
+          setCachedBrandingEnabled(bootstrap.branding_enabled);
+        }
+        const exclusions = Array.isArray(bootstrap?.exclusions) ? bootstrap.exclusions.map((row) => {
+          if (!row || typeof row !== "object") return null;
+          const r = row;
+          const selector = typeof r.selector === "string" ? r.selector.trim() : "";
+          const type = typeof r.type === "string" ? r.type.trim() : "";
+          if (!selector) return null;
+          if (type !== "css" && type !== "xpath") return null;
+          return { selector, type };
+        }).filter(Boolean) : await apiRef.current.fetchExclusions();
+        exclusionsCacheRef.current = exclusions;
+        setMarkerEngineExclusions(exclusions);
+        const criticalMap = bootstrap?.critical?.map && typeof bootstrap.critical.map === "object" && !Array.isArray(bootstrap.critical.map) ? bootstrap.critical.map : {};
+        const hasBootstrapCritical = Object.keys(criticalMap).length > 0;
+        if (Object.keys(criticalMap).length > 0) {
+          setActiveTranslations(toTranslations(criticalMap, targetLocale));
+          if (mode === "dom") {
+            applyActiveTranslations(document.body);
+          }
+          revealNow();
+        }
+        if (autoApplyRules) {
+          const bootstrapDomRules = bootstrap?.dom_rules;
+          const domRules = Array.isArray(bootstrapDomRules) ? bootstrapDomRules : await apiRef.current.fetchDomRules(targetLocale);
+          setAndApplyDomRules(cacheKey, domRules);
+        }
+        let seoActiveForBootstrap = isSeoActive();
+        if (seoProp === false) {
+          seoActiveForBootstrap = false;
+        } else if (typeof bootstrap?.seoEnabled === "boolean") {
+          seoActiveForBootstrap = bootstrap.seoEnabled !== false;
+        } else if (typeof nextEntitlements?.seoEnabled === "boolean") {
+          seoActiveForBootstrap = nextEntitlements.seoEnabled !== false;
+        }
+        if (seoActiveForBootstrap && bootstrap) {
+          const hreflangEnabled = Boolean((bootstrap.entitlements || nextEntitlements)?.hreflangEnabled);
+          applySeoBundle2({ seo: bootstrap.seo, alternates: bootstrap.alternates, jsonld: bootstrap.jsonld }, hreflangEnabled);
+        }
+        writeCriticalCache(targetLocale, normalizedPath, {
+          map: criticalMap,
+          exclusions,
+          loading_bg_color: bootstrap?.loading_bg_color && /^#[0-9a-fA-F]{6}$/.test(bootstrap.loading_bg_color) ? bootstrap.loading_bg_color : null
+        });
+        const shouldWaitForBundle = !revealedViaCachedCritical && !hasBootstrapCritical;
+        if (shouldWaitForBundle) {
+          const bundle = await apiRef.current.fetchBundle(targetLocale, currentPath);
+          if (bundle?.map && typeof bundle.map === "object") {
+            const translations = toTranslations(bundle.map, targetLocale);
+            if (translations.length > 0) {
+              translationCacheRef.current.set(cacheKey, { translations });
+              setActiveTranslations(translations);
+              if (mode === "dom") {
+                applyActiveTranslations(document.body);
+              }
+            }
+          }
+        } else {
+          void (async () => {
+            const bundle = await apiRef.current.fetchBundle(targetLocale, currentPath);
+            if (!bundle || !bundle.map) return;
+            const translations = toTranslations(bundle.map, targetLocale);
+            if (translations.length === 0) return;
+            translationCacheRef.current.set(cacheKey, { translations });
+            setActiveTranslations(translations);
+            if (mode === "dom") {
+              applyActiveTranslations(document.body);
+            }
+          })();
+        }
+        revealNow();
+        retryTimeoutRef.current = setTimeout(() => {
+          if (isNavigatingRef.current) {
+            return;
+          }
+          logDebug(`[Lovalingo] \u{1F504} Retry scan for late-rendering content`);
+          if (mode === "dom") {
+            applyActiveTranslations(document.body);
+          }
+          if (autoApplyRules) {
+            applyCachedDomRules(cacheKey);
+          }
+        }, 500);
+      } catch (error) {
+        errorDebug("Error loading translations:", error);
+        disablePrehide();
+      } finally {
+        setIsLoading(false);
+        if (loadingFailsafeTimeoutRef.current != null) {
+          window.clearTimeout(loadingFailsafeTimeoutRef.current);
+          loadingFailsafeTimeoutRef.current = null;
+        }
+        isNavigatingRef.current = false;
+        if (inFlightLoadKeyRef.current === cacheKey) {
+          inFlightLoadKeyRef.current = null;
+        }
+      }
+    },
+    [
+      allLocales,
+      applyCachedDomRules,
+      applySeoBundle2,
+      autoApplyRules,
+      defaultLocale,
+      disablePrehide,
+      enablePrehide,
+      enhancedPathConfig,
+      fetchAndApplyDomRules,
+      getCachedDomRules,
+      getCachedLoadingBgColor,
+      isSeoActive,
+      mode,
+      nonLocalizedPaths,
+      readCriticalCache,
+      routing,
+      setAndApplyDomRules,
+      setBrandingEnabled,
+      setCachedBrandingEnabled,
+      setCachedLoadingBgColor,
+      setEntitlements,
+      toTranslations,
+      writeCriticalCache
+    ]
+  );
+  (0, import_react5.useEffect)(() => {
+    return () => {
+      if (retryTimeoutRef.current) clearTimeout(retryTimeoutRef.current);
+      if (loadingFailsafeTimeoutRef.current != null) window.clearTimeout(loadingFailsafeTimeoutRef.current);
+    };
+  }, []);
+  return { isLoading, isNavigatingRef, loadData };
+}
+
+// src/hooks/provider/useNavigationPrefetch.ts
+var import_react6 = require("react");
+function useNavigationPrefetch({
+  resolvedApiKey,
+  apiBase,
+  defaultLocale,
+  locale,
+  routing,
+  allLocales,
+  enhancedPathConfig
+}) {
+  (0, import_react6.useEffect)(() => {
+    if (!resolvedApiKey) return;
+    if (typeof window === "undefined" || typeof document === "undefined") return;
+    const connection = navigator?.connection;
+    if (connection?.saveData) return;
+    if (typeof connection?.effectiveType === "string" && /(^|-)2g$/.test(connection.effectiveType)) return;
+    const prefetched = /* @__PURE__ */ new Set();
+    const maxPrefetch = 40;
+    const isAssetPath = (pathname) => {
+      if (pathname === "/robots.txt" || pathname === "/sitemap.xml") return true;
+      if (pathname.startsWith("/.well-known/")) return true;
+      return /\.(?:png|jpg|jpeg|gif|svg|webp|avif|ico|css|js|map|json|xml|txt|pdf|zip|gz|br|woff2?|ttf|eot)$/i.test(pathname);
+    };
+    const pickLocaleForUrl = (url) => {
+      if (routing === "path") {
+        const segment = url.pathname.split("/")[1] || "";
+        if (segment && allLocales.includes(segment)) return segment;
+        return locale;
+      }
+      const q = url.searchParams.get("t") || url.searchParams.get("locale");
+      if (q && allLocales.includes(q)) return q;
+      return locale;
+    };
+    const onIntent = (event) => {
+      if (prefetched.size >= maxPrefetch) return;
+      const target = event.target;
+      const anchor = target?.closest?.("a[href]");
+      if (!anchor) return;
+      const href = anchor.getAttribute("href") || "";
+      if (!href || /^(?:#|mailto:|tel:|sms:|javascript:)/i.test(href)) return;
+      let url;
+      try {
+        url = new URL(href, window.location.origin);
+      } catch {
+        return;
+      }
+      if (url.origin !== window.location.origin) return;
+      if (isAssetPath(url.pathname)) return;
+      const targetLocale = pickLocaleForUrl(url);
+      if (!targetLocale || targetLocale === defaultLocale) return;
+      const normalizedPath = processPath(url.pathname, enhancedPathConfig);
+      const key = `${targetLocale}:${normalizedPath}`;
+      if (prefetched.has(key)) return;
+      prefetched.add(key);
+      const pathParam = `${url.pathname}${url.search}`;
+      const bootstrapUrl = `${apiBase}/functions/v1/bootstrap?key=${encodeURIComponent(resolvedApiKey)}&locale=${encodeURIComponent(targetLocale)}&path=${encodeURIComponent(pathParam)}`;
+      const bundleUrl = `${apiBase}/functions/v1/bundle?key=${encodeURIComponent(resolvedApiKey)}&locale=${encodeURIComponent(targetLocale)}&path=${encodeURIComponent(pathParam)}&scoped=1`;
+      void fetch(bootstrapUrl, { cache: "force-cache" }).catch(() => void 0);
+      void fetch(bundleUrl, { cache: "force-cache" }).catch(() => void 0);
+    };
+    document.addEventListener("pointerover", onIntent, { passive: true });
+    document.addEventListener("touchstart", onIntent, { passive: true });
+    document.addEventListener("focusin", onIntent);
+    return () => {
+      document.removeEventListener("pointerover", onIntent);
+      document.removeEventListener("touchstart", onIntent);
+      document.removeEventListener("focusin", onIntent);
+    };
+  }, [allLocales, apiBase, defaultLocale, enhancedPathConfig, locale, resolvedApiKey, routing]);
+}
+
+// src/hooks/provider/useLinkAutoPrefix.ts
+var import_react7 = require("react");
+function useLinkAutoPrefix({
+  routing,
+  autoPrefixLinks,
+  allLocales,
+  locale,
+  navigateRef,
+  nonLocalizedPaths
+}) {
+  (0, import_react7.useEffect)(() => {
+    if (routing !== "path") return;
+    if (!autoPrefixLinks) return;
+    const supportedLocales = allLocales;
+    const shouldProcessCurrentPath = () => {
+      const parts = window.location.pathname.split("/").filter(Boolean);
+      return parts.length > 0 && supportedLocales.includes(parts[0]);
+    };
+    const buildLocalePrefixedPath = (rawHref) => {
+      if (!rawHref) return null;
+      const trimmed = rawHref.trim();
+      if (!trimmed) return null;
+      const isAbsolutePath = trimmed.startsWith("/");
+      const isAbsoluteUrl = /^https?:\/\//i.test(trimmed) || trimmed.startsWith("//");
+      if (!isAbsolutePath && !isAbsoluteUrl) return null;
+      if (/^(?:#|mailto:|tel:|sms:|javascript:)/i.test(trimmed)) return null;
+      let url;
+      try {
+        url = new URL(trimmed, window.location.origin);
+      } catch {
+        return null;
+      }
+      if (url.origin !== window.location.origin) return null;
+      if (isNonLocalizedPath(url.pathname, nonLocalizedPaths)) return null;
+      const parts = url.pathname.split("/").filter(Boolean);
+      if (parts.length === 0) {
+        return `/${locale}${url.search}${url.hash}`;
+      }
+      if (supportedLocales.includes(parts[0])) return null;
+      const pathWithoutLeadingSlashes = url.pathname.replace(/^\/+/, "");
+      const nextPathname = pathWithoutLeadingSlashes ? `/${locale}/${pathWithoutLeadingSlashes}` : `/${locale}`;
+      return `${nextPathname}${url.search}${url.hash}`;
+    };
+    const ORIGINAL_HREF_KEY = "data-Lovalingo-href-original";
+    const patchAnchor = (a) => {
+      if (!a || a.hasAttribute("data-Lovalingo-exclude")) return;
+      const original = a.getAttribute(ORIGINAL_HREF_KEY) ?? a.getAttribute("href") ?? "";
+      if (!a.getAttribute(ORIGINAL_HREF_KEY) && original) {
+        a.setAttribute(ORIGINAL_HREF_KEY, original);
+      }
+      const fixed = buildLocalePrefixedPath(original);
+      if (fixed) {
+        if (a.getAttribute("href") !== fixed) a.setAttribute("href", fixed);
+      } else if (original) {
+        if (a.getAttribute("href") !== original) a.setAttribute("href", original);
+      }
+    };
+    const patchAllAnchors = () => {
+      if (!shouldProcessCurrentPath()) return;
+      document.querySelectorAll("a[href]").forEach((node) => {
+        if (node instanceof HTMLAnchorElement) patchAnchor(node);
+      });
+    };
+    patchAllAnchors();
+    const mo = new MutationObserver((mutations) => {
+      if (!shouldProcessCurrentPath()) return;
+      for (const mutation of mutations) {
+        mutation.addedNodes.forEach((node) => {
+          if (!(node instanceof HTMLElement)) return;
+          if (node instanceof HTMLAnchorElement) {
+            patchAnchor(node);
+            return;
+          }
+          node.querySelectorAll?.("a[href]").forEach((a) => {
+            if (a instanceof HTMLAnchorElement) patchAnchor(a);
+          });
+        });
+      }
+    });
+    mo.observe(document.body, { childList: true, subtree: true });
+    const onClickCapture = (event) => {
+      if (!shouldProcessCurrentPath()) return;
+      if (event.defaultPrevented) return;
+      if (event.button !== 0) return;
+      if (event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return;
+      const target = event.target;
+      const a = target?.closest?.("a[href]");
+      if (!a) return;
+      if (a.target && a.target !== "_self") return;
+      if (a.hasAttribute("download")) return;
+      if (a.getAttribute("rel")?.includes("external")) return;
+      const original = a.getAttribute(ORIGINAL_HREF_KEY) ?? a.getAttribute("href") ?? "";
+      const fixed = buildLocalePrefixedPath(original);
+      if (!fixed) return;
+      event.preventDefault();
+      event.stopImmediatePropagation();
+      event.stopPropagation();
+      const navigate = navigateRef?.current;
+      if (navigate) {
+        navigate(fixed);
+      } else {
+        window.location.assign(fixed);
+      }
+    };
+    document.addEventListener("click", onClickCapture, true);
+    return () => {
+      mo.disconnect();
+      document.removeEventListener("click", onClickCapture, true);
+    };
+  }, [routing, autoPrefixLinks, allLocales, locale, navigateRef, nonLocalizedPaths]);
+}
+
+// src/hooks/provider/usePageviewTracking.ts
+var import_react8 = require("react");
+function usePageviewTracking({ apiRef, resolvedApiKey }) {
+  const lastPageviewRef = (0, import_react8.useRef)("");
+  const lastPageviewFingerprintRef = (0, import_react8.useRef)("");
+  const pageviewFingerprintTimeoutRef = (0, import_react8.useRef)(null);
+  const pageviewFingerprintRetryTimeoutRef = (0, import_react8.useRef)(null);
+  (0, import_react8.useEffect)(() => {
+    lastPageviewRef.current = "";
+    lastPageviewFingerprintRef.current = "";
+  }, [resolvedApiKey]);
+  const trackPageviewOnce = (0, import_react8.useCallback)(
+    (path) => {
+      const next = (path || "").toString();
+      if (!next) return;
+      if (lastPageviewRef.current === next) return;
+      lastPageviewRef.current = next;
+      apiRef.current.trackPageview(next);
+      const trySendFingerprint = () => {
+        if (typeof window === "undefined") return;
+        const markersReady = window.__lovalingoMarkersReady === true;
+        if (!markersReady) return;
+        const fp = getCriticalFingerprint();
+        if (!fp || fp.critical_count <= 0) return;
+        const signature = `${next}|${fp.critical_hash}|${fp.critical_count}`;
+        if (lastPageviewFingerprintRef.current === signature) return;
+        lastPageviewFingerprintRef.current = signature;
+        apiRef.current.trackPageview(next, fp);
+      };
+      if (pageviewFingerprintTimeoutRef.current != null) window.clearTimeout(pageviewFingerprintTimeoutRef.current);
+      if (pageviewFingerprintRetryTimeoutRef.current != null) window.clearTimeout(pageviewFingerprintRetryTimeoutRef.current);
+      pageviewFingerprintTimeoutRef.current = window.setTimeout(trySendFingerprint, 800);
+      pageviewFingerprintRetryTimeoutRef.current = window.setTimeout(trySendFingerprint, 2e3);
+    },
+    [apiRef]
+  );
+  return { trackPageviewOnce };
+}
+
+// src/hooks/provider/useSitemapLinkTag.ts
+var import_react9 = require("react");
+function useSitemapLinkTag({ enabled, resolvedApiKey, isSeoActive }) {
+  (0, import_react9.useEffect)(() => {
+    if (enabled && resolvedApiKey && isSeoActive()) {
+      const sitemapUrl = `${window.location.origin}/sitemap.xml`;
+      const existingLink = document.querySelector(`link[rel="sitemap"][href="${sitemapUrl}"]`);
+      if (existingLink) return;
+      const link = document.createElement("link");
+      link.rel = "sitemap";
+      link.type = "application/xml";
+      link.href = sitemapUrl;
+      document.head.appendChild(link);
+      return () => {
+        const linkToRemove = document.querySelector(`link[rel="sitemap"][href="${sitemapUrl}"]`);
+        if (linkToRemove) {
+          document.head.removeChild(linkToRemove);
+        }
+      };
+    }
+  }, [enabled, resolvedApiKey, isSeoActive]);
+}
+
+// src/hooks/provider/useStringMissReporting.ts
+var import_react10 = require("react");
+var MISS_SCAN_THROTTLE_MS = 600;
+var MISS_MAX_PER_PAGE = 500;
+function looksLike404Page() {
+  if (typeof document === "undefined") return false;
+  const meta = document.querySelector('meta[name="lovalingo:status"]');
+  if (meta && meta.getAttribute("content") === "404") return true;
+  const title = (document.title || "").toLowerCase();
+  if (/page not found|seite nicht gefunden|article not found|error 404|page missing|does not exist/.test(title)) return true;
+  const h1 = document.querySelector("h1");
+  if (h1) {
+    const txt = (h1.innerText || "").toLowerCase();
+    if (/page not found|seite nicht gefunden|article not found|error 404/.test(txt)) return true;
+    if (txt.includes("404") && txt.length < 50) return true;
+  }
+  return false;
+}
+function useStringMissReporting(args) {
+  const pendingRef = (0, import_react10.useRef)(/* @__PURE__ */ new Set());
+  const seenRef = (0, import_react10.useRef)(/* @__PURE__ */ new Set());
+  const scheduledRef = (0, import_react10.useRef)(null);
+  const inFlightRef = (0, import_react10.useRef)(false);
+  (0, import_react10.useEffect)(() => {
+    pendingRef.current.clear();
+    seenRef.current.clear();
+  }, [args.locale]);
+  const shouldSkip = (0, import_react10.useCallback)(() => {
+    if (typeof window === "undefined" || typeof document === "undefined") return true;
+    if (looksLike404Page()) return true;
+    const disableLiveMisses = Boolean(window.__lovalingoDisableMisses);
+    if (disableLiveMisses) return true;
+    if (!args.resolvedApiKey || args.mode !== "dom") return true;
+    if (args.isLoading) return true;
+    if (args.locale === args.defaultLocale) return true;
+    if (args.routing === "path") {
+      const stripped = stripLocalePrefix(window.location.pathname, args.allLocales);
+      if (isNonLocalizedPath(stripped, args.nonLocalizedPaths)) return true;
+    }
+    return false;
+  }, [args.allLocales, args.defaultLocale, args.isLoading, args.locale, args.mode, args.nonLocalizedPaths, args.resolvedApiKey, args.routing]);
+  const runScan = (0, import_react10.useCallback)(async () => {
+    scheduledRef.current = null;
+    if (shouldSkip()) return;
+    if (!document.body) return;
+    if (inFlightRef.current) return;
+    const ignore = /* @__PURE__ */ new Set([...pendingRef.current, ...seenRef.current]);
+    const { misses } = scanDomForMisses({ max: MISS_MAX_PER_PAGE, ignore });
+    if (misses.length === 0) return;
+    logDebug(`[Lovalingo] Live misses detected: ${misses.length}`);
+    misses.forEach((miss) => pendingRef.current.add(miss.source_text));
+    inFlightRef.current = true;
+    try {
+      const response = await args.apiRef.current.reportStringMisses(args.locale, misses, {
+        sourceLocale: args.defaultLocale,
+        locales: args.allLocales
+      });
+      if (response?.ignored) {
+        for (const miss of misses) {
+          pendingRef.current.delete(miss.source_text);
+          seenRef.current.add(miss.source_text);
+        }
+        return;
+      }
+      const translations = Array.isArray(response?.translations) ? response.translations : [];
+      const pii = Array.isArray(response?.pii) ? response.pii : [];
+      logDebug(`[Lovalingo] Live misses resolved`, { translations: translations.length, pii: pii.length });
+      const resolved = /* @__PURE__ */ new Set();
+      pii.forEach((text) => resolved.add(text));
+      translations.forEach((row) => {
+        if (row?.source_text) resolved.add(row.source_text);
+      });
+      if (translations.length > 0) {
+        const additions = translations.map((row) => ({
+          source_text: row.source_text,
+          translated_text: row.translated_text,
+          source_locale: args.defaultLocale,
+          target_locale: args.locale
+        })).filter((row) => row.source_text && row.translated_text);
+        if (additions.length > 0) {
+          addActiveTranslations(additions);
+          applyActiveTranslations(document.body);
+        }
+      }
+      for (const miss of misses) {
+        pendingRef.current.delete(miss.source_text);
+        if (resolved.has(miss.source_text)) {
+          seenRef.current.add(miss.source_text);
+        }
+      }
+    } catch {
+      for (const miss of misses) {
+        pendingRef.current.delete(miss.source_text);
+      }
+    } finally {
+      inFlightRef.current = false;
+    }
+  }, [args.apiRef, args.defaultLocale, args.locale, shouldSkip]);
+  const scheduleScan2 = (0, import_react10.useCallback)(() => {
+    if (scheduledRef.current != null) return;
+    scheduledRef.current = window.setTimeout(() => {
+      void runScan();
+    }, MISS_SCAN_THROTTLE_MS);
+  }, [runScan]);
+  (0, import_react10.useEffect)(() => {
+    if (shouldSkip()) return;
+    scheduleScan2();
+    if (!document.body) return;
+    const observer2 = new MutationObserver(() => scheduleScan2());
+    observer2.observe(document.body, {
+      childList: true,
+      subtree: true,
+      characterData: true
+    });
+    return () => {
+      observer2.disconnect();
+      if (scheduledRef.current != null) {
+        window.clearTimeout(scheduledRef.current);
+        scheduledRef.current = null;
+      }
+    };
+  }, [scheduleScan2, shouldSkip]);
+}
+
+// src/components/LanguageSwitcher.tsx
+var import_react11 = __toESM(require("react"));
+
+// src/utils/languageFlags.ts
+var EXACT_LOCALE_FLAG_OVERRIDES = {
+  en: "\u{1F1EC}\u{1F1E7}",
+  ar: "\u{1F1F8}\u{1F1E6}",
+  zh: "\u{1F1E8}\u{1F1F3}",
+  fa: "\u{1F1EE}\u{1F1F7}",
+  he: "\u{1F1EE}\u{1F1F1}"
+};
+var LANGUAGE_DEFAULT_REGION = {
+  ar: "SA",
+  bn: "BD",
+  cs: "CZ",
+  da: "DK",
+  de: "DE",
+  el: "GR",
+  en: "GB",
+  es: "ES",
+  fa: "IR",
+  fi: "FI",
+  fr: "FR",
+  he: "IL",
+  hi: "IN",
+  hu: "HU",
+  hy: "AM",
+  id: "ID",
+  it: "IT",
+  ja: "JP",
+  ko: "KR",
+  nl: "NL",
+  no: "NO",
+  pl: "PL",
+  pt: "PT",
+  ro: "RO",
+  ru: "RU",
+  sk: "SK",
+  sv: "SE",
+  th: "TH",
+  tr: "TR",
+  uk: "UA",
+  vi: "VN",
+  yo: "NG",
+  zh: "CN"
+};
+function normalizeLocaleCode(locale) {
+  if (typeof locale !== "string") return "";
+  return locale.trim().replace(/_/g, "-").toLowerCase();
+}
+function parseLocale(locale) {
+  const normalized = normalizeLocaleCode(locale);
+  if (!normalized) return { language: "", region: null };
+  const parts = normalized.split("-").filter(Boolean);
+  const language = parts[0] || "";
+  const regionPart = parts.find((part, index) => index > 0 && /^[a-z]{2}$/.test(part));
+  const region = regionPart ? regionPart.toUpperCase() : null;
+  return { language, region };
+}
+function countryCodeToFlagEmoji(countryCode) {
+  if (typeof countryCode !== "string") return null;
+  const normalized = countryCode.trim().toUpperCase();
+  if (!/^[A-Z]{2}$/.test(normalized)) return null;
+  const first = normalized.charCodeAt(0) + 127397;
+  const second = normalized.charCodeAt(1) + 127397;
+  return String.fromCodePoint(first, second);
+}
+function resolveLocaleFlag(locale) {
+  const normalized = normalizeLocaleCode(locale);
+  if (!normalized) return "\u{1F310}";
+  const exact = EXACT_LOCALE_FLAG_OVERRIDES[normalized];
+  if (exact) return exact;
+  const { language, region } = parseLocale(normalized);
+  if (!language) return "\u{1F310}";
+  if (region) {
+    const regionFlag = countryCodeToFlagEmoji(region);
+    if (regionFlag) return regionFlag;
+  }
+  const defaultRegion = LANGUAGE_DEFAULT_REGION[language];
+  if (defaultRegion) {
+    const defaultFlag = countryCodeToFlagEmoji(defaultRegion);
+    if (defaultFlag) return defaultFlag;
+  }
+  return "\u{1F310}";
+}
+
+// src/components/LanguageSwitcher.tsx
+var LanguageSwitcher = ({
+  locales,
+  currentLocale,
+  onLocaleChange,
+  position = "bottom-right",
+  offsetY = 20,
+  theme = "dark",
+  branding
+}) => {
+  const [isOpen, setIsOpen] = (0, import_react11.useState)(false);
+  const [isMobile, setIsMobile] = (0, import_react11.useState)(false);
+  const containerRef = (0, import_react11.useRef)(null);
+  const isRight = position.endsWith("right");
+  const isTop = position.startsWith("top");
+  const isBottom = position.startsWith("bottom");
+  const tokens = theme === "light" ? {
+    surfaceBg: "rgba(255, 255, 255, 0.93)",
+    surfaceHoverBg: "rgba(245, 245, 245, 0.95)",
+    text: "rgba(13, 13, 13, 0.96)",
+    textMuted: "rgba(13, 13, 13, 0.74)",
+    divider: "rgba(0, 0, 0, 0.10)",
+    insetHighlight: "inset 0 0 1px rgba(0, 0, 0, 0.10)",
+    tabShadowRight: "-2px 0 8px rgba(0, 0, 0, 0.12), inset 0 0 1px rgba(0, 0, 0, 0.10)",
+    tabShadowLeft: "2px 0 8px rgba(0, 0, 0, 0.12), inset 0 0 1px rgba(0, 0, 0, 0.10)",
+    tabHoverShadowRight: "-4px 0 16px rgba(0, 0, 0, 0.16), inset 0 0 1px rgba(0, 0, 0, 0.12)",
+    tabHoverShadowLeft: "4px 0 16px rgba(0, 0, 0, 0.16), inset 0 0 1px rgba(0, 0, 0, 0.12)",
+    panelShadow: "0 8px 24px rgba(0, 0, 0, 0.14), inset 0 0 1px rgba(0, 0, 0, 0.10)"
+  } : {
+    surfaceBg: "rgba(26, 26, 26, 0.93)",
+    surfaceHoverBg: "rgba(35, 35, 35, 0.95)",
+    text: "rgba(255, 255, 255, 0.98)",
+    textMuted: "rgba(255, 255, 255, 0.82)",
+    divider: "rgba(255, 255, 255, 0.12)",
+    insetHighlight: "inset 0 0 1px rgba(255, 255, 255, 0.10)",
+    tabShadowRight: "-2px 0 8px rgba(0, 0, 0, 0.2), inset 0 0 1px rgba(255, 255, 255, 0.10)",
+    tabShadowLeft: "2px 0 8px rgba(0, 0, 0, 0.2), inset 0 0 1px rgba(255, 255, 255, 0.10)",
+    tabHoverShadowRight: "-4px 0 16px rgba(0, 0, 0, 0.3), inset 0 0 1px rgba(255, 255, 255, 0.15)",
+    tabHoverShadowLeft: "4px 0 16px rgba(0, 0, 0, 0.3), inset 0 0 1px rgba(255, 255, 255, 0.15)",
+    panelShadow: "0 8px 24px rgba(0, 0, 0, 0.3), inset 0 0 1px rgba(255, 255, 255, 0.10)"
+  };
+  const normalizedCurrentLocale = (0, import_react11.useMemo)(() => normalizeLocaleCode(currentLocale), [currentLocale]);
+  const orderedLocales = (0, import_react11.useMemo)(() => {
+    const seen = /* @__PURE__ */ new Set();
+    const items = [];
+    const pushLocale = (value) => {
+      const raw = typeof value === "string" ? value.trim() : "";
+      const normalized = normalizeLocaleCode(raw);
+      if (!raw || !normalized || seen.has(normalized)) return;
+      seen.add(normalized);
+      items.push({ raw, normalized });
+    };
+    if (normalizedCurrentLocale) {
+      pushLocale(currentLocale);
+    }
+    for (const locale of locales) {
+      const raw = typeof locale === "string" ? locale.trim() : "";
+      const normalized = normalizeLocaleCode(raw);
+      if (!normalized || normalized === normalizedCurrentLocale) continue;
+      pushLocale(raw);
+    }
+    if (items.length === 0) {
+      for (const locale of locales) pushLocale(locale);
+    }
+    return items;
+  }, [currentLocale, locales, normalizedCurrentLocale]);
+  const tabFlag = (0, import_react11.useMemo)(() => {
+    const fallbackLocale = orderedLocales[0]?.normalized || normalizedCurrentLocale;
+    return resolveLocaleFlag(fallbackLocale);
+  }, [orderedLocales, normalizedCurrentLocale]);
+  (0, import_react11.useEffect)(() => {
+    const handleClickOutside = (event) => {
+      if (containerRef.current && !containerRef.current.contains(event.target)) {
+        setIsOpen(false);
+      }
+    };
+    if (isOpen) {
+      document.addEventListener("mousedown", handleClickOutside);
+      return () => document.removeEventListener("mousedown", handleClickOutside);
+    }
+  }, [isOpen]);
+  (0, import_react11.useEffect)(() => {
+    if (typeof window === "undefined") return;
+    const query = "(max-width: 640px)";
+    const media = window.matchMedia(query);
+    const update = () => setIsMobile(media.matches);
+    update();
+    if (typeof media.addEventListener === "function") {
+      media.addEventListener("change", update);
+      return () => media.removeEventListener("change", update);
+    }
+    media.addListener(update);
+    return () => media.removeListener(update);
+  }, []);
+  (0, import_react11.useEffect)(() => {
+    const handleKeyDown = (event) => {
+      if (event.key === "Escape" && isOpen) {
+        setIsOpen(false);
+      }
+    };
+    if (isOpen) {
+      document.addEventListener("keydown", handleKeyDown);
+      return () => document.removeEventListener("keydown", handleKeyDown);
+    }
+  }, [isOpen]);
+  const containerStyles = {
+    position: "fixed",
+    zIndex: 9999,
+    ...isTop && { top: `calc(env(safe-area-inset-top, 0px) + 24px + ${offsetY}px)` },
+    ...isBottom && { bottom: `calc(env(safe-area-inset-bottom, 0px) + 24px + ${offsetY}px)` },
+    ...isRight && { right: 0 },
+    ...!isRight && { left: 0 },
+    pointerEvents: "none"
+  };
+  const rootStyles = {
+    position: "relative",
+    display: "flex",
+    alignItems: "center",
+    pointerEvents: "none"
+  };
+  const tabStyles = {
+    pointerEvents: "auto",
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center",
+    width: "44px",
+    height: "50px",
+    borderRadius: isRight ? "12px 0 0 12px" : "0 12px 12px 0",
+    background: tokens.surfaceBg,
+    boxShadow: isRight ? tokens.tabShadowRight : tokens.tabShadowLeft,
+    cursor: "pointer",
+    fontSize: "20px",
+    transition: "all 0.2s ease",
+    userSelect: "none",
+    border: "none",
+    color: tokens.text
+  };
+  const panelStyles = {
+    position: "absolute",
+    ...isRight && { right: "48px" },
+    ...!isRight && { left: "48px" },
+    top: "50%",
+    transform: isOpen ? "translateY(-50%) translateX(0)" : `translateY(-50%) translateX(${isRight ? "12px" : "-12px"})`,
+    opacity: isOpen ? 1 : 0,
+    pointerEvents: isOpen ? "auto" : "none",
+    background: tokens.surfaceBg,
+    borderRadius: "16px",
+    padding: "10px 12px",
+    display: "flex",
+    flexDirection: "column",
+    gap: "10px",
+    boxShadow: tokens.panelShadow,
+    transition: "opacity 0.25s ease, transform 0.25s ease",
+    width: isMobile ? "min(320px, calc(100vw - 88px))" : "auto"
+  };
+  const localeRowStyles = {
+    display: isMobile ? "grid" : "flex",
+    gridTemplateColumns: isMobile ? "repeat(5, minmax(0, 1fr))" : void 0,
+    justifyItems: isMobile ? "center" : void 0,
+    gap: "10px",
+    padding: "0 2px"
+  };
+  const badgeRowStyles = {
+    display: "flex",
+    alignItems: "center",
+    gap: "8px",
+    paddingTop: "8px",
+    borderTop: `1px solid ${tokens.divider}`,
+    fontSize: "12px",
+    color: tokens.textMuted,
+    userSelect: "none",
+    whiteSpace: "nowrap"
+  };
+  const badgeLinkStyles = {
+    color: tokens.text,
+    textDecoration: "none",
+    display: "inline-flex",
+    alignItems: "center",
+    gap: "6px"
+  };
+  const flagButtonStyles = (isActive) => ({
+    // Why: the panel stays mounted for the close animation, so buttons must be non-interactive while hidden.
+    pointerEvents: isOpen ? "auto" : "none",
+    width: "32px",
+    height: "32px",
+    borderRadius: "50%",
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center",
+    fontSize: "20px",
+    background: isActive ? "rgba(59, 130, 246, 0.2)" : "transparent",
+    border: isActive ? "2px solid rgb(59, 130, 246)" : "2px solid transparent",
+    cursor: "pointer",
+    transition: "transform 0.15s ease, filter 0.15s ease, background 0.15s ease",
+    flexShrink: 0,
+    userSelect: "none",
+    padding: 0
+  });
+  return /* @__PURE__ */ import_react11.default.createElement("div", { ref: containerRef, style: containerStyles, "data-Lovalingo-exclude": "true" }, /* @__PURE__ */ import_react11.default.createElement("div", { style: rootStyles }, /* @__PURE__ */ import_react11.default.createElement(
+    "button",
+    {
+      style: tabStyles,
+      onClick: () => setIsOpen(!isOpen),
+      onMouseEnter: (e) => {
+        e.currentTarget.style.background = tokens.surfaceHoverBg;
+        e.currentTarget.style.boxShadow = isRight ? tokens.tabHoverShadowRight : tokens.tabHoverShadowLeft;
+      },
+      onMouseLeave: (e) => {
+        e.currentTarget.style.background = tokens.surfaceBg;
+        e.currentTarget.style.boxShadow = isRight ? tokens.tabShadowRight : tokens.tabShadowLeft;
+      },
+      "aria-label": "Open language switcher",
+      "aria-expanded": isOpen
+    },
+    tabFlag
+  ), /* @__PURE__ */ import_react11.default.createElement("div", { style: panelStyles, role: "toolbar", "aria-label": "Language options" }, /* @__PURE__ */ import_react11.default.createElement("div", { style: localeRowStyles }, orderedLocales.map((entry) => {
+    const isActive = entry.normalized === normalizedCurrentLocale;
+    return /* @__PURE__ */ import_react11.default.createElement(
+      "button",
+      {
+        key: entry.normalized,
+        style: flagButtonStyles(isActive),
+        onClick: (e) => {
+          e.stopPropagation();
+          if (isActive) {
+            setIsOpen(false);
+          } else {
+            onLocaleChange(entry.raw);
+            setIsOpen(false);
+          }
+        },
+        onMouseEnter: (e) => {
+          if (!isActive) {
+            e.currentTarget.style.filter = "brightness(1.3)";
+          }
+          e.currentTarget.style.transform = "scale(1.1)";
+        },
+        onMouseLeave: (e) => {
+          e.currentTarget.style.filter = "brightness(1)";
+          e.currentTarget.style.transform = "scale(1)";
+        },
+        "aria-label": `Switch to ${entry.normalized.toUpperCase()}`,
+        title: entry.normalized.toUpperCase(),
+        tabIndex: isOpen ? 0 : -1
+      },
+      resolveLocaleFlag(entry.normalized)
+    );
+  })), (branding?.required || branding?.enabled) && /* @__PURE__ */ import_react11.default.createElement("div", { style: badgeRowStyles, "aria-label": "Lovalingo branding" }, /* @__PURE__ */ import_react11.default.createElement(
+    "a",
+    {
+      href: branding.href || "https://lovalingo.com",
+      target: "_blank",
+      rel: "noreferrer",
+      style: { ...badgeLinkStyles, pointerEvents: isOpen ? "auto" : "none" },
+      tabIndex: isOpen ? 0 : -1,
+      "aria-label": "Localized by Lovalingo",
+      title: "Localized by Lovalingo"
+    },
+    /* @__PURE__ */ import_react11.default.createElement(
+      "span",
+      {
+        style: {
+          width: "16px",
+          height: "16px",
+          borderRadius: "999px",
+          overflow: "hidden",
+          background: "#DA2576",
+          display: "inline-flex",
+          alignItems: "center",
+          justifyContent: "center",
+          boxShadow: "inset 0 0 0 1px rgba(0,0,0,0.25)",
+          flexShrink: 0
+        }
+      },
+      /* @__PURE__ */ import_react11.default.createElement("svg", { width: "16", height: "16", viewBox: "0 0 512 512", fill: "none", "aria-hidden": "true" }, /* @__PURE__ */ import_react11.default.createElement(
+        "path",
+        {
+          d: "M256 480C379.712 480 480 379.712 480 256C480 132.288 379.712 32 256 32C132.288 32 32 132.288 32 256C32 379.712 132.288 480 256 480Z",
+          fill: "#DA2576"
+        }
+      ), /* @__PURE__ */ import_react11.default.createElement(
+        "path",
+        {
+          d: "M226.321 415.004C277.097 408.769 294.564 331.846 283.824 244.374C273.084 156.903 238.204 92.0061 187.427 98.2407C136.65 104.475 104.194 180.439 114.934 267.911C125.674 355.383 175.544 421.238 226.321 415.004Z",
+          fill: "white",
+          stroke: "white",
+          strokeWidth: "10"
+        }
+      ), /* @__PURE__ */ import_react11.default.createElement(
+        "path",
+        {
+          d: "M182.564 395.999C201.42 431.462 270.873 431.411 337.69 395.883C404.508 360.356 443.388 302.806 424.531 267.342C405.675 231.879 336.223 231.931 269.405 267.458C202.588 302.986 163.708 370.535 182.564 395.999Z",
+          fill: "white",
+          stroke: "white",
+          strokeWidth: "10"
+        }
+      ))
+    ),
+    /* @__PURE__ */ import_react11.default.createElement("span", null, branding.label || "Localized by", " ", /* @__PURE__ */ import_react11.default.createElement("strong", { "data-no-translate": true, style: { color: tokens.text } }, "Lovalingo"))
+  )))));
+};
+
+// src/components/provider/providerConstants.ts
+var LOCALE_STORAGE_KEY = "Lovalingo_locale";
+var LOADING_BG_STORAGE_PREFIX = "Lovalingo_loading_bg_color";
+var BRANDING_STORAGE_PREFIX = "Lovalingo_branding_enabled";
+var EDIT_MODE_PARAM = "edit_mode";
+var EDIT_KEY_PARAM = "edit_key";
+var LIVE_MISSES_QUERY_PARAM = "lovalingo_live_misses";
+var DEFAULT_PATH_NORMALIZATION = { enabled: true };
+var EDIT_MODE_VALUES = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
+var EDIT_UI_ATTR = "data-lovalingo-edit-ui";
+var EDIT_HIGHLIGHT_ID = "lovalingo-edit-highlight";
+var EDIT_HINT_ID = "lovalingo-edit-hint";
+
+// src/components/provider/editModeUtils.ts
+function readEditParams() {
+  if (typeof window === "undefined") return { enabled: false, editKey: null };
+  const params = new URLSearchParams(window.location.search);
+  const rawFlag = (params.get(EDIT_MODE_PARAM) || params.get("editMode") || "").trim().toLowerCase();
+  const enabled = EDIT_MODE_VALUES.has(rawFlag);
+  const editKey = (params.get(EDIT_KEY_PARAM) || params.get("editKey") || "").trim() || null;
+  return { enabled, editKey };
+}
+function cssEscape(value) {
+  const esc = typeof window !== "undefined" && window?.CSS?.escape;
+  if (typeof esc === "function") return esc(value);
+  return value.replace(/[ !"#$%&'()*+,.\/:;<=>?@[\\\]^`{|}~]/g, "\\$&");
+}
+function buildCssSelector(element, maxDepth = 5) {
+  if (!element || !element.tagName) return null;
+  if (element.id) return `#${cssEscape(element.id)}`;
+  const parts = [];
+  let node = element;
+  let depth = 0;
+  while (node && depth < maxDepth) {
+    const tag = node.tagName.toLowerCase();
+    if (!tag || tag === "html") break;
+    let part = tag;
+    const nodeTag = node.tagName;
+    const classes = Array.from(node.classList || []).filter(Boolean).filter((cls) => !cls.startsWith("lovalingo-")).slice(0, 2);
+    if (classes.length > 0) {
+      part += `.${classes.map(cssEscape).join(".")}`;
+    }
+    const parentEl = node.parentElement;
+    if (parentEl) {
+      const siblings = Array.from(parentEl.children).filter(
+        (child) => child instanceof HTMLElement && child.tagName === nodeTag
+      );
+      if (siblings.length > 1) {
+        part += `:nth-of-type(${siblings.indexOf(node) + 1})`;
+      }
+    }
+    parts.unshift(part);
+    const selector = parts.join(" > ");
+    try {
+      if (document.querySelectorAll(selector).length === 1) return selector;
+    } catch {
+    }
+    node = parentEl;
+    depth += 1;
+  }
+  return parts.join(" > ") || null;
+}
+
+// src/components/provider/seoUtils.ts
+function applySeoBundle(bundle, hreflangEnabled) {
+  try {
+    const head = document.head;
+    if (!head) return;
+    if (!bundle) return;
+    const seo = bundle?.seo && typeof bundle.seo === "object" ? bundle.seo : {};
+    const alternates = bundle?.alternates && typeof bundle.alternates === "object" ? bundle.alternates : {};
+    const setOrCreateMeta = (attrs, content) => {
+      const key = attrs.name ? `meta[name="${attrs.name}"]` : attrs.property ? `meta[property="${attrs.property}"]` : "";
+      const selector = key || "meta";
+      const existing = selector ? head.querySelector(selector) : null;
+      const el = existing || document.createElement("meta");
+      for (const [k, v] of Object.entries(attrs)) {
+        el.setAttribute(k, v);
+      }
+      el.setAttribute("content", content);
+      if (!existing) head.appendChild(el);
+    };
+    const setOrCreateTitle = (value) => {
+      const existing = head.querySelector("title");
+      if (existing) {
+        existing.textContent = value;
+        return;
+      }
+      const el = document.createElement("title");
+      el.textContent = value;
+      head.appendChild(el);
+    };
+    const getString = (value) => typeof value === "string" && value.trim() ? value.trim() : "";
+    const title = getString(seo.title);
+    if (title) setOrCreateTitle(title);
+    const description = getString(seo.description);
+    if (description) setOrCreateMeta({ name: "description" }, description);
+    const robots = getString(seo.robots);
+    if (robots) setOrCreateMeta({ name: "robots" }, robots);
+    const ogTitle = getString(seo.og_title);
+    if (ogTitle) setOrCreateMeta({ property: "og:title" }, ogTitle);
+    const ogDescription = getString(seo.og_description);
+    if (ogDescription) setOrCreateMeta({ property: "og:description" }, ogDescription);
+    const ogImage = getString(seo.og_image);
+    if (ogImage) setOrCreateMeta({ property: "og:image" }, ogImage);
+    const ogImageAlt = getString(seo.og_image_alt);
+    if (ogImageAlt) setOrCreateMeta({ property: "og:image:alt" }, ogImageAlt);
+    const twitterCard = getString(seo.twitter_card);
+    if (twitterCard) setOrCreateMeta({ name: "twitter:card" }, twitterCard);
+    const twitterTitle = getString(seo.twitter_title);
+    if (twitterTitle) setOrCreateMeta({ name: "twitter:title" }, twitterTitle);
+    const twitterDescription = getString(seo.twitter_description);
+    if (twitterDescription) setOrCreateMeta({ name: "twitter:description" }, twitterDescription);
+    const twitterImage = getString(seo.twitter_image);
+    if (twitterImage) setOrCreateMeta({ name: "twitter:image" }, twitterImage);
+    const twitterImageAlt = getString(seo.twitter_image_alt);
+    if (twitterImageAlt) setOrCreateMeta({ name: "twitter:image:alt" }, twitterImageAlt);
+    const canonicalHref = resolveCanonicalHref(seo, alternates);
+    const languages = alternates.languages && typeof alternates.languages === "object" ? alternates.languages : {};
+    const hasAnyAlternate = Boolean(alternates.xDefault) || Object.values(languages).some(Boolean);
+    if (!canonicalHref && !(hreflangEnabled && hasAnyAlternate)) return;
+    head.querySelectorAll('link[rel="canonical"], link[rel="alternate"][hreflang], link[data-Lovalingo="hreflang"], link[data-Lovalingo="canonical"]').forEach((el) => el.remove());
+    if (canonicalHref) {
+      const canonical = document.createElement("link");
+      canonical.rel = "canonical";
+      canonical.href = canonicalHref;
+      canonical.setAttribute("data-Lovalingo", "canonical");
+      head.appendChild(canonical);
+    }
+    if (!hreflangEnabled) return;
+    for (const [lang, href] of Object.entries(languages)) {
+      if (!href) continue;
+      const link = document.createElement("link");
+      link.rel = "alternate";
+      link.hreflang = lang;
+      link.href = href;
+      link.setAttribute("data-Lovalingo", "hreflang");
+      head.appendChild(link);
+    }
+    if (alternates.xDefault) {
+      const xDefault = document.createElement("link");
+      xDefault.rel = "alternate";
+      xDefault.hreflang = "x-default";
+      xDefault.href = alternates.xDefault;
+      xDefault.setAttribute("data-Lovalingo", "hreflang");
+      head.appendChild(xDefault);
+    }
+  } catch {
+  }
+}
+function resolveCanonicalHref(seo, alternates) {
+  const alt = alternates && typeof alternates === "object" ? alternates : null;
+  if (alt && typeof alt.canonical === "string" && alt.canonical.trim()) return alt.canonical.trim();
+  if (typeof seo?.canonical_url === "string" && seo.canonical_url.trim()) return seo.canonical_url.trim();
+  return "";
+}
+
+// src/components/provider/useEditModeOverlay.ts
+var import_react12 = require("react");
+function useEditModeOverlay({ editMode, excludeElement, setEditMode }) {
+  const editSavingRef = (0, import_react12.useRef)(false);
+  (0, import_react12.useEffect)(() => {
+    if (typeof window === "undefined") return;
+    const existingHighlight = document.getElementById(EDIT_HIGHLIGHT_ID);
+    const existingHint = document.getElementById(EDIT_HINT_ID);
+    if (!editMode) {
+      existingHighlight?.remove();
+      existingHint?.remove();
+      return;
+    }
+    const highlight = existingHighlight || (() => {
+      const node = document.createElement("div");
+      node.id = EDIT_HIGHLIGHT_ID;
+      node.setAttribute(EDIT_UI_ATTR, "true");
+      node.setAttribute("data-lovalingo-exclude", "true");
+      node.style.position = "fixed";
+      node.style.pointerEvents = "none";
+      node.style.zIndex = "2147483646";
+      node.style.border = "2px solid #22c55e";
+      node.style.background = "rgba(34, 197, 94, 0.12)";
+      node.style.borderRadius = "8px";
+      node.style.boxSizing = "border-box";
+      node.style.transition = "transform 80ms ease, width 80ms ease, height 80ms ease";
+      node.style.display = "none";
+      document.body.appendChild(node);
+      return node;
+    })();
+    const hint = existingHint || (() => {
+      const node = document.createElement("div");
+      node.id = EDIT_HINT_ID;
+      node.setAttribute(EDIT_UI_ATTR, "true");
+      node.setAttribute("data-lovalingo-exclude", "true");
+      node.style.position = "fixed";
+      node.style.left = "12px";
+      node.style.bottom = "12px";
+      node.style.zIndex = "2147483647";
+      node.style.background = "rgba(10, 10, 10, 0.85)";
+      node.style.color = "#ffffff";
+      node.style.fontSize = "12px";
+      node.style.lineHeight = "1.4";
+      node.style.padding = "8px 10px";
+      node.style.borderRadius = "8px";
+      node.style.border = "1px solid rgba(255, 255, 255, 0.15)";
+      node.style.pointerEvents = "none";
+      node.style.maxWidth = "280px";
+      node.textContent = "Edit Mode: click an element to exclude. Press Esc to exit.";
+      document.body.appendChild(node);
+      return node;
+    })();
+    let rafId = null;
+    let pendingTarget = null;
+    const previousCursor = document.body.style.cursor;
+    document.body.style.cursor = "crosshair";
+    const updateHighlight = () => {
+      rafId = null;
+      if (!pendingTarget) {
+        highlight.style.display = "none";
+        return;
+      }
+      const rect = pendingTarget.getBoundingClientRect();
+      if (rect.width <= 0 || rect.height <= 0) {
+        highlight.style.display = "none";
+        return;
+      }
+      highlight.style.display = "block";
+      highlight.style.width = `${rect.width}px`;
+      highlight.style.height = `${rect.height}px`;
+      highlight.style.transform = `translate(${rect.left}px, ${rect.top}px)`;
+    };
+    const onMove = (event) => {
+      const rawTarget = event.target;
+      const target = rawTarget instanceof HTMLElement ? rawTarget : rawTarget instanceof Node ? rawTarget.parentElement : null;
+      if (!target || target.closest(`[${EDIT_UI_ATTR}="true"]`)) {
+        pendingTarget = null;
+      } else if (target === document.body || target === document.documentElement) {
+        pendingTarget = null;
+      } else {
+        pendingTarget = target;
+      }
+      if (rafId !== null) return;
+      rafId = window.requestAnimationFrame(updateHighlight);
+    };
+    const onClick = async (event) => {
+      const rawTarget = event.target;
+      const target = rawTarget instanceof HTMLElement ? rawTarget : rawTarget instanceof Node ? rawTarget.parentElement : null;
+      if (!target || target.closest(`[${EDIT_UI_ATTR}="true"]`)) return;
+      event.preventDefault();
+      event.stopPropagation();
+      event.stopImmediatePropagation();
+      const selector = buildCssSelector(target);
+      if (!selector) return;
+      if (editSavingRef.current) return;
+      editSavingRef.current = true;
+      try {
+        await excludeElement(selector);
+      } finally {
+        editSavingRef.current = false;
+      }
+    };
+    const onKeyDown = (event) => {
+      if (event.key === "Escape") {
+        event.preventDefault();
+        setEditMode(false);
+      }
+    };
+    document.addEventListener("mousemove", onMove, true);
+    document.addEventListener("click", onClick, true);
+    document.addEventListener("keydown", onKeyDown, true);
+    return () => {
+      document.removeEventListener("mousemove", onMove, true);
+      document.removeEventListener("click", onClick, true);
+      document.removeEventListener("keydown", onKeyDown, true);
+      if (rafId !== null) window.cancelAnimationFrame(rafId);
+      highlight.remove();
+      hint.remove();
+      document.body.style.cursor = previousCursor;
+    };
+  }, [editMode, excludeElement, setEditMode]);
+}
+
+// src/components/provider/useHistoryNavigationPatch.ts
+var import_react13 = require("react");
+function useHistoryNavigationPatch(onNavigateRef) {
+  const historyPatchedRef = (0, import_react13.useRef)(false);
+  const originalHistoryRef = (0, import_react13.useRef)(null);
+  (0, import_react13.useEffect)(() => {
+    if (typeof window === "undefined") return;
+    if (historyPatchedRef.current) return;
+    historyPatchedRef.current = true;
+    const historyObj = window.history;
+    const originalPushState = historyObj.pushState.bind(historyObj);
+    const originalReplaceState = historyObj.replaceState.bind(historyObj);
+    originalHistoryRef.current = { pushState: originalPushState, replaceState: originalReplaceState };
+    const safeOnNavigate = () => {
+      try {
+        onNavigateRef.current();
+      } catch {
+      }
+    };
+    historyObj.pushState = ((...args) => {
+      const ret = originalPushState(...args);
+      safeOnNavigate();
+      return ret;
+    });
+    historyObj.replaceState = ((...args) => {
+      const ret = originalReplaceState(...args);
+      safeOnNavigate();
+      return ret;
+    });
+    window.addEventListener("popstate", safeOnNavigate);
+    window.addEventListener("hashchange", safeOnNavigate);
+    return () => {
+      const originals = originalHistoryRef.current;
+      if (originals) {
+        historyObj.pushState = originals.pushState;
+        historyObj.replaceState = originals.replaceState;
+      }
+      window.removeEventListener("popstate", safeOnNavigate);
+      window.removeEventListener("hashchange", safeOnNavigate);
+      originalHistoryRef.current = null;
+      historyPatchedRef.current = false;
+    };
+  }, [onNavigateRef]);
+}
+
+// src/components/provider/localeUtils.ts
+function detectLocaleFromLocation({ routing, allLocales, defaultLocale }) {
+  if (routing === "path") {
+    const pathLocale = window.location.pathname.split("/")[1];
+    if (pathLocale && allLocales.includes(pathLocale)) {
+      return pathLocale;
+    }
+  } else if (routing === "query") {
+    const params = new URLSearchParams(window.location.search);
+    const queryLocale = params.get("t") || params.get("locale");
+    if (queryLocale && allLocales.includes(queryLocale)) {
+      return queryLocale;
+    }
+  }
+  try {
+    const storedLocale = localStorage.getItem(LOCALE_STORAGE_KEY);
+    if (storedLocale && allLocales.includes(storedLocale)) {
+      return storedLocale;
+    }
+  } catch (e) {
+    warnDebug("localStorage not available:", e);
+  }
+  return defaultLocale;
+}
+function setDocumentLocale(nextLocale) {
+  try {
+    const html = document.documentElement;
+    if (!html) return;
+    html.setAttribute("lang", nextLocale);
+    const rtlLocales = /* @__PURE__ */ new Set(["ar", "he", "fa", "ur"]);
+    html.setAttribute("dir", rtlLocales.has(nextLocale) ? "rtl" : "ltr");
+  } catch {
+  }
+}
+
+// src/components/provider/useProviderCache.ts
+var import_react14 = require("react");
+function useProviderCache({ overlayBgColor, resolvedApiKey }) {
+  const loadingBgStorageKey = `${LOADING_BG_STORAGE_PREFIX}:${resolvedApiKey || "anonymous"}`;
+  const brandingStorageKey = `${BRANDING_STORAGE_PREFIX}:${resolvedApiKey || "anonymous"}`;
+  const readBrandingCache = (0, import_react14.useCallback)(() => {
+    try {
+      const cached = (localStorage.getItem(brandingStorageKey) || "").trim();
+      if (cached === "0") return false;
+      if (cached === "1") return true;
+    } catch {
+    }
+    return true;
+  }, [brandingStorageKey]);
+  const [brandingEnabled, setBrandingEnabled] = (0, import_react14.useState)(readBrandingCache);
+  const getCachedLoadingBgColor = (0, import_react14.useCallback)(() => {
+    const configured = (overlayBgColor || "").toString().trim();
+    if (/^#[0-9a-fA-F]{6}$/.test(configured)) return configured;
+    try {
+      const cached = localStorage.getItem(loadingBgStorageKey) || "";
+      if (/^#[0-9a-fA-F]{6}$/.test(cached.trim())) return cached.trim();
+    } catch {
+    }
+    try {
+      const bodyBg = window.getComputedStyle(document.body).backgroundColor;
+      if (bodyBg && bodyBg !== "transparent" && bodyBg !== "rgba(0, 0, 0, 0)") return bodyBg;
+      const htmlBg = window.getComputedStyle(document.documentElement).backgroundColor;
+      if (htmlBg && htmlBg !== "transparent" && htmlBg !== "rgba(0, 0, 0, 0)") return htmlBg;
+    } catch {
+    }
+    return "#ffffff";
+  }, [loadingBgStorageKey, overlayBgColor]);
+  const setCachedLoadingBgColor = (0, import_react14.useCallback)(
+    (color) => {
+      const next = (color || "").toString().trim();
+      if (!/^#[0-9a-fA-F]{6}$/.test(next)) return;
+      try {
+        localStorage.setItem(loadingBgStorageKey, next);
+      } catch {
+      }
+    },
+    [loadingBgStorageKey]
+  );
+  (0, import_react14.useEffect)(() => {
+    const configured = (overlayBgColor || "").toString().trim();
+    if (!/^#[0-9a-fA-F]{6}$/.test(configured)) return;
+    setCachedLoadingBgColor(configured);
+  }, [overlayBgColor, setCachedLoadingBgColor]);
+  const setCachedBrandingEnabled = (0, import_react14.useCallback)(
+    (enabled) => {
+      try {
+        localStorage.setItem(brandingStorageKey, enabled === false ? "0" : "1");
+      } catch {
+      }
+    },
+    [brandingStorageKey]
+  );
+  (0, import_react14.useEffect)(() => {
+    setBrandingEnabled(readBrandingCache());
+  }, [readBrandingCache]);
+  return {
+    brandingEnabled,
+    setBrandingEnabled,
+    setCachedBrandingEnabled,
+    getCachedLoadingBgColor,
+    setCachedLoadingBgColor
+  };
+}
+
+// src/components/LovalingoProvider.tsx
+var useIsomorphicLayoutEffect = typeof window !== "undefined" ? import_react15.useLayoutEffect : import_react15.useEffect;
+var LovalingoProvider = ({
+  children,
+  apiKey: apiKeyProp,
+  publicAnonKey,
+  defaultLocale,
+  locales,
+  apiBase = "https://cdn.lovalingo.com",
+  routing = "path",
+  // Default to path mode (SEO-friendly, recommended)
+  autoPrefixLinks = true,
+  overlayBgColor,
+  autoApplyRules = true,
+  switcherPosition = "bottom-right",
+  switcherOffsetY = 20,
+  switcherTheme = "dark",
+  editMode: initialEditMode = false,
+  editKey = "KeyE",
+  pathNormalization = DEFAULT_PATH_NORMALIZATION,
+  // Enable by default
+  mode = "dom",
+  // Default to legacy DOM mode for backward compatibility
+  sitemap = true,
+  // Default: true - Auto-inject sitemap link tag
+  seo = true,
+  // Default: true - Can be disabled per project entitlements
+  navigateRef
+  // For path mode routing
+}) => {
+  const metaKey = typeof document !== "undefined" ? document.querySelector('meta[name="lovalingo-public-anon-key"]')?.content?.trim() || "" : "";
+  const resolvedApiKey = typeof apiKeyProp === "string" && apiKeyProp.trim().length > 0 ? apiKeyProp : typeof publicAnonKey === "string" && publicAnonKey.trim().length > 0 ? publicAnonKey : globalThis.__LOVALINGO_PUBLIC_ANON_KEY__ || globalThis.__LOVALINGO_API_KEY__ || metaKey || "";
+  const rawLocales = Array.isArray(locales) ? locales : [];
+  const localesKey = rawLocales.join(",");
+  const allLocales = (0, import_react15.useMemo)(() => {
+    const base = rawLocales.includes(defaultLocale) ? rawLocales : [defaultLocale, ...rawLocales];
+    return Array.from(new Set(base));
+  }, [defaultLocale, localesKey]);
+  const pathNormalizationKey = (() => {
+    const enabled = pathNormalization?.enabled !== false;
+    const rules = Array.isArray(pathNormalization?.rules) ? pathNormalization.rules : [];
+    const rulesKey = rules.map((r) => `${r.pattern}=>${r.replacement}:${r.includeSubpaths ? 1 : 0}`).join("|");
+    return `${enabled ? 1 : 0}:${rulesKey}`;
+  })();
+  const stablePathNormalization = (0, import_react15.useMemo)(() => {
+    const enabled = pathNormalization?.enabled !== false;
+    const rules = Array.isArray(pathNormalization?.rules) ? pathNormalization.rules : void 0;
+    return rules ? { enabled, rules } : { enabled };
+  }, [pathNormalizationKey]);
+  const [locale, setLocaleState] = (0, import_react15.useState)(() => {
+    if (typeof window === "undefined") return defaultLocale;
+    if (routing === "path") {
+      const pathLocale = window.location.pathname.split("/")[1];
+      if (pathLocale && allLocales.includes(pathLocale)) {
+        return pathLocale;
+      }
+    } else if (routing === "query") {
+      const params = new URLSearchParams(window.location.search);
+      const queryLocale = params.get("t") || params.get("locale");
+      if (queryLocale && allLocales.includes(queryLocale)) {
+        return queryLocale;
+      }
+    }
+    try {
+      const stored = localStorage.getItem(LOCALE_STORAGE_KEY);
+      if (stored && allLocales.includes(stored)) {
+        return stored;
+      }
+    } catch {
+    }
+    return defaultLocale;
+  });
+  const initialEditParams = readEditParams();
+  const [editMode, setEditMode] = (0, import_react15.useState)(initialEditMode || initialEditParams.enabled);
+  const [editSecretKey] = (0, import_react15.useState)(initialEditParams.editKey);
+  const enhancedPathConfig = (0, import_react15.useMemo)(
+    () => routing === "path" ? { ...stablePathNormalization, supportedLocales: allLocales } : stablePathNormalization,
+    [allLocales, routing, stablePathNormalization]
+  );
+  const apiRef = (0, import_react15.useRef)(new LovalingoAPI(resolvedApiKey, apiBase, enhancedPathConfig, editSecretKey ?? void 0));
+  (0, import_react15.useEffect)(() => {
+    apiRef.current = new LovalingoAPI(resolvedApiKey, apiBase, enhancedPathConfig, editSecretKey ?? void 0);
+  }, [apiBase, editSecretKey, enhancedPathConfig, resolvedApiKey]);
+  const routingConfig = (0, import_react15.useContext)(LangRoutingContext);
+  const [entitlements, setEntitlements] = (0, import_react15.useState)(() => apiRef.current.getEntitlements());
+  const { trackPageviewOnce } = usePageviewTracking({ apiRef, resolvedApiKey });
+  const lastNormalizedPathRef = (0, import_react15.useRef)("");
+  const onNavigateRef = (0, import_react15.useRef)(() => void 0);
+  const isInternalNavigationRef = (0, import_react15.useRef)(false);
+  const {
+    brandingEnabled,
+    setBrandingEnabled,
+    setCachedBrandingEnabled,
+    getCachedLoadingBgColor,
+    setCachedLoadingBgColor
+  } = useProviderCache({ overlayBgColor, resolvedApiKey });
+  const config = {
+    apiKey: resolvedApiKey,
+    publicAnonKey: resolvedApiKey,
+    defaultLocale,
+    locales: allLocales,
+    apiBase,
+    routing,
+    autoPrefixLinks,
+    overlayBgColor,
+    switcherPosition,
+    switcherOffsetY,
+    switcherTheme,
+    editMode: initialEditMode,
+    editKey,
+    pathNormalization,
+    mode,
+    autoApplyRules
+  };
+  const isSeoActive = (0, import_react15.useCallback)(() => {
+    const serverEnabled = entitlements?.seoEnabled;
+    if (serverEnabled === false) return false;
+    return seo !== false;
+  }, [entitlements, seo]);
+  (0, import_react15.useEffect)(() => {
+    const stop = startMarkerEngine({ throttleMs: 120 });
+    return () => stop();
+  }, []);
+  const detectLocale = (0, import_react15.useCallback)(
+    () => detectLocaleFromLocation({ routing, allLocales, defaultLocale }),
+    [allLocales, defaultLocale, routing]
+  );
+  (0, import_react15.useEffect)(() => {
+    if (locale !== defaultLocale) return;
+    if (entitlements) return;
+    let cancelled = false;
+    (async () => {
+      const bootstrap = await apiRef.current.fetchBootstrap(locale, window.location.pathname + window.location.search);
+      if (cancelled) return;
+      if (bootstrap?.entitlements) {
+        setEntitlements(mergeEntitlementsSeoEnabled(bootstrap.entitlements, bootstrap.seoEnabled));
+      }
+      if (bootstrap?.loading_bg_color) setCachedLoadingBgColor(bootstrap.loading_bg_color);
+      if (bootstrap?.entitlements?.brandingRequired) {
+        setBrandingEnabled(true);
+        setCachedBrandingEnabled(true);
+      } else if (typeof bootstrap?.branding_enabled === "boolean") {
+        setBrandingEnabled(bootstrap.branding_enabled);
+        setCachedBrandingEnabled(bootstrap.branding_enabled);
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [defaultLocale, entitlements, locale, setCachedBrandingEnabled, setCachedLoadingBgColor]);
+  const applySeoBundle2 = (0, import_react15.useCallback)(
+    (bundle, hreflangEnabled) => {
+      applySeoBundle(bundle, hreflangEnabled);
+    },
+    []
+  );
+  (0, import_react15.useEffect)(() => {
+    setDocumentLocale(locale);
+    if (locale !== defaultLocale) return;
+    if (!isSeoActive()) return;
+    void apiRef.current.fetchSeoBundle(locale).then((bundle) => {
+      applySeoBundle2(bundle, Boolean(entitlements?.hreflangEnabled));
+    });
+  }, [applySeoBundle2, defaultLocale, entitlements, isSeoActive, locale, setDocumentLocale]);
+  const { isLoading, isNavigatingRef, loadData } = useBundleLoading({
+    apiRef,
+    resolvedApiKey,
+    defaultLocale,
+    routing,
+    allLocales,
+    nonLocalizedPaths: routingConfig.nonLocalizedPaths,
+    enhancedPathConfig,
+    mode,
+    autoApplyRules,
+    seoProp: seo,
+    isSeoActive,
+    applySeoBundle: applySeoBundle2,
+    setEntitlements,
+    setBrandingEnabled,
+    setCachedBrandingEnabled,
+    setCachedLoadingBgColor,
+    getCachedLoadingBgColor
+  });
+  (0, import_react15.useEffect)(() => {
+    onNavigateRef.current = () => {
+      trackPageviewOnce(window.location.pathname + window.location.search);
+      const nextLocale = detectLocale();
+      const normalizedPath = processPath(window.location.pathname, enhancedPathConfig);
+      const normalizedPathChanged = normalizedPath !== lastNormalizedPathRef.current;
+      lastNormalizedPathRef.current = normalizedPath;
+      if (normalizedPathChanged && nextLocale !== defaultLocale && !isInternalNavigationRef.current) {
+        void loadData(nextLocale, locale);
+        return;
+      }
+      if (nextLocale !== locale) {
+        setLocaleState(nextLocale);
+        if (!isInternalNavigationRef.current) {
+          void loadData(nextLocale, locale);
+        }
+      } else if (mode === "dom" && nextLocale !== defaultLocale) {
+        applyActiveTranslations(document.body);
+      }
+    };
+  }, [defaultLocale, detectLocale, enhancedPathConfig, loadData, locale, mode, trackPageviewOnce]);
+  useHistoryNavigationPatch(onNavigateRef);
+  const setLocale = (0, import_react15.useCallback)((newLocale) => {
+    void (async () => {
+      if (!allLocales.includes(newLocale)) return;
+      try {
+        localStorage.setItem(LOCALE_STORAGE_KEY, newLocale);
+      } catch (e) {
+        warnDebug("Failed to save locale to localStorage:", e);
+      }
+      isInternalNavigationRef.current = true;
+      isNavigatingRef.current = true;
+      let nextUrl = "";
+      if (routing === "path") {
+        const stripped = stripLocalePrefix(window.location.pathname, allLocales);
+        if (isNonLocalizedPath(stripped, routingConfig.nonLocalizedPaths)) {
+          nextUrl = window.location.href;
+        } else {
+          const pathParts = window.location.pathname.split("/").filter(Boolean);
+          if (allLocales.includes(pathParts[0])) {
+            pathParts.shift();
+          }
+          const basePath = pathParts.join("/");
+          nextUrl = `/${newLocale}${basePath ? "/" + basePath : ""}${window.location.search}${window.location.hash}`;
+        }
+      } else if (routing === "query") {
+        const url = new URL(window.location.href);
+        url.searchParams.set("t", newLocale);
+        nextUrl = url.toString();
+      }
+      if (!nextUrl) nextUrl = window.location.href;
+      window.location.assign(nextUrl);
+      return;
+    })().finally(() => {
+      isInternalNavigationRef.current = false;
+    });
+  }, [allLocales, locale, routing, routingConfig.nonLocalizedPaths]);
+  const loadDataRef = (0, import_react15.useRef)(loadData);
+  (0, import_react15.useEffect)(() => {
+    loadDataRef.current = loadData;
+  }, [loadData]);
+  const detectLocaleRef = (0, import_react15.useRef)(detectLocale);
+  (0, import_react15.useEffect)(() => {
+    detectLocaleRef.current = detectLocale;
+  }, [detectLocale]);
+  (0, import_react15.useEffect)(() => {
+    if (editMode && !editSecretKey) {
+      warnDebug("[Lovalingo] Edit Mode is active but no edit_key was provided in the URL.");
+    }
+  }, [editMode, editSecretKey]);
+  useIsomorphicLayoutEffect(() => {
+    const applyLiveMissesQueryParam = () => {
+      if (typeof window === "undefined") return;
+      const url = new URL(window.location.href);
+      const raw = url.searchParams.get(LIVE_MISSES_QUERY_PARAM);
+      if (raw !== "0" && raw !== "1") return;
+      const g = window;
+      if (raw === "1") {
+        if (g.__lovalingoDisableMisses === true) return;
+        g.__lovalingoDisableMisses = false;
+        return;
+      }
+      g.__lovalingoDisableMisses = true;
+    };
+    applyLiveMissesQueryParam();
+    const initialLocale = detectLocaleRef.current();
+    lastNormalizedPathRef.current = processPath(window.location.pathname, enhancedPathConfig);
+    trackPageviewOnce(window.location.pathname + window.location.search);
+    loadDataRef.current(initialLocale);
+    const handleKeyPress = (e) => {
+      if (e.code === editKey && (e.ctrlKey || e.metaKey)) {
+        e.preventDefault();
+        setEditMode((prev) => !prev);
+      }
+    };
+    window.addEventListener("keydown", handleKeyPress);
+    return () => {
+      window.removeEventListener("keydown", handleKeyPress);
+    };
+  }, [editKey, enhancedPathConfig, trackPageviewOnce]);
+  useSitemapLinkTag({ enabled: sitemap, resolvedApiKey, isSeoActive });
+  useLinkAutoPrefix({
+    routing,
+    autoPrefixLinks,
+    allLocales,
+    locale,
+    navigateRef,
+    nonLocalizedPaths: routingConfig.nonLocalizedPaths
+  });
+  useNavigationPrefetch({
+    resolvedApiKey,
+    apiBase,
+    defaultLocale,
+    locale,
+    routing,
+    allLocales,
+    enhancedPathConfig
+  });
+  useStringMissReporting({
+    apiRef,
+    resolvedApiKey,
+    locale,
+    defaultLocale,
+    routing,
+    allLocales,
+    nonLocalizedPaths: routingConfig.nonLocalizedPaths,
+    isLoading,
+    mode
+  });
+  const translateElement = (0, import_react15.useCallback)((element) => {
+    if (mode !== "dom") return;
+    applyActiveTranslations(element);
+  }, []);
+  const translateDOM = (0, import_react15.useCallback)(() => {
+    if (mode !== "dom") return;
+    applyActiveTranslations(document.body);
+  }, []);
+  const toggleEditMode = (0, import_react15.useCallback)(() => {
+    setEditMode((prev) => !prev);
+  }, []);
+  const excludeElement = (0, import_react15.useCallback)(
+    async (selector) => {
+      if (!editSecretKey) {
+        warnDebug("[Lovalingo] Edit Mode is active but no edit_key was provided in the URL.");
+        return;
+      }
+      const pagePath = lastNormalizedPathRef.current || processPath(window.location.pathname, enhancedPathConfig);
+      await apiRef.current.saveExclusion({
+        selector,
+        type: "css",
+        pagePath,
+        editKey: editSecretKey
+      });
+      const exclusions = await apiRef.current.fetchExclusions();
+      setMarkerEngineExclusions(exclusions);
+    },
+    [editSecretKey, enhancedPathConfig]
+  );
+  useEditModeOverlay({ editMode, excludeElement, setEditMode });
+  const contextValue = {
+    locale,
+    setLocale,
+    isLoading,
+    translationMap: {},
+    config,
+    translateElement,
+    translateDOM,
+    editMode,
+    toggleEditMode,
+    excludeElement
+  };
+  return /* @__PURE__ */ import_react15.default.createElement(LovalingoContext.Provider, { value: contextValue }, children, (() => {
+    if (routing !== "path") return true;
+    if (typeof window === "undefined") return true;
+    const stripped = stripLocalePrefix(window.location.pathname, allLocales);
+    return !isNonLocalizedPath(stripped, routingConfig.nonLocalizedPaths);
+  })() && /* @__PURE__ */ import_react15.default.createElement(
+    LanguageSwitcher,
+    {
+      locales: allLocales,
+      currentLocale: locale,
+      onLocaleChange: setLocale,
+      position: switcherPosition,
+      offsetY: switcherOffsetY,
+      theme: switcherTheme,
+      branding: {
+        required: Boolean(entitlements?.brandingRequired),
+        enabled: brandingEnabled,
+        href: "https://lovalingo.com"
+      }
+    }
+  ));
+};
+
+// src/hooks/useAixster.ts
+var import_react16 = require("react");
+var useLovalingo = () => {
+  const context = (0, import_react16.useContext)(LovalingoContext);
+  if (!context) {
+    throw new Error("useLovalingo must be used within LovalingoProvider");
+  }
+  return {
+    locale: context.locale,
+    setLocale: context.setLocale,
+    isLoading: context.isLoading,
+    config: context.config
+  };
+};
+
+// src/hooks/useAixsterTranslate.ts
+var import_react17 = require("react");
+var useLovalingoTranslate = () => {
+  const context = (0, import_react17.useContext)(LovalingoContext);
+  if (!context) {
+    throw new Error("useLovalingoTranslate must be used within LovalingoProvider");
+  }
+  return {
+    translateElement: context.translateElement,
+    translateDOM: context.translateDOM
+  };
+};
+
+// src/hooks/useAixsterEdit.ts
+var import_react18 = require("react");
+var useLovalingoEdit = () => {
+  const context = (0, import_react18.useContext)(LovalingoContext);
+  if (!context) {
+    throw new Error("useLovalingoEdit must be used within LovalingoProvider");
+  }
+  return {
+    editMode: context.editMode,
+    toggleEditMode: context.toggleEditMode,
+    excludeElement: context.excludeElement
+  };
+};
+
+// src/version.ts
+var VERSION = "0.6.0";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LanguageSwitcher,
+  LovalingoProvider,
+  VERSION,
+  useLovalingo,
+  useLovalingoEdit,
+  useLovalingoTranslate
+});