@zumer/snapdom 1.9.8 → 1.9.10-dev.0

package/dist/snapdom.js

@@ -1,13 +1,15 @@
 
 /*
 * snapdom
-* v.1.9.8
+* v.1.9.10-dev.0
 * Author Juan Martin Muda
 * License MIT
 **/
 
 (() => {
   var __defProp = Object.defineProperty;
+  var __defProps = Object.defineProperties;
+  var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
   var __getOwnPropSymbols = Object.getOwnPropertySymbols;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
   var __propIsEnum = Object.prototype.propertyIsEnumerable;
@@ -23,18 +25,7 @@
       }
     return a;
   };
-  var __objRest = (source, exclude) => {
-    var target = {};
-    for (var prop in source)
-      if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
-        target[prop] = source[prop];
-    if (source != null && __getOwnPropSymbols)
-      for (var prop of __getOwnPropSymbols(source)) {
-        if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
-          target[prop] = source[prop];
-      }
-    return target;
-  };
+  var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
   var __async = (__this, __arguments, generator) => {
     return new Promise((resolve, reject) => {
       var fulfilled = (value) => {
@@ -65,23 +56,314 @@
     baseStyle: /* @__PURE__ */ new Map(),
     computedStyle: /* @__PURE__ */ new WeakMap(),
     font: /* @__PURE__ */ new Set(),
-    snapshot: /* @__PURE__ */ new WeakMap(),
-    snapshotKey: /* @__PURE__ */ new Map(),
-    preStyleMap: /* @__PURE__ */ new Map(),
-    preStyle: /* @__PURE__ */ new WeakMap(),
-    preNodeMap: /* @__PURE__ */ new Map(),
-    reset: resetCache
+    session: {
+      styleMap: /* @__PURE__ */ new Map(),
+      styleCache: /* @__PURE__ */ new WeakMap(),
+      nodeMap: /* @__PURE__ */ new Map()
+    }
   };
-  function resetCache() {
-    cache.computedStyle = /* @__PURE__ */ new WeakMap();
-    cache.snapshot = /* @__PURE__ */ new WeakMap();
-    cache.snapshotKey.clear();
-    cache.preStyleMap.clear();
-    cache.preStyle = /* @__PURE__ */ new WeakMap();
-    cache.preNodeMap.clear();
+  function applyCachePolicy(policy = "soft") {
+    switch (policy) {
+      case "auto": {
+        cache.session.styleMap = /* @__PURE__ */ new Map();
+        cache.session.nodeMap = /* @__PURE__ */ new Map();
+        return;
+      }
+      case "soft": {
+        cache.session.styleMap = /* @__PURE__ */ new Map();
+        cache.session.nodeMap = /* @__PURE__ */ new Map();
+        cache.session.styleCache = /* @__PURE__ */ new WeakMap();
+        return;
+      }
+      case "full": {
+        return;
+      }
+      case "disabled": {
+        cache.session.styleMap = /* @__PURE__ */ new Map();
+        cache.session.nodeMap = /* @__PURE__ */ new Map();
+        cache.session.styleCache = /* @__PURE__ */ new WeakMap();
+        cache.image.clear();
+        cache.background.clear();
+        cache.resource.clear();
+        cache.font.clear();
+        return;
+      }
+      default: {
+        cache.session.styleMap = /* @__PURE__ */ new Map();
+        cache.session.nodeMap = /* @__PURE__ */ new Map();
+        cache.session.styleCache = /* @__PURE__ */ new WeakMap();
+        return;
+      }
+    }
+  }
+
+  // src/utils/helpers.js
+  function extractURL(value) {
+    const match = value.match(/url\((['"]?)(.*?)(\1)\)/);
+    if (!match) return null;
+    const url = match[2].trim();
+    if (url.startsWith("#")) return null;
+    return url;
+  }
+  function stripTranslate(transform) {
+    if (!transform || transform === "none") return "";
+    let cleaned = transform.replace(/translate[XY]?\([^)]*\)/g, "");
+    cleaned = cleaned.replace(/matrix\(([^)]+)\)/g, (_, values) => {
+      const parts = values.split(",").map((s) => s.trim());
+      if (parts.length !== 6) return `matrix(${values})`;
+      parts[4] = "0";
+      parts[5] = "0";
+      return `matrix(${parts.join(", ")})`;
+    });
+    cleaned = cleaned.replace(/matrix3d\(([^)]+)\)/g, (_, values) => {
+      const parts = values.split(",").map((s) => s.trim());
+      if (parts.length !== 16) return `matrix3d(${values})`;
+      parts[12] = "0";
+      parts[13] = "0";
+      return `matrix3d(${parts.join(", ")})`;
+    });
+    return cleaned.trim().replace(/\s{2,}/g, " ");
+  }
+  function safeEncodeURI(uri) {
+    if (/%[0-9A-Fa-f]{2}/.test(uri)) return uri;
+    try {
+      return encodeURI(uri);
+    } catch (e) {
+      return uri;
+    }
   }
 
-  // src/utils/cssTools.js
+  // src/modules/snapFetch.js
+  function createSnapLogger(prefix = "[snapDOM]", { ttlMs = 5 * 6e4, maxEntries = 12 } = {}) {
+    const seen = /* @__PURE__ */ new Map();
+    let emitted = 0;
+    function log(level, key, msg) {
+      if (emitted >= maxEntries) return;
+      const now = Date.now();
+      const until = seen.get(key) || 0;
+      if (until > now) return;
+      seen.set(key, now + ttlMs);
+      emitted++;
+      if (level === "warn" && console && console.warn) console.warn(`${prefix} ${msg}`);
+      else if (console && console.error) console.error(`${prefix} ${msg}`);
+    }
+    return {
+      warnOnce(key, msg) {
+        log("warn", key, msg);
+      },
+      errorOnce(key, msg) {
+        log("error", key, msg);
+      },
+      reset() {
+        seen.clear();
+        emitted = 0;
+      }
+    };
+  }
+  var snapLogger = createSnapLogger("[snapDOM]", { ttlMs: 3 * 6e4, maxEntries: 10 });
+  var _inflight = /* @__PURE__ */ new Map();
+  var _errorCache = /* @__PURE__ */ new Map();
+  function isSpecialURL(url) {
+    return /^data:|^blob:|^about:blank$/.test(url);
+  }
+  function shouldProxy(url, useProxy) {
+    if (!useProxy || isSpecialURL(url)) return false;
+    try {
+      const base = typeof location !== "undefined" && location.href ? location.href : "http://localhost/";
+      const u = new URL(url, base);
+      return typeof location !== "undefined" ? u.origin !== location.origin : true;
+    } catch (e) {
+      return !!useProxy;
+    }
+  }
+  function applyProxy(url, useProxy) {
+    if (!useProxy) return url;
+    if (useProxy.includes("{url}")) return useProxy.replace("{url}", encodeURIComponent(url));
+    const sep = useProxy.endsWith("?") ? "" : useProxy.includes("?") ? "&" : "?";
+    return `${useProxy}${sep}url=${encodeURIComponent(url)}`;
+  }
+  function blobToDataURL(blob) {
+    return new Promise((res, rej) => {
+      const fr = new FileReader();
+      fr.onload = () => res(String(fr.result || ""));
+      fr.onerror = () => rej(new Error("read_failed"));
+      fr.readAsDataURL(blob);
+    });
+  }
+  function makeKey(url, o) {
+    var _a, _b;
+    return [
+      o.as || "blob",
+      (_a = o.timeout) != null ? _a : 3e3,
+      o.useProxy || "",
+      (_b = o.errorTTL) != null ? _b : 8e3,
+      url
+    ].join("|");
+  }
+  function snapFetch(_0) {
+    return __async(this, arguments, function* (url, options = {}) {
+      var _a, _b, _c;
+      const as = (_a = options.as) != null ? _a : "blob";
+      const timeout = (_b = options.timeout) != null ? _b : 3e3;
+      const useProxy = options.useProxy || "";
+      const errorTTL = (_c = options.errorTTL) != null ? _c : 8e3;
+      const headers = options.headers || {};
+      const silent = !!options.silent;
+      const key = makeKey(url, { as, timeout, useProxy, errorTTL });
+      const e = _errorCache.get(key);
+      if (e && e.until > Date.now()) {
+        return __spreadProps(__spreadValues({}, e.result), { fromCache: true });
+      } else if (e) {
+        _errorCache.delete(key);
+      }
+      const inflight = _inflight.get(key);
+      if (inflight) return inflight;
+      const finalURL = shouldProxy(url, useProxy) ? applyProxy(url, useProxy) : url;
+      let cred = options.credentials;
+      if (!cred) {
+        try {
+          const base = typeof location !== "undefined" && location.href ? location.href : "http://localhost/";
+          const u = new URL(url, base);
+          const sameOrigin = typeof location !== "undefined" && u.origin === location.origin;
+          cred = sameOrigin ? "include" : "omit";
+        } catch (e2) {
+          cred = "omit";
+        }
+      }
+      const ctrl = new AbortController();
+      const timer = setTimeout(() => ctrl.abort("timeout"), timeout);
+      const p = (() => __async(null, null, function* () {
+        var _a2, _b2;
+        try {
+          const resp = yield fetch(finalURL, { signal: ctrl.signal, credentials: cred, headers });
+          if (!resp.ok) {
+            const result = { ok: false, data: null, status: resp.status, url: finalURL, fromCache: false, reason: "http_error" };
+            _errorCache.set(key, { until: Date.now() + errorTTL, result });
+            if (!silent) {
+              const short = `${resp.status} ${resp.statusText || ""}`.trim();
+              snapLogger.warnOnce(
+                `http:${resp.status}:${as}:${new URL(url, (_a2 = location == null ? void 0 : location.href) != null ? _a2 : "http://localhost/").origin}`,
+                `HTTP error ${short} while fetching ${as} ${url}`
+              );
+            }
+            options.onError && options.onError(result);
+            return result;
+          }
+          if (as === "text") {
+            const text = yield resp.text();
+            return { ok: true, data: text, status: resp.status, url: finalURL, fromCache: false };
+          }
+          const blob = yield resp.blob();
+          const mime = blob.type || resp.headers.get("content-type") || "";
+          if (as === "dataURL") {
+            const dataURL = yield blobToDataURL(blob);
+            return { ok: true, data: dataURL, status: resp.status, url: finalURL, fromCache: false, mime };
+          }
+          return { ok: true, data: blob, status: resp.status, url: finalURL, fromCache: false, mime };
+        } catch (err) {
+          const reason = err && typeof err === "object" && "name" in err && err.name === "AbortError" ? String(err.message || "").includes("timeout") ? "timeout" : "abort" : "network";
+          const result = { ok: false, data: null, status: 0, url: finalURL, fromCache: false, reason };
+          _errorCache.set(key, { until: Date.now() + errorTTL, result });
+          if (!silent) {
+            const k = `${reason}:${as}:${new URL(url, (_b2 = location == null ? void 0 : location.href) != null ? _b2 : "http://localhost/").origin}`;
+            const tips = reason === "timeout" ? `Timeout after ${timeout}ms. Consider increasing timeout or using a proxy for ${url}` : reason === "abort" ? `Request aborted while fetching ${as} ${url}` : `Network/CORS issue while fetching ${as} ${url}. A proxy may be required`;
+            snapLogger.errorOnce(k, tips);
+          }
+          options.onError && options.onError(result);
+          return result;
+        } finally {
+          clearTimeout(timer);
+          _inflight.delete(key);
+        }
+      }))();
+      _inflight.set(key, p);
+      return p;
+    });
+  }
+
+  // src/utils/image.js
+  function createBackground(baseCanvas, backgroundColor) {
+    if (!backgroundColor || !baseCanvas.width || !baseCanvas.height) {
+      return baseCanvas;
+    }
+    const temp = document.createElement("canvas");
+    temp.width = baseCanvas.width;
+    temp.height = baseCanvas.height;
+    const ctx = temp.getContext("2d");
+    ctx.fillStyle = backgroundColor;
+    ctx.fillRect(0, 0, temp.width, temp.height);
+    ctx.drawImage(baseCanvas, 0, 0);
+    return temp;
+  }
+  function inlineSingleBackgroundEntry(_0) {
+    return __async(this, arguments, function* (entry, options = {}) {
+      const isGradient = /^((repeating-)?(linear|radial|conic)-gradient)\(/i.test(entry);
+      if (isGradient || entry.trim() === "none") {
+        return entry;
+      }
+      const rawUrl = extractURL(entry);
+      if (!rawUrl) {
+        return entry;
+      }
+      const encodedUrl = safeEncodeURI(rawUrl);
+      if (cache.background.has(encodedUrl)) {
+        const dataUrl = cache.background.get(encodedUrl);
+        return dataUrl ? `url("${dataUrl}")` : "none";
+      }
+      try {
+        const dataUrl = yield snapFetch(encodedUrl, { as: "dataURL", useProxy: options.useProxy });
+        if (dataUrl.ok) {
+          cache.background.set(encodedUrl, dataUrl.data);
+          return `url("${dataUrl.data}")`;
+        }
+        cache.background.set(encodedUrl, null);
+        return "none";
+      } catch (e) {
+        cache.background.set(encodedUrl, null);
+        return "none";
+      }
+    });
+  }
+
+  // src/utils/css.js
+  var NO_CAPTURE_TAGS = /* @__PURE__ */ new Set([
+    "meta",
+    "script",
+    "noscript",
+    "title",
+    "link",
+    "template"
+  ]);
+  var NO_DEFAULTS_TAGS = /* @__PURE__ */ new Set([
+    // non-painting / head stuff
+    "meta",
+    "link",
+    "style",
+    "title",
+    "noscript",
+    "script",
+    "template",
+    // SVG whole namespace (safe for LeaderLine/presentation attrs)
+    "svg",
+    "g",
+    "defs",
+    "use",
+    "marker",
+    "mask",
+    "clipPath",
+    "pattern",
+    "path",
+    "polygon",
+    "polyline",
+    "line",
+    "circle",
+    "ellipse",
+    "rect",
+    "filter",
+    "lineargradient",
+    "radialgradient",
+    "stop"
+  ]);
   var commonTags = [
     "div",
     "span",
@@ -108,12 +390,6 @@
     "h4",
     "h5",
     "h6",
-    "svg",
-    "path",
-    "circle",
-    "rect",
-    "line",
-    "g",
     "table",
     "thead",
     "tbody",
@@ -123,28 +399,33 @@
   ];
   function precacheCommonTags() {
     for (let tag of commonTags) {
-      getDefaultStyleForTag(tag);
+      const t = String(tag).toLowerCase();
+      if (NO_CAPTURE_TAGS.has(t)) continue;
+      if (NO_DEFAULTS_TAGS.has(t)) continue;
+      getDefaultStyleForTag(t);
     }
   }
   function getDefaultStyleForTag(tagName) {
-    if (cache.defaultStyle.has(tagName)) {
-      return cache.defaultStyle.get(tagName);
-    }
-    const skipTags = /* @__PURE__ */ new Set(["script", "style", "meta", "link", "noscript", "template", "defs", "symbol", "title", "metadata", "desc"]);
-    if (skipTags.has(tagName)) {
+    tagName = String(tagName).toLowerCase();
+    if (NO_DEFAULTS_TAGS.has(tagName)) {
       const empty = {};
       cache.defaultStyle.set(tagName, empty);
       return empty;
     }
+    if (cache.defaultStyle.has(tagName)) {
+      return cache.defaultStyle.get(tagName);
+    }
     let sandbox = document.getElementById("snapdom-sandbox");
     if (!sandbox) {
       sandbox = document.createElement("div");
       sandbox.id = "snapdom-sandbox";
+      sandbox.setAttribute("data-snapdom-sandbox", "true");
+      sandbox.setAttribute("aria-hidden", "true");
       sandbox.style.position = "absolute";
       sandbox.style.left = "-9999px";
       sandbox.style.top = "-9999px";
-      sandbox.style.width = "0";
-      sandbox.style.height = "0";
+      sandbox.style.width = "0px";
+      sandbox.style.height = "0px";
       sandbox.style.overflow = "hidden";
       document.body.appendChild(sandbox);
     }
@@ -154,32 +435,55 @@
     const styles = getComputedStyle(el);
     const defaults = {};
     for (let prop of styles) {
-      defaults[prop] = styles.getPropertyValue(prop);
+      if (shouldIgnoreProp(prop)) continue;
+      const value = styles.getPropertyValue(prop);
+      defaults[prop] = value;
     }
     sandbox.removeChild(el);
     cache.defaultStyle.set(tagName, defaults);
     return defaults;
   }
-  var IGNORED_PROPS = /* @__PURE__ */ new Set([
-    "-webkit-locale"
+  var NO_PAINT_TOKEN = /(?:^|-)(animation|transition)(?:-|$)/i;
+  var NO_PAINT_PREFIX = /^(--|view-timeline|scroll-timeline|animation-trigger|offset-|position-try|app-region|interactivity|overlay|view-transition|-webkit-locale|-webkit-user-(?:drag|modify)|-webkit-tap-highlight-color|-webkit-text-security)$/i;
+  var NO_PAINT_EXACT = /* @__PURE__ */ new Set([
+    // Interaction hints
+    "cursor",
+    "pointer-events",
+    "touch-action",
+    "user-select",
+    // Printing/speech/reading-mode hints
+    "print-color-adjust",
+    "speak",
+    "reading-flow",
+    "reading-order",
+    // Anchoring/container/timeline scopes (metadata for layout queries)
+    "anchor-name",
+    "anchor-scope",
+    "container-name",
+    "container-type",
+    "timeline-scope"
   ]);
-  function getStyleKey(snapshot, tagName, compress = false) {
+  function shouldIgnoreProp(prop) {
+    const p = String(prop).toLowerCase();
+    if (NO_PAINT_EXACT.has(p)) return true;
+    if (NO_PAINT_PREFIX.test(p)) return true;
+    if (NO_PAINT_TOKEN.test(p)) return true;
+    return false;
+  }
+  function getStyleKey(snapshot, tagName) {
+    tagName = String(tagName || "").toLowerCase();
+    if (NO_DEFAULTS_TAGS.has(tagName)) {
+      return "";
+    }
     const entries = [];
-    const defaultStyles = getDefaultStyleForTag(tagName);
+    const defaults = getDefaultStyleForTag(tagName);
     for (let [prop, value] of Object.entries(snapshot)) {
-      if (IGNORED_PROPS.has(prop)) continue;
-      if (!compress) {
-        if (value) {
-          entries.push(`${prop}:${value}`);
-        }
-      } else {
-        const defaultValue = defaultStyles[prop];
-        if (value && value !== defaultValue) {
-          entries.push(`${prop}:${value}`);
-        }
-      }
+      if (shouldIgnoreProp(prop)) continue;
+      const def = defaults[prop];
+      if (value && value !== def) entries.push(`${prop}:${value}`);
     }
-    return entries.sort().join(";");
+    entries.sort();
+    return entries.join(";");
   }
   function collectUsedTagNames(root) {
     const tagSet = /* @__PURE__ */ new Set();
@@ -200,6 +504,7 @@
       const styles = cache.defaultStyle.get(tagName);
       if (!styles) continue;
       const key = Object.entries(styles).map(([k, v]) => `${k}:${v};`).sort().join("");
+      if (!key) continue;
       if (!groups.has(key)) {
         groups.set(key, []);
       }
@@ -212,46 +517,13 @@
     }
     return css;
   }
-  function generateCSSClasses() {
-    const keySet = new Set(cache.preStyleMap.values());
+  function generateCSSClasses(styleMap) {
+    const keys = Array.from(new Set(styleMap.values())).filter(Boolean).sort();
     const classMap = /* @__PURE__ */ new Map();
-    let counter = 1;
-    for (const key of keySet) {
-      if (!key.trim()) continue;
-      classMap.set(key, `c${counter++}`);
-    }
+    let i = 1;
+    for (const k of keys) classMap.set(k, `c${i++}`);
     return classMap;
   }
-
-  // src/utils/helpers.js
-  function inlineSingleBackgroundEntry(_0) {
-    return __async(this, arguments, function* (entry, options = {}) {
-      const rawUrl = extractURL(entry);
-      const isGradient = /^((repeating-)?(linear|radial|conic)-gradient)\(/i.test(entry);
-      if (rawUrl) {
-        const encodedUrl = safeEncodeURI(rawUrl);
-        if (cache.background.has(encodedUrl)) {
-          return options.skipInline ? void 0 : `url(${cache.background.get(encodedUrl)})`;
-        } else {
-          const dataUrl = yield fetchImage(encodedUrl, { useProxy: options.useProxy });
-          cache.background.set(encodedUrl, dataUrl);
-          return options.skipInline ? void 0 : `url("${dataUrl}")`;
-        }
-      }
-      if (isGradient || entry === "none") {
-        return entry;
-      }
-      return entry;
-    });
-  }
-  function idle(fn, { fast = false } = {}) {
-    if (fast) return fn();
-    if ("requestIdleCallback" in window) {
-      requestIdleCallback(fn, { timeout: 50 });
-    } else {
-      setTimeout(fn, 1);
-    }
-  }
   function getStyle(el, pseudo = null) {
     if (!(el instanceof Element)) {
       return window.getComputedStyle(el, pseudo);
@@ -278,124 +550,6 @@
     }
     return clean;
   }
-  function extractURL(value) {
-    const match = value.match(/url\((['"]?)(.*?)(\1)\)/);
-    if (!match) return null;
-    const url = match[2].trim();
-    if (url.startsWith("#")) return null;
-    return url;
-  }
-  function fetchImage(src, { timeout = 3e3, useProxy = "" } = {}) {
-    function getCrossOriginMode(url) {
-      try {
-        const parsed = new URL(url, window.location.href);
-        return parsed.origin === window.location.origin ? "use-credentials" : "anonymous";
-      } catch (e) {
-        return "anonymous";
-      }
-    }
-    function fetchWithFallback(url) {
-      return __async(this, null, function* () {
-        const fetchBlobAsDataURL = (fetchUrl) => fetch(fetchUrl, {
-          mode: "cors",
-          credentials: getCrossOriginMode(fetchUrl) === "use-credentials" ? "include" : "omit"
-        }).then((r) => r.blob()).then((blob) => new Promise((resolve, reject) => {
-          const reader = new FileReader();
-          reader.onloadend = () => {
-            const base64 = reader.result;
-            if (typeof base64 !== "string" || !base64.startsWith("data:image/")) {
-              reject(new Error("Invalid image data URL"));
-              return;
-            }
-            resolve(base64);
-          };
-          reader.onerror = () => reject(new Error("FileReader error"));
-          reader.readAsDataURL(blob);
-        }));
-        try {
-          return yield fetchBlobAsDataURL(url);
-        } catch (e) {
-          if (useProxy && typeof useProxy === "string") {
-            const proxied = useProxy.replace(/\/$/, "") + safeEncodeURI(url);
-            try {
-              return yield fetchBlobAsDataURL(proxied);
-            } catch (e2) {
-              throw new Error("[SnapDOM - fetchImage] CORS restrictions prevented image capture (even via proxy)");
-            }
-          } else {
-            throw new Error("[SnapDOM - fetchImage] Fetch fallback failed and no proxy provided");
-          }
-        }
-      });
-    }
-    const crossOriginValue = getCrossOriginMode(src);
-    if (cache.image.has(src)) {
-      return Promise.resolve(cache.image.get(src));
-    }
-    const isDataURI = src.startsWith("data:image/");
-    if (isDataURI) {
-      cache.image.set(src, src);
-      return Promise.resolve(src);
-    }
-    const isSVG = /\.svg(\?.*)?$/i.test(src);
-    if (isSVG) {
-      return (() => __async(null, null, function* () {
-        try {
-          const response = yield fetch(src, {
-            mode: "cors",
-            credentials: crossOriginValue === "use-credentials" ? "include" : "omit"
-          });
-          const svgText = yield response.text();
-          const encoded = `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svgText)}`;
-          cache.image.set(src, encoded);
-          return encoded;
-        } catch (e) {
-          return fetchWithFallback(src);
-        }
-      }))();
-    }
-    return new Promise((resolve, reject) => {
-      const timeoutId = setTimeout(() => {
-        reject(new Error("[SnapDOM - fetchImage] Image load timed out"));
-      }, timeout);
-      const image = new Image();
-      image.crossOrigin = crossOriginValue;
-      image.onload = () => __async(null, null, function* () {
-        clearTimeout(timeoutId);
-        try {
-          yield image.decode();
-          const canvas = document.createElement("canvas");
-          canvas.width = image.width;
-          canvas.height = image.height;
-          const ctx = canvas.getContext("2d");
-          ctx.drawImage(image, 0, 0, canvas.width, canvas.height);
-          const dataURL = canvas.toDataURL("image/png");
-          cache.image.set(src, dataURL);
-          resolve(dataURL);
-        } catch (e) {
-          try {
-            const fallbackDataURL = yield fetchWithFallback(src);
-            cache.image.set(src, fallbackDataURL);
-            resolve(fallbackDataURL);
-          } catch (e2) {
-            reject(e2);
-          }
-        }
-      });
-      image.onerror = () => __async(null, null, function* () {
-        clearTimeout(timeoutId);
-        console.error(`[SnapDOM - fetchImage] Image failed to load: ${src}`);
-        try {
-          const fallbackDataURL = yield fetchWithFallback(src);
-          cache.image.set(src, fallbackDataURL);
-          resolve(fallbackDataURL);
-        } catch (e) {
-          reject(e);
-        }
-      });
-      image.src = src;
-    });
-  }
   function snapshotComputedStyle(style) {
     const snap = {};
     for (let prop of style) {
@@ -403,36 +557,6 @@
     }
     return snap;
   }
-  function isSafari() {
-    return /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
-  }
-  function stripTranslate(transform) {
-    if (!transform || transform === "none") return "";
-    let cleaned = transform.replace(/translate[XY]?\([^)]*\)/g, "");
-    cleaned = cleaned.replace(/matrix\(([^)]+)\)/g, (_, values) => {
-      const parts = values.split(",").map((s) => s.trim());
-      if (parts.length !== 6) return `matrix(${values})`;
-      parts[4] = "0";
-      parts[5] = "0";
-      return `matrix(${parts.join(", ")})`;
-    });
-    cleaned = cleaned.replace(/matrix3d\(([^)]+)\)/g, (_, values) => {
-      const parts = values.split(",").map((s) => s.trim());
-      if (parts.length !== 16) return `matrix3d(${values})`;
-      parts[12] = "0";
-      parts[13] = "0";
-      return `matrix3d(${parts.join(", ")})`;
-    });
-    return cleaned.trim().replace(/\s{2,}/g, " ");
-  }
-  function safeEncodeURI(uri) {
-    if (/%[0-9A-Fa-f]{2}/.test(uri)) return uri;
-    try {
-      return encodeURI(uri);
-    } catch (e) {
-      return uri;
-    }
-  }
   function splitBackgroundImage(bg) {
     const parts = [];
     let depth = 0;
@@ -450,52 +574,277 @@
     return parts;
   }
 
+  // src/utils/browser.js
+  function idle(fn, { fast = false } = {}) {
+    if (fast) return fn();
+    if ("requestIdleCallback" in window) {
+      requestIdleCallback(fn, { timeout: 50 });
+    } else {
+      setTimeout(fn, 1);
+    }
+  }
+  function isSafari() {
+    return /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+  }
+
   // src/modules/styles.js
+  var snapshotCache = /* @__PURE__ */ new WeakMap();
+  var snapshotKeyCache = /* @__PURE__ */ new Map();
+  var __epoch = 0;
+  function bumpEpoch() {
+    __epoch++;
+  }
+  var __wired = false;
+  function setupInvalidationOnce(root = document.documentElement) {
+    var _a, _b;
+    if (__wired) return;
+    __wired = true;
+    try {
+      const domObs = new MutationObserver(() => bumpEpoch());
+      domObs.observe(root, { subtree: true, childList: true, characterData: true, attributes: true });
+    } catch (e) {
+    }
+    try {
+      const headObs = new MutationObserver(() => bumpEpoch());
+      headObs.observe(document.head, { subtree: true, childList: true, characterData: true, attributes: true });
+    } catch (e) {
+    }
+    try {
+      const f = document.fonts;
+      if (f) {
+        (_a = f.addEventListener) == null ? void 0 : _a.call(f, "loadingdone", bumpEpoch);
+        (_b = f.ready) == null ? void 0 : _b.then(() => bumpEpoch()).catch(() => {
+        });
+      }
+    } catch (e) {
+    }
+  }
   function snapshotComputedStyleFull(style) {
-    const result = {};
-    const computedVisibility = style.getPropertyValue("visibility");
+    const out = {};
+    const vis = style.getPropertyValue("visibility");
     for (let i = 0; i < style.length; i++) {
       const prop = style[i];
       let val = style.getPropertyValue(prop);
       if ((prop === "background-image" || prop === "content") && val.includes("url(") && !val.includes("data:")) {
         val = "none";
       }
-      result[prop] = val;
+      out[prop] = val;
     }
-    if (computedVisibility === "hidden") {
-      result.opacity = "0";
+    if (vis === "hidden") out.opacity = "0";
+    return out;
+  }
+  var __snapshotSig = /* @__PURE__ */ new WeakMap();
+  function styleSignature(snap) {
+    let sig = __snapshotSig.get(snap);
+    if (sig) return sig;
+    const entries = Object.entries(snap).sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+    sig = entries.map(([k, v]) => `${k}:${v}`).join(";");
+    __snapshotSig.set(snap, sig);
+    return sig;
+  }
+  function getSnapshot(el, preStyle = null) {
+    const rec = snapshotCache.get(el);
+    if (rec && rec.epoch === __epoch) return rec.snapshot;
+    const style = preStyle || getComputedStyle(el);
+    const snap = snapshotComputedStyleFull(style);
+    snapshotCache.set(el, { epoch: __epoch, snapshot: snap });
+    return snap;
+  }
+  function _resolveCtx(sessionOrCtx, opts) {
+    if (sessionOrCtx && sessionOrCtx.session && sessionOrCtx.persist) return sessionOrCtx;
+    if (sessionOrCtx && (sessionOrCtx.styleMap || sessionOrCtx.styleCache || sessionOrCtx.nodeMap)) {
+      return {
+        session: sessionOrCtx,
+        persist: {
+          snapshotKeyCache,
+          defaultStyle: cache.defaultStyle,
+          baseStyle: cache.baseStyle,
+          image: cache.image,
+          resource: cache.resource,
+          background: cache.background,
+          font: cache.font
+        },
+        options: opts || {}
+      };
     }
-    return result;
+    return {
+      session: cache.session,
+      persist: {
+        snapshotKeyCache,
+        defaultStyle: cache.defaultStyle,
+        baseStyle: cache.baseStyle,
+        image: cache.image,
+        resource: cache.resource,
+        background: cache.background,
+        font: cache.font
+      },
+      options: sessionOrCtx || opts || {}
+    };
   }
-  function inlineAllStyles(source, clone, compress) {
-    var _a;
-    if (source.tagName === "STYLE") return;
-    if (!cache.preStyle.has(source)) {
-      cache.preStyle.set(source, getStyle(source));
-    }
-    const style = cache.preStyle.get(source);
-    if (!cache.snapshot.has(source)) {
-      const snapshot2 = snapshotComputedStyleFull(style);
-      cache.snapshot.set(source, snapshot2);
-    }
-    const snapshot = cache.snapshot.get(source);
-    const hash = Object.entries(snapshot).sort(([a], [b]) => a.localeCompare(b)).map(([prop, val]) => `${prop}:${val}`).join(";");
-    if (cache.snapshotKey.has(hash)) {
-      cache.preStyleMap.set(clone, cache.snapshotKey.get(hash));
-      return;
-    }
-    const tagName = ((_a = source.tagName) == null ? void 0 : _a.toLowerCase()) || "div";
-    const key = getStyleKey(snapshot, tagName, compress);
-    cache.snapshotKey.set(hash, key);
-    cache.preStyleMap.set(clone, key);
+  function inlineAllStyles(source, clone, sessionOrCtx, opts) {
+    return __async(this, null, function* () {
+      var _a, _b, _c;
+      if (source.tagName === "STYLE") return;
+      const ctx = _resolveCtx(sessionOrCtx, opts);
+      const resetMode = ctx.options && ctx.options.cache || "auto";
+      if (resetMode !== "disabled") setupInvalidationOnce(document.documentElement);
+      if (NO_DEFAULTS_TAGS.has((_a = source.tagName) == null ? void 0 : _a.toLowerCase())) {
+        const author = (_b = source.getAttribute) == null ? void 0 : _b.call(source, "style");
+        if (author) clone.setAttribute("style", author);
+      }
+      const { session, persist } = ctx;
+      if (!session.styleCache.has(source)) {
+        session.styleCache.set(source, getComputedStyle(source));
+      }
+      const pre = session.styleCache.get(source);
+      const snap = getSnapshot(source, pre);
+      const sig = styleSignature(snap);
+      let key = persist.snapshotKeyCache.get(sig);
+      if (!key) {
+        const tag = ((_c = source.tagName) == null ? void 0 : _c.toLowerCase()) || "div";
+        key = getStyleKey(snap, tag);
+        persist.snapshotKeyCache.set(sig, key);
+      }
+      session.styleMap.set(clone, key);
+    });
   }
 
   // src/core/clone.js
-  function deepClone(node, compress, options = {}, originalRoot) {
-    var _a, _b;
+  function addNotSlottedRightmost(sel) {
+    sel = sel.trim();
+    if (!sel) return sel;
+    if (/\:not\(\s*\[data-sd-slotted\]\s*\)\s*$/.test(sel)) return sel;
+    return `${sel}:not([data-sd-slotted])`;
+  }
+  function wrapWithScope(selectorList, scopeSelector, excludeSlotted = true) {
+    return selectorList.split(",").map((s) => s.trim()).filter(Boolean).map((s) => {
+      if (s.startsWith(":where(")) return s;
+      if (s.startsWith("@")) return s;
+      const body = excludeSlotted ? addNotSlottedRightmost(s) : s;
+      return `:where(${scopeSelector} ${body})`;
+    }).join(", ");
+  }
+  function rewriteShadowCSS(cssText, scopeSelector) {
+    if (!cssText) return "";
+    cssText = cssText.replace(/:host\(([^)]+)\)/g, (_, sel) => {
+      return `:where(${scopeSelector}:is(${sel.trim()}))`;
+    });
+    cssText = cssText.replace(/:host\b/g, `:where(${scopeSelector})`);
+    cssText = cssText.replace(/:host-context\(([^)]+)\)/g, (_, sel) => {
+      return `:where(:where(${sel.trim()}) ${scopeSelector})`;
+    });
+    cssText = cssText.replace(/::slotted\(([^)]+)\)/g, (_, sel) => {
+      return `:where(${scopeSelector} ${sel.trim()})`;
+    });
+    cssText = cssText.replace(/(^|})(\s*)([^@}{]+){/g, (_, brace, ws, selectorList) => {
+      const wrapped = wrapWithScope(
+        selectorList,
+        scopeSelector,
+        /*excludeSlotted*/
+        true
+      );
+      return `${brace}${ws}${wrapped}{`;
+    });
+    return cssText;
+  }
+  function nextShadowScopeId(sessionCache) {
+    sessionCache.shadowScopeSeq = (sessionCache.shadowScopeSeq || 0) + 1;
+    return `s${sessionCache.shadowScopeSeq}`;
+  }
+  function extractShadowCSS(sr) {
+    let css = "";
+    try {
+      sr.querySelectorAll("style").forEach((s) => {
+        css += (s.textContent || "") + "\n";
+      });
+      const sheets = sr.adoptedStyleSheets || [];
+      for (const sh of sheets) {
+        try {
+          if (sh && sh.cssRules) {
+            for (const rule of sh.cssRules) css += rule.cssText + "\n";
+          }
+        } catch (e) {
+        }
+      }
+    } catch (e) {
+    }
+    return css;
+  }
+  function injectScopedStyle(hostClone, cssText, scopeId) {
+    if (!cssText) return;
+    const style = document.createElement("style");
+    style.setAttribute("data-sd", scopeId);
+    style.textContent = cssText;
+    hostClone.insertBefore(style, hostClone.firstChild || null);
+  }
+  function freezeImgSrcset(original, cloned) {
+    try {
+      const chosen = original.currentSrc || original.src || "";
+      if (!chosen) return;
+      cloned.setAttribute("src", chosen);
+      cloned.removeAttribute("srcset");
+      cloned.removeAttribute("sizes");
+      cloned.loading = "eager";
+      cloned.decoding = "sync";
+    } catch (e) {
+    }
+  }
+  function collectCustomPropsFromCSS(cssText) {
+    const out = /* @__PURE__ */ new Set();
+    if (!cssText) return out;
+    const re = /var\(\s*(--[A-Za-z0-9_-]+)\b/g;
+    let m;
+    while (m = re.exec(cssText)) out.add(m[1]);
+    return out;
+  }
+  function resolveCustomProp(el, name) {
+    try {
+      const cs = getComputedStyle(el);
+      let v = cs.getPropertyValue(name).trim();
+      if (v) return v;
+    } catch (e) {
+    }
+    try {
+      const rootCS = getComputedStyle(document.documentElement);
+      let v = rootCS.getPropertyValue(name).trim();
+      if (v) return v;
+    } catch (e) {
+    }
+    return "";
+  }
+  function buildSeedCustomPropsRule(hostEl, names, scopeSelector) {
+    const decls = [];
+    for (const name of names) {
+      const val = resolveCustomProp(hostEl, name);
+      if (val) decls.push(`${name}: ${val};`);
+    }
+    if (!decls.length) return "";
+    return `${scopeSelector}{${decls.join("")}}
+`;
+  }
+  function markSlottedSubtree(root) {
+    if (!root) return;
+    if (root.nodeType === Node.ELEMENT_NODE) {
+      root.setAttribute("data-sd-slotted", "");
+    }
+    if (root.querySelectorAll) {
+      root.querySelectorAll("*").forEach((el) => el.setAttribute("data-sd-slotted", ""));
+    }
+  }
+  function deepClone(node, sessionCache, options) {
+    var _a, _b, _c, _d, _e;
     if (!node) throw new Error("Invalid node");
     const clonedAssignedNodes = /* @__PURE__ */ new Set();
     let pendingSelectValue = null;
+    if (node.nodeType === Node.ELEMENT_NODE) {
+      const tag = (node.localName || node.tagName || "").toLowerCase();
+      if (node.id === "snapdom-sandbox" || node.hasAttribute("data-snapdom-sandbox")) {
+        return null;
+      }
+      if (NO_CAPTURE_TAGS.has(tag)) {
+        return null;
+      }
+    }
     if (node.nodeType === Node.TEXT_NODE) {
       return node.cloneNode(true);
     }
@@ -524,7 +873,7 @@
     }
     if (typeof options.filter === "function") {
       try {
-        if (!options.filter(node, originalRoot || node)) {
+        if (!options.filter(node)) {
           const spacer = document.createElement("div");
           const rect = node.getBoundingClientRect();
           spacer.style.cssText = `display:inline-block;width:${rect.width}px;height:${rect.height}px;visibility:hidden;`;
@@ -541,8 +890,8 @@
     }
     if (node.getAttribute("data-capture") === "placeholder") {
       const clone2 = node.cloneNode(false);
-      cache.preNodeMap.set(clone2, node);
-      inlineAllStyles(node, clone2, compress);
+      sessionCache.nodeMap.set(clone2, node);
+      inlineAllStyles(node, clone2, sessionCache, options);
       const placeholder = document.createElement("div");
       placeholder.textContent = node.getAttribute("data-placeholder-text") || "";
       placeholder.style.cssText = `color:#666;font-size:12px;text-align:center;line-height:1.4;padding:0.5em;box-sizing:border-box;`;
@@ -555,14 +904,17 @@
       img.src = dataURL;
       img.width = node.width;
       img.height = node.height;
-      cache.preNodeMap.set(img, node);
-      inlineAllStyles(node, img, compress);
+      sessionCache.nodeMap.set(img, node);
+      inlineAllStyles(node, img, sessionCache, options);
       return img;
     }
     let clone;
     try {
       clone = node.cloneNode(false);
-      cache.preNodeMap.set(clone, node);
+      sessionCache.nodeMap.set(clone, node);
+      if (node.tagName === "IMG") {
+        freezeImgSrcset(node, clone);
+      }
     } catch (err) {
       console.error("[Snapdom] Failed to clone node:", node, err);
       throw err;
@@ -587,49 +939,56 @@
     if (node instanceof HTMLSelectElement) {
       pendingSelectValue = node.value;
     }
-    inlineAllStyles(node, clone, compress);
+    inlineAllStyles(node, clone, sessionCache, options);
     if (node.shadowRoot) {
-      const hasSlot = Array.from(node.shadowRoot.querySelectorAll("slot")).length > 0;
-      if (hasSlot) {
-        for (const child of node.shadowRoot.childNodes) {
-          if (child.nodeType === Node.ELEMENT_NODE && child.tagName === "STYLE") {
-            const cssText = child.textContent || "";
-            if (cssText.trim() && compress) {
-              if (!cache.preStyle) cache.preStyle = /* @__PURE__ */ new WeakMap();
-              cache.preStyle.set(child, cssText);
-            }
-          }
-        }
-      } else {
-        const shadowFrag = document.createDocumentFragment();
-        for (const child of node.shadowRoot.childNodes) {
-          if (child.nodeType === Node.ELEMENT_NODE && child.tagName === "STYLE") {
-            const cssText = child.textContent || "";
-            if (cssText.trim() && compress) {
-              if (!cache.preStyle) cache.preStyle = /* @__PURE__ */ new WeakMap();
-              cache.preStyle.set(child, cssText);
-            }
-            continue;
+      try {
+        const slots = node.shadowRoot.querySelectorAll("slot");
+        for (const s of slots) {
+          let assigned = [];
+          try {
+            assigned = ((_b = s.assignedNodes) == null ? void 0 : _b.call(s, { flatten: true })) || ((_c = s.assignedNodes) == null ? void 0 : _c.call(s)) || [];
+          } catch (e) {
+            assigned = ((_d = s.assignedNodes) == null ? void 0 : _d.call(s)) || [];
           }
-          const clonedChild = deepClone(child, compress, options, originalRoot || node);
-          if (clonedChild) shadowFrag.appendChild(clonedChild);
+          for (const an of assigned) clonedAssignedNodes.add(an);
         }
-        clone.appendChild(shadowFrag);
+      } catch (e) {
+      }
+      const scopeId = nextShadowScopeId(sessionCache);
+      const scopeSelector = `[data-sd="${scopeId}"]`;
+      try {
+        clone.setAttribute("data-sd", scopeId);
+      } catch (e) {
       }
+      const rawCSS = extractShadowCSS(node.shadowRoot);
+      const rewritten = rewriteShadowCSS(rawCSS, scopeSelector);
+      const neededVars = collectCustomPropsFromCSS(rawCSS);
+      const seed = buildSeedCustomPropsRule(node, neededVars, scopeSelector);
+      injectScopedStyle(clone, seed + rewritten, scopeId);
+      const shadowFrag = document.createDocumentFragment();
+      for (const child of node.shadowRoot.childNodes) {
+        if (child.nodeType === Node.ELEMENT_NODE && child.tagName === "STYLE") continue;
+        const clonedChild = deepClone(child, sessionCache, options);
+        if (clonedChild) shadowFrag.appendChild(clonedChild);
+      }
+      clone.appendChild(shadowFrag);
     }
     if (node.tagName === "SLOT") {
-      const assigned = ((_b = node.assignedNodes) == null ? void 0 : _b.call(node, { flatten: true })) || [];
+      const assigned = ((_e = node.assignedNodes) == null ? void 0 : _e.call(node, { flatten: true })) || [];
       const nodesToClone = assigned.length > 0 ? assigned : Array.from(node.childNodes);
       const fragment = document.createDocumentFragment();
       for (const child of nodesToClone) {
-        const clonedChild = deepClone(child, compress, options, originalRoot || node);
-        if (clonedChild) fragment.appendChild(clonedChild);
+        const clonedChild = deepClone(child, sessionCache, options);
+        if (clonedChild) {
+          markSlottedSubtree(clonedChild);
+          fragment.appendChild(clonedChild);
+        }
       }
       return fragment;
     }
     for (const child of node.childNodes) {
       if (clonedAssignedNodes.has(child)) continue;
-      const clonedChild = deepClone(child, compress, options, originalRoot || node);
+      const clonedChild = deepClone(child, sessionCache, options);
       if (clonedChild) clone.appendChild(clonedChild);
     }
     if (pendingSelectValue !== null && clone instanceof HTMLSelectElement) {
@@ -672,7 +1031,7 @@
       }
     }
   }
-  function isIconFont(input) {
+  function isIconFont2(input) {
     const text = typeof input === "string" ? input : "";
     const candidates = [...defaultIconFonts, ...userIconFonts];
     for (const rx of candidates) {
@@ -721,192 +1080,630 @@
       };
     });
   }
-  function isStylesheetLoaded(href) {
-    return Array.from(document.styleSheets).some((sheet) => sheet.href === href);
-  }
-  function injectLinkIfMissing(href) {
-    return new Promise((resolve) => {
-      if (isStylesheetLoaded(href)) return resolve(null);
-      const link = document.createElement("link");
-      link.rel = "stylesheet";
-      link.href = href;
-      link.setAttribute("data-snapdom", "injected-import");
-      link.onload = () => resolve(link);
-      link.onerror = () => resolve(null);
-      document.head.appendChild(link);
-    });
+  var GENERIC_FAMILIES = /* @__PURE__ */ new Set([
+    "serif",
+    "sans-serif",
+    "monospace",
+    "cursive",
+    "fantasy",
+    "system-ui",
+    "emoji",
+    "math",
+    "fangsong",
+    "ui-serif",
+    "ui-sans-serif",
+    "ui-monospace",
+    "ui-rounded"
+  ]);
+  function pickPrimaryFamily(familyList) {
+    if (!familyList) return "";
+    for (let raw of familyList.split(",")) {
+      let f = raw.trim().replace(/^['"]+|['"]+$/g, "");
+      if (!f) continue;
+      if (!GENERIC_FAMILIES.has(f.toLowerCase())) return f;
+    }
+    return "";
+  }
+  function normWeight(w) {
+    const t = String(w != null ? w : "400").trim().toLowerCase();
+    if (t === "normal") return 400;
+    if (t === "bold") return 700;
+    const n = parseInt(t, 10);
+    return Number.isFinite(n) ? Math.min(900, Math.max(100, n)) : 400;
+  }
+  function normStyle(s) {
+    const t = String(s != null ? s : "normal").trim().toLowerCase();
+    if (t.startsWith("italic")) return "italic";
+    if (t.startsWith("oblique")) return "oblique";
+    return "normal";
+  }
+  function normStretchPct(st) {
+    const m = String(st != null ? st : "100%").match(/(\d+(?:\.\d+)?)\s*%/);
+    return m ? Math.max(50, Math.min(200, parseFloat(m[1]))) : 100;
+  }
+  function parseWeightSpec(spec) {
+    const s = String(spec || "400").trim();
+    const m = s.match(/^(\d{2,3})\s+(\d{2,3})$/);
+    if (m) {
+      const a = normWeight(m[1]), b = normWeight(m[2]);
+      return { min: Math.min(a, b), max: Math.max(a, b) };
+    }
+    const v = normWeight(s);
+    return { min: v, max: v };
+  }
+  function parseStyleSpec(spec) {
+    const t = String(spec || "normal").trim().toLowerCase();
+    if (t === "italic") return { kind: "italic" };
+    if (t.startsWith("oblique")) return { kind: "oblique" };
+    return { kind: "normal" };
+  }
+  function parseStretchSpec(spec) {
+    const s = String(spec || "100%").trim();
+    const mm = s.match(/(\d+(?:\.\d+)?)\s*%\s+(\d+(?:\.\d+)?)\s*%/);
+    if (mm) {
+      const a = parseFloat(mm[1]), b = parseFloat(mm[2]);
+      return { min: Math.min(a, b), max: Math.max(a, b) };
+    }
+    const m = s.match(/(\d+(?:\.\d+)?)\s*%/);
+    const v = m ? parseFloat(m[1]) : 100;
+    return { min: v, max: v };
+  }
+  function isLikelyFontStylesheet(href, requiredFamilies) {
+    if (!href) return false;
+    try {
+      const u = new URL(href, location.href);
+      const sameOrigin = u.origin === location.origin;
+      if (sameOrigin) return true;
+      const host = u.host.toLowerCase();
+      const FONT_HOSTS = [
+        "fonts.googleapis.com",
+        "fonts.gstatic.com",
+        "use.typekit.net",
+        "p.typekit.net",
+        "kit.fontawesome.com",
+        "use.fontawesome.com"
+      ];
+      if (FONT_HOSTS.some((h) => host.endsWith(h))) return true;
+      const path = (u.pathname + u.search).toLowerCase();
+      if (/\bfont(s)?\b/.test(path) || /\.woff2?(\b|$)/.test(path)) return true;
+      for (const fam of requiredFamilies) {
+        const tokenA = fam.toLowerCase().replace(/\s+/g, "+");
+        const tokenB = fam.toLowerCase().replace(/\s+/g, "-");
+        if (path.includes(tokenA) || path.includes(tokenB)) return true;
+      }
+      return false;
+    } catch (e) {
+      return false;
+    }
+  }
+  function familiesFromRequired(required) {
+    var _a;
+    const out = /* @__PURE__ */ new Set();
+    for (const k of required || []) {
+      const fam = (_a = String(k).split("__")[0]) == null ? void 0 : _a.trim();
+      if (fam) out.add(fam);
+    }
+    return out;
   }
   function embedCustomFonts() {
-    return __async(this, arguments, function* ({ preCached = false } = {}) {
-      if (cache.resource.has("fonts-embed-css")) {
-        if (preCached) {
-          const style = document.createElement("style");
-          style.setAttribute("data-snapdom", "embedFonts");
-          style.textContent = cache.resource.get("fonts-embed-css");
-          document.head.appendChild(style);
+    return __async(this, arguments, function* ({
+      required,
+      usedCodepoints,
+      exclude = void 0,
+      localFonts = [],
+      useProxy = ""
+    } = {}) {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r;
+      if (!(required instanceof Set)) required = /* @__PURE__ */ new Set();
+      if (!(usedCodepoints instanceof Set)) usedCodepoints = /* @__PURE__ */ new Set();
+      const requiredIndex = /* @__PURE__ */ new Map();
+      for (const key of required) {
+        const [fam, w, s, st] = String(key).split("__");
+        if (!fam) continue;
+        const arr = requiredIndex.get(fam) || [];
+        arr.push({ w: parseInt(w, 10), s, st: parseInt(st, 10) });
+        requiredIndex.set(fam, arr);
+      }
+      const IMPORT_RE = /@import\s+url\(["']?([^"')]+)["']?\)/g;
+      const URL_RE = /url\((["']?)([^"')]+)\1\)/g;
+      const FACE_RE = /@font-face[^{}]*\{[^}]*\}/g;
+      function faceMatchesRequired(fam, styleSpec, weightSpec, stretchSpec) {
+        if (!requiredIndex.has(fam)) return false;
+        const need = requiredIndex.get(fam);
+        const ws = parseWeightSpec(weightSpec);
+        const ss = parseStyleSpec(styleSpec);
+        const ts = parseStretchSpec(stretchSpec);
+        const faceIsRange = ws.min !== ws.max;
+        const faceSingleW = ws.min;
+        const styleOK = (reqKind) => ss.kind === "normal" && reqKind === "normal" || ss.kind !== "normal" && (reqKind === "italic" || reqKind === "oblique");
+        let exactMatched = false;
+        for (const r of need) {
+          const wOk = faceIsRange ? r.w >= ws.min && r.w <= ws.max : r.w === faceSingleW;
+          const sOk = styleOK(normStyle(r.s));
+          const tOk = r.st >= ts.min && r.st <= ts.max;
+          if (wOk && sOk && tOk) {
+            exactMatched = true;
+            break;
+          }
+        }
+        if (exactMatched) return true;
+        if (!faceIsRange) {
+          for (const r of need) {
+            const sOk = styleOK(normStyle(r.s));
+            const tOk = r.st >= ts.min && r.st <= ts.max;
+            const nearWeight = Math.abs(faceSingleW - r.w) <= 300;
+            if (nearWeight && sOk && tOk) {
+              return true;
+            }
+          }
+        }
+        return false;
+      }
+      function parseUnicodeRange(ur) {
+        if (!ur) return [];
+        const ranges = [];
+        const parts = ur.split(",").map((s) => s.trim()).filter(Boolean);
+        for (const p of parts) {
+          const m = p.match(/^U\+([0-9A-Fa-f?]+)(?:-([0-9A-Fa-f?]+))?$/);
+          if (!m) continue;
+          const a = m[1], b = m[2];
+          const expand = (hex) => {
+            if (!hex.includes("?")) return parseInt(hex, 16);
+            const min = parseInt(hex.replace(/\?/g, "0"), 16);
+            const max = parseInt(hex.replace(/\?/g, "F"), 16);
+            return [min, max];
+          };
+          if (b) {
+            const A = expand(a), B = expand(b);
+            const min = Array.isArray(A) ? A[0] : A;
+            const max = Array.isArray(B) ? B[1] : B;
+            ranges.push([Math.min(min, max), Math.max(min, max)]);
+          } else {
+            const X = expand(a);
+            if (Array.isArray(X)) ranges.push([X[0], X[1]]);
+            else ranges.push([X, X]);
+          }
+        }
+        return ranges;
+      }
+      function unicodeIntersects(used, ranges) {
+        if (!ranges.length) return true;
+        if (!used || used.size === 0) return true;
+        for (const cp of used) {
+          for (const [a, b] of ranges) if (cp >= a && cp <= b) return true;
+        }
+        return false;
+      }
+      function extractSrcUrls(srcValue, baseHref) {
+        const urls = [];
+        if (!srcValue) return urls;
+        for (const m of srcValue.matchAll(URL_RE)) {
+          let u = (m[2] || "").trim();
+          if (!u || u.startsWith("data:")) continue;
+          if (!/^https?:/i.test(u)) {
+            try {
+              u = new URL(u, baseHref || location.href).href;
+            } catch (e) {
+            }
+          }
+          urls.push(u);
+        }
+        return urls;
+      }
+      function inlineUrlsInCssBlock(cssBlock, baseHref) {
+        return __async(this, null, function* () {
+          var _a2, _b2, _c2, _d2, _e2;
+          let out = cssBlock;
+          for (const m of cssBlock.matchAll(URL_RE)) {
+            const raw = extractURL(m[0]);
+            if (!raw) continue;
+            let abs = raw;
+            if (!abs.startsWith("http") && !abs.startsWith("data:")) {
+              try {
+                abs = new URL(abs, baseHref || location.href).href;
+              } catch (e) {
+              }
+            }
+            if (isIconFont2(abs)) continue;
+            if ((_a2 = cache.resource) == null ? void 0 : _a2.has(abs)) {
+              (_b2 = cache.font) == null ? void 0 : _b2.add(abs);
+              out = out.replace(m[0], `url(${cache.resource.get(abs)})`);
+              continue;
+            }
+            if ((_c2 = cache.font) == null ? void 0 : _c2.has(abs)) continue;
+            try {
+              const r = yield snapFetch(abs, { as: "dataURL", useProxy, silent: true });
+              if (r.ok && typeof r.data === "string") {
+                const b64 = r.data;
+                (_d2 = cache.resource) == null ? void 0 : _d2.set(abs, b64);
+                (_e2 = cache.font) == null ? void 0 : _e2.add(abs);
+                out = out.replace(m[0], `url(${b64})`);
+              }
+            } catch (e) {
+              console.warn("[snapDOM] Failed to fetch font resource:", abs);
+            }
+          }
+          return out;
+        });
+      }
+      function subsetFromRanges(ranges) {
+        if (!ranges.length) return null;
+        const hit = (a, b) => ranges.some(([x, y]) => !(y < a || x > b));
+        const latin = hit(0, 255) || hit(305, 305);
+        const latinExt = hit(256, 591) || hit(7680, 7935);
+        const greek = hit(880, 1023);
+        const cyr = hit(1024, 1279);
+        const viet = hit(7840, 7929) || hit(258, 259) || hit(416, 417) || hit(431, 432);
+        if (viet) return "vietnamese";
+        if (cyr) return "cyrillic";
+        if (greek) return "greek";
+        if (latinExt) return "latin-ext";
+        if (latin) return "latin";
+        return null;
+      }
+      function buildSimpleExcluder(ex = {}) {
+        const famSet = new Set((ex.families || []).map((s) => String(s).toLowerCase()));
+        const domSet = new Set((ex.domains || []).map((s) => String(s).toLowerCase()));
+        const subSet = new Set((ex.subsets || []).map((s) => String(s).toLowerCase()));
+        return (meta, parsedRanges) => {
+          if (famSet.size && famSet.has(meta.family.toLowerCase())) return true;
+          if (domSet.size) {
+            for (const u of meta.srcUrls) {
+              try {
+                if (domSet.has(new URL(u).host.toLowerCase())) return true;
+              } catch (e) {
+              }
+            }
+          }
+          if (subSet.size) {
+            const label = subsetFromRanges(parsedRanges);
+            if (label && subSet.has(label)) return true;
+          }
+          return false;
+        };
+      }
+      const simpleExcluder = buildSimpleExcluder(exclude);
+      function dedupeFontFaces(cssText) {
+        var _a2, _b2, _c2, _d2, _e2, _f2;
+        if (!cssText) return cssText;
+        const FACE_RE2 = /@font-face[^{}]*\{[^}]*\}/gi;
+        const seen = /* @__PURE__ */ new Set();
+        const out = [];
+        for (const block of cssText.match(FACE_RE2) || []) {
+          const familyRaw = ((_a2 = block.match(/font-family:\s*([^;]+);/i)) == null ? void 0 : _a2[1]) || "";
+          const family = pickPrimaryFamily(familyRaw);
+          const weightSpec = (((_b2 = block.match(/font-weight:\s*([^;]+);/i)) == null ? void 0 : _b2[1]) || "400").trim();
+          const styleSpec = (((_c2 = block.match(/font-style:\s*([^;]+);/i)) == null ? void 0 : _c2[1]) || "normal").trim();
+          const stretchSpec = (((_d2 = block.match(/font-stretch:\s*([^;]+);/i)) == null ? void 0 : _d2[1]) || "100%").trim();
+          const urange = (((_e2 = block.match(/unicode-range:\s*([^;]+);/i)) == null ? void 0 : _e2[1]) || "").trim();
+          const srcRaw = (((_f2 = block.match(/src\s*:\s*([^;]+);/i)) == null ? void 0 : _f2[1]) || "").trim();
+          const urls = extractSrcUrls(srcRaw, location.href);
+          const srcPart = urls.length ? urls.map((u) => String(u).toLowerCase()).sort().join("|") : srcRaw.toLowerCase();
+          const key = [
+            String(family || "").toLowerCase(),
+            weightSpec,
+            styleSpec,
+            stretchSpec,
+            urange.toLowerCase(),
+            srcPart
+          ].join("|");
+          if (!seen.has(key)) {
+            seen.add(key);
+            out.push(block);
+          }
         }
-        return cache.resource.get("fonts-embed-css");
+        if (out.length === 0) return cssText;
+        let i = 0;
+        return cssText.replace(FACE_RE2, () => out[i++] || "");
+      }
+      function buildFontsCacheKey() {
+        const req = Array.from(required || []).sort().join("|");
+        const ex = exclude ? JSON.stringify({
+          families: (exclude.families || []).map((s) => String(s).toLowerCase()).sort(),
+          domains: (exclude.domains || []).map((s) => String(s).toLowerCase()).sort(),
+          subsets: (exclude.subsets || []).map((s) => String(s).toLowerCase()).sort()
+        }) : "";
+        const lf = (localFonts || []).map((f) => `${(f.family || "").toLowerCase()}::${f.weight || "normal"}::${f.style || "normal"}::${f.src || ""}`).sort().join("|");
+        const px = useProxy || "";
+        return `fonts-embed-css::req=${req}::ex=${ex}::lf=${lf}::px=${px}`;
+      }
+      const cacheKey = buildFontsCacheKey();
+      if ((_a = cache.resource) == null ? void 0 : _a.has(cacheKey)) {
+        const css = cache.resource.get(cacheKey);
+        return css;
       }
-      const importRegex = /@import\s+url\(["']?([^"')]+)["']?\)/g;
-      const styleImports = [];
+      const requiredFamilies = familiesFromRequired(required);
+      const importUrls = [];
       for (const styleTag of document.querySelectorAll("style")) {
         const cssText = styleTag.textContent || "";
-        const matches = Array.from(cssText.matchAll(importRegex));
-        for (const match of matches) {
-          const importUrl = match[1];
-          if (isIconFont(importUrl)) continue;
-          if (!isStylesheetLoaded(importUrl)) {
-            styleImports.push(importUrl);
-          }
+        for (const m of cssText.matchAll(IMPORT_RE)) {
+          const u = m[1];
+          if (!u || isIconFont2(u)) continue;
+          const hasLink = !!document.querySelector(`link[rel="stylesheet"][href="${u}"]`);
+          if (!hasLink) importUrls.push(u);
         }
       }
-      yield Promise.all(styleImports.map(injectLinkIfMissing));
-      const links = Array.from(document.querySelectorAll('link[rel="stylesheet"]')).filter((link) => link.href);
+      if (importUrls.length) {
+        yield Promise.all(importUrls.map((u) => new Promise((resolve) => {
+          if (document.querySelector(`link[rel="stylesheet"][href="${u}"]`)) return resolve(null);
+          const link = document.createElement("link");
+          link.rel = "stylesheet";
+          link.href = u;
+          link.setAttribute("data-snapdom", "injected-import");
+          link.onload = () => resolve(link);
+          link.onerror = () => resolve(null);
+          document.head.appendChild(link);
+        })));
+      }
       let finalCSS = "";
-      for (const link of links) {
+      const linkNodes = Array.from(document.querySelectorAll('link[rel="stylesheet"]')).filter((l) => !!l.href);
+      for (const link of linkNodes) {
         try {
-          const res = yield fetch(link.href);
-          const cssText = yield res.text();
-          if (isIconFont(link.href) || isIconFont(cssText)) continue;
-          const urlRegex = /url\((["']?)([^"')]+)\1\)/g;
-          const inlinedCSS = yield Promise.all(
-            Array.from(cssText.matchAll(urlRegex)).map((match) => __async(null, null, function* () {
-              let rawUrl = extractURL(match[0]);
-              if (!rawUrl) return null;
-              let url = rawUrl;
-              if (!url.startsWith("http") && !url.startsWith("data:")) {
-                url = new URL(url, link.href).href;
-              }
-              if (isIconFont(url)) return null;
-              if (cache.resource.has(url)) {
-                cache.font.add(url);
-                return { original: match[0], inlined: `url(${cache.resource.get(url)})` };
-              }
-              if (cache.font.has(url)) return null;
+          if (isIconFont2(link.href)) continue;
+          let cssText = "";
+          let sameOrigin = false;
+          try {
+            sameOrigin = new URL(link.href, location.href).origin === location.origin;
+          } catch (e) {
+          }
+          if (!sameOrigin) {
+            if (!isLikelyFontStylesheet(link.href, requiredFamilies)) continue;
+          }
+          if (sameOrigin) {
+            const sheet = Array.from(document.styleSheets).find((s) => s.href === link.href);
+            if (sheet) {
               try {
-                const fontRes = yield fetch(url);
-                const blob = yield fontRes.blob();
-                const b64 = yield new Promise((resolve) => {
-                  const reader = new FileReader();
-                  reader.onload = () => resolve(reader.result);
-                  reader.readAsDataURL(blob);
-                });
-                cache.resource.set(url, b64);
-                cache.font.add(url);
-                return { original: match[0], inlined: `url(${b64})` };
+                const rules = sheet.cssRules || [];
+                cssText = Array.from(rules).map((r) => r.cssText).join("");
               } catch (e) {
-                console.warn("[snapdom] Failed to fetch font resource:", url);
-                return null;
               }
-            }))
-          );
-          let cssFinal = cssText;
-          for (const r of inlinedCSS) {
-            if (r) cssFinal = cssFinal.replace(r.original, r.inlined);
+            }
+          }
+          if (!cssText) {
+            const res = yield snapFetch(link.href, { as: "text", useProxy });
+            cssText = res.data;
+            if (isIconFont2(link.href)) continue;
+          }
+          let facesOut = "";
+          for (const face of cssText.match(FACE_RE) || []) {
+            const famRaw = (((_b = face.match(/font-family:\s*([^;]+);/i)) == null ? void 0 : _b[1]) || "").trim();
+            const family = pickPrimaryFamily(famRaw);
+            if (!family || isIconFont2(family)) {
+              continue;
+            }
+            const weightSpec = (((_c = face.match(/font-weight:\s*([^;]+);/i)) == null ? void 0 : _c[1]) || "400").trim();
+            const styleSpec = (((_d = face.match(/font-style:\s*([^;]+);/i)) == null ? void 0 : _d[1]) || "normal").trim();
+            const stretchSpec = (((_e = face.match(/font-stretch:\s*([^;]+);/i)) == null ? void 0 : _e[1]) || "100%").trim();
+            const urange = (((_f = face.match(/unicode-range:\s*([^;]+);/i)) == null ? void 0 : _f[1]) || "").trim();
+            const srcRaw = (((_g = face.match(/src\s*:\s*([^;]+);/i)) == null ? void 0 : _g[1]) || "").trim();
+            const srcUrls = extractSrcUrls(srcRaw, link.href);
+            if (!faceMatchesRequired(family, styleSpec, weightSpec, stretchSpec)) {
+              continue;
+            }
+            const ranges = parseUnicodeRange(urange);
+            if (!unicodeIntersects(usedCodepoints, ranges)) {
+              continue;
+            }
+            const meta = { family, weightSpec, styleSpec, stretchSpec, unicodeRange: urange, srcRaw, srcUrls, href: link.href };
+            if (exclude && simpleExcluder(meta, ranges)) {
+              continue;
+            }
+            const newFace = /url\(/i.test(srcRaw) ? yield inlineUrlsInCssBlock(face, link.href) : face;
+            facesOut += newFace + "";
           }
-          finalCSS += cssFinal + "\n";
+          if (facesOut.trim()) finalCSS += facesOut + "";
         } catch (e) {
-          console.warn("[snapdom] Failed to fetch CSS:", link.href);
+          console.warn("[snapdom] Failed to process stylesheet:", link.href);
         }
       }
       for (const sheet of document.styleSheets) {
         try {
-          if (!sheet.href || links.every((link) => link.href !== sheet.href)) {
-            for (const rule of sheet.cssRules) {
-              if (rule.type === CSSRule.FONT_FACE_RULE) {
-                const src = rule.style.getPropertyValue("src");
-                const family = rule.style.getPropertyValue("font-family");
-                if (!src || isIconFont(family)) continue;
-                const urlRegex = /url\((["']?)([^"')]+)\1\)/g;
-                const localRegex = /local\((["']?)[^)]+?\1\)/g;
-                const hasURL = !!src.match(urlRegex);
-                const hasLocal = !!src.match(localRegex);
-                if (!hasURL && hasLocal) {
-                  finalCSS += `@font-face{font-family:${family};src:${src};font-style:${rule.style.getPropertyValue("font-style") || "normal"};font-weight:${rule.style.getPropertyValue("font-weight") || "normal"};}`;
-                  continue;
-                }
-                let inlinedSrc = src;
-                const matches = Array.from(src.matchAll(urlRegex));
-                for (const match of matches) {
-                  let rawUrl = match[2].trim();
-                  if (!rawUrl) continue;
-                  let url = rawUrl;
-                  if (!url.startsWith("http") && !url.startsWith("data:")) {
-                    url = new URL(url, sheet.href || location.href).href;
-                  }
-                  if (isIconFont(url)) continue;
-                  if (cache.resource.has(url)) {
-                    cache.font.add(url);
-                    inlinedSrc = inlinedSrc.replace(match[0], `url(${cache.resource.get(url)})`);
-                    continue;
-                  }
-                  if (cache.font.has(url)) continue;
-                  try {
-                    const res = yield fetch(url);
-                    const blob = yield res.blob();
-                    const b64 = yield new Promise((resolve) => {
-                      const reader = new FileReader();
-                      reader.onload = () => resolve(reader.result);
-                      reader.readAsDataURL(blob);
-                    });
-                    cache.resource.set(url, b64);
-                    cache.font.add(url);
-                    inlinedSrc = inlinedSrc.replace(match[0], `url(${b64})`);
-                  } catch (e) {
-                    console.warn("[snapdom] Failed to fetch font URL:", url);
-                  }
-                }
-                finalCSS += `@font-face{font-family:${family};src:${inlinedSrc};font-style:${rule.style.getPropertyValue("font-style") || "normal"};font-weight:${rule.style.getPropertyValue("font-weight") || "normal"};}`;
-              }
+          if (sheet.href && linkNodes.some((l) => l.href === sheet.href)) continue;
+          const rules = sheet.cssRules || [];
+          for (const rule of rules) {
+            if (rule.type !== CSSRule.FONT_FACE_RULE) continue;
+            const famRaw = (rule.style.getPropertyValue("font-family") || "").trim();
+            const family = pickPrimaryFamily(famRaw);
+            if (!family || isIconFont2(family)) continue;
+            const weightSpec = (rule.style.getPropertyValue("font-weight") || "400").trim();
+            const styleSpec = (rule.style.getPropertyValue("font-style") || "normal").trim();
+            const stretchSpec = (rule.style.getPropertyValue("font-stretch") || "100%").trim();
+            const srcRaw = (rule.style.getPropertyValue("src") || "").trim();
+            const urange = (rule.style.getPropertyValue("unicode-range") || "").trim();
+            const srcUrls = extractSrcUrls(srcRaw, sheet.href || location.href);
+            if (!faceMatchesRequired(family, styleSpec, weightSpec, stretchSpec)) continue;
+            const ranges = parseUnicodeRange(urange);
+            if (!unicodeIntersects(usedCodepoints, ranges)) continue;
+            const meta = { family, weightSpec, styleSpec, stretchSpec, unicodeRange: urange, srcRaw, srcUrls, href: sheet.href || location.href };
+            if (exclude && simpleExcluder(meta, ranges)) continue;
+            if (/url\(/i.test(srcRaw)) {
+              const inlinedSrc = yield inlineUrlsInCssBlock(srcRaw, sheet.href || location.href);
+              finalCSS += `@font-face{font-family:${family};src:${inlinedSrc};font-style:${styleSpec};font-weight:${weightSpec};font-stretch:${stretchSpec};${urange ? `unicode-range:${urange};` : ""}}`;
+            } else {
+              finalCSS += `@font-face{font-family:${family};src:${srcRaw};font-style:${styleSpec};font-weight:${weightSpec};font-stretch:${stretchSpec};${urange ? `unicode-range:${urange};` : ""}}`;
             }
           }
         } catch (e) {
-          console.warn("[snapdom] Cannot access stylesheet", sheet.href, e);
         }
       }
-      for (const font of document.fonts) {
-        if (font.family && font.status === "loaded" && font._snapdomSrc) {
-          if (isIconFont(font.family)) continue;
-          let b64 = font._snapdomSrc;
-          if (!b64.startsWith("data:")) {
-            if (cache.resource.has(font._snapdomSrc)) {
-              b64 = cache.resource.get(font._snapdomSrc);
-              cache.font.add(font._snapdomSrc);
-            } else if (!cache.font.has(font._snapdomSrc)) {
+      try {
+        for (const f of document.fonts || []) {
+          if (!f || !f.family || f.status !== "loaded" || !f._snapdomSrc) continue;
+          const fam = String(f.family).replace(/^['"]+|['"]+$/g, "");
+          if (isIconFont2(fam)) continue;
+          if (!requiredIndex.has(fam)) continue;
+          if ((exclude == null ? void 0 : exclude.families) && exclude.families.some((n) => String(n).toLowerCase() === fam.toLowerCase())) {
+            continue;
+          }
+          let b64 = f._snapdomSrc;
+          if (!String(b64).startsWith("data:")) {
+            if ((_h = cache.resource) == null ? void 0 : _h.has(f._snapdomSrc)) {
+              b64 = cache.resource.get(f._snapdomSrc);
+              (_i = cache.font) == null ? void 0 : _i.add(f._snapdomSrc);
+            } else if (!((_j = cache.font) == null ? void 0 : _j.has(f._snapdomSrc))) {
               try {
-                const res = yield fetch(font._snapdomSrc);
-                const blob = yield res.blob();
-                b64 = yield new Promise((resolve) => {
-                  const reader = new FileReader();
-                  reader.onload = () => resolve(reader.result);
-                  reader.readAsDataURL(blob);
-                });
-                cache.resource.set(font._snapdomSrc, b64);
-                cache.font.add(font._snapdomSrc);
+                const r = yield snapFetch(f._snapdomSrc, { as: "dataURL", useProxy, silent: true });
+                if (r.ok && typeof r.data === "string") {
+                  b64 = r.data;
+                  (_k = cache.resource) == null ? void 0 : _k.set(f._snapdomSrc, b64);
+                  (_l = cache.font) == null ? void 0 : _l.add(f._snapdomSrc);
+                } else {
+                  continue;
+                }
               } catch (e) {
-                console.warn("[snapdom] Failed to fetch dynamic font src:", font._snapdomSrc);
+                console.warn("[snapdom] Failed to fetch dynamic font src:", f._snapdomSrc);
                 continue;
               }
             }
           }
-          finalCSS += `@font-face{font-family:'${font.family}';src:url(${b64});font-style:${font.style || "normal"};font-weight:${font.weight || "normal"};}`;
+          finalCSS += `@font-face{font-family:'${fam}';src:url(${b64});font-style:${f.style || "normal"};font-weight:${f.weight || "normal"};}`;
         }
+      } catch (e) {
       }
-      if (finalCSS) {
-        cache.resource.set("fonts-embed-css", finalCSS);
-        if (preCached) {
-          const style = document.createElement("style");
-          style.setAttribute("data-snapdom", "embedFonts");
-          style.textContent = finalCSS;
-          document.head.appendChild(style);
+      for (const font of localFonts) {
+        if (!font || typeof font !== "object") continue;
+        const family = String(font.family || "").replace(/^['"]+|['"]+$/g, "");
+        if (!family || isIconFont2(family)) continue;
+        if (!requiredIndex.has(family)) continue;
+        if ((exclude == null ? void 0 : exclude.families) && exclude.families.some((n) => String(n).toLowerCase() === family.toLowerCase())) continue;
+        const weight = font.weight != null ? String(font.weight) : "normal";
+        const style = font.style != null ? String(font.style) : "normal";
+        const stretch = font.stretchPct != null ? `${font.stretchPct}%` : "100%";
+        const src = String(font.src || "");
+        let b64 = src;
+        if (!b64.startsWith("data:")) {
+          if ((_m = cache.resource) == null ? void 0 : _m.has(src)) {
+            b64 = cache.resource.get(src);
+            (_n = cache.font) == null ? void 0 : _n.add(src);
+          } else if (!((_o = cache.font) == null ? void 0 : _o.has(src))) {
+            try {
+              const r = yield snapFetch(src, { as: "dataURL", useProxy, silent: true });
+              if (r.ok && typeof r.data === "string") {
+                b64 = r.data;
+                (_p = cache.resource) == null ? void 0 : _p.set(src, b64);
+                (_q = cache.font) == null ? void 0 : _q.add(src);
+              } else {
+                continue;
+              }
+            } catch (e) {
+              console.warn("[snapdom] Failed to fetch localFonts src:", src);
+              continue;
+            }
+          }
         }
+        finalCSS += `@font-face{font-family:'${family}';src:url(${b64});font-style:${style};font-weight:${weight};font-stretch:${stretch};}`;
+      }
+      if (finalCSS) {
+        finalCSS = dedupeFontFaces(finalCSS);
+        (_r = cache.resource) == null ? void 0 : _r.set(cacheKey, finalCSS);
       }
       return finalCSS;
     });
   }
+  function collectUsedFontVariants(root) {
+    const req = /* @__PURE__ */ new Set();
+    if (!root) return req;
+    const tw = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, null);
+    const addFromStyle = (cs) => {
+      const family = pickPrimaryFamily(cs.fontFamily);
+      if (!family) return;
+      const key = (w, s, st) => `${family}__${normWeight(w)}__${normStyle(s)}__${normStretchPct(st)}`;
+      req.add(key(cs.fontWeight, cs.fontStyle, cs.fontStretch));
+    };
+    addFromStyle(getComputedStyle(root));
+    const csBeforeRoot = getComputedStyle(root, "::before");
+    if (csBeforeRoot && csBeforeRoot.content && csBeforeRoot.content !== "none") addFromStyle(csBeforeRoot);
+    const csAfterRoot = getComputedStyle(root, "::after");
+    if (csAfterRoot && csAfterRoot.content && csAfterRoot.content !== "none") addFromStyle(csAfterRoot);
+    while (tw.nextNode()) {
+      const el = (
+        /** @type {Element} */
+        tw.currentNode
+      );
+      const cs = getComputedStyle(el);
+      addFromStyle(cs);
+      const b = getComputedStyle(el, "::before");
+      if (b && b.content && b.content !== "none") addFromStyle(b);
+      const a = getComputedStyle(el, "::after");
+      if (a && a.content && a.content !== "none") addFromStyle(a);
+    }
+    return req;
+  }
+  function collectUsedCodepoints(root) {
+    const used = /* @__PURE__ */ new Set();
+    const pushText = (txt) => {
+      if (!txt) return;
+      for (const ch of txt) used.add(ch.codePointAt(0));
+    };
+    const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT, null);
+    while (walker.nextNode()) {
+      const n = walker.currentNode;
+      if (n.nodeType === Node.TEXT_NODE) {
+        pushText(n.nodeValue || "");
+      } else if (n.nodeType === Node.ELEMENT_NODE) {
+        const el = (
+          /** @type {Element} */
+          n
+        );
+        for (const pseudo of ["::before", "::after"]) {
+          const cs = getComputedStyle(el, pseudo);
+          const c = cs == null ? void 0 : cs.getPropertyValue("content");
+          if (!c || c === "none") continue;
+          if (/^"/.test(c) || /^'/.test(c)) {
+            pushText(c.slice(1, -1));
+          } else {
+            const matches = c.match(/\\[0-9A-Fa-f]{1,6}/g);
+            if (matches) {
+              for (const m of matches) {
+                try {
+                  used.add(parseInt(m.slice(1), 16));
+                } catch (e) {
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    return used;
+  }
+  function ensureFontsReady(families, warmupRepetitions = 1) {
+    return __async(this, null, function* () {
+      try {
+        yield document.fonts.ready;
+      } catch (e) {
+      }
+      const fams = Array.from(families || []).filter(Boolean);
+      if (fams.length === 0) return;
+      const warmupOnce = () => {
+        const container = document.createElement("div");
+        container.style.cssText = `position: absolute !important;left: -9999px !important;top: 0 !important;opacity: 0 !important;pointer-events: none !important;contain: layout size style;`;
+        for (const fam of fams) {
+          const span = document.createElement("span");
+          span.textContent = "AaBbGg1234\xC1\xC9\xCD\xD3\xDA\xE7\xF1\u2014\u221E";
+          span.style.fontFamily = `"${fam}"`;
+          span.style.fontWeight = "700";
+          span.style.fontStyle = "italic";
+          span.style.fontSize = "32px";
+          span.style.lineHeight = "1";
+          span.style.whiteSpace = "nowrap";
+          span.style.margin = "0";
+          span.style.padding = "0";
+          container.appendChild(span);
+        }
+        document.body.appendChild(container);
+        container.offsetWidth;
+        document.body.removeChild(container);
+      };
+      for (let i = 0; i < Math.max(1, warmupRepetitions); i++) {
+        warmupOnce();
+        yield new Promise((r) => requestAnimationFrame(() => requestAnimationFrame(r)));
+      }
+    });
+  }
 
   // src/modules/pseudo.js
-  function inlinePseudoElements(source, clone, options) {
+  function inlinePseudoElements(source, clone, sessionCache, options) {
     return __async(this, null, function* () {
       var _a;
       if (!(source instanceof Element) || !(clone instanceof Element)) return;
@@ -936,8 +1733,8 @@
             span.textContent = first;
             span.dataset.snapdomPseudo = "::first-letter";
             const snapshot2 = snapshotComputedStyle(style);
-            const key2 = getStyleKey(snapshot2, "span", options);
-            cache.preStyleMap.set(span, key2);
+            const key2 = getStyleKey(snapshot2, "span");
+            sessionCache.styleMap.set(span, key2);
             const restNode = document.createTextNode(rest);
             clone.replaceChild(restNode, textNode);
             clone.insertBefore(span, restNode);
@@ -957,7 +1754,7 @@
           const borderStyle = style.borderStyle;
           const borderWidth = parseFloat(style.borderWidth);
           const transform = style.transform;
-          const isIconFont2 = isIconFont(fontFamily);
+          const isIconFont22 = isIconFont2(fontFamily);
           const hasExplicitContent = content !== "none" && cleanContent !== "";
           const hasBg = bg && bg !== "none";
           const hasBgColor = bgColor && bgColor !== "transparent" && bgColor !== "rgba(0, 0, 0, 0)";
@@ -970,9 +1767,9 @@
           pseudoEl.dataset.snapdomPseudo = pseudo;
           pseudoEl.style.verticalAlign = "middle";
           const snapshot = snapshotComputedStyle(style);
-          const key = getStyleKey(snapshot, "span", options);
-          cache.preStyleMap.set(pseudoEl, key);
-          if (isIconFont2 && cleanContent.length === 1) {
+          const key = getStyleKey(snapshot, "span");
+          sessionCache.styleMap.set(pseudoEl, key);
+          if (isIconFont22 && cleanContent.length === 1) {
             const { dataUrl, width: width2, height: height2 } = yield iconToImage(cleanContent, fontFamily, fontWeight, fontSize, color);
             const imgEl = document.createElement("img");
             imgEl.src = dataUrl;
@@ -984,15 +1781,15 @@
             if (rawUrl == null ? void 0 : rawUrl.trim()) {
               try {
                 const imgEl = document.createElement("img");
-                const dataUrl = yield fetchImage(safeEncodeURI(rawUrl), options);
-                imgEl.src = dataUrl;
+                const dataUrl = yield snapFetch(safeEncodeURI(rawUrl), { as: "dataURL", useProxy: options.useProxy });
+                imgEl.src = dataUrl.data;
                 imgEl.style = `width:${fontSize}px;height:auto;object-fit:contain;`;
                 pseudoEl.appendChild(imgEl);
               } catch (e) {
                 console.error(`[snapdom] Error in pseudo ${pseudo} for`, source, e);
               }
             }
-          } else if (!isIconFont2 && hasExplicitContent) {
+          } else if (!isIconFont22 && hasExplicitContent) {
             pseudoEl.textContent = cleanContent;
           }
           if (hasBg) {
@@ -1020,7 +1817,7 @@
       const sChildren = Array.from(source.children);
       const cChildren = Array.from(clone.children).filter((child) => !child.dataset.snapdomPseudo);
       for (let i = 0; i < Math.min(sChildren.length, cChildren.length); i++) {
-        yield inlinePseudoElements(sChildren[i], cChildren[i], options);
+        yield inlinePseudoElements(sChildren[i], cChildren[i], sessionCache, options);
       }
     });
   }
@@ -1077,10 +1874,16 @@
 
   // src/core/prepare.js
   function prepareClone(_0) {
-    return __async(this, arguments, function* (element, compress = false, embedFonts = false, options = {}) {
+    return __async(this, arguments, function* (element, options = {}) {
       var _a, _b;
+      const sessionCache = {
+        styleMap: cache.session.styleMap,
+        styleCache: cache.session.styleCache,
+        nodeMap: cache.session.nodeMap
+      };
       let clone;
       let classCSS = "";
+      let shadowScopedCSS = "";
       stabilizeLayout(element);
       try {
         inlineExternalDefsAndSymbols(element);
@@ -1088,42 +1891,45 @@
         console.warn("inlineExternal defs or symbol failed:", e);
       }
       try {
-        clone = deepClone(element, compress, options, element);
+        clone = deepClone(element, sessionCache, options, element);
       } catch (e) {
         console.warn("deepClone failed:", e);
         throw e;
       }
       try {
-        yield inlinePseudoElements(element, clone, compress, embedFonts, options.useProxy);
+        yield inlinePseudoElements(element, clone, sessionCache, options);
       } catch (e) {
         console.warn("inlinePseudoElements failed:", e);
       }
-      if (compress) {
-        const keyToClass = generateCSSClasses();
-        classCSS = Array.from(keyToClass.entries()).map(([key, className]) => `.${className}{${key}}`).join("");
-        for (const [node, key] of cache.preStyleMap.entries()) {
-          if (node.tagName === "STYLE") continue;
-          if (node.getRootNode && node.getRootNode() instanceof ShadowRoot) {
-            node.setAttribute("style", key.replace(/;/g, "; "));
-            continue;
-          }
-          const className = keyToClass.get(key);
-          if (className) node.classList.add(className);
-          const bgImage = (_a = node.style) == null ? void 0 : _a.backgroundImage;
-          const hasIcon = (_b = node.dataset) == null ? void 0 : _b.snapdomHasIcon;
-          if (bgImage && bgImage !== "none") node.style.backgroundImage = bgImage;
-          if (hasIcon) {
-            node.style.verticalAlign = "middle";
-            node.style.display = "inline";
-          }
+      yield resolveBlobUrlsInTree(clone);
+      try {
+        const styleNodes = clone.querySelectorAll("style[data-sd]");
+        for (const s of styleNodes) {
+          shadowScopedCSS += s.textContent || "";
+          s.remove();
         }
-      } else {
-        for (const [node, key] of cache.preStyleMap.entries()) {
-          if (node.tagName === "STYLE") continue;
+      } catch (e) {
+      }
+      const keyToClass = generateCSSClasses(sessionCache.styleMap);
+      classCSS = Array.from(keyToClass.entries()).map(([key, className]) => `.${className}{${key}}`).join("");
+      classCSS = shadowScopedCSS + classCSS;
+      for (const [node, key] of sessionCache.styleMap.entries()) {
+        if (node.tagName === "STYLE") continue;
+        if (node.getRootNode && node.getRootNode() instanceof ShadowRoot) {
           node.setAttribute("style", key.replace(/;/g, "; "));
+          continue;
+        }
+        const className = keyToClass.get(key);
+        if (className) node.classList.add(className);
+        const bgImage = (_a = node.style) == null ? void 0 : _a.backgroundImage;
+        const hasIcon = (_b = node.dataset) == null ? void 0 : _b.snapdomHasIcon;
+        if (bgImage && bgImage !== "none") node.style.backgroundImage = bgImage;
+        if (hasIcon) {
+          node.style.verticalAlign = "middle";
+          node.style.display = "inline";
         }
       }
-      for (const [cloneNode, originalNode] of cache.preNodeMap.entries()) {
+      for (const [cloneNode, originalNode] of sessionCache.nodeMap.entries()) {
         const scrollX = originalNode.scrollLeft;
         const scrollY = originalNode.scrollTop;
         const hasScroll = scrollX || scrollY;
@@ -1142,9 +1948,9 @@
           cloneNode.appendChild(inner);
         }
       }
-      if (element === cache.preNodeMap.get(clone)) {
-        const computed = cache.preStyle.get(element) || window.getComputedStyle(element);
-        cache.preStyle.set(element, computed);
+      if (element === sessionCache.nodeMap.get(clone)) {
+        const computed = sessionCache.styleCache.get(element) || window.getComputedStyle(element);
+        sessionCache.styleCache.set(element, computed);
         const transform = stripTranslate(computed.transform);
         clone.style.margin = "0";
         clone.style.position = "static";
@@ -1157,13 +1963,13 @@
         clone.style.clear = "none";
         clone.style.transform = transform || "";
       }
-      for (const [cloneNode, originalNode] of cache.preNodeMap.entries()) {
+      for (const [cloneNode, originalNode] of sessionCache.nodeMap.entries()) {
         if (originalNode.tagName === "PRE") {
           cloneNode.style.marginTop = "0";
           cloneNode.style.marginBlockStart = "0";
         }
       }
-      return { clone, classCSS };
+      return { clone, classCSS, styleCache: sessionCache.styleCache };
     });
   }
   function stabilizeLayout(element) {
@@ -1178,24 +1984,178 @@
       element.style.border = `${outlineWidth} solid transparent`;
     }
   }
+  var _blobToDataUrlCache = /* @__PURE__ */ new Map();
+  function blobUrlToDataUrl(blobUrl) {
+    return __async(this, null, function* () {
+      var _a;
+      if ((_a = cache.resource) == null ? void 0 : _a.has(blobUrl)) return cache.resource.get(blobUrl);
+      if (_blobToDataUrlCache.has(blobUrl)) return _blobToDataUrlCache.get(blobUrl);
+      const p = (() => __async(null, null, function* () {
+        var _a2;
+        const r = yield snapFetch(blobUrl, { as: "dataURL", silent: true });
+        if (!r.ok || typeof r.data !== "string") {
+          throw new Error(`[snapDOM] Failed to read blob URL: ${blobUrl}`);
+        }
+        (_a2 = cache.resource) == null ? void 0 : _a2.set(blobUrl, r.data);
+        return r.data;
+      }))();
+      _blobToDataUrlCache.set(blobUrl, p);
+      try {
+        const data = yield p;
+        _blobToDataUrlCache.set(blobUrl, data);
+        return data;
+      } catch (e) {
+        _blobToDataUrlCache.delete(blobUrl);
+        throw e;
+      }
+    });
+  }
+  var BLOB_URL_RE = /\bblob:[^)"'\s]+/g;
+  function replaceBlobUrlsInCssText(cssText) {
+    return __async(this, null, function* () {
+      if (!cssText || cssText.indexOf("blob:") === -1) return cssText;
+      const uniques = Array.from(new Set(cssText.match(BLOB_URL_RE) || []));
+      if (uniques.length === 0) return cssText;
+      let out = cssText;
+      for (const u of uniques) {
+        try {
+          const d = yield blobUrlToDataUrl(u);
+          out = out.split(u).join(d);
+        } catch (e) {
+        }
+      }
+      return out;
+    });
+  }
+  function isBlobUrl(u) {
+    return typeof u === "string" && u.startsWith("blob:");
+  }
+  function parseSrcset(srcset) {
+    return (srcset || "").split(",").map((s) => s.trim()).filter(Boolean).map((item) => {
+      const m = item.match(/^(\S+)(\s+.+)?$/);
+      return m ? { url: m[1], desc: m[2] || "" } : null;
+    }).filter(Boolean);
+  }
+  function stringifySrcset(parts) {
+    return parts.map((p) => p.desc ? `${p.url} ${p.desc.trim()}` : p.url).join(", ");
+  }
+  function resolveBlobUrlsInTree(root) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      if (!root) return;
+      const imgs = root.querySelectorAll ? root.querySelectorAll("img") : [];
+      for (const img of imgs) {
+        try {
+          const srcAttr = img.getAttribute("src");
+          const effective = srcAttr || img.currentSrc || "";
+          if (isBlobUrl(effective)) {
+            const data = yield blobUrlToDataUrl(effective);
+            img.setAttribute("src", data);
+          }
+          const srcset = img.getAttribute("srcset");
+          if (srcset && srcset.includes("blob:")) {
+            const parts = parseSrcset(srcset);
+            let changed = false;
+            for (const p of parts) {
+              if (isBlobUrl(p.url)) {
+                try {
+                  p.url = yield blobUrlToDataUrl(p.url);
+                  changed = true;
+                } catch (e) {
+                }
+              }
+            }
+            if (changed) img.setAttribute("srcset", stringifySrcset(parts));
+          }
+        } catch (e) {
+        }
+      }
+      const svgImages = root.querySelectorAll ? root.querySelectorAll("image") : [];
+      for (const node of svgImages) {
+        try {
+          const XLINK_NS = "http://www.w3.org/1999/xlink";
+          const href = node.getAttribute("href") || ((_a = node.getAttributeNS) == null ? void 0 : _a.call(node, XLINK_NS, "href"));
+          if (isBlobUrl(href)) {
+            const d = yield blobUrlToDataUrl(href);
+            node.setAttribute("href", d);
+            (_b = node.removeAttributeNS) == null ? void 0 : _b.call(node, XLINK_NS, "href");
+          }
+        } catch (e) {
+        }
+      }
+      const styled = root.querySelectorAll ? root.querySelectorAll("[style*='blob:']") : [];
+      for (const el of styled) {
+        try {
+          const styleText = el.getAttribute("style");
+          if (styleText && styleText.includes("blob:")) {
+            const replaced = yield replaceBlobUrlsInCssText(styleText);
+            el.setAttribute("style", replaced);
+          }
+        } catch (e) {
+        }
+      }
+      const styleTags = root.querySelectorAll ? root.querySelectorAll("style") : [];
+      for (const s of styleTags) {
+        try {
+          const css = s.textContent || "";
+          if (css.includes("blob:")) {
+            s.textContent = yield replaceBlobUrlsInCssText(css);
+          }
+        } catch (e) {
+        }
+      }
+      const urlAttrs = ["poster"];
+      for (const attr of urlAttrs) {
+        const nodes = root.querySelectorAll ? root.querySelectorAll(`[${attr}^='blob:']`) : [];
+        for (const n of nodes) {
+          try {
+            const u = n.getAttribute(attr);
+            if (isBlobUrl(u)) {
+              n.setAttribute(attr, yield blobUrlToDataUrl(u));
+            }
+          } catch (e) {
+          }
+        }
+      }
+    });
+  }
 
   // src/modules/images.js
   function inlineImages(_0) {
     return __async(this, arguments, function* (clone, options = {}) {
       const imgs = Array.from(clone.querySelectorAll("img"));
       const processImg = (img) => __async(null, null, function* () {
-        const src = img.src;
-        try {
-          const dataUrl = yield fetchImage(src, { useProxy: options.useProxy });
-          img.src = dataUrl;
+        if (!img.getAttribute("src")) {
+          const eff = img.currentSrc || img.src || "";
+          if (eff) img.setAttribute("src", eff);
+        }
+        img.removeAttribute("srcset");
+        img.removeAttribute("sizes");
+        const src = img.src || "";
+        if (!src) return;
+        const r = yield snapFetch(src, { as: "dataURL", useProxy: options.useProxy });
+        if (r.ok && typeof r.data === "string" && r.data.startsWith("data:")) {
+          img.src = r.data;
           if (!img.width) img.width = img.naturalWidth || 100;
           if (!img.height) img.height = img.naturalHeight || 100;
-        } catch (e) {
-          const fallback = document.createElement("div");
-          fallback.style = `width: ${img.width || 100}px; height: ${img.height || 100}px; background: #ccc; display: inline-block; text-align: center; line-height: ${img.height || 100}px; color: #666; font-size: 12px;`;
-          fallback.innerText = "img";
-          img.replaceWith(fallback);
+          return;
         }
+        const w = img.width || img.naturalWidth || 100;
+        const h = img.height || img.naturalHeight || 100;
+        const fallback = document.createElement("div");
+        fallback.style.cssText = [
+          `width:${w}px`,
+          `height:${h}px`,
+          "background:#ccc",
+          "display:inline-block",
+          "text-align:center",
+          `line-height:${h}px`,
+          "color:#666",
+          "font-size:12px",
+          "overflow:hidden"
+        ].join(";");
+        fallback.textContent = "img";
+        img.replaceWith(fallback);
       });
       for (let i = 0; i < imgs.length; i += 4) {
         const group = imgs.slice(i, i + 4).map(processImg);
@@ -1205,8 +2165,8 @@
   }
 
   // src/modules/background.js
-  function inlineBackgroundImages(_0, _1) {
-    return __async(this, arguments, function* (source, clone, options = {}) {
+  function inlineBackgroundImages(_0, _1, _2) {
+    return __async(this, arguments, function* (source, clone, styleCache, options = {}) {
       const queue = [[source, clone]];
       const imageProps = [
         "background-image",
@@ -1226,8 +2186,8 @@
       ];
       while (queue.length) {
         const [srcNode, cloneNode] = queue.shift();
-        const style = cache.preStyle.get(srcNode) || getStyle(srcNode);
-        if (!cache.preStyle.has(srcNode)) cache.preStyle.set(srcNode, style);
+        const style = styleCache.get(srcNode) || getStyle(srcNode);
+        if (!styleCache.has(srcNode)) styleCache.set(srcNode, style);
         const hasBorderImage = (() => {
           const bi = style.getPropertyValue("border-image");
           const bis = style.getPropertyValue("border-image-source");
@@ -1247,10 +2207,6 @@
             cloneNode.style.setProperty(prop, inlined.join(", "));
           }
         }
-        const bgColor = style.getPropertyValue("background-color");
-        if (bgColor && bgColor !== "transparent" && bgColor !== "rgba(0, 0, 0, 0)") {
-          cloneNode.style.backgroundColor = bgColor;
-        }
         const sChildren = Array.from(srcNode.children);
         const cChildren = Array.from(cloneNode.children);
         for (let i = 0; i < Math.min(sChildren.length, cChildren.length); i++) {
@@ -1261,17 +2217,17 @@
   }
 
   // src/core/capture.js
-  function captureDOM(_0) {
-    return __async(this, arguments, function* (element, options = {}) {
+  function captureDOM(element, options) {
+    return __async(this, null, function* () {
       if (!element) throw new Error("Element cannot be null or undefined");
-      cache.reset();
-      const { compress = true, embedFonts = false, fast = true, scale = 1, useProxy = "" } = options;
-      let clone, classCSS;
+      applyCachePolicy(options.cache);
+      const fast = options.fast;
+      let clone, classCSS, styleCache;
       let fontsCSS = "";
       let baseCSS = "";
       let dataURL;
       let svgString;
-      ({ clone, classCSS } = yield prepareClone(element, compress, embedFonts, options));
+      ({ clone, classCSS, styleCache } = yield prepareClone(element, options));
       yield new Promise((resolve) => {
         idle(() => __async(null, null, function* () {
           yield inlineImages(clone, options);
@@ -1280,32 +2236,38 @@
       });
       yield new Promise((resolve) => {
         idle(() => __async(null, null, function* () {
-          yield inlineBackgroundImages(element, clone, options);
+          yield inlineBackgroundImages(element, clone, styleCache, options);
           resolve();
         }), { fast });
       });
-      if (embedFonts) {
+      if (options.embedFonts) {
         yield new Promise((resolve) => {
           idle(() => __async(null, null, function* () {
-            fontsCSS = yield embedCustomFonts();
+            const required = collectUsedFontVariants(element);
+            const usedCodepoints = collectUsedCodepoints(element);
+            if (isSafari) {
+              const families = new Set(
+                Array.from(required).map((k) => String(k).split("__")[0]).filter(Boolean)
+              );
+              yield ensureFontsReady(families, 2);
+            }
+            fontsCSS = yield embedCustomFonts({ required, usedCodepoints, preCached: false, exclude: options.excludeFonts, useProxy: options.useProxy });
             resolve();
           }), { fast });
         });
       }
-      if (compress) {
-        const usedTags = collectUsedTagNames(clone).sort();
-        const tagKey = usedTags.join(",");
-        if (cache.baseStyle.has(tagKey)) {
-          baseCSS = cache.baseStyle.get(tagKey);
-        } else {
-          yield new Promise((resolve) => {
-            idle(() => {
-              baseCSS = generateDedupedBaseCSS(usedTags);
-              cache.baseStyle.set(tagKey, baseCSS);
-              resolve();
-            }, { fast });
-          });
-        }
+      const usedTags = collectUsedTagNames(clone).sort();
+      const tagKey = usedTags.join(",");
+      if (cache.baseStyle.has(tagKey)) {
+        baseCSS = cache.baseStyle.get(tagKey);
+      } else {
+        yield new Promise((resolve) => {
+          idle(() => {
+            baseCSS = generateDedupedBaseCSS(usedTags);
+            cache.baseStyle.set(tagKey, baseCSS);
+            resolve();
+          }, { fast });
+        });
       }
       yield new Promise((resolve) => {
         idle(() => {
@@ -1364,26 +2326,77 @@
     });
   }
 
-  // src/api/snapdom.js
-  function toImg(_0) {
-    return __async(this, arguments, function* (url, { scale = 1 } = {}) {
+  // src/core/context.js
+  function normalizeCachePolicy(v) {
+    if (v === true) return "soft";
+    if (v === false) return "disabled";
+    if (typeof v === "string") {
+      const s = v.toLowerCase().trim();
+      if (s === "disabled" || s === "full" || s === "auto" || s === "soft") return (
+        /** @type {CachePolicy} */
+        s
+      );
+    }
+    return "soft";
+  }
+  function createContext(options = {}) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
+    const resolvedFormat = (_a = options.format) != null ? _a : "png";
+    const cachePolicy = normalizeCachePolicy(options.cache);
+    return {
+      // Debug & perf
+      debug: (_b = options.debug) != null ? _b : false,
+      fast: (_c = options.fast) != null ? _c : true,
+      scale: (_d = options.scale) != null ? _d : 1,
+      // DOM filters
+      exclude: (_e = options.exclude) != null ? _e : [],
+      filter: (_f = options.filter) != null ? _f : null,
+      // Fuentes
+      embedFonts: (_g = options.embedFonts) != null ? _g : false,
+      iconFonts: Array.isArray(options.iconFonts) ? options.iconFonts : options.iconFonts ? [options.iconFonts] : [],
+      localFonts: Array.isArray(options.localFonts) ? options.localFonts : [],
+      excludeFonts: (_h = options.excludeFonts) != null ? _h : void 0,
+      /** Cache policy (disabled|full|auto|soft). Default: "soft" */
+      /** @type {CachePolicy} */
+      cache: cachePolicy,
+      // Red
+      useProxy: typeof options.useProxy === "string" ? options.useProxy : "",
+      // Salida
+      width: (_i = options.width) != null ? _i : null,
+      height: (_j = options.height) != null ? _j : null,
+      format: resolvedFormat,
+      type: (_k = options.type) != null ? _k : "svg",
+      quality: (_l = options.quality) != null ? _l : 0.92,
+      dpr: (_m = options.dpr) != null ? _m : window.devicePixelRatio || 1,
+      backgroundColor: (_n = options.backgroundColor) != null ? _n : ["jpg", "jpeg", "webp"].includes(resolvedFormat) ? "#ffffff" : null,
+      filename: (_o = options.filename) != null ? _o : "snapDOM"
+      // Plugins (reservado para futura activación)
+      // plugins: normalizePlugins(...),
+    };
+  }
+
+  // src/exporters/toImg.js
+  function toImg(url, options) {
+    return __async(this, null, function* () {
       const img = new Image();
       img.src = url;
       yield img.decode();
-      if (scale !== 1) {
-        img.style.width = `${img.naturalWidth * scale}px`;
-        img.style.height = `${img.naturalHeight * scale}px`;
+      if (options.scale !== 1) {
+        img.style.width = `${img.naturalWidth * options.scale}px`;
+        img.style.height = `${img.naturalHeight * options.scale}px`;
       }
       return img;
     });
   }
-  function toCanvas(_0) {
-    return __async(this, arguments, function* (url, { dpr = 1, scale = 1 } = {}) {
+
+  // src/exporters/toCanvas.js
+  function toCanvas(url, options) {
+    return __async(this, null, function* () {
       const img = new Image();
-      img.src = url;
       img.crossOrigin = "anonymous";
       img.loading = "eager";
       img.decoding = "sync";
+      img.src = url;
       const isSafariBrowser = isSafari();
       let appended = false;
       if (isSafariBrowser) {
@@ -1391,16 +2404,11 @@
         appended = true;
       }
       yield img.decode();
-      if (isSafariBrowser) {
-        yield new Promise((resolve) => setTimeout(resolve, 100));
-      }
-      if (img.width === 0 || img.height === 0) {
-        if (appended) img.remove();
-        throw new Error("Image failed to load or has no dimensions");
-      }
-      const width = img.naturalWidth * scale;
-      const height = img.naturalHeight * scale;
+      if (isSafariBrowser) yield new Promise((resolve) => setTimeout(resolve, 100));
+      const width = img.naturalWidth * options.scale;
+      const height = img.naturalHeight * options.scale;
       const canvas = document.createElement("canvas");
+      const dpr = options.dpr;
       canvas.width = Math.ceil(width * dpr);
       canvas.height = Math.ceil(height * dpr);
       canvas.style.width = `${width}px`;
@@ -1412,194 +2420,188 @@
       return canvas;
     });
   }
-  function toBlob(_0) {
-    return __async(this, arguments, function* (url, {
-      type = "svg",
-      scale = 1,
-      backgroundColor = "#fff",
-      quality
-    } = {}) {
-      const mime = {
-        jpg: "image/jpeg",
-        jpeg: "image/jpeg",
-        png: "image/png",
-        webp: "image/webp"
-      }[type] || "image/png";
+
+  // src/exporters/toBlob.js
+  function toBlob(url, options) {
+    return __async(this, null, function* () {
+      const type = options.type;
       if (type === "svg") {
         const svgText = decodeURIComponent(url.split(",")[1]);
         return new Blob([svgText], { type: "image/svg+xml" });
       }
-      const canvas = yield createBackground(url, { dpr: 1, scale }, backgroundColor);
-      return new Promise((resolve) => {
-        canvas.toBlob((blob) => resolve(blob), `${mime}`, quality);
-      });
-    });
-  }
-  function createBackground(_0, _1, _2) {
-    return __async(this, arguments, function* (url, { dpr = 1, scale = 1 }, backgroundColor) {
-      const baseCanvas = yield toCanvas(url, { dpr, scale });
-      if (!backgroundColor) return baseCanvas;
-      const temp = document.createElement("canvas");
-      temp.width = baseCanvas.width;
-      temp.height = baseCanvas.height;
-      const ctx = temp.getContext("2d");
-      ctx.fillStyle = backgroundColor;
-      ctx.fillRect(0, 0, temp.width, temp.height);
-      ctx.drawImage(baseCanvas, 0, 0);
-      return temp;
+      const canvas = yield toCanvas(url, options);
+      const finalCanvas = options.backgroundColor ? createBackground(canvas, options.backgroundColor) : canvas;
+      return new Promise(
+        (resolve) => finalCanvas.toBlob(
+          (blob) => resolve(blob),
+          `image/${type}`,
+          options.quality
+        )
+      );
     });
   }
-  function toRasterImg(_0, _1) {
-    return __async(this, arguments, function* (url, { dpr = 1, scale = 1, backgroundColor, quality }, format = "png") {
-      const defaultBg = ["jpg", "jpeg", "webp"].includes(format) ? "#fff" : void 0;
-      const finalBg = backgroundColor != null ? backgroundColor : defaultBg;
-      const canvas = yield createBackground(url, { dpr, scale }, finalBg);
+
+  // src/modules/rasterize.js
+  function rasterize(url, options) {
+    return __async(this, null, function* () {
+      const canvas = yield toCanvas(url, options);
+      const finalCanvas = options.backgroundColor ? createBackground(canvas, options.backgroundColor) : canvas;
       const img = new Image();
-      img.src = canvas.toDataURL(`image/${format}`, quality);
+      img.src = finalCanvas.toDataURL(`image/${options.format}`, options.quality);
       yield img.decode();
-      img.style.width = `${canvas.width / dpr}px`;
-      img.style.height = `${canvas.height / dpr}px`;
+      img.style.width = `${finalCanvas.width / options.dpr}px`;
+      img.style.height = `${finalCanvas.height / options.dpr}px`;
       return img;
     });
   }
-  function download(_0) {
-    return __async(this, arguments, function* (url, { dpr = 1, scale = 1, backgroundColor, format = "png", filename = "snapDOM" } = {}) {
-      if (format === "svg") {
-        const blob = yield toBlob(url);
+
+  // src/exporters/download.js
+  function download(url, options) {
+    return __async(this, null, function* () {
+      if (options.format === "svg") {
+        const blob = yield toBlob(url, __spreadProps(__spreadValues({}, options), { type: "svg" }));
         const objectURL = URL.createObjectURL(blob);
         const a2 = document.createElement("a");
         a2.href = objectURL;
-        a2.download = `${filename}.svg`;
+        a2.download = options.filename;
         a2.click();
         URL.revokeObjectURL(objectURL);
         return;
       }
-      const defaultBg = ["jpg", "jpeg", "webp"].includes(format) ? "#fff" : void 0;
-      const finalBg = backgroundColor != null ? backgroundColor : defaultBg;
-      const canvas = yield createBackground(url, { dpr, scale }, finalBg);
-      const mime = {
-        jpg: "image/jpeg",
-        jpeg: "image/jpeg",
-        png: "image/png",
-        webp: "image/webp"
-      }[format] || "image/png";
-      const dataURL = canvas.toDataURL(mime);
+      const canvas = yield toCanvas(url, options);
+      const finalCanvas = options.backgroundColor ? createBackground(canvas, options.backgroundColor) : canvas;
       const a = document.createElement("a");
-      a.href = dataURL;
-      a.download = `${filename}.${format}`;
+      a.href = finalCanvas.toDataURL(`image/${options.format}`, options.quality);
+      a.download = options.filename;
       a.click();
     });
   }
-  function snapdom(_0) {
-    return __async(this, arguments, function* (element, options = {}) {
-      options = __spreadValues({ scale: 1 }, options);
+
+  // src/api/snapdom.js
+  var INTERNAL_TOKEN = Symbol("snapdom.internal");
+  function snapdom(element, userOptions) {
+    return __async(this, null, function* () {
       if (!element) throw new Error("Element cannot be null or undefined");
-      if (options.iconFonts) {
-        extendIconFonts(options.iconFonts);
-      }
-      return yield snapdom.capture(element, options);
+      const context = createContext(userOptions);
+      if (context.iconFonts && context.iconFonts.length > 0) extendIconFonts(context.iconFonts);
+      return snapdom.capture(element, context, INTERNAL_TOKEN);
     });
   }
-  snapdom.capture = (_0, ..._1) => __async(null, [_0, ..._1], function* (el, options = {}) {
-    var _a;
-    const url = yield captureDOM(el, options);
-    const dpr = (_a = options.dpr) != null ? _a : window.devicePixelRatio || 1;
-    const scale = options.scale || 1;
+  snapdom.capture = (el, context, _token) => __async(null, null, function* () {
+    if (_token !== INTERNAL_TOKEN) {
+      throw new Error("[snapdom.capture] is internal. Use snapdom(...) instead.");
+    }
+    const url = yield captureDOM(el, context);
+    const ensureContext = (opts) => __spreadValues(__spreadValues({}, context), opts || {});
+    const withFormat = (format) => (opts) => rasterize(url, ensureContext(__spreadProps(__spreadValues({}, opts || {}), { format })));
     return {
       url,
-      options,
       toRaw: () => url,
-      toImg: (opts = {}) => toImg(url, __spreadValues({ dpr, scale }, opts)),
-      toCanvas: (opts = {}) => toCanvas(url, __spreadValues({ dpr, scale }, opts)),
-      toBlob: (opts = {}) => toBlob(url, __spreadValues({ dpr, scale }, opts)),
-      toPng: (opts = {}) => toRasterImg(url, __spreadValues({ dpr, scale }, opts), "png"),
-      toJpg: (opts = {}) => toRasterImg(url, __spreadValues({ dpr, scale }, opts), "jpeg"),
-      toWebp: (opts = {}) => toRasterImg(url, __spreadValues({ dpr, scale }, opts), "webp"),
-      download: (_b = {}) => {
-        var _c = _b, { format = "png", filename = "snapDOM", backgroundColor } = _c, opts = __objRest(_c, ["format", "filename", "backgroundColor"]);
-        return download(url, __spreadValues({ dpr, scale, format, filename, backgroundColor }, opts));
-      }
+      toImg: (opts) => toImg(url, ensureContext(opts)),
+      toCanvas: (opts) => toCanvas(url, ensureContext(opts)),
+      toBlob: (opts) => toBlob(url, ensureContext(opts)),
+      toPng: withFormat("png"),
+      toJpg: withFormat("jpeg"),
+      toWebp: withFormat("webp"),
+      download: (opts) => download(url, ensureContext(opts))
     };
   });
-  snapdom.toRaw = (el, options) => __async(null, null, function* () {
-    return (yield snapdom.capture(el, options)).toRaw();
-  });
-  snapdom.toImg = (el, options) => __async(null, null, function* () {
-    return (yield snapdom.capture(el, options)).toImg();
-  });
-  snapdom.toCanvas = (el, options) => __async(null, null, function* () {
-    return (yield snapdom.capture(el, options)).toCanvas();
-  });
-  snapdom.toBlob = (el, options) => __async(null, null, function* () {
-    return (yield snapdom.capture(el, options)).toBlob(options);
-  });
-  snapdom.toPng = (el, options) => __async(null, null, function* () {
-    return (yield snapdom.capture(el, options)).toPng(options);
-  });
-  snapdom.toJpg = (el, options) => __async(null, null, function* () {
-    return (yield snapdom.capture(el, options)).toJpg(options);
-  });
-  snapdom.toWebp = (el, options) => __async(null, null, function* () {
-    return (yield snapdom.capture(el, options)).toWebp(options);
-  });
-  snapdom.download = (_0, ..._1) => __async(null, [_0, ..._1], function* (el, options = {}) {
-    const _a = options, {
-      format = "png",
-      filename = "capture",
-      backgroundColor
-    } = _a, rest = __objRest(_a, [
-      "format",
-      "filename",
-      "backgroundColor"
-    ]);
-    const capture = yield snapdom.capture(el, rest);
-    return yield capture.download({ format, filename, backgroundColor });
-  });
+  snapdom.toRaw = (el, options) => snapdom(el, options).then((result) => result.toRaw());
+  snapdom.toImg = (el, options) => snapdom(el, options).then((result) => result.toImg());
+  snapdom.toCanvas = (el, options) => snapdom(el, options).then((result) => result.toCanvas());
+  snapdom.toBlob = (el, options) => snapdom(el, options).then((result) => result.toBlob());
+  snapdom.toPng = (el, options) => snapdom(el, __spreadProps(__spreadValues({}, options), { format: "png" })).then((result) => result.toPng());
+  snapdom.toJpg = (el, options) => snapdom(el, __spreadProps(__spreadValues({}, options), { format: "jpeg" })).then((result) => result.toJpg());
+  snapdom.toWebp = (el, options) => snapdom(el, __spreadProps(__spreadValues({}, options), { format: "webp" })).then((result) => result.toWebp());
+  snapdom.download = (el, options) => snapdom(el, options).then((result) => result.download());
 
   // src/api/preCache.js
   function preCache() {
     return __async(this, arguments, function* (root = document, options = {}) {
-      const { embedFonts = true, reset = false } = options;
-      if (reset) {
-        cache.reset();
-        return;
+      var _a;
+      const {
+        embedFonts = true,
+        cacheOpt = "full",
+        useProxy = ""
+      } = options;
+      applyCachePolicy(cacheOpt);
+      try {
+        yield document.fonts.ready;
+      } catch (e) {
       }
-      yield document.fonts.ready;
       precacheCommonTags();
+      cache.session = cache.session || {};
+      if (!cache.session.styleCache) {
+        cache.session.styleCache = /* @__PURE__ */ new WeakMap();
+      }
+      try {
+        yield inlineBackgroundImages(
+          root,
+          /* mirror */
+          void 0,
+          cache.session.styleCache,
+          { useProxy }
+        );
+      } catch (e) {
+      }
       let imgEls = [], allEls = [];
-      if (root == null ? void 0 : root.querySelectorAll) {
-        imgEls = Array.from(root.querySelectorAll("img[src]"));
-        allEls = Array.from(root.querySelectorAll("*"));
+      try {
+        if (root == null ? void 0 : root.querySelectorAll) {
+          imgEls = Array.from(root.querySelectorAll("img[src]"));
+          allEls = Array.from(root.querySelectorAll("*"));
+        }
+      } catch (e) {
       }
       const promises = [];
       for (const img of imgEls) {
-        const src = img.src;
+        const src = img == null ? void 0 : img.src;
+        if (!src) continue;
         if (!cache.image.has(src)) {
-          promises.push(
-            fetchImage(src, { useProxy: options.useProxy }).then((dataURL) => cache.image.set(src, dataURL)).catch(() => {
-            })
-          );
+          const p = Promise.resolve().then(() => snapFetch(src, { as: "dataURL", useProxy })).then((dataURL) => {
+            cache.image.set(src, dataURL);
+          }).catch(() => {
+          });
+          promises.push(p);
         }
       }
       for (const el of allEls) {
-        const bg = getStyle(el).backgroundImage;
+        let bg = "";
+        try {
+          bg = getStyle(el).backgroundImage;
+        } catch (e) {
+        }
         if (bg && bg !== "none") {
-          const bgSplits = splitBackgroundImage(bg);
-          for (const entry of bgSplits) {
-            const isUrl = entry.startsWith("url(");
-            if (isUrl) {
-              promises.push(
-                inlineSingleBackgroundEntry(entry, options).catch(() => {
-                })
-              );
+          const parts = splitBackgroundImage(bg);
+          for (const entry of parts) {
+            if (entry.startsWith("url(")) {
+              const p = Promise.resolve().then(() => inlineSingleBackgroundEntry(entry, __spreadProps(__spreadValues({}, options), { useProxy }))).catch(() => {
+              });
+              promises.push(p);
             }
           }
         }
       }
       if (embedFonts) {
-        yield embedCustomFonts({ preCached: true });
+        try {
+          const required = collectUsedFontVariants(root);
+          const usedCodepoints = collectUsedCodepoints(root);
+          if (typeof isSafari === "function" ? isSafari() : !!isSafari) {
+            const families = new Set(
+              Array.from(required).map((k) => String(k).split("__")[0]).filter(Boolean)
+            );
+            yield ensureFontsReady(families, 2);
+          }
+          yield embedCustomFonts({
+            required,
+            usedCodepoints,
+            exclude: options.excludeFonts,
+            localFonts: options.localFonts,
+            useProxy: (_a = options.useProxy) != null ? _a : useProxy
+          });
+        } catch (e) {
+        }
       }
-      yield Promise.all(promises);
+      yield Promise.allSettled(promises);
     });
   }