@unicom-cloud/utils 0.1.2 → 0.1.4

package/class-name/index.js

@@ -1,9 +1,8 @@
-import r from "lodash/isPlainObject";
-import a from "lodash/uniq";
-function m(...n) {
-  const i = " ", e = n.map((t, f, l) => r(t) ? Object.keys(t).filter((o) => t[o]) : t).flat(1 / 0).filter(Boolean).join(i).split(i).filter(Boolean);
-  return a(e).join(i);
+import o from "lodash/isPlainObject";
+function s(...e) {
+  const n = " ", i = e.flat(1 / 0).map((t, r, f) => o(t) ? Object.keys(t).filter((a) => t[a]) : t).flat(1 / 0).filter(Boolean).join(n).split(n).filter(Boolean);
+  return [...new Set(i)].join(n);
 }
 export {
-  m as default
+  s as default
 };

package/clipboard-copy/index.js

@@ -1,41 +1,35 @@
 import "../is/index.js";
 import r from "lodash/isString";
-function n() {
-  return new DOMException("The request is not allowed", "NotAllowedError");
-}
-async function i(e) {
-  if (!navigator.clipboard)
-    throw n();
-  return navigator.clipboard.writeText(e);
-}
-async function l(e) {
-  const o = document.createElement("span");
-  o.textContent = e, o.style.whiteSpace = "pre", o.style.webkitUserSelect = "auto", o.style.userSelect = "all", document.body.appendChild(o);
-  const t = window.getSelection(), a = window.document.createRange();
-  t.removeAllRanges(), a.selectNode(o), t.addRange(a);
-  let c = !1;
+async function a(o) {
+  const e = document.createElement("span");
+  e.textContent = o, e.style.whiteSpace = "pre", e.style.webkitUserSelect = "auto", e.style.userSelect = "all", document.body.appendChild(e);
+  const n = window.getSelection(), t = window.document.createRange();
+  n.removeAllRanges(), t.selectNode(e), n.addRange(t);
   try {
-    c = window.document.execCommand("copy");
+    return window.document.execCommand("copy");
+  } catch (c) {
+    console.error(c);
   } finally {
-    t.removeAllRanges(), window.document.body.removeChild(o);
+    n.removeAllRanges(), window.document.body.removeChild(e);
   }
-  if (!c) throw n();
 }
-async function p(e) {
-  try {
-    r(e) || (e = JSON.stringify(e) ?? e);
-  } catch {
+async function s(o) {
+  if (!r(o)) try {
+    o = JSON.stringify(o);
+  } catch (e) {
+    console.error(e);
   }
   try {
-    await i(e);
-  } catch (o) {
+    await window.navigator.clipboard.writeText(o);
+  } catch (e) {
+    console.error(e);
     try {
-      await l(e);
-    } catch (t) {
-      throw t || o || n();
+      await a(o);
+    } catch (n) {
+      console.error(n);
     }
   }
 }
 export {
-  p as default
+  s as default
 };

package/math/index.js

@@ -1,34 +1,26 @@
-import { Decimal as e } from "../decimal/decimal.js";
-function u(t, n) {
-  return new e(t).plus(n).toNumber();
+import { Decimal as t } from "../decimal/decimal.js";
+function u(n, e) {
+  return new t(n).plus(e).toNumber();
 }
-function i(t, n) {
-  return new e(t).minus(n).toNumber();
+function r(n, e) {
+  return new t(n).minus(e).toNumber();
 }
-function o(t, n) {
-  return new e(t).times(n).toNumber();
+function i(n, e) {
+  return new t(n).times(e).toNumber();
 }
-function r(t, n) {
-  return new e(t).div(n).toNumber();
+function o(n, e) {
+  return new t(n).div(e).toNumber();
 }
-const s = u, m = i, c = o, d = r, l = {
+const s = {
   plus: u,
-  minus: i,
-  times: o,
-  div: r,
-  add: s,
-  subtract: m,
-  multiply: c,
-  divide: d
+  minus: r,
+  times: i,
+  div: o
 };
 export {
-  s as add,
-  l as default,
-  r as div,
-  d as divide,
-  i as minus,
-  c as multiply,
+  s as default,
+  o as div,
+  r as minus,
   u as plus,
-  m as subtract,
-  o as times
+  i as times
 };

package/mock/MockWebSocket.js

@@ -84,7 +84,7 @@ const I = class I extends EventTarget {
       ) && e(this, d).push(a);
       const f = (h = e(this, l)) == null ? void 0 : h.template;
       if (e(this, d).length)
-        e(this, d).forEach((m) => {
+        e(this, d).forEach((m, A, K) => {
           var T;
           let N = new MessageEvent("message", {
             data: (f == null ? void 0 : f({ ...m, sendCount: e(this, p) })) ?? f

package/package.json

@@ -1 +1 @@
-{"name":"@unicom-cloud/utils","version":"0.1.2","dependencies":{},"peerDependencies":{"lodash":"^4.17.21"},"main":"./index.js","type":"module","types":"types/*","publishConfig":{"registry":"https://registry.npmjs.org/","access":"public"}}
+{"name":"@unicom-cloud/utils","version":"0.1.4","dependencies":{},"peerDependencies":{"lodash":"^4.17.21"},"main":"./index.js","type":"module","types":"types/*","publishConfig":{"registry":"https://registry.npmjs.org/","access":"public"}}

package/snapdom/index.js

@@ -0,0 +1,6 @@
+import { preCache as e } from "./src/api/preCache.js";
+import { snapdom as m } from "./src/api/snapdom.js";
+export {
+  e as preCache,
+  m as snapdom
+};

package/snapdom/src/api/preCache.js

@@ -0,0 +1,33 @@
+import { imageCache as s, bgCache as o, resourceCache as p, baseCSSCache as g, computedStyleCache as C } from "../core/cache.js";
+import { embedCustomFonts as d } from "../modules/fonts.js";
+import { precacheCommonTags as y } from "../utils/cssTools.js";
+import { fetchImage as i, extractUrl as S } from "../utils/helpers.js";
+async function I(r = document, f = {}) {
+  const { embedFonts: m = !0, reset: u = !1, preWarm: b = !0 } = f;
+  if (u) {
+    s.clear(), o.clear(), p.clear(), g.clear(), C.clear();
+    return;
+  }
+  await document.fonts.ready, y();
+  let l = [], n = [];
+  r != null && r.querySelectorAll && (l = Array.from(r.querySelectorAll("img[src]")), n = Array.from(r.querySelectorAll("*")));
+  const t = [];
+  for (const a of l) {
+    const c = a.src;
+    s.has(c) || t.push(
+      i(c).then((e) => s.set(c, e)).catch(() => {
+      })
+    );
+  }
+  for (const a of n) {
+    const c = getComputedStyle(a).backgroundImage, e = S(c);
+    e && !o.has(e) && t.push(
+      i(e).then((h) => o.set(e, h)).catch(() => {
+      })
+    );
+  }
+  m && await d({ ignoreIconFonts: !m, preCached: !0 }), await Promise.all(t);
+}
+export {
+  I as preCache
+};

package/snapdom/src/api/snapdom.js

@@ -0,0 +1,92 @@
+import { captureDOM as v } from "../core/capture.js";
+import { isSafari as R } from "../utils/helpers.js";
+async function I(a, { dpr: t = 1, scale: n = 1 }) {
+  const e = new Image();
+  return e.src = a, await e.decode(), R ? (e.width = e.width * n, e.height = e.height * n) : (e.width = e.width / n, e.height = e.height / n), e;
+}
+async function h(a, { dpr: t = 1, scale: n = 1 }) {
+  const e = new Image();
+  e.src = a, await e.decode();
+  const c = document.createElement("canvas"), o = e.width * n * t, g = e.height * n * t;
+  c.width = Math.ceil(o), c.height = Math.ceil(g);
+  const s = c.getContext("2d");
+  return s.scale(n * t, n * t), s.drawImage(e, 0, 0), c;
+}
+async function p(a) {
+  const t = decodeURIComponent(a.split(",")[1]);
+  return new Blob([t], { type: "image/svg+xml" });
+}
+async function m(a, { dpr: t = 1, scale: n = 1 }, e) {
+  const c = await h(a, { dpr: t, scale: n });
+  if (!e) return c;
+  const o = document.createElement("canvas");
+  o.width = c.width, o.height = c.height;
+  const g = o.getContext("2d");
+  return g.fillStyle = e, g.fillRect(0, 0, o.width, o.height), g.drawImage(c, 0, 0), o;
+}
+async function d(a, { dpr: t = 1, scale: n = 1, backgroundColor: e = "#fff", quality: c }, o = "png") {
+  const g = await m(a, { dpr: t, scale: n }, e), s = new Image();
+  return s.src = g.toDataURL(`image/${o}`, c), await s.decode(), s.style.width = `${g.width / t}px`, s.style.height = `${g.height / t}px`, s;
+}
+async function j(a, {
+  dpr: t = 1,
+  scale: n = 1,
+  backgroundColor: e = "#fff",
+  format: c = "png",
+  filename: o = "capture"
+} = {}) {
+  if (c === "svg") {
+    const b = await p(a), u = URL.createObjectURL(b), w = document.createElement("a");
+    w.href = u, w.download = `${o}.svg`, w.click(), URL.revokeObjectURL(u);
+    return;
+  }
+  const g = ["jpg", "jpeg", "webp"].includes(c) ? "#fff" : void 0, l = await m(a, { dpr: t, scale: n }, e ?? g), f = {
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    png: "image/png",
+    webp: "image/webp"
+  }[c] || "image/png", y = l.toDataURL(f), r = document.createElement("a");
+  r.href = y, r.download = `${o}.${c}`, r.click();
+}
+async function i(a, t = {}) {
+  if (t = { scale: 1, ...t }, !a) throw new Error("Element cannot be null or undefined");
+  return await i.capture(a, t);
+}
+i.capture = async (a, t = {}) => {
+  const n = await v(a, t), e = window.devicePixelRatio || 1, c = t.scale || 1;
+  return {
+    url: n,
+    options: t,
+    toRaw: () => n,
+    toImg: () => I(n, { dpr: e, scale: c }),
+    toCanvas: () => h(n, { dpr: e, scale: c }),
+    toBlob: () => p(n),
+    toPng: (o) => d(n, { dpr: e, scale: c, ...o }, "png"),
+    toJpg: (o) => d(n, { dpr: e, scale: c, ...o }, "jpeg"),
+    toWebp: (o) => d(n, { dpr: e, scale: c, ...o }, "webp"),
+    download: ({
+      format: o = "png",
+      filename: g = "capture",
+      backgroundColor: s
+    } = {}) => j(n, { dpr: e, scale: c, backgroundColor: s, format: o, filename: g })
+  };
+};
+i.toRaw = async (a, t) => (await i.capture(a, t)).toRaw();
+i.toImg = async (a, t) => (await i.capture(a, t)).toImg();
+i.toCanvas = async (a, t) => (await i.capture(a, t)).toCanvas();
+i.toBlob = async (a, t) => (await i.capture(a, t)).toBlob();
+i.toPng = async (a, t) => (await i.capture(a, t)).toPng(t);
+i.toJpg = async (a, t) => (await i.capture(a, t)).toJpg(t);
+i.toWebp = async (a, t) => (await i.capture(a, t)).toWebp(t);
+i.download = async (a, t = {}) => {
+  const {
+    format: n = "png",
+    filename: e = "capture",
+    backgroundColor: c,
+    ...o
+  } = t;
+  return await (await i.capture(a, o)).download({ format: n, filename: e, backgroundColor: c });
+};
+export {
+  i as snapdom
+};

package/snapdom/src/core/cache.js

@@ -0,0 +1,9 @@
+const e = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), t = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new WeakMap();
+export {
+  t as baseCSSCache,
+  a as bgCache,
+  o as computedStyleCache,
+  n as defaultStylesCache,
+  e as imageCache,
+  c as resourceCache
+};

package/snapdom/src/core/capture.js

@@ -0,0 +1,73 @@
+import { inlineBackgroundImages as $ } from "../modules/background.js";
+import { embedCustomFonts as B } from "../modules/fonts.js";
+import { inlineImages as E } from "../modules/images.js";
+import { collectUsedTagNames as F, generateDedupedBaseCSS as I } from "../utils/cssTools.js";
+import { idle as i, isSafari as P } from "../utils/helpers.js";
+import { baseCSSCache as g } from "./cache.js";
+import { prepareClone as z } from "./prepare.js";
+async function L(a, y = {}) {
+  if (!a) throw new Error("Element cannot be null or undefined");
+  const {
+    compress: w = !0,
+    embedFonts: l = !1,
+    fast: s = !0,
+    scale: d = 1
+  } = y;
+  let t, f, p, h = "", r = "", u, S;
+  if ({ clone: t, classCSS: f, styleCache: p } = await z(
+    a,
+    w,
+    l
+  ), await new Promise((e) => {
+    i(
+      async () => {
+        await E(t), e();
+      },
+      { fast: s }
+    );
+  }), await new Promise((e) => {
+    i(
+      async () => {
+        await $(a, t, p), e();
+      },
+      { fast: s }
+    );
+  }), l && await new Promise((e) => {
+    i(
+      async () => {
+        h = await B({ ignoreIconFonts: !l }), e();
+      },
+      { fast: s }
+    );
+  }), w) {
+    const e = F(t).sort(), o = e.join(",");
+    g.has(o) ? r = g.get(o) : await new Promise((c) => {
+      i(
+        () => {
+          r = I(e), g.set(o, r), c();
+        },
+        { fast: s }
+      );
+    });
+  }
+  await new Promise((e) => {
+    i(
+      () => {
+        const o = a.getBoundingClientRect(), c = Math.ceil(o.width), v = Math.ceil(o.height);
+        t.setAttribute("xmlns", "http://www.w3.org/1999/xhtml"), t.style.transformOrigin = "top left", d !== 1 && P() && (t.style.scale = `${d}`);
+        const C = "http://www.w3.org/2000/svg", n = document.createElementNS(C, "foreignObject");
+        n.setAttribute("width", "100%"), n.setAttribute("height", "100%");
+        const b = document.createElement("style");
+        b.textContent = r + h + "svg{overflow:visible;}" + f, n.appendChild(b), n.appendChild(t);
+        const x = new XMLSerializer().serializeToString(n);
+        S = `<svg xmlns="${C}" width="${c}" height="${v}" viewBox="0 0 ${c} ${v}">` + x + "</svg>", u = `data:image/svg+xml;charset=utf-8,${encodeURIComponent(S)}`, e();
+      },
+      { fast: s }
+    );
+  });
+  const m = document.getElementById("snapdom-sandbox");
+  return m && m.style.position === "absolute" && m.remove(), u;
+}
+export {
+  L as captureDOM
+};

package/snapdom/src/core/clone.js

@@ -0,0 +1,50 @@
+import { inlineAllStyles as h } from "../modules/styles.js";
+function f(t, a, l, c, o) {
+  var s;
+  if (t.nodeType === Node.ELEMENT_NODE && t.getAttribute("data-capture") === "exclude") {
+    const i = document.createElement("div"), e = t.getBoundingClientRect();
+    return i.style.cssText = `display: inline-block; width: ${e.width}px; height: ${e.height}px; visibility: hidden;`, i;
+  }
+  if (t.tagName === "IFRAME") {
+    const i = document.createElement("div");
+    return i.textContent = "", i.style.cssText = `width: ${t.offsetWidth}px; height: ${t.offsetHeight}px; background: 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;`, i;
+  }
+  if (t.nodeType === Node.ELEMENT_NODE && t.getAttribute("data-capture") === "placeholder") {
+    const i = t.cloneNode(!1);
+    c.set(i, t), h(t, i, a, l, o);
+    const e = document.createElement("div");
+    return e.textContent = t.getAttribute("data-placeholder-text") || "", e.style.cssText = "color: #666;font-size: 12px;text-align: center;line-height: 1.4;padding: 0.5em;box-sizing: border-box;", i.appendChild(e), i;
+  }
+  if (t.tagName === "CANVAS") {
+    const i = t.toDataURL(), e = document.createElement("img");
+    return e.src = i, e.width = t.width, e.height = t.height, e.style.display = "inline-block", e.style.width = `${t.width}px`, e.style.height = `${t.height}px`, e;
+  }
+  if (t.nodeType === Node.TEXT_NODE) {
+    if ((s = t.parentElement) != null && s.shadowRoot) {
+      const i = t.parentElement.tagName.toLowerCase();
+      if (customElements.get(i)) return null;
+    }
+    return t.cloneNode(!0);
+  }
+  if (t.nodeType !== Node.ELEMENT_NODE) return t.cloneNode(!0);
+  const r = t.cloneNode(!1);
+  c.set(r, t), h(t, r, a, l, o);
+  const d = document.createDocumentFragment();
+  if (t.childNodes.forEach((i) => {
+    const e = f(
+      i,
+      a,
+      l,
+      c,
+      o
+    );
+    e && d.appendChild(e);
+  }), r.appendChild(d), t.shadowRoot) {
+    const i = Array.from(t.shadowRoot.children).filter((n) => n.tagName !== "STYLE").map((n) => f(n, a, l, c)).filter(Boolean), e = document.createDocumentFragment();
+    i.forEach((n) => e.appendChild(n)), r.appendChild(e);
+  }
+  return r;
+}
+export {
+  f as deepClone
+};

package/snapdom/src/core/prepare.js

@@ -0,0 +1,53 @@
+import { inlinePseudoElements as h } from "../modules/pseudo.js";
+import { generateCSSClasses as g } from "../utils/cssTools.js";
+import { deepClone as C } from "./clone.js";
+async function b(f, r = !1, m = !1) {
+  var p;
+  const l = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new WeakMap(), d = /* @__PURE__ */ new Map();
+  let c;
+  try {
+    c = C(f, l, i, d, r);
+  } catch (e) {
+    throw console.warn("deepClone failed:", e), e;
+  }
+  try {
+    await h(
+      f,
+      c,
+      l,
+      i,
+      r,
+      m
+    );
+  } catch (e) {
+    console.warn("inlinePseudoElements failed:", e);
+  }
+  let y = "";
+  if (r) {
+    const e = g(l);
+    y = Array.from(e.entries()).map(([t, n]) => `.${n}{${t}}`).join("");
+    for (const [t, n] of l.entries()) {
+      if (t.tagName === "STYLE") continue;
+      const s = e.get(n);
+      s && t.classList.add(s);
+      const a = (p = t.style) == null ? void 0 : p.backgroundImage;
+      t.removeAttribute("style"), a && a !== "none" && (t.style.backgroundImage = a);
+    }
+  } else
+    for (const [e, t] of l.entries())
+      e.tagName !== "STYLE" && e.setAttribute("style", t.replace(/;/g, "; "));
+  for (const [e, t] of d.entries()) {
+    const n = t.scrollLeft, s = t.scrollTop;
+    if ((n || s) && e instanceof HTMLElement) {
+      e.style.overflow = "hidden", e.style.scrollbarWidth = "none", e.style.msOverflowStyle = "none";
+      const o = document.createElement("div");
+      for (o.style.transform = `translate(${-n}px, ${-s}px)`, o.style.willChange = "transform", o.style.display = "inline-block", o.style.width = "100%"; e.firstChild; )
+        o.appendChild(e.firstChild);
+      e.appendChild(o);
+    }
+  }
+  return { clone: c, classCSS: y, styleCache: i };
+}
+export {
+  b as prepareClone
+};

package/snapdom/src/modules/background.js

@@ -0,0 +1,27 @@
+import { bgCache as a } from "../core/cache.js";
+import { getStyle as f, fetchImage as m } from "../utils/helpers.js";
+async function p(u, d, o) {
+  const c = [[u, d]];
+  for (; c.length; ) {
+    const [t, l] = c.shift(), i = o.get(t) || f(t);
+    o.has(t) || o.set(t, i);
+    const s = i.getPropertyValue("background-image");
+    if (s && s.includes("url(")) {
+      const e = s.match(/url\(["']?([^"')]+)["']?\)/);
+      if (e != null && e[1])
+        try {
+          const n = e[1];
+          let r;
+          a.has(n) ? r = a.get(n) : (r = await m(n), a.set(n, r)), l.style.backgroundImage = `url(${r})`;
+        } catch {
+          l.style.backgroundImage = "none";
+        }
+    }
+    const g = Array.from(t.children), h = Array.from(l.children);
+    for (let e = 0; e < Math.min(g.length, h.length); e++)
+      c.push([g[e], h[e]]);
+  }
+}
+export {
+  p as inlineBackgroundImages
+};

package/snapdom/src/modules/fonts.js

@@ -0,0 +1,63 @@
+import { resourceCache as x } from "../core/cache.js";
+import { isIconFont as w } from "../utils/helpers.js";
+async function y(i, r, u, n = 32, e = "#000") {
+  r = r.replace(/^['"]+|['"]+$/g, "");
+  const c = window.devicePixelRatio || 1, d = document.createElement("canvas").getContext("2d");
+  d.font = u ? `${u} ${n}px "${r}"` : `${n}px "${r}"`;
+  const f = d.measureText(i), s = f.actualBoundingBoxAscent || n * 0.8, a = f.actualBoundingBoxDescent || n * 0.2, t = s + a, m = f.width, l = document.createElement("canvas");
+  l.width = Math.ceil(m * c), l.height = Math.ceil(t * c);
+  const o = l.getContext("2d");
+  return o.scale(c, c), o.font = d.font, o.textAlign = "left", o.textBaseline = "alphabetic", o.fillStyle = e, o.fillText(i, 0, s), l.toDataURL();
+}
+async function A({
+  ignoreIconFonts: i = !0,
+  preCached: r = !1
+}) {
+  const u = Array.from(
+    document.querySelectorAll('link[rel="stylesheet"]')
+  ).filter((e) => e.href);
+  let n = "";
+  for (const e of u)
+    try {
+      const h = await (await fetch(e.href)).text();
+      if (i && (w(e.href) || w(h)))
+        continue;
+      const d = /url\(([^)]+)\)/g, f = await Promise.all(
+        Array.from(h.matchAll(d)).map(async (a) => {
+          let t = a[1].replace(/["']/g, "");
+          if (t.startsWith("http") || (t = new URL(t, e.href).href), i && w(t))
+            return null;
+          if (x.has(t))
+            return {
+              original: a[0],
+              inlined: `url(${x.get(t)})`
+            };
+          try {
+            const l = await (await fetch(t)).blob(), o = await new Promise((g) => {
+              const p = new FileReader();
+              p.onload = () => g(p.result), p.readAsDataURL(l);
+            });
+            return x.set(t, o), { original: a[0], inlined: `url(${o})` };
+          } catch {
+            return console.warn("❌ Failed to fetch font:", t), null;
+          }
+        })
+      );
+      let s = h;
+      for (const a of f)
+        a && (s = s.replace(a.original, a.inlined));
+      n += s + `
+`;
+    } catch {
+      console.warn("❌ Failed to fetch CSS:", e.href);
+    }
+  if (n && r) {
+    const e = document.createElement("style");
+    e.setAttribute("data-snapdom", "embedFonts"), e.textContent = n, document.head.appendChild(e);
+  }
+  return n;
+}
+export {
+  A as embedCustomFonts,
+  y as iconToImage
+};

package/snapdom/src/modules/images.js

@@ -0,0 +1,20 @@
+import { fetchImage as i } from "../utils/helpers.js";
+async function h(a) {
+  const n = Array.from(a.querySelectorAll("img")), r = async (t) => {
+    const c = t.src;
+    try {
+      const e = await i(c);
+      t.src = e, t.width || (t.width = t.naturalWidth || 100), t.height || (t.height = t.naturalHeight || 100);
+    } catch {
+      const e = document.createElement("div");
+      e.style = `width: ${t.width || 100}px; height: ${t.height || 100}px; background: #ccc; display: inline-block; text-align: center; line-height: ${t.height || 100}px; color: #666; font-size: 12px;`, e.innerText = "img", t.replaceWith(e);
+    }
+  };
+  for (let t = 0; t < n.length; t += 4) {
+    const c = n.slice(t, t + 4).map(r);
+    await Promise.allSettled(c);
+  }
+}
+export {
+  h as inlineImages
+};

package/snapdom/src/modules/pseudo.js

@@ -0,0 +1,63 @@
+import { getStyleKey as S } from "../utils/cssTools.js";
+import { getStyle as x, snapshotComputedStyle as W, parseContent as j, fetchImage as z } from "../utils/helpers.js";
+import { iconToImage as A } from "./fonts.js";
+async function B(s, a, f, y, p, m = !1) {
+  if (!(s instanceof Element) || !(a instanceof Element)) return;
+  for (const t of ["::before", "::after"])
+    try {
+      const e = x(s, t);
+      if (!e) continue;
+      const r = e.getPropertyValue("content"), g = e.getPropertyValue("background-image"), u = r && r !== "none" && r !== '""' && r !== "''", C = g && g.startsWith("url(");
+      if (u || C) {
+        const l = e.getPropertyValue("font-family"), E = parseInt(e.getPropertyValue("font-size")) || 32, w = parseInt(e.getPropertyValue("font-weight")) || !1, P = e.getPropertyValue("color") || "#000", o = document.createElement("span");
+        o.dataset.snapdomPseudo = t;
+        const b = W(e), V = S(b, "span", p);
+        f.set(o, V);
+        const I = l && /font.*awesome|material|bootstrap|glyphicons|ionicons|remixicon|simple-line-icons|octicons|feather|typicons|weathericons/i.test(
+          l
+        );
+        let i = j(r);
+        if (!m && I && i.length === 1) {
+          const n = document.createElement("img");
+          n.src = await A(
+            i,
+            l,
+            w,
+            E,
+            P
+          ), n.style = "display:block;width:100%;height:100%;object-fit:contain;", o.appendChild(n);
+        } else if (i.startsWith("url(")) {
+          const n = i.match(/url\(["']?([^"')]+)["']?\)/);
+          if (n != null && n[1])
+            try {
+              const c = document.createElement("img"), k = await z(n[1]);
+              c.src = k, c.style = "display:block;width:100%;height:100%;object-fit:contain;", o.appendChild(c);
+            } catch (c) {
+              console.error(
+                `[snapdom] Error in pseudo ${t} for`,
+                s,
+                c
+              );
+            }
+        } else i && i !== "none" && (o.textContent = i);
+        t === "::before" ? a.insertBefore(o, a.firstChild) : a.appendChild(o);
+      }
+    } catch (e) {
+      console.warn(`[snapdom] Failed to capture ${t} for`, s, e);
+    }
+  const d = Array.from(s.children), h = Array.from(a.children).filter(
+    (t) => !t.dataset.snapdomPseudo
+  );
+  for (let t = 0; t < Math.min(d.length, h.length); t++)
+    await B(
+      d[t],
+      h[t],
+      f,
+      y,
+      p,
+      m
+    );
+}
+export {
+  B as inlinePseudoElements
+};

package/snapdom/src/modules/styles.js

@@ -0,0 +1,12 @@
+import { getStyleKey as g } from "../utils/cssTools.js";
+import { getStyle as p, snapshotComputedStyle as f } from "../utils/helpers.js";
+function N(t, o, s, e, a) {
+  var n;
+  if (t.tagName === "STYLE") return;
+  e.has(t) || e.set(t, p(t));
+  const i = e.get(t), l = f(i), m = ((n = t.tagName) == null ? void 0 : n.toLowerCase()) || "div", y = g(l, m, a);
+  s.set(o, y);
+}
+export {
+  N as inlineAllStyles
+};

package/snapdom/src/utils/cssTools.js

@@ -0,0 +1,111 @@
+import { defaultStylesCache as r } from "../core/cache.js";
+const d = [
+  "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 u() {
+  for (let t of d)
+    c(t);
+}
+function c(t) {
+  if (r.has(t))
+    return r.get(t);
+  if ((/* @__PURE__ */ new Set([
+    "script",
+    "style",
+    "meta",
+    "link",
+    "noscript",
+    "template"
+  ])).has(t)) {
+    const o = {};
+    return r.set(t, o), o;
+  }
+  let e = document.getElementById("snapdom-sandbox");
+  e || (e = document.createElement("div"), e.id = "snapdom-sandbox", e.style.position = "absolute", e.style.left = "-9999px", e.style.top = "-9999px", e.style.width = "0", e.style.height = "0", e.style.overflow = "hidden", document.body.appendChild(e));
+  const n = document.createElement(t);
+  n.style.all = "initial", e.appendChild(n);
+  const l = getComputedStyle(n), a = {};
+  for (let o of l)
+    a[o] = l.getPropertyValue(o);
+  return e.removeChild(n), r.set(t, a), a;
+}
+function p(t, s, e = !1) {
+  const n = [], l = c(s);
+  for (let [a, o] of Object.entries(t))
+    if (!e)
+      o && n.push(`${a}:${o}`);
+    else {
+      const i = l[a];
+      o && o !== i && n.push(`${a}:${o}`);
+    }
+  return n.sort().join(";");
+}
+function y(t) {
+  const s = /* @__PURE__ */ new Set();
+  return t.nodeType !== Node.ELEMENT_NODE && t.nodeType !== Node.DOCUMENT_FRAGMENT_NODE ? [] : (t.tagName && s.add(t.tagName.toLowerCase()), typeof t.querySelectorAll == "function" && t.querySelectorAll("*").forEach((e) => s.add(e.tagName.toLowerCase())), Array.from(s));
+}
+function h(t) {
+  const s = /* @__PURE__ */ new Map();
+  for (let n of t) {
+    const l = r.get(n);
+    if (!l) continue;
+    const a = Object.entries(l).map(([o, i]) => `${o}:${i};`).sort().join("");
+    s.has(a) || s.set(a, []), s.get(a).push(n);
+  }
+  let e = "";
+  for (let [n, l] of s.entries())
+    e += `${l.join(",")} { ${n} }
+`;
+  return e;
+}
+function m(t) {
+  const s = new Set(t.values()), e = /* @__PURE__ */ new Map();
+  let n = 1;
+  for (const l of s)
+    e.set(l, `c${n++}`);
+  return e;
+}
+export {
+  y as collectUsedTagNames,
+  m as generateCSSClasses,
+  h as generateDedupedBaseCSS,
+  c as getDefaultStyleForTag,
+  p as getStyleKey,
+  u as precacheCommonTags
+};

package/snapdom/src/utils/helpers.js

@@ -0,0 +1,87 @@
+import { imageCache as s, computedStyleCache as m } from "../core/cache.js";
+function g(t, { fast: e = !1 } = {}) {
+  if (e) return t();
+  "requestIdleCallback" in window ? requestIdleCallback(t, { timeout: 50 }) : setTimeout(t, 1);
+}
+function d(t, e = null) {
+  if (!(t instanceof Element))
+    return window.getComputedStyle(t, e);
+  let n = m.get(t);
+  if (n || (n = /* @__PURE__ */ new Map(), m.set(t, n)), !n.has(e)) {
+    const i = window.getComputedStyle(t, e);
+    n.set(e, i);
+  }
+  return n.get(e);
+}
+function f(t) {
+  let e = t.replace(/^['"]|['"]$/g, "");
+  if (e.startsWith("\\"))
+    try {
+      return String.fromCharCode(parseInt(e.replace("\\", ""), 16));
+    } catch {
+      return e;
+    }
+  return e;
+}
+function h(t) {
+  const e = t.match(/url\(["']?([^"')]+)["']?\)/);
+  return e ? e[1] : null;
+}
+function p(t) {
+  return [
+    /font\s*awesome/i,
+    /material\s*icons/i,
+    /ionicons/i,
+    /glyphicons/i,
+    /feather/i,
+    /bootstrap\s*icons/i,
+    /remix\s*icons/i,
+    /heroicons/i
+  ].some((n) => n.test(t));
+}
+function w(t, e = 3e3) {
+  return s.has(t) ? Promise.resolve(s.get(t)) : new Promise((n, i) => {
+    const c = setTimeout(() => {
+      i(new Error("Image load timed out"));
+    }, e), o = new Image();
+    o.crossOrigin = "anonymous", o.onload = async () => {
+      clearTimeout(c);
+      try {
+        await o.decode();
+        const r = document.createElement("canvas");
+        r.width = o.width, r.height = o.height, r.getContext("2d").drawImage(o, 0, 0);
+        try {
+          const a = r.toDataURL("image/png");
+          s.set(t, a), n(a);
+        } catch {
+          i(new Error("CORS restrictions prevented image capture"));
+        }
+      } catch (r) {
+        i(r);
+      }
+    }, o.onerror = (r) => {
+      clearTimeout(c), i(
+        new Error("Failed to load image: " + (r.message || "Unknown error"))
+      );
+    }, o.src = t;
+  });
+}
+function C(t) {
+  const e = {};
+  for (let n of t)
+    e[n] = t.getPropertyValue(n);
+  return e;
+}
+function y() {
+  return /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+}
+export {
+  h as extractUrl,
+  w as fetchImage,
+  d as getStyle,
+  g as idle,
+  p as isIconFont,
+  y as isSafari,
+  f as parseContent,
+  C as snapshotComputedStyle
+};