@lovalingo/lovalingo 0.1.2 → 0.2.0

package/README.md

@@ -1,10 +1,10 @@
 # @lovalingo/lovalingo
 
-Lovalingo is a translation runtime for React (React Router) and Next.js that loads **pre-built artifacts** (JSON bundles + DOM rules) from the Lovalingo backend and applies them with **zero-flash**.
+Lovalingo is a React translation library and AI-powered i18n alternative for Lovable, v0, Bolt, and other vibe-coding tools. It delivers SEO-friendly i18n URLs, zero-flash auto-translation, and deterministic JSON bundles. Best Weglot alternative for developers; learn more at https://lovalingo.com.
 
-It does **not** generate translations in the browser.
+Built for React and Next.js apps, Lovalingo does **not** generate translations in the browser and keeps pricing simple (free up to 500 visitors). See https://lovalingo.com/use-cases for examples.
 
-## How it works (high level)
+## i18n alternative for lovable and vibecoding tools
 
 1. Your app renders normally (source language).
 2. Lovalingo loads the current locale’s bundle from the backend.
@@ -30,6 +30,8 @@ Debug (runtime logs): set `window.__lovalingoDebug = true` before initializing `
 npm install @lovalingo/lovalingo react-router-dom
 ```
 
+Pricing and onboarding: https://lovalingo.com
+
 ## React Router
 
 ### Query mode (default)

package/dist/components/AixsterProvider.js

@@ -1,9 +1,8 @@
 import React, { useMemo, useState, useEffect, useCallback, useRef } from 'react';
 import { LovalingoContext } from '../context/LovalingoContext';
 import { LovalingoAPI } from '../utils/api';
-import { Translator } from '../utils/translator';
 import { applyDomRules } from '../utils/domRules';
-import { startMarkerEngine } from '../utils/markerEngine';
+import { applyActiveTranslations, restoreDom, setActiveTranslations, setMarkerEngineExclusions, startMarkerEngine } from '../utils/markerEngine';
 import { logDebug, warnDebug, errorDebug } from '../utils/logger';
 import { LanguageSwitcher } from './LanguageSwitcher';
 import { NavigationOverlay } from './NavigationOverlay';
@@ -51,14 +50,12 @@ navigateRef, // For path mode routing
     const [isLoading, setIsLoading] = useState(false);
     const [isNavigationLoading, setIsNavigationLoading] = useState(false);
     const [editMode, setEditMode] = useState(initialEditMode);
-    const translatorRef = useRef(new Translator());
     // Enhanced path normalization with supportedLocales for path mode
     const enhancedPathConfig = routing === 'path'
         ? { ...pathNormalization, supportedLocales: allLocales }
         : pathNormalization;
     const apiRef = useRef(new LovalingoAPI(resolvedApiKey, apiBase, enhancedPathConfig));
     const [entitlements, setEntitlements] = useState(() => apiRef.current.getEntitlements());
-    const observerRef = useRef(null);
     const retryTimeoutRef = useRef(null);
     const isNavigatingRef = useRef(false);
     const isInternalNavigationRef = useRef(false);
@@ -276,8 +273,8 @@ navigateRef, // For path mode routing
         if (targetLocale === defaultLocale) {
             if (showOverlay)
                 setIsNavigationLoading(false);
-            translatorRef.current.setTranslations([]);
-            translatorRef.current.restoreDOM(); // Safe to restore when going back to source language
+            setActiveTranslations(null);
+            restoreDom(document.body); // React-safe: only text/attrs, no DOM structure mutation
             isNavigatingRef.current = false;
             return;
         }
