@zumer/snapdom 1.9.5 → 1.9.6-dev.1

package/dist/snapdom.js

@@ -1,13 +1,14 @@
 
 /*
 * snapdom
-* v.1.9.5
+* v.1.9.6-dev.0
 * Author Juan Martin Muda
 * License MIT
 **/
 
 (() => {
   var __defProp = Object.defineProperty;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
   var __getOwnPropSymbols = Object.getOwnPropertySymbols;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
   var __propIsEnum = Object.prototype.propertyIsEnumerable;
@@ -35,6 +36,12 @@
       }
     return target;
   };
+  var __esm = (fn, res) => function __init() {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  };
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
   var __async = (__this, __arguments, generator) => {
     return new Promise((resolve, reject) => {
       var fulfilled = (value) => {
@@ -57,67 +64,49 @@
   };
 
   // src/core/cache.js
-  var imageCache = /* @__PURE__ */ new Map();
-  var bgCache = /* @__PURE__ */ new Map();
-  var resourceCache = /* @__PURE__ */ new Map();
-  var defaultStylesCache = /* @__PURE__ */ new Map();
-  var baseCSSCache = /* @__PURE__ */ new Map();
-  var computedStyleCache = /* @__PURE__ */ new WeakMap();
-  var processedFontURLs = /* @__PURE__ */ new Set();
+  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();
+  }
+  var cache;
+  var init_cache = __esm({
+    "src/core/cache.js"() {
+      cache = {
+        image: /* @__PURE__ */ new Map(),
+        background: /* @__PURE__ */ new Map(),
+        resource: /* @__PURE__ */ new Map(),
+        defaultStyle: /* @__PURE__ */ new Map(),
+        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
+      };
+    }
+  });
 
   // src/utils/cssTools.js
-  var commonTags = [
-    "div",
-    "span",
-    "p",
-    "a",
-    "img",
-    "ul",
-    "li",
-    "button",
-    "input",
-    "select",
-    "textarea",
-    "label",
-    "section",
-    "article",
-    "header",
-    "footer",
-    "nav",
-    "main",
-    "aside",
-    "h1",
-    "h2",
-    "h3",
-    "h4",
-    "h5",
-    "h6",
-    "svg",
-    "path",
-    "circle",
-    "rect",
-    "line",
-    "g",
-    "table",
-    "thead",
-    "tbody",
-    "tr",
-    "td",
-    "th"
-  ];
   function precacheCommonTags() {
     for (let tag of commonTags) {
       getDefaultStyleForTag(tag);
     }
   }
   function getDefaultStyleForTag(tagName) {
-    if (defaultStylesCache.has(tagName)) {
-      return defaultStylesCache.get(tagName);
+    if (cache.defaultStyle.has(tagName)) {
+      return cache.defaultStyle.get(tagName);
     }
     const skipTags = /* @__PURE__ */ new Set(["script", "style", "meta", "link", "noscript", "template"]);
     if (skipTags.has(tagName)) {
       const empty = {};
-      defaultStylesCache.set(tagName, empty);
+      cache.defaultStyle.set(tagName, empty);
       return empty;
     }
     let sandbox = document.getElementById("snapdom-sandbox");
@@ -141,7 +130,7 @@
       defaults[prop] = styles.getPropertyValue(prop);
     }
     sandbox.removeChild(el);
-    defaultStylesCache.set(tagName, defaults);
+    cache.defaultStyle.set(tagName, defaults);
     return defaults;
   }
   function getStyleKey(snapshot, tagName, compress = false) {
@@ -177,7 +166,7 @@
   function generateDedupedBaseCSS(usedTagNames) {
     const groups = /* @__PURE__ */ new Map();
     for (let tagName of usedTagNames) {
-      const styles = defaultStylesCache.get(tagName);
+      const styles = cache.defaultStyle.get(tagName);
       if (!styles) continue;
       const key = Object.entries(styles).map(([k, v]) => `${k}:${v};`).sort().join("");
       if (!groups.has(key)) {
@@ -192,8 +181,8 @@
     }
     return css;
   }
-  function generateCSSClasses(styleMap) {
-    const keySet = new Set(styleMap.values());
+  function generateCSSClasses() {
+    const keySet = new Set(cache.preStyleMap.values());
     const classMap = /* @__PURE__ */ new Map();
     let counter = 1;
     for (const key of keySet) {
@@ -201,20 +190,64 @@
     }
     return classMap;
   }
+  var commonTags;
+  var init_cssTools = __esm({
+    "src/utils/cssTools.js"() {
+      init_cache();
+      commonTags = [
+        "div",
+        "span",
+        "p",
+        "a",
+        "img",
+        "ul",
+        "li",
+        "button",
+        "input",
+        "select",
+        "textarea",
+        "label",
+        "section",
+        "article",
+        "header",
+        "footer",
+        "nav",
+        "main",
+        "aside",
+        "h1",
+        "h2",
+        "h3",
+        "h4",
+        "h5",
+        "h6",
+        "svg",
+        "path",
+        "circle",
+        "rect",
+        "line",
+        "g",
+        "table",
+        "thead",
+        "tbody",
+        "tr",
+        "td",
+        "th"
+      ];
+    }
+  });
 
   // src/utils/helpers.js
   function inlineSingleBackgroundEntry(_0) {
     return __async(this, arguments, function* (entry, options = {}) {
-      const match = entry.match(/url\(["']?(.*?)["']?\)/);
-      const rawUrl = match == null ? void 0 : match[1];
+      const rawUrl = extractURL(entry);
       const isGradient = /^((repeating-)?(linear|radial|conic)-gradient)\(/i.test(entry);
       if (rawUrl) {
         const encodedUrl = safeEncodeURI(rawUrl);
-        if (bgCache.has(encodedUrl)) {
-          return options.skipInline ? void 0 : `url(${bgCache.get(encodedUrl)})`;
+        if (cache.background.has(encodedUrl)) {
+          return options.skipInline ? void 0 : `url(${cache.background.get(encodedUrl)})`;
         } else {
           const dataUrl = yield fetchImage(encodedUrl, { useProxy: options.useProxy });
-          bgCache.set(encodedUrl, dataUrl);
+          cache.background.set(encodedUrl, dataUrl);
           return options.skipInline ? void 0 : `url("${dataUrl}")`;
         }
       }
@@ -236,10 +269,10 @@
     if (!(el instanceof Element)) {
       return window.getComputedStyle(el, pseudo);
     }
-    let map = computedStyleCache.get(el);
+    let map = cache.computedStyle.get(el);
     if (!map) {
       map = /* @__PURE__ */ new Map();
-      computedStyleCache.set(el, map);
+      cache.computedStyle.set(el, map);
     }
     if (!map.has(pseudo)) {
       const st = window.getComputedStyle(el, pseudo);
@@ -315,13 +348,13 @@
     }
     const crossOriginValue = getCrossOriginMode(src);
     console.log(`[SnapDOM - fetchImage] Start loading image: ${src} with crossOrigin=${crossOriginValue}`);
-    if (imageCache.has(src)) {
+    if (cache.image.has(src)) {
       console.log(`[SnapDOM - fetchImage] Cache hit for: ${src}`);
-      return Promise.resolve(imageCache.get(src));
+      return Promise.resolve(cache.image.get(src));
     }
     const isDataURI = src.startsWith("data:image/");
     if (isDataURI) {
-      imageCache.set(src, src);
+      cache.image.set(src, src);
       return Promise.resolve(src);
     }
     const isSVG = /\.svg(\?.*)?$/i.test(src);
@@ -334,7 +367,7 @@
           });
           const svgText = yield response.text();
           const encoded = `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svgText)}`;
-          imageCache.set(src, encoded);
+          cache.image.set(src, encoded);
           return encoded;
         } catch (e) {
           return fetchWithFallback(src);
@@ -358,12 +391,12 @@
           const ctx = canvas.getContext("2d");
           ctx.drawImage(image, 0, 0, canvas.width, canvas.height);
           const dataURL = canvas.toDataURL("image/png");
-          imageCache.set(src, dataURL);
+          cache.image.set(src, dataURL);
           resolve(dataURL);
         } catch (e) {
           try {
             const fallbackDataURL = yield fetchWithFallback(src);
-            imageCache.set(src, fallbackDataURL);
+            cache.image.set(src, fallbackDataURL);
             resolve(fallbackDataURL);
           } catch (e2) {
             reject(e2);
@@ -375,7 +408,7 @@
         console.error(`[SnapDOM - fetchImage] Image failed to load: ${src}`);
         try {
           const fallbackDataURL = yield fetchWithFallback(src);
-          imageCache.set(src, fallbackDataURL);
+          cache.image.set(src, fallbackDataURL);
           resolve(fallbackDataURL);
         } catch (e) {
           reject(e);
@@ -437,10 +470,13 @@
     parts.push(bg.slice(lastIndex).trim());
     return parts;
   }
+  var init_helpers = __esm({
+    "src/utils/helpers.js"() {
+      init_cache();
+    }
+  });
 
   // src/modules/styles.js
-  var snapshotCache = /* @__PURE__ */ new WeakMap();
-  var snapshotKeyCache = /* @__PURE__ */ new Map();
   function snapshotComputedStyleFull(style) {
     const result = {};
     for (let i = 0; i < style.length; i++) {
@@ -453,166 +489,200 @@
     }
     return result;
   }
-  function inlineAllStyles(source, clone, styleMap, cache, compress) {
+  function inlineAllStyles(source, clone, compress) {
     var _a;
     if (source.tagName === "STYLE") return;
-    if (!cache.has(source)) {
-      cache.set(source, getStyle(source));
+    if (!cache.preStyle.has(source)) {
+      cache.preStyle.set(source, getStyle(source));
     }
-    const style = cache.get(source);
-    if (!snapshotCache.has(source)) {
+    const style = cache.preStyle.get(source);
+    if (!cache.snapshot.has(source)) {
       const snapshot2 = snapshotComputedStyleFull(style);
-      snapshotCache.set(source, snapshot2);
+      cache.snapshot.set(source, snapshot2);
     }
-    const snapshot = snapshotCache.get(source);
+    const snapshot = cache.snapshot.get(source);
     const hash = Object.entries(snapshot).sort(([a], [b]) => a.localeCompare(b)).map(([prop, val]) => `${prop}:${val}`).join(";");
-    if (snapshotKeyCache.has(hash)) {
-      styleMap.set(clone, snapshotKeyCache.get(hash));
+    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);
-    snapshotKeyCache.set(hash, key);
-    styleMap.set(clone, key);
+    cache.snapshotKey.set(hash, key);
+    cache.preStyleMap.set(clone, key);
   }
+  var init_styles = __esm({
+    "src/modules/styles.js"() {
+      init_cssTools();
+      init_helpers();
+      init_cache();
+    }
+  });
 
   // src/core/clone.js
   function isSlotElement(node) {
     return node.nodeType === Node.ELEMENT_NODE && node.tagName === "SLOT";
   }
-  function deepClone(node, styleMap, styleCache, nodeMap, compress, options = {}, originalRoot) {
+  function deepClone(node, compress, options = {}, originalRoot) {
     var _a, _b;
-    if (node.nodeType === Node.TEXT_NODE) {
-      return node.cloneNode(true);
-    }
-    if (node.nodeType !== Node.ELEMENT_NODE) return node.cloneNode(true);
-    if (node.getAttribute("data-capture") === "exclude") {
-      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;`;
-      return spacer;
+    if (!node) {
+      throw new Error("Invalid node: node is null or undefined");
     }
-    if (options.exclude && Array.isArray(options.exclude)) {
-      for (const selector of options.exclude) {
+    try {
+      if (node.nodeType === Node.TEXT_NODE) {
+        return node.cloneNode(true);
+      }
+      if (node.nodeType !== Node.ELEMENT_NODE) {
+        return node.cloneNode(true);
+      }
+      if (node.getAttribute("data-capture") === "exclude") {
+        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;`;
+        return spacer;
+      }
+      if (options.exclude && Array.isArray(options.exclude)) {
+        for (const selector of options.exclude) {
+          try {
+            if ((_a = node.matches) == null ? void 0 : _a.call(node, selector)) {
+              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;`;
+              return spacer;
+            }
+          } catch (err) {
+            console.warn(`Invalid selector in exclude option: ${selector}`, err);
+          }
+        }
+      }
+      if (typeof options.filter === "function") {
         try {
-          if ((_a = node.matches) == null ? void 0 : _a.call(node, selector)) {
+          if (!options.filter(node, originalRoot || 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;`;
             return spacer;
           }
         } catch (err) {
-          console.warn(`Invalid selector in exclude option: ${selector}`, err);
+          console.warn("Error in filter function:", err);
         }
       }
-    }
-    if (typeof options.filter === "function") {
+      if (node.tagName === "IFRAME") {
+        const fallback = document.createElement("div");
+        fallback.textContent = "";
+        fallback.style.cssText = `width: ${node.offsetWidth}px; height: ${node.offsetHeight}px; background-image: repeating-linear-gradient(45deg, #ddd, #ddd 5px, #f9f9f9 5px, #f9f9f9 10px);display: flex;align-items: center;justify-content: center;font-size: 12px;color: #555; border: 1px solid #aaa;`;
+        return fallback;
+      }
+      if (node.getAttribute("data-capture") === "placeholder") {
+        const clone2 = node.cloneNode(false);
+        cache.preNodeMap.set(clone2, node);
+        inlineAllStyles(node, clone2, compress);
+        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;`;
+        clone2.appendChild(placeholder);
+        return clone2;
+      }
+      if (node.tagName === "CANVAS") {
+        const dataURL = node.toDataURL();
+        const img = document.createElement("img");
+        img.src = dataURL;
+        img.width = node.width;
+        img.height = node.height;
+        img.style.display = "inline-block";
+        img.style.width = node.style.width || `${node.width}px`;
+        img.style.height = node.style.height || `${node.height}px`;
+        return img;
+      }
+      let clone;
       try {
-        if (!options.filter(node, originalRoot || 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;`;
-          return spacer;
+        clone = node.cloneNode(false);
+        if (!clone) {
+          throw new Error("Failed to clone node: cloneNode returned null");
         }
+        cache.preNodeMap.set(clone, node);
       } catch (err) {
-        console.warn("Error in filter function:", err);
-      }
-    }
-    if (node.tagName === "IFRAME") {
-      const fallback = document.createElement("div");
-      fallback.textContent = "";
-      fallback.style.cssText = `width: ${node.offsetWidth}px; height: ${node.offsetHeight}px; background-image: repeating-linear-gradient(45deg, #ddd, #ddd 5px, #f9f9f9 5px, #f9f9f9 10px);display: flex;align-items: center;justify-content: center;font-size: 12px;color: #555; border: 1px solid #aaa;`;
-      return fallback;
-    }
-    if (node.getAttribute("data-capture") === "placeholder") {
-      const clone2 = node.cloneNode(false);
-      nodeMap.set(clone2, node);
-      inlineAllStyles(node, clone2, styleMap, styleCache, compress);
-      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;`;
-      clone2.appendChild(placeholder);
-      return clone2;
-    }
-    if (node.tagName === "CANVAS") {
-      const dataURL = node.toDataURL();
-      const img = document.createElement("img");
-      img.src = dataURL;
-      img.width = node.width;
-      img.height = node.height;
-      img.style.display = "inline-block";
-      img.style.width = node.style.width || `${node.width}px`;
-      img.style.height = node.style.height || `${node.height}px`;
-      return img;
-    }
-    const clone = node.cloneNode(false);
-    nodeMap.set(clone, node);
-    if (node instanceof HTMLInputElement) {
-      clone.value = node.value;
-      clone.setAttribute("value", node.value);
-      if (node.checked !== void 0) {
-        clone.checked = node.checked;
-        if (node.checked) clone.setAttribute("checked", "");
+        console.error("[Snapdom] Failed to clone node:", node, err);
+        throw err;
       }
-    } else if (node instanceof HTMLTextAreaElement) {
-      const rect = node.getBoundingClientRect();
-      clone.textContent = node.value;
-      clone.style.width = `${rect.width}px`;
-      clone.style.height = `${rect.height}px`;
-    } else if (node instanceof HTMLSelectElement) {
-      clone.value = node.value;
-      Array.from(clone.options).forEach((opt) => {
-        if (opt.value === node.value) {
-          opt.setAttribute("selected", "");
-        } else {
-          opt.removeAttribute("selected");
+      if (node instanceof HTMLInputElement) {
+        clone.value = node.value;
+        clone.setAttribute("value", node.value);
+        if (node.checked !== void 0) {
+          clone.checked = node.checked;
+          if (node.checked) clone.setAttribute("checked", "");
         }
-      });
-    }
-    inlineAllStyles(node, clone, styleMap, styleCache, compress);
-    if (isSlotElement(node)) {
-      const assigned = ((_b = node.assignedNodes) == null ? void 0 : _b.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, styleMap, styleCache, nodeMap, compress, options, originalRoot || node);
-        if (clonedChild) fragment.appendChild(clonedChild);
-      }
-      return fragment;
-    } else if (node instanceof HTMLTextAreaElement) {
-    } else {
-      const baseChildren = node.shadowRoot ? node.shadowRoot.childNodes : node.childNodes;
-      for (const child of baseChildren) {
-        const clonedChild = deepClone(child, styleMap, styleCache, nodeMap, compress, options, originalRoot || node);
-        if (clonedChild) clone.appendChild(clonedChild);
+      } else if (node instanceof HTMLTextAreaElement) {
+        const rect = node.getBoundingClientRect();
+        clone.textContent = node.value;
+        clone.style.width = `${rect.width}px`;
+        clone.style.height = `${rect.height}px`;
+      } else if (node instanceof HTMLSelectElement) {
+        clone.value = node.value;
+        Array.from(clone.options).forEach((opt) => {
+          if (opt.value === node.value) {
+            opt.setAttribute("selected", "");
+          } else {
+            opt.removeAttribute("selected");
+          }
+        });
       }
-      if (node.shadowRoot && node.childNodes.length > 0 && !node.shadowRoot.querySelector("slot")) {
-        const lightDomContent = document.createDocumentFragment();
-        for (const child of node.childNodes) {
-          const clonedChild = deepClone(child, styleMap, styleCache, nodeMap, compress, options, originalRoot || node);
-          if (clonedChild) lightDomContent.appendChild(clonedChild);
+      inlineAllStyles(node, clone, compress);
+      try {
+        if (isSlotElement(node)) {
+          const assigned = ((_b = node.assignedNodes) == null ? void 0 : _b.call(node, { flatten: true })) || [];
+          const nodesToClone = assigned.length > 0 ? assigned : Array.from(node.childNodes);
+          const fragment = document.createDocumentFragment();
+          for (const child of nodesToClone) {
+            try {
+              const clonedChild = deepClone(child, compress, options, originalRoot || node);
+              if (clonedChild) fragment.appendChild(clonedChild);
+            } catch (err) {
+              console.warn("[Snapdom] Failed to clone slot content:", child, err);
+            }
+          }
+          return fragment;
+        } else {
+          const baseChildren = node.shadowRoot ? node.shadowRoot.childNodes : node.childNodes;
+          for (const child of baseChildren) {
+            try {
+              const clonedChild = deepClone(child, compress, options, originalRoot || node);
+              if (clonedChild) clone.appendChild(clonedChild);
+            } catch (err) {
+              console.warn("[Snapdom] Failed to clone child node:", child, err);
+            }
+          }
+          if (node.shadowRoot && node.childNodes.length > 0 && !node.shadowRoot.querySelector("slot")) {
+            const lightDomContent = document.createDocumentFragment();
+            for (const child of node.childNodes) {
+              try {
+                const clonedChild = deepClone(child, compress, options, originalRoot || node);
+                if (clonedChild) lightDomContent.appendChild(clonedChild);
+              } catch (err) {
+                console.warn("[Snapdom] Failed to clone light DOM child:", child, err);
+              }
+            }
+            clone.appendChild(lightDomContent);
+          }
         }
-        clone.appendChild(lightDomContent);
+      } catch (err) {
+        console.error("[Snapdom] Error cloning children:", err);
+        throw err;
       }
+      return clone;
+    } catch (error) {
+      console.error("[Snapdom] Error in deepClone:", error);
+      throw error;
     }
-    return clone;
   }
+  var init_clone = __esm({
+    "src/core/clone.js"() {
+      init_styles();
+      init_cache();
+    }
+  });
 
   // src/modules/iconFonts.js
-  var defaultIconFonts = [
-    // /uicons/i,
-    /font\s*awesome/i,
-    /material\s*icons/i,
-    /ionicons/i,
-    /glyphicons/i,
-    /feather/i,
-    /bootstrap\s*icons/i,
-    /remix\s*icons/i,
-    /heroicons/i,
-    /layui/i,
-    /lucide/i
-  ];
-  var userIconFonts = [];
   function extendIconFonts(fonts) {
     const list = Array.isArray(fonts) ? fonts : [fonts];
     for (const f of list) {
@@ -634,6 +704,25 @@
     if (/icon/i.test(text) || /glyph/i.test(text) || /symbols/i.test(text) || /feather/i.test(text) || /fontawesome/i.test(text)) return true;
     return false;
   }
+  var defaultIconFonts, userIconFonts;
+  var init_iconFonts = __esm({
+    "src/modules/iconFonts.js"() {
+      defaultIconFonts = [
+        // /uicons/i,
+        /font\s*awesome/i,
+        /material\s*icons/i,
+        /ionicons/i,
+        /glyphicons/i,
+        /feather/i,
+        /bootstrap\s*icons/i,
+        /remix\s*icons/i,
+        /heroicons/i,
+        /layui/i,
+        /lucide/i
+      ];
+      userIconFonts = [];
+    }
+  });
 
   // src/modules/fonts.js
   function iconToImage(unicodeChar, fontFamily, fontWeight, fontSize = 32, color = "#000") {
@@ -678,14 +767,14 @@
   }
   function embedCustomFonts() {
     return __async(this, arguments, function* ({ preCached = false } = {}) {
-      if (resourceCache.has("fonts-embed-css")) {
+      if (cache.resource.has("fonts-embed-css")) {
         if (preCached) {
           const style = document.createElement("style");
           style.setAttribute("data-snapdom", "embedFonts");
-          style.textContent = resourceCache.get("fonts-embed-css");
+          style.textContent = cache.resource.get("fonts-embed-css");
           document.head.appendChild(style);
         }
-        return resourceCache.get("fonts-embed-css");
+        return cache.resource.get("fonts-embed-css");
       }
       const importRegex = /@import\s+url\(["']?([^"')]+)["']?\)/g;
       const styleImports = [];
@@ -718,11 +807,11 @@
                 url = new URL(url, link.href).href;
               }
               if (isIconFont(url)) return null;
-              if (resourceCache.has(url)) {
-                processedFontURLs.add(url);
-                return { original: match[0], inlined: `url(${resourceCache.get(url)})` };
+              if (cache.resource.has(url)) {
+                cache.font.add(url);
+                return { original: match[0], inlined: `url(${cache.resource.get(url)})` };
               }
-              if (processedFontURLs.has(url)) return null;
+              if (cache.font.has(url)) return null;
               try {
                 const fontRes = yield fetch(url);
                 const blob = yield fontRes.blob();
@@ -731,8 +820,8 @@
                   reader.onload = () => resolve(reader.result);
                   reader.readAsDataURL(blob);
                 });
-                resourceCache.set(url, b64);
-                processedFontURLs.add(url);
+                cache.resource.set(url, b64);
+                cache.font.add(url);
                 return { original: match[0], inlined: `url(${b64})` };
               } catch (e) {
                 console.warn("[snapdom] Failed to fetch font resource:", url);
@@ -768,12 +857,12 @@
                     url = new URL(url, sheet.href || location.href).href;
                   }
                   if (isIconFont(url)) continue;
-                  if (resourceCache.has(url)) {
-                    processedFontURLs.add(url);
-                    inlinedSrc = inlinedSrc.replace(match[0], `url(${resourceCache.get(url)})`);
+                  if (cache.resource.has(url)) {
+                    cache.font.add(url);
+                    inlinedSrc = inlinedSrc.replace(match[0], `url(${cache.resource.get(url)})`);
                     continue;
                   }
-                  if (processedFontURLs.has(url)) continue;
+                  if (cache.font.has(url)) continue;
                   try {
                     const res = yield fetch(url);
                     const blob = yield res.blob();
@@ -782,8 +871,8 @@
                       reader.onload = () => resolve(reader.result);
                       reader.readAsDataURL(blob);
                     });
-                    resourceCache.set(url, b64);
-                    processedFontURLs.add(url);
+                    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);
@@ -808,10 +897,10 @@
           if (isIconFont(font.family)) continue;
           let b64 = font._snapdomSrc;
           if (!b64.startsWith("data:")) {
-            if (resourceCache.has(font._snapdomSrc)) {
-              b64 = resourceCache.get(font._snapdomSrc);
-              processedFontURLs.add(font._snapdomSrc);
-            } else if (!processedFontURLs.has(font._snapdomSrc)) {
+            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 {
                 const res = yield fetch(font._snapdomSrc);
                 const blob = yield res.blob();
@@ -820,8 +909,8 @@
                   reader.onload = () => resolve(reader.result);
                   reader.readAsDataURL(blob);
                 });
-                resourceCache.set(font._snapdomSrc, b64);
-                processedFontURLs.add(font._snapdomSrc);
+                cache.resource.set(font._snapdomSrc, b64);
+                cache.font.add(font._snapdomSrc);
               } catch (e) {
                 console.warn("[snapdom] Failed to fetch dynamic font src:", font._snapdomSrc);
                 continue;
@@ -838,7 +927,7 @@
         }
       }
       if (finalCSS) {
-        resourceCache.set("fonts-embed-css", finalCSS);
+        cache.resource.set("fonts-embed-css", finalCSS);
         if (preCached) {
           const style = document.createElement("style");
           style.setAttribute("data-snapdom", "embedFonts");
@@ -849,9 +938,16 @@
       return finalCSS;
     });
   }
+  var init_fonts = __esm({
+    "src/modules/fonts.js"() {
+      init_helpers();
+      init_cache();
+      init_iconFonts();
+    }
+  });
 
   // src/modules/pseudo.js
-  function inlinePseudoElements(source, clone, styleMap, styleCache, compress, embedFonts = false, useProxy) {
+  function inlinePseudoElements(source, clone, compress, embedFonts = false, useProxy) {
     return __async(this, null, function* () {
       if (!(source instanceof Element) || !(clone instanceof Element)) return;
       for (const pseudo of ["::before", "::after", "::first-letter"]) {
@@ -876,7 +972,7 @@
             span.dataset.snapdomPseudo = "::first-letter";
             const snapshot = snapshotComputedStyle(style);
             const key = getStyleKey(snapshot, "span", compress);
-            styleMap.set(span, key);
+            cache.preStyleMap.set(span, key);
             const restNode = document.createTextNode(rest);
             clone.replaceChild(restNode, textNode);
             clone.insertBefore(span, restNode);
@@ -897,7 +993,7 @@
             pseudoEl.dataset.snapdomPseudo = pseudo;
             const snapshot = snapshotComputedStyle(style);
             const key = getStyleKey(snapshot, "span", compress);
-            styleMap.set(pseudoEl, key);
+            cache.preStyleMap.set(pseudoEl, key);
             const isIconFont2 = isIconFont(fontFamily);
             const cleanContent = parseContent(content);
             if (isIconFont2 && cleanContent.length === 1) {
@@ -948,8 +1044,6 @@
         yield inlinePseudoElements(
           sChildren[i],
           cChildren[i],
-          styleMap,
-          styleCache,
           compress,
           embedFonts,
           useProxy
@@ -957,6 +1051,15 @@
       }
     });
   }
+  var init_pseudo = __esm({
+    "src/modules/pseudo.js"() {
+      init_helpers();
+      init_cssTools();
+      init_fonts();
+      init_iconFonts();
+      init_cache();
+    }
+  });
 
   // src/modules/svgDefs.js
   function inlineExternalDef(root) {
@@ -987,23 +1090,25 @@
       }
     });
   }
+  var init_svgDefs = __esm({
+    "src/modules/svgDefs.js"() {
+    }
+  });
 
   // src/core/prepare.js
   function prepareClone(_0) {
     return __async(this, arguments, function* (element, compress = false, embedFonts = false, options = {}) {
       var _a;
-      const styleMap = /* @__PURE__ */ new Map();
-      const styleCache = /* @__PURE__ */ new WeakMap();
-      const nodeMap = /* @__PURE__ */ new Map();
       let clone;
+      let classCSS = "";
       try {
-        clone = deepClone(element, styleMap, styleCache, nodeMap, compress, options, element);
+        clone = deepClone(element, compress, options, element);
       } catch (e) {
         console.warn("deepClone failed:", e);
         throw e;
       }
       try {
-        yield inlinePseudoElements(element, clone, styleMap, styleCache, compress, embedFonts, options.useProxy);
+        yield inlinePseudoElements(element, clone, compress, embedFonts, options.useProxy);
       } catch (e) {
         console.warn("inlinePseudoElements failed:", e);
       }
@@ -1012,11 +1117,10 @@
       } catch (e) {
         console.warn("inlineExternalDef failed:", e);
       }
-      let classCSS = "";
       if (compress) {
-        const keyToClass = generateCSSClasses(styleMap);
+        const keyToClass = generateCSSClasses();
         classCSS = Array.from(keyToClass.entries()).map(([key, className]) => `.${className}{${key}}`).join("");
-        for (const [node, key] of styleMap.entries()) {
+        for (const [node, key] of cache.preStyleMap.entries()) {
           if (node.tagName === "STYLE") continue;
           const className = keyToClass.get(key);
           if (className) node.classList.add(className);
@@ -1025,12 +1129,12 @@
           if (bgImage && bgImage !== "none") node.style.backgroundImage = bgImage;
         }
       } else {
-        for (const [node, key] of styleMap.entries()) {
+        for (const [node, key] of cache.preStyleMap.entries()) {
           if (node.tagName === "STYLE") continue;
           node.setAttribute("style", key.replace(/;/g, "; "));
         }
       }
-      for (const [cloneNode, originalNode] of nodeMap.entries()) {
+      for (const [cloneNode, originalNode] of cache.preNodeMap.entries()) {
         const scrollX = originalNode.scrollLeft;
         const scrollY = originalNode.scrollTop;
         const hasScroll = scrollX || scrollY;
@@ -1049,9 +1153,9 @@
           cloneNode.appendChild(inner);
         }
       }
-      if (element === nodeMap.get(clone)) {
-        const computed = styleCache.get(element) || window.getComputedStyle(element);
-        styleCache.set(element, computed);
+      if (element === cache.preNodeMap.get(clone)) {
+        const computed = cache.preStyle.get(element) || window.getComputedStyle(element);
+        cache.preStyle.set(element, computed);
         const transform = stripTranslate(computed.transform);
         clone.style.margin = "0";
         clone.style.position = "static";
@@ -1064,15 +1168,25 @@
         clone.style.clear = "none";
         clone.style.transform = transform || "";
       }
-      for (const [cloneNode, originalNode] of nodeMap.entries()) {
+      for (const [cloneNode, originalNode] of cache.preNodeMap.entries()) {
         if (originalNode.tagName === "PRE") {
           cloneNode.style.marginTop = "0";
           cloneNode.style.marginBlockStart = "0";
         }
       }
-      return { clone, classCSS, styleCache };
+      return { clone, classCSS };
     });
   }
+  var init_prepare = __esm({
+    "src/core/prepare.js"() {
+      init_cssTools();
+      init_helpers();
+      init_clone();
+      init_pseudo();
+      init_svgDefs();
+      init_cache();
+    }
+  });
 
   // src/modules/images.js
   function inlineImages(_0) {
@@ -1098,10 +1212,15 @@
       }
     });
   }
+  var init_images = __esm({
+    "src/modules/images.js"() {
+      init_helpers();
+    }
+  });
 
   // src/modules/background.js
-  function inlineBackgroundImages(_0, _1, _2) {
-    return __async(this, arguments, function* (source, clone, styleCache, options = {}) {
+  function inlineBackgroundImages(_0, _1) {
+    return __async(this, arguments, function* (source, clone, options = {}) {
       const queue = [[source, clone]];
       const imageProps = [
         "background-image",
@@ -1115,8 +1234,8 @@
       ];
       while (queue.length) {
         const [srcNode, cloneNode] = queue.shift();
-        const style = styleCache.get(srcNode) || getStyle(srcNode);
-        if (!styleCache.has(srcNode)) styleCache.set(srcNode, style);
+        const style = cache.preStyle.get(srcNode) || getStyle(srcNode);
+        if (!cache.preStyle.has(srcNode)) cache.preStyle.set(srcNode, style);
         for (const prop of imageProps) {
           const val = style.getPropertyValue(prop);
           if (!val || val === "none") continue;
@@ -1140,18 +1259,25 @@
       }
     });
   }
+  var init_background = __esm({
+    "src/modules/background.js"() {
+      init_helpers();
+      init_cache();
+    }
+  });
 
   // src/core/capture.js
   function captureDOM(_0) {
     return __async(this, arguments, function* (element, options = {}) {
       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, styleCache;
+      let clone, classCSS;
       let fontsCSS = "";
       let baseCSS = "";
       let dataURL;
       let svgString;
-      ({ clone, classCSS, styleCache } = yield prepareClone(element, compress, embedFonts, options));
+      ({ clone, classCSS } = yield prepareClone(element, compress, embedFonts, options));
       yield new Promise((resolve) => {
         idle(() => __async(null, null, function* () {
           yield inlineImages(clone, options);
@@ -1160,7 +1286,7 @@
       });
       yield new Promise((resolve) => {
         idle(() => __async(null, null, function* () {
-          yield inlineBackgroundImages(element, clone, styleCache, options);
+          yield inlineBackgroundImages(element, clone, options);
           resolve();
         }), { fast });
       });
@@ -1175,13 +1301,13 @@
       if (compress) {
         const usedTags = collectUsedTagNames(clone).sort();
         const tagKey = usedTags.join(",");
-        if (baseCSSCache.has(tagKey)) {
-          baseCSS = baseCSSCache.get(tagKey);
+        if (cache.baseStyle.has(tagKey)) {
+          baseCSS = cache.baseStyle.get(tagKey);
         } else {
           yield new Promise((resolve) => {
             idle(() => {
               baseCSS = generateDedupedBaseCSS(usedTags);
-              baseCSSCache.set(tagKey, baseCSS);
+              cache.baseStyle.set(tagKey, baseCSS);
               resolve();
             }, { fast });
           });
@@ -1245,6 +1371,17 @@
       return dataURL;
     });
   }
+  var init_capture = __esm({
+    "src/core/capture.js"() {
+      init_prepare();
+      init_images();
+      init_background();
+      init_helpers();
+      init_cssTools();
+      init_fonts();
+      init_cache();
+    }
+  });
 
   // src/api/snapdom.js
   function toImg(_0, _1) {
@@ -1318,8 +1455,10 @@
     });
   }
   function toRasterImg(_0, _1) {
-    return __async(this, arguments, function* (url, { dpr = 1, scale = 1, backgroundColor = "#fff", quality }, format = "png") {
-      const canvas = yield createBackground(url, { dpr, scale }, backgroundColor);
+    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);
       const img = new Image();
       img.src = canvas.toDataURL(`image/${format}`, quality);
       yield img.decode();
@@ -1366,56 +1505,63 @@
       return yield snapdom.capture(element, options);
     });
   }
-  snapdom.capture = (_0, ..._1) => __async(null, [_0, ..._1], function* (el, options = {}) {
-    const url = yield captureDOM(el, options);
-    const dpr = window.devicePixelRatio || 1;
-    const scale = options.scale || 1;
-    return {
-      url,
-      options,
-      toRaw: () => url,
-      toImg: () => toImg(url, { dpr, scale }),
-      toCanvas: () => toCanvas(url, { dpr, scale }),
-      toBlob: (options2) => toBlob(url, __spreadValues({ dpr, scale }, options2)),
-      toPng: (options2) => toRasterImg(url, __spreadValues({ dpr, scale }, options2), "png"),
-      toJpg: (options2) => toRasterImg(url, __spreadValues({ dpr, scale }, options2), "jpeg"),
-      toWebp: (options2) => toRasterImg(url, __spreadValues({ dpr, scale }, options2), "webp"),
-      download: ({ format = "png", filename = "capture", backgroundColor } = {}) => download(url, { dpr, scale, backgroundColor, format, filename })
-    };
-  });
-  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 });
+  var init_snapdom = __esm({
+    "src/api/snapdom.js"() {
+      init_capture();
+      init_helpers();
+      init_iconFonts();
+      snapdom.capture = (_0, ..._1) => __async(null, [_0, ..._1], function* (el, options = {}) {
+        const url = yield captureDOM(el, options);
+        const dpr = window.devicePixelRatio || 1;
+        const scale = options.scale || 1;
+        return {
+          url,
+          options,
+          toRaw: () => url,
+          toImg: () => toImg(url, { dpr, scale }),
+          toCanvas: () => toCanvas(url, { dpr, scale }),
+          toBlob: (options2) => toBlob(url, __spreadValues({ dpr, scale }, options2)),
+          toPng: (options2) => toRasterImg(url, __spreadValues({ dpr, scale }, options2), "png"),
+          toJpg: (options2) => toRasterImg(url, __spreadValues({ dpr, scale }, options2), "jpeg"),
+          toWebp: (options2) => toRasterImg(url, __spreadValues({ dpr, scale }, options2), "webp"),
+          download: ({ format = "png", filename = "capture", backgroundColor } = {}) => download(url, { dpr, scale, backgroundColor, format, filename })
+        };
+      });
+      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 });
+      });
+    }
   });
 
   // src/api/preCache.js
@@ -1423,10 +1569,7 @@
     return __async(this, arguments, function* (root = document, options = {}) {
       const { embedFonts = true, reset = false } = options;
       if (reset) {
-        imageCache.clear();
-        bgCache.clear();
-        resourceCache.clear();
-        baseCSSCache.clear();
+        cache.reset();
         return;
       }
       yield document.fonts.ready;
@@ -1439,9 +1582,9 @@
       const promises = [];
       for (const img of imgEls) {
         const src = img.src;
-        if (!imageCache.has(src)) {
+        if (!cache.image.has(src)) {
           promises.push(
-            fetchImage(src, { useProxy: options.useProxy }).then((dataURL) => imageCache.set(src, dataURL)).catch(() => {
+            fetchImage(src, { useProxy: options.useProxy }).then((dataURL) => cache.image.set(src, dataURL)).catch(() => {
             })
           );
         }
@@ -1467,8 +1610,38 @@
       yield Promise.all(promises);
     });
   }
+  var init_preCache = __esm({
+    "src/api/preCache.js"() {
+      init_helpers();
+      init_fonts();
+      init_cssTools();
+      init_cache();
+    }
+  });
 
   // src/index.browser.js
-  window.snapdom = snapdom;
-  window.preCache = preCache;
+  var require_index_browser = __commonJS({
+    "src/index.browser.js"(exports, module) {
+      init_snapdom();
+      init_preCache();
+      window.snapdom = snapdom;
+      if (typeof window !== "undefined") {
+        window.snapdom = snapdom;
+        window.preCache = preCache;
+      }
+      if (typeof module !== "undefined" && typeof module.exports !== "undefined") {
+        module.exports = { snapdom, preCache };
+      }
+      if (typeof define === "function" && define.amd) {
+        define([], function() {
+          return { snapdom, preCache };
+        });
+      }
+      if (typeof globalThis !== "undefined") {
+        globalThis.snapdom = snapdom;
+        globalThis.preCache = preCache;
+      }
+    }
+  });
+  require_index_browser();
 })();