@unicom-cloud/utils 0.1.12 → 0.1.14

package/snapdom/src/utils/helpers.js

@@ -1,186 +1,183 @@
-import { imageCache as f, computedStyleCache as p, bgCache as m } from "../core/cache.js";
-async function x(e, t = {}) {
-  const r = e.startsWith("url("), i = /^((repeating-)?(linear|radial|conic)-gradient)\(/i.test(
-    e
+import { cache as s } from "../core/cache.js";
+async function R(t, e = {}) {
+  const n = p(t), i = /^((repeating-)?(linear|radial|conic)-gradient)\(/i.test(
+    t
   );
-  if (r) {
-    const n = I(e);
-    if (!n) return e;
-    const a = w(n);
-    if (m.has(a))
-      return t.skipInline ? void 0 : `url(${m.get(a)})`;
+  if (n) {
+    const a = h(n);
+    if (s.background.has(a))
+      return e.skipInline ? void 0 : `url(${s.background.get(a)})`;
     {
-      const s = await y(a, {
-        useProxy: t.useProxy
+      const c = await w(a, {
+        useProxy: e.useProxy
       });
-      return m.set(a, s), t.skipInline ? void 0 : `url(${s})`;
+      return s.background.set(a, c), e.skipInline ? void 0 : `url("${c}")`;
     }
   }
-  return e;
+  return t;
 }
-function $(e, { fast: t = !1 } = {}) {
-  if (t) return e();
-  "requestIdleCallback" in window ? requestIdleCallback(e, { timeout: 50 }) : setTimeout(e, 1);
+function S(t, { fast: e = !1 } = {}) {
+  if (e) return t();
+  "requestIdleCallback" in window ? requestIdleCallback(t, { timeout: 50 }) : setTimeout(t, 1);
 }
-function O(e, t = null) {
-  if (!(e instanceof Element))
-    return window.getComputedStyle(e, t);
-  let r = p.get(e);
-  if (r || (r = /* @__PURE__ */ new Map(), p.set(e, r)), !r.has(t)) {
-    const i = window.getComputedStyle(e, t);
-    r.set(t, i);
+function U(t, e = null) {
+  if (!(t instanceof Element))
+    return window.getComputedStyle(t, e);
+  let n = s.computedStyle.get(t);
+  if (n || (n = /* @__PURE__ */ new Map(), s.computedStyle.set(t, n)), !n.has(e)) {
+    const i = window.getComputedStyle(t, e);
+    n.set(e, i);
   }
-  return r.get(t);
+  return n.get(e);
 }
-function C(e) {
-  let t = e.replace(/^['"]|['"]$/g, "");
-  if (t.startsWith("\\"))
+function k(t) {
+  let e = t.replace(/^['"]|['"]$/g, "");
+  if (e.startsWith("\\"))
     try {
-      return String.fromCharCode(parseInt(t.replace("\\", ""), 16));
+      return String.fromCharCode(parseInt(e.replace("\\", ""), 16));
     } catch {
-      return t;
+      return e;
     }
-  return t;
+  return e;
 }
-function I(e) {
-  const t = e.indexOf("url(");
-  if (t === -1) return null;
-  let r = e.slice(t + 4).trim();
-  return r.endsWith(")") && (r = r.slice(0, -1).trim()), (r.startsWith('"') && r.endsWith('"') || r.startsWith("'") && r.endsWith("'")) && (r = r.slice(1, -1)), r;
+function p(t) {
+  const e = t.match(/url\((['"]?)(.*?)(\1)\)/);
+  if (!e) return null;
+  const n = e[2].trim();
+  return n.startsWith("#") ? null : n;
 }
-function y(e, { timeout: t = 3e3, useProxy: r = "" }) {
-  function i(a) {
+function w(t, { timeout: e = 3e3, useProxy: n = "" } = {}) {
+  function i(l) {
     try {
-      return new URL(a, window.location.href).origin === window.location.origin ? "use-credentials" : "anonymous";
+      return new URL(l, window.location.href).origin === window.location.origin ? "use-credentials" : "anonymous";
     } catch {
       return "anonymous";
     }
   }
-  const n = i(e);
-  return console.log(
-    `[SnapDOM - fetchImage] Start loading image: ${e} with crossOrigin=${n}`
-  ), f.has(e) ? (console.log(`[SnapDOM - fetchImage] Cache hit for: ${e}`), Promise.resolve(f.get(e))) : new Promise((a, s) => {
-    const h = setTimeout(() => {
-      console.log(
-        `[SnapDOM - fetchImage] Timeout after ${t}ms for image: ${e}`
-      ), s(new Error("Image load timed out"));
-    }, t), g = () => {
-      console.warn(`[SnapDOM - fetchImage] Trying fetch fallback for: ${e}`), fetch(e, {
-        mode: "cors",
-        credentials: n === "use-credentials" ? "include" : "omit"
-      }).then((o) => (console.log(
-        `[SnapDOM - fetchImage] Fetch response received for: ${e}`
-      ), o.blob())).then((o) => {
-        const d = new FileReader();
-        d.onloadend = () => {
-          const c = d.result;
-          if (typeof c == "string" && c.startsWith("data:application/octet-stream")) {
-            s(new Error("Image response was empty or blocked"));
+  async function a(l) {
+    const u = (d) => fetch(d, {
+      mode: "cors",
+      credentials: i(d) === "use-credentials" ? "include" : "omit"
+    }).then((o) => o.blob()).then(
+      (o) => new Promise((r, g) => {
+        const m = new FileReader();
+        m.onloadend = () => {
+          const f = m.result;
+          if (typeof f != "string" || !f.startsWith("data:image/")) {
+            g(new Error("Invalid image data URL"));
             return;
           }
-          f.set(e, c), a(c);
-        }, d.readAsDataURL(o);
-      }).catch(() => {
-        if (console.warn(
-          `[SnapDOM - fetchImage] Fetch fallback failed for: ${e}`
-        ), r !== "") {
-          const o = typeof r == "string" ? r.replace(/\/$/, "") + w(e) : null;
-          o ? (console.log(
-            `[SnapDOM - fetchImage] Trying proxy fallback: ${o}`
-          ), fetch(o).then((d) => d.blob()).then((d) => {
-            const c = new FileReader();
-            c.onloadend = () => {
-              const u = c.result;
-              if (typeof u == "string" && u.startsWith("data:application/octet-stream")) {
-                s(new Error("Image response was empty or blocked"));
-                return;
-              }
-              f.set(e, u), a(u);
-            }, c.readAsDataURL(d);
-          }).catch(() => {
-            console.error(
-              `[SnapDOM - fetchImage] Proxy fallback failed for: ${e}`
-            ), s(
-              new Error(
-                "CORS restrictions prevented image capture (even via proxy)"
-              )
-            );
-          })) : console.error(
-            `[SnapDOM - fetchImage] Provide a valid proxy url: ${e}`
-          );
-        } else
-          console.error(
-            '[SnapDOM - fetchImage] You may try add a proxy "useProxy: url" '
-          );
-      });
-    }, l = new Image();
-    l.crossOrigin = n, l.onload = async () => {
-      clearTimeout(h);
-      try {
-        await l.decode();
-        const o = document.createElement("canvas");
-        o.width = l.width, o.height = l.height, o.getContext("2d").drawImage(l, 0, 0, o.width, o.height);
+          r(f);
+        }, m.onerror = () => g(new Error("FileReader error")), m.readAsDataURL(o);
+      })
+    );
+    try {
+      return await u(l);
+    } catch {
+      if (n && typeof n == "string") {
+        const o = n.replace(/\/$/, "") + h(l);
         try {
-          const c = o.toDataURL("image/png");
-          f.set(e, c), a(c);
+          return await u(o);
         } catch {
-          g();
+          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 c = i(t);
+  return s.image.has(t) ? Promise.resolve(s.image.get(t)) : t.startsWith("data:image/") ? (s.image.set(t, t), Promise.resolve(t)) : /\.svg(\?.*)?$/i.test(t) ? (async () => {
+    try {
+      const u = await (await fetch(t, {
+        mode: "cors",
+        credentials: c === "use-credentials" ? "include" : "omit"
+      })).text(), d = `data:image/svg+xml;charset=utf-8,${encodeURIComponent(u)}`;
+      return s.image.set(t, d), d;
+    } catch {
+      return a(t);
+    }
+  })() : new Promise((l, u) => {
+    const d = setTimeout(() => {
+      u(new Error("[SnapDOM - fetchImage] Image load timed out"));
+    }, e), o = new Image();
+    o.crossOrigin = c, o.onload = async () => {
+      clearTimeout(d);
+      try {
+        await o.decode();
+        const r = document.createElement("canvas");
+        r.width = o.width, r.height = o.height, r.getContext("2d").drawImage(o, 0, 0, r.width, r.height);
+        const m = r.toDataURL("image/png");
+        s.image.set(t, m), l(m);
       } catch {
-        g();
+        try {
+          const r = await a(t);
+          s.image.set(t, r), l(r);
+        } catch (r) {
+          u(r);
+        }
+      }
+    }, o.onerror = async () => {
+      clearTimeout(d), console.error(`[SnapDOM - fetchImage] Image failed to load: ${t}`);
+      try {
+        const r = await a(t);
+        s.image.set(t, r), l(r);
+      } catch (r) {
+        u(r);
       }
-    }, l.onerror = (o) => {
-      clearTimeout(h), console.error(`[SnapDOM - fetchImage] Image failed to load: ${e}`, o), g();
-    }, l.src = e;
+    }, o.src = t;
   });
 }
-function D(e) {
-  const t = {};
-  for (let r of e)
-    t[r] = e.getPropertyValue(r);
-  return t;
+function C(t) {
+  const e = {};
+  for (let n of t)
+    e[n] = t.getPropertyValue(n);
+  return e;
 }
-function b() {
+function v() {
   return /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
 }
-function k(e) {
-  if (!e || e === "none") return "";
-  let t = e.replace(/translate[XY]?\([^)]*\)/g, "");
-  return t = t.replace(/matrix\(([^)]+)\)/g, (r, i) => {
-    const n = i.split(",").map((a) => a.trim());
-    return n.length !== 6 ? `matrix(${i})` : (n[4] = "0", n[5] = "0", `matrix(${n.join(", ")})`);
-  }), t = t.replace(/matrix3d\(([^)]+)\)/g, (r, i) => {
-    const n = i.split(",").map((a) => a.trim());
-    return n.length !== 16 ? `matrix3d(${i})` : (n[12] = "0", n[13] = "0", `matrix3d(${n.join(", ")})`);
-  }), t.trim().replace(/\s{2,}/g, " ");
+function D(t) {
+  if (!t || t === "none") return "";
+  let e = t.replace(/translate[XY]?\([^)]*\)/g, "");
+  return e = e.replace(/matrix\(([^)]+)\)/g, (n, i) => {
+    const a = i.split(",").map((c) => c.trim());
+    return a.length !== 6 ? `matrix(${i})` : (a[4] = "0", a[5] = "0", `matrix(${a.join(", ")})`);
+  }), e = e.replace(/matrix3d\(([^)]+)\)/g, (n, i) => {
+    const a = i.split(",").map((c) => c.trim());
+    return a.length !== 16 ? `matrix3d(${i})` : (a[12] = "0", a[13] = "0", `matrix3d(${a.join(", ")})`);
+  }), e.trim().replace(/\s{2,}/g, " ");
 }
-function w(e) {
-  if (/%[0-9A-Fa-f]{2}/.test(e)) return e;
+function h(t) {
+  if (/%[0-9A-Fa-f]{2}/.test(t)) return t;
   try {
-    return encodeURI(e);
+    return encodeURI(t);
   } catch {
-    return e;
+    return t;
   }
 }
-function M(e) {
-  const t = [];
-  let r = 0, i = 0;
-  for (let n = 0; n < e.length; n++) {
-    const a = e[n];
-    a === "(" && r++, a === ")" && r--, a === "," && r === 0 && (t.push(e.slice(i, n).trim()), i = n + 1);
+function $(t) {
+  const e = [];
+  let n = 0, i = 0;
+  for (let a = 0; a < t.length; a++) {
+    const c = t[a];
+    c === "(" && n++, c === ")" && n--, c === "," && n === 0 && (e.push(t.slice(i, a).trim()), i = a + 1);
   }
-  return t.push(e.slice(i).trim()), t;
+  return e.push(t.slice(i).trim()), e;
 }
 export {
-  I as extractURL,
-  y as fetchImage,
-  O as getStyle,
-  $ as idle,
-  x as inlineSingleBackgroundEntry,
-  b as isSafari,
-  C as parseContent,
-  w as safeEncodeURI,
-  D as snapshotComputedStyle,
-  M as splitBackgroundImage,
-  k as stripTranslate
+  p as extractURL,
+  w as fetchImage,
+  U as getStyle,
+  S as idle,
+  R as inlineSingleBackgroundEntry,
+  v as isSafari,
+  k as parseContent,
+  h as safeEncodeURI,
+  C as snapshotComputedStyle,
+  $ as splitBackgroundImage,
+  D as stripTranslate
 };

package/tree/index.js

@@ -1,4 +1,4 @@
-import { default as I } from "./searchTree.js";
+import { default as I } from "./search/index.js";
 function a(e, r, f, l = "children") {
   if (Array.isArray(e) && (e = {
     [l]: e

package/tree/search/index.js

@@ -0,0 +1,90 @@
+import "../../is/index.js";
+import A from "lodash/isArray";
+import z from "lodash/isObjectLike";
+import w from "lodash/isString";
+import T from "lodash/isFunction";
+function v(r, l, a, f) {
+  return l && r ? { shouldExit: !0, newMatch: !0 } : a && !r ? { shouldExit: !0, newMatch: !1 } : { shouldExit: !1, newMatch: f || r };
+}
+function q(r, l, a = {}) {
+  if (!A(r)) throw new TypeError("参数treeData必须是一个数组");
+  if (!z(l)) throw new TypeError("参数searchCondition必须是一个对象");
+  const f = {
+    strategy: "BFS",
+    childrenKey: "children",
+    strict: !1,
+    fuzzyMatch: !1,
+    returnAllMatches: !1,
+    caseSensitive: !1,
+    allowEmptyString: !1,
+    matchMode: "AND",
+    ...a
+    // 用户配置覆盖默认值
+  }, {
+    strategy: p,
+    childrenKey: S,
+    strict: x,
+    fuzzyMatch: O,
+    returnAllMatches: y,
+    caseSensitive: m,
+    allowEmptyString: B,
+    matchMode: E
+  } = f, M = E === "OR", g = E === "AND", h = p === "BFS";
+  if (!(h || p === "DFS")) throw new Error('配置 strategy 必须是 "BFS" 或 "DFS"');
+  if (!(M || g)) throw new Error('配置 matchMode 必须是 "AND" 或 "OR"');
+  if (!w(S)) throw new TypeError("配置 childrenKey 必须是字符串");
+  const c = [...r], F = [], D = Object.entries(l);
+  if (D.length) {
+    const N = (s) => {
+      let t = !1;
+      for (const [n, e] of D) {
+        const i = s[n];
+        if (e === "" && !B)
+          continue;
+        let o = !1;
+        try {
+          if (e instanceof RegExp)
+            o = w(i) ? e.test(i) : !1;
+          else if (T(e))
+            o = !!e(i);
+          else if (O && w(e)) {
+            const d = String(i), R = m ? e : e.toLowerCase();
+            o = (m ? d : d.toLowerCase()).includes(R);
+          } else
+            o = x ? i === e : i == e;
+        } catch {
+          o = !1;
+        }
+        const u = v(o, M, g, t);
+        if (u.shouldExit)
+          return u.newMatch;
+        t = u.newMatch;
+      }
+      return t;
+    };
+    for (; c.length > 0; ) {
+      const s = h ? c.shift() : c.pop();
+      if (!s) continue;
+      try {
+        if (N(s))
+          if (y)
+            F.push(s);
+          else
+            return s;
+      } catch {
+        continue;
+      }
+      const t = s[S];
+      if (A(t))
+        if (h)
+          c.push(...t);
+        else
+          for (let n = t.length - 1; n >= 0; n--)
+            c.push(t[n]);
+    }
+  }
+  return y ? F : null;
+}
+export {
+  q as default
+};

package/tree.js

@@ -1,4 +1,4 @@
-import { default as a } from "./tree/searchTree.js";
+import { default as a } from "./tree/search/index.js";
 import { getItemBy as y, findNodeBy as m, getChildWithParentBy as B, getItemBy as g, getItemBy2 as o, getItemBy3 as I, getItemByID as d, getLabelFromDictionaryByValue as f } from "./tree/index.js";
 export {
   y as default,

package/types/filesize/src/constants.d.ts

@@ -1,24 +1,24 @@
-export const ARRAY: "array";
+export const INVALID_NUMBER: "Invalid number";
+export const INVALID_ROUND: "Invalid rounding method";
+export const IEC: "iec";
+export const JEDEC: "jedec";
+export const SI: "si";
 export const BIT: "bit";
 export const BITS: "bits";
 export const BYTE: "byte";
 export const BYTES: "bytes";
-export const EMPTY: "";
-export const EXPONENT: "exponent";
+export const SI_KBIT: "kbit";
+export const SI_KBYTE: "kB";
+export const ARRAY: "array";
 export const FUNCTION: "function";
-export const IEC: "iec";
-export const INVALID_NUMBER: "Invalid number";
-export const INVALID_ROUND: "Invalid rounding method";
-export const JEDEC: "jedec";
 export const OBJECT: "object";
-export const PERIOD: ".";
+export const STRING: "string";
+export const EXPONENT: "exponent";
 export const ROUND: "round";
+export const EMPTY: "";
+export const PERIOD: ".";
 export const S: "s";
-export const SI: "si";
-export const SI_KBIT: "kbit";
-export const SI_KBYTE: "kB";
 export const SPACE: " ";
-export const STRING: "string";
 export const ZERO: "0";
 export namespace STRINGS {
     namespace symbol {

package/types/filesize/src/filesize.d.ts

@@ -1,47 +1,88 @@
-export function filesize(arg: any, { bits, pad, base, round, locale, localeOptions, separator, spacer, symbols, standard, output, fullform, fullforms, exponent, roundingMethod, precision, }?: {
+/**
+ * Converts a file size in bytes to a human-readable string with appropriate units
+ * @param {number|string|bigint} arg - The file size in bytes to convert
+ * @param {Object} [options={}] - Configuration options for formatting
+ * @param {boolean} [options.bits=false] - If true, calculates bits instead of bytes
+ * @param {boolean} [options.pad=false] - If true, pads decimal places to match round parameter
+ * @param {number} [options.base=-1] - Number base (2 for binary, 10 for decimal, -1 for auto)
+ * @param {number} [options.round=2] - Number of decimal places to round to
+ * @param {string|boolean} [options.locale=""] - Locale for number formatting, true for system locale
+ * @param {Object} [options.localeOptions={}] - Additional options for locale formatting
+ * @param {string} [options.separator=""] - Custom decimal separator
+ * @param {string} [options.spacer=" "] - String to separate value and unit
+ * @param {Object} [options.symbols={}] - Custom unit symbols
+ * @param {string} [options.standard=""] - Unit standard to use (SI, IEC, JEDEC)
+ * @param {string} [options.output="string"] - Output format: "string", "array", "object", or "exponent"
+ * @param {boolean} [options.fullform=false] - If true, uses full unit names instead of abbreviations
+ * @param {Array} [options.fullforms=[]] - Custom full unit names
+ * @param {number} [options.exponent=-1] - Force specific exponent (-1 for auto)
+ * @param {string} [options.roundingMethod="round"] - Math rounding method to use
+ * @param {number} [options.precision=0] - Number of significant digits (0 for auto)
+ * @returns {string|Array|Object|number} Formatted file size based on output option
+ * @throws {TypeError} When arg is not a valid number or roundingMethod is invalid
+ * @example
+ * filesize(1024) // "1 KB"
+ * filesize(1024, {bits: true}) // "8 Kb"
+ * filesize(1024, {output: "object"}) // {value: 1, symbol: "KB", exponent: 1, unit: "KB"}
+ */
+export function filesize(arg: number | string | bigint, { bits, pad, base, round, locale, localeOptions, separator, spacer, symbols, standard, output, fullform, fullforms, exponent, roundingMethod, precision, }?: {
     bits?: boolean | undefined;
     pad?: boolean | undefined;
     base?: number | undefined;
     round?: number | undefined;
-    locale?: string | undefined;
-    localeOptions?: {} | undefined;
+    locale?: string | boolean | undefined;
+    localeOptions?: Object | undefined;
     separator?: string | undefined;
     spacer?: string | undefined;
-    symbols?: {} | undefined;
+    symbols?: Object | undefined;
     standard?: string | undefined;
     output?: string | undefined;
     fullform?: boolean | undefined;
-    fullforms?: never[] | undefined;
+    fullforms?: any[] | undefined;
     exponent?: number | undefined;
     roundingMethod?: string | undefined;
     precision?: number | undefined;
-}): string | number | any[] | {
-    value: any;
-    symbol: any;
-    exponent: number;
-    unit: string;
-};
+}): string | any[] | Object | number;
+/**
+ * Creates a partially applied version of filesize with preset options
+ * @param {Object} [options={}] - Default options to apply to the returned function
+ * @param {boolean} [options.bits=false] - If true, calculates bits instead of bytes
+ * @param {boolean} [options.pad=false] - If true, pads decimal places to match round parameter
+ * @param {number} [options.base=-1] - Number base (2 for binary, 10 for decimal, -1 for auto)
+ * @param {number} [options.round=2] - Number of decimal places to round to
+ * @param {string|boolean} [options.locale=""] - Locale for number formatting, true for system locale
+ * @param {Object} [options.localeOptions={}] - Additional options for locale formatting
+ * @param {string} [options.separator=""] - Custom decimal separator
+ * @param {string} [options.spacer=" "] - String to separate value and unit
+ * @param {Object} [options.symbols={}] - Custom unit symbols
+ * @param {string} [options.standard=""] - Unit standard to use (SI, IEC, JEDEC)
+ * @param {string} [options.output="string"] - Output format: "string", "array", "object", or "exponent"
+ * @param {boolean} [options.fullform=false] - If true, uses full unit names instead of abbreviations
+ * @param {Array} [options.fullforms=[]] - Custom full unit names
+ * @param {number} [options.exponent=-1] - Force specific exponent (-1 for auto)
+ * @param {string} [options.roundingMethod="round"] - Math rounding method to use
+ * @param {number} [options.precision=0] - Number of significant digits (0 for auto)
+ * @returns {Function} A function that takes a file size and returns formatted output
+ * @example
+ * const formatBytes = partial({round: 1, standard: "IEC"});
+ * formatBytes(1024) // "1.0 KiB"
+ * formatBytes(2048) // "2.0 KiB"
+ */
 export function partial({ bits, pad, base, round, locale, localeOptions, separator, spacer, symbols, standard, output, fullform, fullforms, exponent, roundingMethod, precision, }?: {
     bits?: boolean | undefined;
     pad?: boolean | undefined;
     base?: number | undefined;
     round?: number | undefined;
-    locale?: string | undefined;
-    localeOptions?: {} | undefined;
+    locale?: string | boolean | undefined;
+    localeOptions?: Object | undefined;
     separator?: string | undefined;
     spacer?: string | undefined;
-    symbols?: {} | undefined;
+    symbols?: Object | undefined;
     standard?: string | undefined;
     output?: string | undefined;
     fullform?: boolean | undefined;
-    fullforms?: never[] | undefined;
+    fullforms?: any[] | undefined;
     exponent?: number | undefined;
     roundingMethod?: string | undefined;
     precision?: number | undefined;
-}): (arg: any) => string | number | any[] | {
-    value: any;
-    symbol: any;
-    exponent: number;
-    unit: string;
-};
-export default filesize;
+}): Function;

package/types/snapdom/src/core/cache.d.ts

@@ -1,11 +1,17 @@
-/**
- * Caches for images, backgrounds, resources, and computed styles used during DOM capture.
- * @module cache
- */
-export const imageCache: Map<any, any>;
-export const bgCache: Map<any, any>;
-export const resourceCache: Map<any, any>;
-export const defaultStylesCache: Map<any, any>;
-export const baseCSSCache: Map<any, any>;
-export const computedStyleCache: WeakMap<WeakKey, any>;
-export const processedFontURLs: Set<any>;
+export namespace cache {
+    export let image: Map<any, any>;
+    export let background: Map<any, any>;
+    export let resource: Map<any, any>;
+    export let defaultStyle: Map<any, any>;
+    export let baseStyle: Map<any, any>;
+    export let computedStyle: WeakMap<WeakKey, any>;
+    export let font: Set<any>;
+    export let snapshot: WeakMap<WeakKey, any>;
+    export let snapshotKey: Map<any, any>;
+    export let preStyleMap: Map<any, any>;
+    export let preStyle: WeakMap<WeakKey, any>;
+    export let preNodeMap: Map<any, any>;
+    export { resetCache as reset };
+}
+declare function resetCache(): void;
+export {};

package/types/snapdom/src/core/capture.d.ts

@@ -7,6 +7,8 @@
  * @param {boolean} [options.embedFonts=false] - Whether to embed custom fonts
  * @param {boolean} [options.fast=true] - Whether to skip idle delay for faster results
  * @param {number} [options.scale=1] - Output scale multiplier
+ * @param {string[]} [options.exclude] - CSS selectors for elements to exclude
+ * @param {Function} [options.filter] - Custom filter function
  * @returns {Promise<string>} Promise that resolves to an SVG data URL
  */
 export function captureDOM(element: Element, options?: {
@@ -14,4 +16,6 @@ export function captureDOM(element: Element, options?: {
     embedFonts?: boolean | undefined;
     fast?: boolean | undefined;
     scale?: number | undefined;
+    exclude?: string[] | undefined;
+    filter?: Function | undefined;
 }): Promise<string>;

package/types/snapdom/src/core/clone.d.ts

@@ -2,10 +2,9 @@
  * Creates a deep clone of a DOM node, including styles, shadow DOM, and special handling for excluded/placeholder/canvas nodes.
  *
  * @param {Node} node - Node to clone
- * @param {Map} styleMap - Map to store element-to-style-key mappings
- * @param {WeakMap} styleCache - Cache of computed styles
- * @param {WeakMap} nodeMap - Map to track original-to-clone node relationships
  * @param {boolean} compress - Whether to compress style keys
- * @returns {Node|null} Cloned node with styles and shadow DOM content, or null for empty text nodes
+ * @param {Object} [options={}] - Capture options including exclude and filter
+ * @param {Node} [originalRoot] - Original root element being captured
+ * @returns {Node|null} Cloned node with styles and shadow DOM content, or null for empty text nodes or filtered elements
  */
-export function deepClone(node: Node, styleMap: Map<any, any>, styleCache: WeakMap<any, any>, nodeMap: WeakMap<any, any>, compress: boolean): Node | null;
+export function deepClone(node: Node, compress: boolean, options?: Object, originalRoot?: Node): Node | null;