@@ -291,10 +288,10 @@ navigateRef, // For path mode routing
         if (cachedEntry && cachedExclusions) {
             // CACHE HIT - Use cached data immediately (FAST!)
             logDebug(`[Lovalingo] Using cached translations for ${targetLocale} on ${currentPath}`);
-            translatorRef.current.setTranslations(cachedEntry.translations);
-            translatorRef.current.setExclusions(cachedExclusions);
+            setActiveTranslations(cachedEntry.translations);
+            setMarkerEngineExclusions(cachedExclusions);
             if (mode === 'dom') {
-                translatorRef.current.translateDOM();
+                applyActiveTranslations(document.body);
             }
             if (autoApplyRules) {
                 if (Array.isArray(cachedDomRules)) {
@@ -314,7 +311,7 @@ navigateRef, // For path mode routing
                 }
                 logDebug(`[Lovalingo] 🔄 Retry scan for late-rendering content`);
                 if (mode === 'dom') {
-                    translatorRef.current.translateDOM();
+                    applyActiveTranslations(document.body);
                 }
                 if (autoApplyRules) {
                     const rules = domRulesCacheRef.current.get(cacheKey) || cachedDomRules || [];
@@ -356,10 +353,10 @@ navigateRef, // For path mode routing
             if (autoApplyRules) {
                 domRulesCacheRef.current.set(cacheKey, domRules);
             }
-            translatorRef.current.setTranslations(translations);
-            translatorRef.current.setExclusions(exclusions);
+            setActiveTranslations(translations);
+            setMarkerEngineExclusions(exclusions);
             if (mode === 'dom') {
-                translatorRef.current.translateDOM();
+                applyActiveTranslations(document.body);
             }
             if (autoApplyRules) {
                 applyDomRules(domRules);
@@ -372,7 +369,7 @@ navigateRef, // For path mode routing
                 }
                 logDebug(`[Lovalingo] 🔄 Retry scan for late-rendering content`);
                 if (mode === "dom") {
-                    translatorRef.current.translateDOM();
+                    applyActiveTranslations(document.body);
                 }
                 if (autoApplyRules) {
                     const rules = domRulesCacheRef.current.get(cacheKey) || domRules || [];
@@ -392,7 +389,47 @@ navigateRef, // For path mode routing
             setIsLoading(false);
             isNavigatingRef.current = false;
         }
-    }, [defaultLocale]);
+    }, [autoApplyRules, defaultLocale, mode]);
+    // SPA router hook-in: track History API navigations (React Router/Next/etc) without app changes.
+    useEffect(() => {
+        const historyObj = window.history;
+        const originalPushState = historyObj.pushState.bind(historyObj);
+        const originalReplaceState = historyObj.replaceState.bind(historyObj);
+        const onNavigate = () => {
+            try {
+                apiRef.current.trackPageview(window.location.pathname + window.location.search);
+            }
+            catch {
+                // ignore
+            }
+            const nextLocale = detectLocale();
+            if (nextLocale !== locale) {
+                setLocaleState(nextLocale);
+                void loadData(nextLocale, locale, false);
+            }
+            else if (mode === "dom" && nextLocale !== defaultLocale) {
+                applyActiveTranslations(document.body);
+            }
+        };
+        historyObj.pushState = ((...args) => {
+            const ret = originalPushState(...args);
+            onNavigate();
+            return ret;
+        });
+        historyObj.replaceState = ((...args) => {
+            const ret = originalReplaceState(...args);
+            onNavigate();
+            return ret;
+        });
+        window.addEventListener("popstate", onNavigate);
+        window.addEventListener("hashchange", onNavigate);
+        return () => {
+            historyObj.pushState = originalPushState;
+            historyObj.replaceState = originalReplaceState;
+            window.removeEventListener("popstate", onNavigate);
+            window.removeEventListener("hashchange", onNavigate);
+        };
+    }, [defaultLocale, detectLocale, loadData, locale, mode]);
     // Change locale
     const setLocale = useCallback((newLocale) => {
         void (async () => {
@@ -729,50 +766,17 @@ navigateRef, // For path mode routing
             document.removeEventListener('click', onClickCapture, true);
         };
     }, [routing, autoPrefixLinks, allLocales, locale, navigateRef]);
-    // Set up MutationObserver for dynamic content (DOM mode only)
-    useEffect(() => {
-        if (mode !== 'dom')
-            return; // Skip for context mode
-        if (locale === defaultLocale)
-            return;
-        const observer = new MutationObserver((mutations) => {
-            // SKIP translation during navigation to prevent React conflicts
-            if (isNavigatingRef.current) {
-                return;
-            }
-            mutations.forEach((mutation) => {
-                // Avoid feedback loops: ignore mutations caused by Lovalingo DOM updates.
-                if (mutation.target instanceof HTMLElement) {
-                    if (mutation.target.closest('[data-Lovalingo-translating="1"]')) {
-                        return;
-                    }
-                }
-                mutation.addedNodes.forEach((node) => {
-                    if (node.nodeType === Node.ELEMENT_NODE) {
-                        const el = node;
-                        if (el.closest?.('[data-Lovalingo-translating="1"]'))
-                            return;
-                        translatorRef.current.translateElement(node);
-                    }
-                });
-            });
-        });
-        observer.observe(document.body, {
-            childList: true,
-            subtree: true,
-        });
-        observerRef.current = observer;
-        return () => {
-            observer.disconnect();
-            observerRef.current = null;
-        };
-    }, [locale, defaultLocale, mode]);
+    // Dynamic DOM updates are handled by the marker engine observer (React-safe in-place text/attr updates).
     // No periodic string-miss reporting. Page discovery is tracked via pageview only.
     const translateElement = useCallback((element) => {
-        translatorRef.current.translateElement(element);
+        if (mode !== "dom")
+            return;
+        applyActiveTranslations(element);
     }, []);
     const translateDOM = useCallback(() => {
-        translatorRef.current.translateDOM();
+        if (mode !== "dom")
+            return;
+        applyActiveTranslations(document.body);
     }, []);
     const toggleEditMode = useCallback(() => {
         setEditMode(prev => !prev);
@@ -780,7 +784,7 @@ navigateRef, // For path mode routing
     const excludeElement = useCallback(async (selector) => {
         await apiRef.current.saveExclusion(selector, 'css');
         const exclusions = await apiRef.current.fetchExclusions();
-        translatorRef.current.setExclusions(exclusions);
+        setMarkerEngineExclusions(exclusions);
     }, []);
     const contextValue = {
         locale,

package/dist/utils/markerEngine.d.ts

@@ -1,3 +1,4 @@
+import type { Exclusion, Translation } from "../types";
 type MarkerStats = {
     totalTextNodes: number;
     markedNodes: number;
@@ -15,7 +16,29 @@ type MarkerStats = {
 type MarkerEngineOptions = {
     throttleMs?: number;
 };
+export type DomScanOccurrence = {
+    source_text: string;
+    semantic_context?: string;
+};
+export type DomScanSegment = {
+    kind: "text" | "title" | "aria-label" | "placeholder";
+    selector: string | null;
+    original: string | null;
+    current: string | null;
+    html: null;
+};
+export type DomScanResult = {
+    version: 1;
+    stats: MarkerStats;
+    segments: DomScanSegment[];
+    occurrences: DomScanOccurrence[];
+    truncated: boolean;
+};
 export declare function startMarkerEngine(options?: MarkerEngineOptions): typeof stopMarkerEngine;
 export declare function stopMarkerEngine(): void;
 export declare function getMarkerStats(): MarkerStats;
+export declare function setMarkerEngineExclusions(exclusions: Exclusion[] | null): void;
+export declare function setActiveTranslations(translations: Translation[] | null): void;
+export declare function applyActiveTranslations(root?: ParentNode | null): number;
+export declare function restoreDom(root?: ParentNode | null): void;
 export {};

package/dist/utils/markerEngine.js

@@ -1,9 +1,7 @@
 import { hashContent } from "./hash";
 const DEFAULT_THROTTLE_MS = 150;
 const EXCLUDE_SELECTOR = "[data-lovalingo-exclude],[data-notranslate],[translate-no],[data-no-translate]";
-const MARKER_SELECTOR = "[data-lovalingo-original]";
 const UNSAFE_CONTAINER_TAGS = new Set(["script", "style", "noscript", "template", "svg", "canvas"]);
-const DIRECT_MARK_TAGS = new Set(["option", "textarea"]);
 const ATTRIBUTE_MARKS = [
     { attr: "title", marker: "data-lovalingo-title-original" },
     { attr: "aria-label", marker: "data-lovalingo-aria-label-original" },
@@ -15,6 +13,11 @@ let scheduled = null;
 let running = false;
 let lastStats = buildEmptyStats();
 let throttleMs = DEFAULT_THROTTLE_MS;
+let applying = false;
+let customExcludeSelector = null;
+let activeTranslationMap = null;
+const originalTextByNode = new WeakMap();
+const originalAttrByEl = new WeakMap();
 function buildEmptyStats() {
     return {
         totalTextNodes: 0,
@@ -37,11 +40,31 @@ function setGlobalStats(stats) {
         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 = () => scanDom({ maxSegments: 20000 });
+    g.__lovalingo.dom.apply = (bundle) => ({ applied: applyTranslationMap(bundle, document.body) });
+    g.__lovalingo.dom.restore = () => restoreDom(document.body);
 }
 function isExcludedElement(el) {
     if (!el)
         return false;
-    return Boolean(el.closest(EXCLUDE_SELECTOR));
+    if (el.closest(EXCLUDE_SELECTOR))
+        return true;
+    if (customExcludeSelector) {
+        try {
+            if (el.closest(customExcludeSelector))
+                return true;
+        }
+        catch {
+            // ignore invalid selector strings
+        }
+    }
+    return false;
 }
 function findUnsafeContainer(el) {
     if (!el)
@@ -85,6 +108,9 @@ function buildElementPath(el) {
     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;
@@ -102,18 +128,51 @@ function buildStableId(el, text, textIndex) {
     const raw = `${path}#text[${textIndex}]|${text.trim()}|${key}`;
     return hashContent(raw);
 }
-function markElementDirect(el, rawText, stats) {
-    if (!el.hasAttribute("data-lovalingo-original")) {
-        el.setAttribute("data-lovalingo-original", rawText.trim());
+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;
     }
-    if (!el.hasAttribute("data-lovalingo-id")) {
-        el.setAttribute("data-lovalingo-id", buildStableId(el, rawText, 0));
+    return null;
+}
+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 = new Map();
+        originalAttrByEl.set(el, map);
     }
-    el.setAttribute("data-lovalingo-kind", "text");
-    stats.markedNodes += 1;
-    stats.markedChars += rawText.length;
+    const existing = map.get(attr);
+    if (existing != null)
+        return existing;
+    const value = (el.getAttribute(attr) || "").toString();
+    map.set(attr, value);
+    return value;
 }
-function markTextNode(node, stats) {
+function considerTextNode(node, stats, segments, occurrences, seen, maxSegments) {
     const raw = node.nodeValue || "";
     if (!raw)
         return;
@@ -134,9 +193,6 @@ function markTextNode(node, stats) {
     if (unsafe) {
         stats.skippedUnsafeNodes += 1;
         stats.skippedUnsafeChars += raw.length;
-        if (!unsafe.hasAttribute("data-lovalingo-unsafe")) {
-            unsafe.setAttribute("data-lovalingo-unsafe", unsafe.tagName.toLowerCase());
-        }
         return;
     }
     if (!isTranslatableText(trimmed)) {
@@ -144,53 +200,55 @@ function markTextNode(node, stats) {
         stats.skippedNonTranslatableChars += raw.length;
         return;
     }
-    const existingMarker = parent.closest(MARKER_SELECTOR);
-    if (existingMarker) {
-        if (!existingMarker.getAttribute("data-lovalingo-id")) {
-            const textIndex = getTextNodeIndex(node);
-            existingMarker.setAttribute("data-lovalingo-id", buildStableId(parent, raw, textIndex));
-        }
-        stats.markedNodes += 1;
-        stats.markedChars += raw.length;
-        return;
-    }
-    const parentTag = parent.tagName.toLowerCase();
-    if (DIRECT_MARK_TAGS.has(parentTag)) {
-        markElementDirect(parent, raw, stats);
-        return;
-    }
-    const wrapper = document.createElement("span");
-    wrapper.setAttribute("data-lovalingo-original", trimmed);
-    wrapper.setAttribute("data-lovalingo-id", buildStableId(parent, raw, getTextNodeIndex(node)));
-    wrapper.setAttribute("data-lovalingo-kind", "text");
-    wrapper.setAttribute("data-lovalingo-marker", "1");
-    wrapper.textContent = raw;
-    try {
-        parent.replaceChild(wrapper, node);
-    }
-    catch {
-        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" });
+        }
+    }
 }
-function markAttributes(root) {
+function considerAttributes(root, segments, occurrences, seen, maxSegments) {
     const nodes = root.querySelectorAll("[title],[aria-label],[placeholder]");
     nodes.forEach((el) => {
         if (isExcludedElement(el))
             return;
         if (findUnsafeContainer(el))
             return;
-        for (const { attr, marker } of ATTRIBUTE_MARKS) {
-            if (el.hasAttribute(marker))
-                continue;
+        for (const { attr } of ATTRIBUTE_MARKS) {
             const value = el.getAttribute(attr);
             if (!value)
                 continue;
             const trimmed = value.trim();
             if (!trimmed || !isTranslatableText(trimmed))
                 continue;
-            el.setAttribute(marker, trimmed);
+            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}` });
+            }
         }
     });
 }
@@ -206,27 +264,38 @@ function finalizeStats(stats) {
     stats.coverageRatio = eligibleNodes > 0 ? stats.markedNodes / eligibleNodes : 1;
     stats.coverageRatioChars = eligibleChars > 0 ? stats.markedChars / eligibleChars : 1;
 }
-function scanAndMark() {
-    if (!running)
-        return;
+function scanDom(opts) {
     const root = document.body;
     if (!root) {
-        setGlobalStats(buildEmptyStats());
-        return;
+        const empty = buildEmptyStats();
+        setGlobalStats(empty);
+        return { version: 1, stats: empty, segments: [], occurrences: [], truncated: false };
     }
     const stats = buildEmptyStats();
+    const maxSegments = Math.max(0, Math.floor(opts.maxSegments || 0)) || 20000;
     const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
     const nodes = [];
+    const segments = [];
+    const occurrences = [];
+    const seen = new Set();
     let node = walker.nextNode();
     while (node) {
         if (node.nodeType === Node.TEXT_NODE)
             nodes.push(node);
         node = walker.nextNode();
     }
-    nodes.forEach((textNode) => markTextNode(textNode, stats));
-    markAttributes(root);
+    nodes.forEach((textNode) => considerTextNode(textNode, stats, segments, occurrences, seen, maxSegments));
+    considerAttributes(root, segments, occurrences, seen, maxSegments);
     finalizeStats(stats);
     setGlobalStats(stats);
+    const truncated = segments.length >= maxSegments;
+    return {
+        version: 1,
+        stats,
+        segments,
+        occurrences,
+        truncated,
+    };
 }
 function scheduleScan() {
     if (!running)
@@ -235,7 +304,16 @@ function scheduleScan() {
         return;
     scheduled = window.setTimeout(() => {
         scheduled = null;
-        scanAndMark();
+        try {
+            scanDom({ maxSegments: 20000 });
+            if (activeTranslationMap) {
+                applying = true;
+                applyActiveTranslations(document.body);
+            }
+        }
+        finally {
+            applying = false;
+        }
     }, throttleMs);
 }
 export function startMarkerEngine(options = {}) {
@@ -252,13 +330,17 @@ export function startMarkerEngine(options = {}) {
             window.setTimeout(startObserver, 50);
             return;
         }
-        observer = new MutationObserver(() => scheduleScan());
+        observer = new MutationObserver(() => {
+            if (applying)
+                return;
+            scheduleScan();
+        });
         observer.observe(document.body, {
             childList: true,
             subtree: true,
             characterData: true,
         });
-        scanAndMark();
+        scanDom({ maxSegments: 20000 });
     };
     startObserver();
     return stopMarkerEngine;
@@ -277,3 +359,158 @@ export function stopMarkerEngine() {
 export function getMarkerStats() {
     return lastStats;
 }
+export function setMarkerEngineExclusions(exclusions) {
+    if (!exclusions || exclusions.length === 0) {
+        customExcludeSelector = null;
+        return;
+    }
+    const selectors = exclusions
+        .filter((e) => e && e.type === "css" && typeof e.selector === "string" && e.selector.trim())
+        .map((e) => e.selector.trim());
+    customExcludeSelector = selectors.length ? selectors.join(",") : null;
+}
+export function setActiveTranslations(translations) {
+    if (!translations || translations.length === 0) {
+        activeTranslationMap = null;
+        return;
+    }
+    const map = new Map();
+    for (const t of translations) {
+        const source = (t?.source_text || "").toString().trim();
+        const translated = (t?.translated_text ?? "").toString();
+        if (!source || !translated)
+            continue;
+        map.set(source, translated);
+    }
+    activeTranslationMap = map;
+}
+function applyTranslationMap(bundle, root) {
+    if (!root)
+        return 0;
+    const map = new Map();
+    for (const [k, v] of Object.entries(bundle || {})) {
+        const source = (k || "").toString().trim();
+        const translated = (v ?? "").toString();
+        if (!source || !translated)
+            continue;
+        map.set(source, translated);
+    }
+    activeTranslationMap = map;
+    return applyActiveTranslations(root);
+}
+export function applyActiveTranslations(root = document.body) {
+    if (!root || !activeTranslationMap || activeTranslationMap.size === 0)
+        return 0;
+    const map = activeTranslationMap;
+    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 translation = map.get(original.trimmed);
+        if (!translation)
+            continue;
+        const next = `${original.leading}${translation}${original.trailing}`;
+        if (textNode.nodeValue === next)
+            continue;
+        try {
+            textNode.nodeValue = next;
+            applied += 1;
+        }
+        catch {
+            // ignore
+        }
+    }
+    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 {
+                    // ignore
+                }
+            }
+        });
+    }
+    return applied;
+}
+export 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 {
+                    // ignore
+                }
+            }
+        }
+        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 {
+                    // ignore
+                }
+            }
+        });
+    }
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.1.2";
+export declare const VERSION = "0.2.0";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = "0.1.2";
+export const VERSION = "0.2.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lovalingo/lovalingo",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "React translation runtime with i18n routing, deterministic bundles + DOM rules, and zero-flash rendering.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",