@unicom-cloud/utils 0.1.23 → 0.1.24

package/snapdom/src/modules/fonts.js

@@ -1,211 +1,672 @@
-import { cache as o } from "../core/cache.js";
-import { isIconFont as $ } from "./iconFonts.js";
-import { fetchResource as A, extractURL as v } from "../utils/helpers.js";
-async function H(h, d, c, y = 32, C = "#000") {
-  d = d.replace(/^['"]+|['"]+$/g, "");
-  const p = window.devicePixelRatio || 1;
-  await document.fonts.ready;
-  const i = document.createElement("span");
-  i.textContent = h, i.style.position = "absolute", i.style.visibility = "hidden", i.style.fontFamily = `"${d}"`, i.style.fontWeight = c || "normal", i.style.fontSize = `${y}px`, i.style.lineHeight = "1", i.style.whiteSpace = "nowrap", i.style.padding = "0", i.style.margin = "0", document.body.appendChild(i);
-  const m = i.getBoundingClientRect(), t = Math.ceil(m.width), n = Math.ceil(m.height);
-  document.body.removeChild(i);
-  const e = document.createElement("canvas");
-  e.width = t * p, e.height = n * p;
-  const a = e.getContext("2d");
-  return a.scale(p, p), a.font = c ? `${c} ${y}px "${d}"` : `${y}px "${d}"`, a.textAlign = "left", a.textBaseline = "top", a.fillStyle = C, a.fillText(h, 0, 0), {
-    dataUrl: e.toDataURL(),
-    width: t,
-    height: n
+/* 2025-10-28 09:57:10 */
+import { cache as g } from "../core/cache.js";
+import { extractURL as X } from "../utils/helpers.js";
+import { isIconFont as x } from "./iconFonts.js";
+import { snapFetch as A } from "./snapFetch.js";
+async function lt(o, e, r, a = 32, n = "#000") {
+  e = e.replace(/^['"]+|['"]+$/g, "");
+  const c = window.devicePixelRatio || 1;
+  try {
+    await document.fonts.ready;
+  } catch {
+  }
+  const t = document.createElement("span");
+  t.textContent = o, t.style.position = "absolute", t.style.visibility = "hidden", t.style.fontFamily = `"${e}"`, t.style.fontWeight = r || "normal", t.style.fontSize = `${a}px`, t.style.lineHeight = "1", t.style.whiteSpace = "nowrap", t.style.padding = "0", t.style.margin = "0", document.body.appendChild(t);
+  const f = t.getBoundingClientRect(), s = Math.ceil(f.width), u = Math.ceil(f.height);
+  document.body.removeChild(t);
+  const m = document.createElement("canvas");
+  m.width = Math.max(1, s * c), m.height = Math.max(1, u * c);
+  const d = m.getContext("2d");
+  return d.scale(c, c), d.font = r ? `${r} ${a}px "${e}"` : `${a}px "${e}"`, d.textAlign = "left", d.textBaseline = "top", d.fillStyle = n, d.fillText(o, 0, 0), {
+    dataUrl: m.toDataURL(),
+    width: s,
+    height: u
   };
 }
-function T(h) {
-  return Array.from(document.styleSheets).some((d) => d.href === h);
+const G = /* @__PURE__ */ new Set([
+  "serif",
+  "sans-serif",
+  "monospace",
+  "cursive",
+  "fantasy",
+  "system-ui",
+  "emoji",
+  "math",
+  "fangsong",
+  "ui-serif",
+  "ui-sans-serif",
+  "ui-monospace",
+  "ui-rounded"
+]);
+function T(o) {
+  if (!o) return "";
+  for (let e of o.split(",")) {
+    let r = e.trim().replace(/^['"]+|['"]+$/g, "");
+    if (r && !G.has(r.toLowerCase()))
+      return r;
+  }
+  return "";
+}
+function N(o) {
+  const e = String(o ?? "400").trim().toLowerCase();
+  if (e === "normal") return 400;
+  if (e === "bold") return 700;
+  const r = parseInt(e, 10);
+  return Number.isFinite(r) ? Math.min(900, Math.max(100, r)) : 400;
+}
+function W(o) {
+  const e = String(o ?? "normal").trim().toLowerCase();
+  return e.startsWith("italic") ? "italic" : e.startsWith("oblique") ? "oblique" : "normal";
+}
+function Y(o) {
+  const e = String(o ?? "100%").match(/(\d+(?:\.\d+)?)\s*%/);
+  return e ? Math.max(50, Math.min(200, parseFloat(e[1]))) : 100;
+}
+function J(o) {
+  const e = String(o || "400").trim(), r = e.match(/^(\d{2,3})\s+(\d{2,3})$/);
+  if (r) {
+    const n = N(r[1]), c = N(r[2]);
+    return { min: Math.min(n, c), max: Math.max(n, c) };
+  }
+  const a = N(e);
+  return { min: a, max: a };
+}
+function K(o) {
+  const e = String(o || "normal").trim().toLowerCase();
+  return e === "italic" ? { kind: "italic" } : e.startsWith("oblique") ? { kind: "oblique" } : { kind: "normal" };
+}
+function Q(o) {
+  const e = String(o || "100%").trim(), r = e.match(/(\d+(?:\.\d+)?)\s*%\s+(\d+(?:\.\d+)?)\s*%/);
+  if (r) {
+    const c = parseFloat(r[1]), t = parseFloat(r[2]);
+    return { min: Math.min(c, t), max: Math.max(c, t) };
+  }
+  const a = e.match(/(\d+(?:\.\d+)?)\s*%/), n = a ? parseFloat(a[1]) : 100;
+  return { min: n, max: n };
+}
+function Z(o, e) {
+  if (!o) return !1;
+  try {
+    const r = new URL(o, location.href);
+    if (r.origin === location.origin) return !0;
+    const n = r.host.toLowerCase();
+    if ([
+      "fonts.googleapis.com",
+      "fonts.gstatic.com",
+      "use.typekit.net",
+      "p.typekit.net",
+      "kit.fontawesome.com",
+      "use.fontawesome.com"
+    ].some((f) => n.endsWith(f))) return !0;
+    const t = (r.pathname + r.search).toLowerCase();
+    if (/\bfont(s)?\b/.test(t) || /\.woff2?(\b|$)/.test(t)) return !0;
+    for (const f of e) {
+      const s = f.toLowerCase().replace(/\s+/g, "+"), u = f.toLowerCase().replace(/\s+/g, "-");
+      if (t.includes(s) || t.includes(u)) return !0;
+    }
+    return !1;
+  } catch {
+    return !1;
+  }
+}
+function tt(o) {
+  const e = /* @__PURE__ */ new Set();
+  for (const r of o || []) {
+    const a = String(r).split("__")[0]?.trim();
+    a && e.add(a);
+  }
+  return e;
 }
-function I(h) {
-  return new Promise((d) => {
-    if (T(h)) return d(null);
-    const c = document.createElement("link");
-    c.rel = "stylesheet", c.href = h, c.setAttribute("data-snapdom", "injected-import"), c.onload = () => d(c), c.onerror = () => d(null), document.head.appendChild(c);
+function q(o, e) {
+  return o && o.replace(/url\(\s*(['"]?)([^)'"]+)\1\s*\)/g, (r, a, n) => {
+    const c = (n || "").trim();
+    if (!c || /^data:|^blob:|^https?:|^file:|^about:/i.test(c)) return r;
+    let t = c;
+    try {
+      t = new URL(c, e || location.href).href;
+    } catch {
+    }
+    return `url("${t}")`;
   });
 }
-async function N({
-  preCached: h = !1,
-  localFonts: d = [],
-  useProxy: c = ""
-} = {}) {
-  if (o.resource.has("fonts-embed-css")) {
-    if (h) {
-      const t = document.createElement("style");
-      t.setAttribute("data-snapdom", "embedFonts"), t.textContent = o.resource.get("fonts-embed-css"), document.head.appendChild(t);
+const v = /@import\s+(?:url\(\s*(['"]?)([^)"']+)\1\s*\)|(['"])([^"']+)\3)([^;]*);/g, I = 4;
+async function et(o, e, r) {
+  if (!o) return o;
+  const a = /* @__PURE__ */ new Set();
+  function n(f, s) {
+    try {
+      return new URL(f, s || location.href).href;
+    } catch {
+      return f;
+    }
+  }
+  async function c(f, s, u = 0) {
+    if (u > I)
+      return console.warn(
+        `[snapDOM] @import depth exceeded (${I}) at ${s}`
+      ), f;
+    let m = "", d = 0, p;
+    for (; p = v.exec(f); ) {
+      m += f.slice(d, p.index), d = v.lastIndex;
+      const L = (p[2] || p[4] || "").trim(), C = n(L, s);
+      if (a.has(C)) {
+        console.warn(`[snapDOM] Skipping circular @import: ${C}`);
+        continue;
+      }
+      a.add(C);
+      let i = "";
+      try {
+        const l = await A(C, {
+          as: "text",
+          useProxy: r,
+          silent: !0
+        });
+        l.ok && typeof l.data == "string" && (i = l.data);
+      } catch {
+      }
+      i ? (i = q(i, C), i = await c(i, C, u + 1), m += `
+/* inlined: ${C} */
+${i}
+`) : m += p[0];
     }
-    return o.resource.get("fonts-embed-css");
+    return m += f.slice(d), m;
   }
-  const y = /* @__PURE__ */ new Set();
+  let t = q(o, e || location.href);
+  return t = await c(t, e || location.href, 0), t;
+}
+const j = /url\((["']?)([^"')]+)\1\)/g, nt = /@font-face[^{}]*\{[^}]*\}/g;
+function B(o) {
+  if (!o) return [];
+  const e = [], r = o.split(",").map((a) => a.trim()).filter(Boolean);
+  for (const a of r) {
+    const n = a.match(/^U\+([0-9A-Fa-f?]+)(?:-([0-9A-Fa-f?]+))?$/);
+    if (!n) continue;
+    const c = n[1], t = n[2], f = (s) => {
+      if (!s.includes("?")) return parseInt(s, 16);
+      const u = parseInt(s.replace(/\?/g, "0"), 16), m = parseInt(s.replace(/\?/g, "F"), 16);
+      return [u, m];
+    };
+    if (t) {
+      const s = f(c), u = f(t), m = Array.isArray(s) ? s[0] : s, d = Array.isArray(u) ? u[1] : u;
+      e.push([Math.min(m, d), Math.max(m, d)]);
+    } else {
+      const s = f(c);
+      Array.isArray(s) ? e.push([s[0], s[1]]) : e.push([s, s]);
+    }
+  }
+  return e;
+}
+function V(o, e) {
+  if (!e.length || !o || o.size === 0) return !0;
+  for (const r of o)
+    for (const [a, n] of e) if (r >= a && r <= n) return !0;
+  return !1;
+}
+function P(o, e) {
+  const r = [];
+  if (!o) return r;
+  for (const a of o.matchAll(j)) {
+    let n = (a[2] || "").trim();
+    if (!(!n || n.startsWith("data:"))) {
+      if (!/^https?:/i.test(n))
+        try {
+          n = new URL(n, e || location.href).href;
+        } catch {
+        }
+      r.push(n);
+    }
+  }
+  return r;
+}
+async function z(o, e, r = "") {
+  let a = o;
+  for (const n of o.matchAll(j)) {
+    const c = X(n[0]);
+    if (!c) continue;
+    let t = c;
+    if (!t.startsWith("http") && !t.startsWith("data:"))
+      try {
+        t = new URL(t, e || location.href).href;
+      } catch {
+      }
+    if (!x(t)) {
+      if (g.resource?.has(t)) {
+        g.font?.add(t), a = a.replace(n[0], `url(${g.resource.get(t)})`);
+        continue;
+      }
+      if (!g.font?.has(t))
+        try {
+          const f = await A(t, { as: "dataURL", useProxy: r, silent: !0 });
+          if (f.ok && typeof f.data == "string") {
+            const s = f.data;
+            g.resource?.set(t, s), g.font?.add(t), a = a.replace(n[0], `url(${s})`);
+          }
+        } catch {
+          console.warn("[snapDOM] Failed to fetch font resource:", t);
+        }
+    }
+  }
+  return a;
+}
+function ot(o) {
+  if (!o.length) return null;
+  const e = (f, s) => o.some(([u, m]) => !(m < f || u > s)), r = e(0, 255) || e(305, 305), a = e(256, 591) || e(7680, 7935), n = e(880, 1023), c = e(1024, 1279);
+  return e(7840, 7929) || e(258, 259) || e(416, 417) || e(431, 432) ? "vietnamese" : c ? "cyrillic" : n ? "greek" : a ? "latin-ext" : r ? "latin" : null;
+}
+function D(o = {}) {
+  const e = new Set(
+    (o.families || []).map((n) => String(n).toLowerCase())
+  ), r = new Set(
+    (o.domains || []).map((n) => String(n).toLowerCase())
+  ), a = new Set(
+    (o.subsets || []).map((n) => String(n).toLowerCase())
+  );
+  return (n, c) => {
+    if (e.size && e.has(n.family.toLowerCase())) return !0;
+    if (r.size)
+      for (const t of n.srcUrls)
+        try {
+          if (r.has(new URL(t).host.toLowerCase())) return !0;
+        } catch {
+        }
+    if (a.size) {
+      const t = ot(c);
+      if (t && a.has(t)) return !0;
+    }
+    return !1;
+  };
+}
+function rt(o) {
+  if (!o) return o;
+  const e = /@font-face[^{}]*\{[^}]*\}/gi, r = /* @__PURE__ */ new Set(), a = [];
+  for (const c of o.match(e) || []) {
+    const t = c.match(/font-family:\s*([^;]+);/i)?.[1] || "", f = T(t), s = (c.match(/font-weight:\s*([^;]+);/i)?.[1] || "400").trim(), u = (c.match(/font-style:\s*([^;]+);/i)?.[1] || "normal").trim(), m = (c.match(/font-stretch:\s*([^;]+);/i)?.[1] || "100%").trim(), d = (c.match(/unicode-range:\s*([^;]+);/i)?.[1] || "").trim(), p = (c.match(/src\s*:\s*([^;]+);/i)?.[1] || "").trim(), L = P(p, location.href), C = L.length ? L.map((l) => String(l).toLowerCase()).sort().join("|") : p.toLowerCase(), i = [
+      String(f || "").toLowerCase(),
+      s,
+      u,
+      m,
+      d.toLowerCase(),
+      C
+    ].join("|");
+    r.has(i) || (r.add(i), a.push(c));
+  }
+  if (a.length === 0) return o;
+  let n = 0;
+  return o.replace(e, () => a[n++] || "");
+}
+function st(o, e, r, a) {
+  const n = Array.from(o || []).sort().join("|"), c = e ? JSON.stringify({
+    families: (e.families || []).map((s) => String(s).toLowerCase()).sort(),
+    domains: (e.domains || []).map((s) => String(s).toLowerCase()).sort(),
+    subsets: (e.subsets || []).map((s) => String(s).toLowerCase()).sort()
+  }) : "", t = (r || []).map(
+    (s) => `${(s.family || "").toLowerCase()}::${s.weight || "normal"}::${s.style || "normal"}::${s.src || ""}`
+  ).sort().join("|");
+  return `fonts-embed-css::req=${n}::ex=${c}::lf=${t}::px=${a || ""}`;
+}
+async function H(o, e, r, a) {
+  let n;
   try {
-    for (const t of document.fonts)
-      t.status === "loaded" && y.add(
-        `${t.family}__${t.weight || "normal"}__${t.style || "normal"}`
-      );
+    n = o.cssRules || [];
   } catch {
+    return;
+  }
+  const c = (t, f) => {
+    try {
+      return new URL(t, f || location.href).href;
+    } catch {
+      return t;
+    }
+  };
+  for (const t of n) {
+    if (t.type === CSSRule.IMPORT_RULE && t.styleSheet) {
+      const f = t.href ? c(t.href, e) : e;
+      if (a.depth >= I) {
+        console.warn(
+          `[snapDOM] CSSOM import depth exceeded (${I}) at ${f}`
+        );
+        continue;
+      }
+      if (f && a.visitedSheets.has(f)) {
+        console.warn(`[snapDOM] Skipping circular CSSOM import: ${f}`);
+        continue;
+      }
+      f && a.visitedSheets.add(f);
+      const s = { ...a, depth: (a.depth || 0) + 1 };
+      await H(
+        t.styleSheet,
+        f,
+        r,
+        s
+      );
+      continue;
+    }
+    if (t.type === CSSRule.FONT_FACE_RULE) {
+      const f = (t.style.getPropertyValue("font-family") || "").trim(), s = T(f);
+      if (!s || x(s)) continue;
+      const u = (t.style.getPropertyValue("font-weight") || "400").trim(), m = (t.style.getPropertyValue("font-style") || "normal").trim(), d = (t.style.getPropertyValue("font-stretch") || "100%").trim(), p = (t.style.getPropertyValue("src") || "").trim(), L = (t.style.getPropertyValue("unicode-range") || "").trim();
+      if (!a.faceMatchesRequired(s, m, u, d))
+        continue;
+      const C = B(L);
+      if (!V(a.usedCodepoints, C)) continue;
+      const i = {
+        family: s,
+        weightSpec: u,
+        styleSpec: m,
+        stretchSpec: d,
+        unicodeRange: L,
+        srcRaw: p,
+        srcUrls: P(p, e || location.href),
+        href: e || location.href
+      };
+      if (a.simpleExcluder && a.simpleExcluder(i, C)) continue;
+      if (/url\(/i.test(p)) {
+        const l = await z(
+          p,
+          e || location.href,
+          a.useProxy
+        );
+        await r(
+          `@font-face{font-family:${s};src:${l};font-style:${m};font-weight:${u};font-stretch:${d};${L ? `unicode-range:${L};` : ""}}`
+        );
+      } else
+        await r(
+          `@font-face{font-family:${s};src:${p};font-style:${m};font-weight:${u};font-stretch:${d};${L ? `unicode-range:${L};` : ""}}`
+        );
+    }
+  }
+}
+async function ut({
+  required: o,
+  usedCodepoints: e,
+  exclude: r = void 0,
+  localFonts: a = [],
+  useProxy: n = ""
+} = {}) {
+  o instanceof Set || (o = /* @__PURE__ */ new Set()), e instanceof Set || (e = /* @__PURE__ */ new Set());
+  const c = /* @__PURE__ */ new Map();
+  for (const i of o) {
+    const [l, h, w, S] = String(i).split("__");
+    if (!l) continue;
+    const y = c.get(l) || [];
+    y.push({ w: parseInt(h, 10), s: w, st: parseInt(S, 10) }), c.set(l, y);
+  }
+  function t(i, l, h, w) {
+    if (!c.has(i)) return !1;
+    const S = c.get(i), y = J(h), R = K(l), b = Q(w), F = y.min !== y.max, M = y.min, E = ($) => R.kind === "normal" && $ === "normal" || R.kind !== "normal" && ($ === "italic" || $ === "oblique");
+    let k = !1;
+    for (const $ of S) {
+      const _ = F ? $.w >= y.min && $.w <= y.max : $.w === M, O = E(W($.s)), U = $.st >= b.min && $.st <= b.max;
+      if (_ && O && U) {
+        k = !0;
+        break;
+      }
+    }
+    if (k) return !0;
+    if (!F)
+      for (const $ of S) {
+        const _ = E(W($.s)), O = $.st >= b.min && $.st <= b.max;
+        if (Math.abs(M - $.w) <= 300 && _ && O) return !0;
+      }
+    return !1;
   }
-  const C = /@import\s+url\(["']?([^"')]+)["']?\)/g, p = [];
-  for (const t of document.querySelectorAll("style")) {
-    const n = t.textContent || "", e = Array.from(n.matchAll(C));
-    for (const a of e) {
-      const r = a[1];
-      $(r) || T(r) || p.push(r);
+  const f = D(r), s = st(o, r, a, n);
+  if (g.resource?.has(s))
+    return g.resource.get(s);
+  const u = tt(o), m = [], d = v;
+  for (const i of document.querySelectorAll("style")) {
+    const l = i.textContent || "";
+    for (const h of l.matchAll(d)) {
+      const w = (h[2] || h[4] || "").trim();
+      if (!w || x(w)) continue;
+      !!document.querySelector(
+        `link[rel="stylesheet"][href="${w}"]`
+      ) || m.push(w);
     }
   }
-  await Promise.all(p.map(I));
-  const i = Array.from(
+  m.length && await Promise.all(
+    m.map(
+      (i) => new Promise((l) => {
+        if (document.querySelector(`link[rel="stylesheet"][href="${i}"]`))
+          return l(null);
+        const h = document.createElement("link");
+        h.rel = "stylesheet", h.href = i, h.setAttribute("data-snapdom", "injected-import"), h.onload = () => l(h), h.onerror = () => l(null), document.head.appendChild(h);
+      })
+    )
+  );
+  let p = "";
+  const L = Array.from(
     document.querySelectorAll('link[rel="stylesheet"]')
-  ).filter((t) => t.href);
-  let m = "";
-  for (const t of i)
+  ).filter((i) => !!i.href);
+  for (const i of L)
     try {
-      const e = await (await A(t.href, { useProxy: c })).text();
-      if ($(t.href) || $(e)) continue;
-      const a = /@font-face[^{}]*{[^}]*}/g;
-      let r = e;
-      for (const s of e.match(a) || []) {
-        const b = s.match(/font-family:\s*([^;]+);/i);
-        if (!b) continue;
-        const R = b[1].replace(/['"]/g, "").trim(), S = s.match(/font-weight:\s*([^;]+);/i), u = s.match(/font-style:\s*([^;]+);/i), F = S ? S[1].trim() : "normal", w = u ? u[1].trim() : "normal", k = `${R}__${F}__${w}`, x = /url\((["']?)([^"')]+)\1\)/g, L = /url\(/i.test(s), f = /local\(/i.test(s);
-        if (!L && f)
-          continue;
-        if (!y.has(k)) {
-          r = r.replace(s, "");
-          continue;
-        }
-        let g = s;
-        const E = Array.from(s.matchAll(x));
-        for (const _ of E) {
-          let U = v(_[0]);
-          if (!U) continue;
-          let l = U;
-          if (!l.startsWith("http") && !l.startsWith("data:") && (l = new URL(l, t.href).href), !$(l)) {
-            if (o.resource.has(l)) {
-              o.font.add(l), g = g.replace(
-                _[0],
-                `url(${o.resource.get(l)})`
-              );
-              continue;
-            }
-            if (!o.font.has(l))
-              try {
-                const D = await (await A(l, { useProxy: c })).blob(), M = await new Promise((W) => {
-                  const P = new FileReader();
-                  P.onload = () => W(P.result), P.readAsDataURL(D);
-                });
-                o.resource.set(l, M), o.font.add(l), g = g.replace(_[0], `url(${M})`);
-              } catch {
-                console.warn("[snapdom] Failed to fetch font resource:", l);
-              }
+      if (x(i.href)) continue;
+      let l = "", h = !1;
+      try {
+        h = new URL(i.href, location.href).origin === location.origin;
+      } catch {
+      }
+      if (!h && !Z(i.href, u))
+        continue;
+      if (h) {
+        const S = Array.from(document.styleSheets).find(
+          (y) => y.href === i.href
+        );
+        if (S)
+          try {
+            const y = S.cssRules || [];
+            l = Array.from(y).map((R) => R.cssText).join("");
+          } catch {
           }
-        }
-        r = r.replace(s, g);
       }
-      m += r + `
-`;
+      if (!l && (l = (await A(i.href, { as: "text", useProxy: n })).data, x(i.href)))
+        continue;
+      l = await et(l, i.href, n);
+      let w = "";
+      for (const S of l.match(nt) || []) {
+        const y = (S.match(/font-family:\s*([^;]+);/i)?.[1] || "").trim(), R = T(y);
+        if (!R || x(R)) continue;
+        const b = (S.match(/font-weight:\s*([^;]+);/i)?.[1] || "400").trim(), F = (S.match(/font-style:\s*([^;]+);/i)?.[1] || "normal").trim(), M = (S.match(/font-stretch:\s*([^;]+);/i)?.[1] || "100%").trim(), E = (S.match(/unicode-range:\s*([^;]+);/i)?.[1] || "").trim(), k = (S.match(/src\s*:\s*([^;]+);/i)?.[1] || "").trim(), $ = P(k, i.href);
+        if (!t(R, F, b, M))
+          continue;
+        const _ = B(E);
+        if (!V(e, _)) continue;
+        const O = {
+          family: R,
+          weightSpec: b,
+          styleSpec: F,
+          stretchSpec: M,
+          unicodeRange: E,
+          srcRaw: k,
+          srcUrls: $,
+          href: i.href
+        };
+        if (r && f(O, _)) continue;
+        const U = /url\(/i.test(k) ? await z(S, i.href, n) : S;
+        w += U;
+      }
+      w.trim() && (p += w);
     } catch {
-      console.warn("[snapdom] Failed to fetch CSS:", t.href);
+      console.warn("[snapDOM] Failed to process stylesheet:", i.href);
     }
-  for (const t of document.styleSheets)
-    try {
-      if (!t.href || i.every((n) => n.href !== t.href)) {
-        for (const n of t.cssRules)
-          if (n.type === CSSRule.FONT_FACE_RULE) {
-            const e = n.style.getPropertyValue("src"), a = n.style.getPropertyValue("font-family");
-            if (!e || $(a)) continue;
-            const r = n.style.getPropertyValue("font-weight") || "normal", s = n.style.getPropertyValue("font-style") || "normal", b = `${a}__${r}__${s}`, R = /url\((["']?)([^"')]+)\1\)/g, S = /local\((["']?)[^)]+?\1\)/g, u = !!e.match(R), F = !!e.match(S);
-            if (!u && F) {
-              m += `@font-face{font-family:${a};src:${e};font-style:${s};font-weight:${r};}`;
-              continue;
-            }
-            if (!y.has(b)) continue;
-            let w = e;
-            const k = Array.from(e.matchAll(R));
-            for (const x of k) {
-              let L = x[2].trim();
-              if (!L) continue;
-              let f = L;
-              if (!f.startsWith("http") && !f.startsWith("data:") && (f = new URL(f, t.href || location.href).href), !$(f)) {
-                if (o.resource.has(f)) {
-                  o.font.add(f), w = w.replace(
-                    x[0],
-                    `url(${o.resource.get(f)})`
-                  );
-                  continue;
-                }
-                if (!o.font.has(f))
-                  try {
-                    const E = await (await A(f, { useProxy: c })).blob(), _ = await new Promise((U) => {
-                      const l = new FileReader();
-                      l.onload = () => U(l.result), l.readAsDataURL(E);
-                    });
-                    o.resource.set(f, _), o.font.add(f), w = w.replace(x[0], `url(${_})`);
-                  } catch {
-                    console.warn("[snapdom] Failed to fetch font URL:", f);
-                  }
-              }
-            }
-            m += `@font-face{font-family:${a};src:${w};font-style:${s};font-weight:${r};}`;
-          }
+  const C = {
+    requiredIndex: c,
+    usedCodepoints: e,
+    faceMatchesRequired: t,
+    simpleExcluder: r ? D(r) : null,
+    useProxy: n,
+    visitedSheets: /* @__PURE__ */ new Set(),
+    depth: 0
+  };
+  for (const i of document.styleSheets)
+    if (!(i.href && L.some((l) => l.href === i.href)))
+      try {
+        const l = i.href || location.href;
+        l && C.visitedSheets.add(l), await H(
+          i,
+          l,
+          async (h) => {
+            p += h;
+          },
+          C
+        );
+      } catch {
       }
-    } catch (n) {
-      console.warn("[snapdom] Cannot access stylesheet", t.href, n);
-    }
-  for (const t of document.fonts)
-    if (t.family && t.status === "loaded" && t._snapdomSrc) {
-      if ($(t.family)) continue;
-      let n = t._snapdomSrc;
-      if (!n.startsWith("data:")) {
-        if (o.resource.has(t._snapdomSrc))
-          n = o.resource.get(t._snapdomSrc), o.font.add(t._snapdomSrc);
-        else if (!o.font.has(t._snapdomSrc))
+  try {
+    for (const i of document.fonts || []) {
+      if (!i || !i.family || i.status !== "loaded" || !i._snapdomSrc) continue;
+      const l = String(i.family).replace(/^['"]+|['"]+$/g, "");
+      if (x(l) || !c.has(l) || r?.families && r.families.some(
+        (w) => String(w).toLowerCase() === l.toLowerCase()
+      ))
+        continue;
+      let h = i._snapdomSrc;
+      if (!String(h).startsWith("data:")) {
+        if (g.resource?.has(i._snapdomSrc))
+          h = g.resource.get(i._snapdomSrc), g.font?.add(i._snapdomSrc);
+        else if (!g.font?.has(i._snapdomSrc))
           try {
-            const a = await (await A(t._snapdomSrc, { useProxy: c })).blob();
-            n = await new Promise((r) => {
-              const s = new FileReader();
-              s.onload = () => r(s.result), s.readAsDataURL(a);
-            }), o.resource.set(t._snapdomSrc, n), o.font.add(t._snapdomSrc);
+            const w = await A(i._snapdomSrc, {
+              as: "dataURL",
+              useProxy: n,
+              silent: !0
+            });
+            if (w.ok && typeof w.data == "string")
+              h = w.data, g.resource?.set(i._snapdomSrc, h), g.font?.add(i._snapdomSrc);
+            else
+              continue;
           } catch {
             console.warn(
-              "[snapdom] Failed to fetch dynamic font src:",
-              t._snapdomSrc
+              "[snapDOM] Failed to fetch dynamic font src:",
+              i._snapdomSrc
             );
             continue;
           }
       }
-      m += `@font-face{font-family:'${t.family}';src:url(${n});font-style:${t.style || "normal"};font-weight:${t.weight || "normal"};}`;
-    }
-  for (const t of d) {
-    if (!t || typeof t != "object") continue;
-    const { family: n, src: e, weight: a = "normal", style: r = "normal" } = t;
-    if (!n || !e) continue;
-    let s = e;
-    if (s.startsWith("data:"))
-      o.resource.set(e, s), o.font.add(e);
-    else
-      try {
-        const R = await (await A(e, { useProxy: c })).blob();
-        s = await new Promise((S) => {
-          const u = new FileReader();
-          u.onload = () => S(u.result), u.readAsDataURL(R);
-        }), o.resource.set(e, s), o.font.add(e);
-      } catch {
-        console.warn("[snapdom] Failed to load local font:", e);
-        continue;
+      p += `@font-face{font-family:'${l}';src:url(${h});font-style:${i.style || "normal"};font-weight:${i.weight || "normal"};}`;
+    }
+  } catch {
+  }
+  for (const i of a) {
+    if (!i || typeof i != "object") continue;
+    const l = String(i.family || "").replace(/^['"]+|['"]+$/g, "");
+    if (!l || x(l) || !c.has(l) || r?.families && r.families.some(
+      (b) => String(b).toLowerCase() === l.toLowerCase()
+    ))
+      continue;
+    const h = i.weight != null ? String(i.weight) : "normal", w = i.style != null ? String(i.style) : "normal", S = i.stretchPct != null ? `${i.stretchPct}%` : "100%", y = String(i.src || "");
+    let R = y;
+    if (!R.startsWith("data:")) {
+      if (g.resource?.has(y))
+        R = g.resource.get(y), g.font?.add(y);
+      else if (!g.font?.has(y))
+        try {
+          const b = await A(y, {
+            as: "dataURL",
+            useProxy: n,
+            silent: !0
+          });
+          if (b.ok && typeof b.data == "string")
+            R = b.data, g.resource?.set(y, R), g.font?.add(y);
+          else
+            continue;
+        } catch {
+          console.warn("[snapDOM] Failed to fetch localFonts src:", y);
+          continue;
+        }
+    }
+    p += `@font-face{font-family:'${l}';src:url(${R});font-style:${w};font-weight:${h};font-stretch:${S};}`;
+  }
+  return p && (p = rt(p), g.resource?.set(s, p)), p;
+}
+function mt(o) {
+  const e = /* @__PURE__ */ new Set();
+  if (!o) return e;
+  const r = document.createTreeWalker(o, NodeFilter.SHOW_ELEMENT, null), a = (t) => {
+    const f = T(t.fontFamily);
+    if (!f) return;
+    const s = (u, m, d) => `${f}__${N(u)}__${W(m)}__${Y(d)}`;
+    e.add(s(t.fontWeight, t.fontStyle, t.fontStretch));
+  };
+  a(getComputedStyle(o));
+  const n = getComputedStyle(o, "::before");
+  n && n.content && n.content !== "none" && a(n);
+  const c = getComputedStyle(o, "::after");
+  for (c && c.content && c.content !== "none" && a(c); r.nextNode(); ) {
+    const t = (
+      /** @type {Element} */
+      r.currentNode
+    ), f = getComputedStyle(t);
+    a(f);
+    const s = getComputedStyle(t, "::before");
+    s && s.content && s.content !== "none" && a(s);
+    const u = getComputedStyle(t, "::after");
+    u && u.content && u.content !== "none" && a(u);
+  }
+  return e;
+}
+function ht(o) {
+  const e = /* @__PURE__ */ new Set(), r = (n) => {
+    if (n)
+      for (const c of n) e.add(c.codePointAt(0));
+  }, a = document.createTreeWalker(
+    o,
+    NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT,
+    null
+  );
+  for (; a.nextNode(); ) {
+    const n = a.currentNode;
+    if (n.nodeType === Node.TEXT_NODE)
+      r(n.nodeValue || "");
+    else if (n.nodeType === Node.ELEMENT_NODE) {
+      const c = (
+        /** @type {Element} */
+        n
+      );
+      for (const t of ["::before", "::after"]) {
+        const s = getComputedStyle(c, t)?.getPropertyValue("content");
+        if (!(!s || s === "none"))
+          if (/^"/.test(s) || /^'/.test(s))
+            r(s.slice(1, -1));
+          else {
+            const u = s.match(/\\[0-9A-Fa-f]{1,6}/g);
+            if (u)
+              for (const m of u)
+                try {
+                  e.add(parseInt(m.slice(1), 16));
+                } catch {
+                }
+          }
       }
-    m += `@font-face{font-family:'${n}';src:url(${s});font-style:${r};font-weight:${a};}`;
+    }
   }
-  if (m && (o.resource.set("fonts-embed-css", m), h)) {
-    const t = document.createElement("style");
-    t.setAttribute("data-snapdom", "embedFonts"), t.textContent = m, document.head.appendChild(t);
+  return e;
+}
+async function dt(o, e = 2) {
+  try {
+    await document.fonts.ready;
+  } catch {
   }
-  return m;
+  const r = Array.from(o || []).filter(Boolean);
+  if (r.length === 0) return;
+  const a = () => {
+    const n = document.createElement("div");
+    n.style.cssText = "position:absolute!important;left:-9999px!important;top:0!important;opacity:0!important;pointer-events:none!important;contain:layout size style;";
+    for (const c of r) {
+      const t = document.createElement("span");
+      t.textContent = "AaBbGg1234ÁÉÍÓÚçñ—∞", t.style.fontFamily = `"${c}"`, t.style.fontWeight = "700", t.style.fontStyle = "italic", t.style.fontSize = "32px", t.style.lineHeight = "1", t.style.whiteSpace = "nowrap", t.style.margin = "0", t.style.padding = "0", n.appendChild(t);
+    }
+    document.body.appendChild(n), n.offsetWidth, document.body.removeChild(n);
+  };
+  for (let n = 0; n < Math.max(1, e); n++)
+    a(), await new Promise(
+      (c) => requestAnimationFrame(() => requestAnimationFrame(c))
+    );
 }
 export {
-  N as embedCustomFonts,
-  H as iconToImage
+  ht as collectUsedCodepoints,
+  mt as collectUsedFontVariants,
+  ut as embedCustomFonts,
+  dt as ensureFontsReady,
+  lt as iconToImage
 };