@fraczled/sdk 1.30.26 → 1.30.48

package/dist/canvasExportPipeline-CfYHrVvI.js

@@ -0,0 +1,624 @@
+import { g as V, b as q, a as B, t as I, c as Z, d as R, e as Q, f as K, h as m, i as J, j as x, k as nt, l as at, s as it, m as lt, n as ct, E as H, o as tt, p as ot, r as ft } from "./index-D8e-pyQj.js";
+const ht = {
+  normal: "source-over",
+  dissolve: "source-over",
+  darken: "darken",
+  multiply: "multiply",
+  "color-burn": "color-burn",
+  "linear-burn": "color-burn",
+  "darker-color": "darken",
+  lighten: "lighten",
+  screen: "screen",
+  "color-dodge": "color-dodge",
+  "linear-dodge": "lighter",
+  "lighter-color": "lighten",
+  overlay: "overlay",
+  "soft-light": "soft-light",
+  "hard-light": "hard-light",
+  "vivid-light": "hard-light",
+  "linear-light": "hard-light",
+  "pin-light": "hard-light",
+  "hard-mix": "hard-light",
+  difference: "difference",
+  exclusion: "exclusion",
+  subtract: "difference",
+  divide: "color-dodge",
+  hue: "hue",
+  saturation: "saturation",
+  color: "color",
+  luminosity: "luminosity"
+}, dt = (t) => t && ht[t] || "source-over", ut = (t = "behind") => {
+  const o = ["adjustments"];
+  return t === "behind" && o.push("stroke-behind"), o.push("effect", "fill"), t === "front" && o.push("stroke-front"), o;
+}, gt = (t, o) => !o || o === "none" ? t : o === "uppercase" ? t.toUpperCase() : o === "lowercase" ? t.toLowerCase() : o === "capitalize" ? t.replace(/\b\w/g, (s) => s.toUpperCase()) : t, Y = (t, o, s) => o ? t.measureText(o).width + (o.length > 1 ? s * (o.length - 1) : 0) : 0, pt = (t, o, s, n) => {
+  const a = [], r = o.split(`
+`);
+  return r.forEach((i, l) => {
+    if (s === void 0 || s <= 0) {
+      a.push({ text: i, width: Y(t, i, n) }), l < r.length - 1 && i === "" && a.push({ text: "", width: 0 });
+      return;
+    }
+    const e = i.split(/(\s+)/).filter((h) => h.length > 0);
+    let c = "";
+    e.forEach((h) => {
+      const d = c + h;
+      if (!c && (Y(t, h, n) <= s || h.trim() === "")) {
+        c = h;
+        return;
+      }
+      if (Y(t, d, n) <= s) {
+        c = d;
+        return;
+      }
+      if (c && a.push({ text: c, width: Y(t, c, n) }), Y(t, h, n) <= s) {
+        c = h;
+        return;
+      }
+      let f = "";
+      for (const g of h) {
+        const b = f + g;
+        if (!f || Y(t, b, n) <= s) {
+          f = b;
+          continue;
+        }
+        a.push({ text: f, width: Y(t, f, n) }), f = g;
+      }
+      c = f;
+    }), c && a.push({ text: c, width: Y(t, c, n) }), l < r.length - 1 && i === "" && a.push({ text: "", width: 0 });
+  }), a;
+}, yt = (t, o, s) => {
+  const n = o.fontSize || 24, a = nt(
+    n,
+    o.fontFamily || "sans-serif",
+    o.fontWeight || "normal",
+    o.fontStyle || "normal"
+  ), r = (o.lineHeight ?? 1.4) * n, i = (o.letterSpacing ?? 0) * n, l = o.textAlign || "left", e = o.autoWidth ? void 0 : s, c = gt(o.content || "", o.textTransform);
+  t.save(), t.font = a;
+  const h = pt(t, c, e, i);
+  return t.restore(), {
+    lines: h,
+    lineHeight: r,
+    letterSpacing: i,
+    width: s,
+    align: l,
+    font: a
+  };
+}, _ = (t, o, s, n, a, r) => {
+  if (!o) return;
+  if (a === 0) {
+    r === "fill" ? t.fillText(o, s, n) : t.strokeText(o, s, n);
+    return;
+  }
+  let i = s;
+  for (const l of o)
+    r === "fill" ? t.fillText(l, i, n) : t.strokeText(l, i, n), i += t.measureText(l).width + a;
+}, C = (t, o, s) => {
+  const { lines: n, lineHeight: a, letterSpacing: r, width: i, align: l, font: e } = o, c = s.offsetX ?? 0, h = s.offsetY ?? 0;
+  t.save(), t.font = e, t.textBaseline = "top", t.textAlign = "left", s.fillStyle && (t.fillStyle = s.fillStyle), s.strokeStyle && s.strokeWidth && (t.strokeStyle = s.strokeStyle, t.lineWidth = s.strokeWidth, t.lineJoin = s.lineJoin ?? "round", t.lineCap = s.lineCap ?? "round"), n.forEach((d, p) => {
+    const u = p * a + h, f = d.width;
+    let g = c;
+    l === "center" ? g = i / 2 - f / 2 + c : l === "right" && (g = i - f + c), s.strokeStyle && s.strokeWidth && _(t, d.text, g, u, r, "stroke"), s.fillStyle && _(t, d.text, g, u, r, "fill");
+  }), t.restore();
+}, wt = (t, o, s, n, a, r) => {
+  const i = (n - 90) * Math.PI / 180, l = Math.cos(i), e = Math.sin(i), c = o / 2 - l * (o / 2), h = s / 2 - e * (s / 2), d = o / 2 + l * (o / 2), p = s / 2 + e * (s / 2), u = t.createLinearGradient(c, h, d, p);
+  return u.addColorStop(0, a), u.addColorStop(1, r), u;
+}, bt = (t, o, s) => {
+  const { lines: n, lineHeight: a, width: r, align: i } = o, l = s.spread, e = Math.max(0, s.roundness);
+  n.forEach((c, h) => {
+    const d = c.width;
+    let p = 0;
+    i === "center" ? p = r / 2 - d / 2 : i === "right" && (p = r - d);
+    const u = h * a, f = p - l, g = u, b = d + l * 2, v = a;
+    if (t.save(), t.fillStyle = s.fillStyle, t.beginPath(), e <= 0)
+      t.rect(f, g, b, v);
+    else {
+      const w = Math.min(e, b / 2, v / 2);
+      t.moveTo(f + w, g), t.lineTo(f + b - w, g), t.arcTo(f + b, g, f + b, g + w, w), t.lineTo(f + b, g + v - w), t.arcTo(f + b, g + v, f + b - w, g + v, w), t.lineTo(f + w, g + v), t.arcTo(f, g + v, f, g + v - w, w), t.lineTo(f, g + w), t.arcTo(f, g, f + w, g, w), t.closePath();
+    }
+    t.fill(), t.restore();
+  });
+}, j = (t, o, s, n, a, r) => {
+  var T;
+  const i = yt(t, o, s);
+  if (i.lines.length === 0) return;
+  const l = o.color || "#000000", e = V(r, l), c = q((T = o.effect) == null ? void 0 : T.adjustments), h = r.blurAmount ?? 5, d = a === "blur" ? `${c} blur(${h}px)` : c, p = o.textStrokeWidth ?? 0, u = o.textStrokeColor || "#000000", f = o.textStrokePosition || "behind", g = o.textStrokeStyle || "round", b = g === "round" ? "round" : "miter", v = g === "round" ? "round" : "butt", w = () => {
+    p <= 0 || C(t, i, {
+      strokeStyle: u,
+      strokeWidth: p,
+      lineJoin: b,
+      lineCap: v
+    });
+  }, M = ut(f === "front" ? "front" : "behind");
+  t.save(), t.filter = d, M.forEach((D) => {
+    switch (D) {
+      case "stroke-behind":
+        w();
+        break;
+      case "effect": {
+        switch (a) {
+          case "shadow": {
+            const { offsetX: y, offsetY: S } = R(r), P = r.blur ?? 0, X = B(r), k = I(e, X);
+            t.save(), t.shadowColor = k, t.shadowBlur = P, t.shadowOffsetX = y, t.shadowOffsetY = S, C(t, i, { fillStyle: l }), t.restore();
+            break;
+          }
+          case "lift": {
+            const y = x(r), S = `rgba(0,0,0, ${0.5 * y})`;
+            t.save(), t.shadowColor = S, t.shadowBlur = 20 * y, t.shadowOffsetX = 0, t.shadowOffsetY = 10 * y, C(t, i, { fillStyle: l }), t.restore();
+            break;
+          }
+          case "neon": {
+            const y = J(r), S = r.textColor || "#ffffff";
+            t.save(), [y * 5, y * 3, y].forEach((P) => {
+              t.shadowColor = e, t.shadowBlur = P, t.shadowOffsetX = 0, t.shadowOffsetY = 0, C(t, i, { fillStyle: S });
+            }), C(t, i, { fillStyle: S }), t.restore();
+            break;
+          }
+          case "outline": {
+            const y = m(r);
+            C(t, i, {
+              strokeStyle: e,
+              strokeWidth: y,
+              lineJoin: "round",
+              lineCap: "round",
+              fillStyle: l
+            });
+            break;
+          }
+          case "hollow": {
+            const y = K(r);
+            C(t, i, {
+              strokeStyle: e,
+              strokeWidth: y,
+              lineJoin: "round",
+              lineCap: "round"
+            });
+            break;
+          }
+          case "splice": {
+            const y = Q(r), { offsetX: S, offsetY: P } = R(r);
+            t.save(), t.shadowColor = "rgba(0,0,0,0.2)", t.shadowBlur = 0, t.shadowOffsetX = S, t.shadowOffsetY = P, C(t, i, {
+              strokeStyle: e,
+              strokeWidth: y,
+              lineJoin: "round",
+              lineCap: "round"
+            }), t.restore(), C(t, i, {
+              strokeStyle: e,
+              strokeWidth: y,
+              lineJoin: "round",
+              lineCap: "round"
+            });
+            break;
+          }
+          case "echo": {
+            const { offsetX: y, offsetY: S } = R(r);
+            C(t, i, { fillStyle: I(e, 0.5), offsetX: y, offsetY: S }), C(t, i, {
+              fillStyle: I(e, 0.3),
+              offsetX: y * 2,
+              offsetY: S * 2
+            }), C(t, i, { fillStyle: l });
+            break;
+          }
+          case "glitch": {
+            const y = Z(r);
+            C(t, i, { fillStyle: "#0ea5e9", offsetX: -y, offsetY: 0 }), C(t, i, { fillStyle: "#f43f5e", offsetX: y, offsetY: 0 }), C(t, i, { fillStyle: l });
+            break;
+          }
+          case "blur": {
+            C(t, i, { fillStyle: l });
+            break;
+          }
+          case "duotone": {
+            const y = r.duotoneLight || "#f472b6", S = r.duotoneDark || "#1e40af";
+            C(t, i, { fillStyle: y, offsetX: 1, offsetY: 1 }), C(t, i, { fillStyle: y, offsetX: -1, offsetY: -1 }), C(t, i, { fillStyle: S });
+            break;
+          }
+          case "reflection": {
+            const y = (r.reflectionOpacity ?? 50) / 100, S = r.reflectionDistance ?? 5, P = `rgba(0,0,0, ${y * 0.3})`;
+            t.save(), t.shadowColor = P, t.shadowBlur = S, t.shadowOffsetX = 0, t.shadowOffsetY = S + 10, C(t, i, { fillStyle: l }), t.restore();
+            break;
+          }
+          case "background": {
+            const y = B(r), S = (r.spread ?? 50) / 5, P = (r.roundness ?? 0) / 2;
+            bt(t, i, {
+              fillStyle: I(e, y),
+              spread: S,
+              roundness: P
+            });
+            break;
+          }
+          case "gradient_overlay": {
+            const y = r.gradientColor1 || "#667eea", S = r.gradientColor2 || "#764ba2", P = r.gradientAngle || 135, X = wt(t, s, n, P, y, S);
+            C(t, i, { fillStyle: X });
+            break;
+          }
+          default:
+            C(t, i, { fillStyle: l });
+        }
+        break;
+      }
+      case "fill":
+        a === "background" && C(t, i, { fillStyle: l });
+        break;
+      case "stroke-front":
+        w();
+        break;
+    }
+  }), t.restore();
+}, E = {
+  triangle: "50,0 100,100 0,100",
+  star: "50,0 61,35 98,35 68,57 79,91 50,70 21,91 32,57 2,35 39,35",
+  hexagon: "25,0 75,0 100,50 75,100 25,100 0,50",
+  pentagon: "50,0 95,35 77,90 23,90 5,35",
+  diamond: "50,0 100,50 50,100 0,50",
+  arrow: "0,35 60,35 60,15 100,50 60,85 60,65 0,65",
+  heart: "50,20 55,15 65,10 80,10 95,25 95,45 50,90 5,45 5,25 20,10 35,10 45,15"
+}, L = (t, o, s) => {
+  const n = document.createElement("canvas");
+  n.width = Math.max(1, Math.ceil(t * s)), n.height = Math.max(1, Math.ceil(o * s));
+  const a = n.getContext("2d");
+  if (!a)
+    throw new Error("Failed to get canvas context");
+  return a.setTransform(1, 0, 0, 1, 0, 0), a.scale(s, s), { canvas: n, ctx: a };
+}, z = (t) => {
+  if (!t)
+    return { x: 0, y: 0, width: 0, height: 0 };
+  const o = t.split(/[\s,]+/).map((s) => Number.parseFloat(s)).filter((s) => !Number.isNaN(s));
+  return o.length >= 4 ? { x: o[0], y: o[1], width: o[2], height: o[3] } : { x: 0, y: 0, width: 0, height: 0 };
+}, kt = (t) => {
+  try {
+    let o = "linear", s = 90, n = "";
+    if (t.includes("radial-gradient")) {
+      o = "radial";
+      const r = t.match(/radial-gradient\((.*)\)/);
+      if (!r) return null;
+      const l = r[1].split(/,(?![^()]*\))/).map((e) => e.trim());
+      l[0].includes("circle") || l[0].includes("ellipse") || l[0].includes("at ") ? n = l.slice(1).join(",") : n = l.join(",");
+    } else {
+      const r = t.match(/linear-gradient\((.*)\)/);
+      if (!r) return null;
+      const l = r[1].split(/,(?![^()]*\))/).map((e) => e.trim());
+      l[0].includes("deg") ? (s = parseInt(l[0], 10), n = l.slice(1).join(",")) : l[0].includes("to ") ? (l[0] === "to right" ? s = 90 : l[0] === "to bottom" ? s = 180 : l[0] === "to left" ? s = 270 : l[0] === "to top" ? s = 0 : s = 180, n = l.slice(1).join(",")) : (s = 180, n = l.join(","));
+    }
+    const a = n.split(/,(?![^()]*\))/).map((r) => r.trim()).map((r) => {
+      const i = r.match(/(.+)\s+(\d+)%$/);
+      return i ? { color: i[1], offset: i[2] + "%" } : { color: r, offset: "" };
+    }).filter((r) => r.color);
+    return a.length === 2 && (a[0].offset || (a[0].offset = "0%"), a[1].offset || (a[1].offset = "100%")), { type: o, angle: s, stops: a };
+  } catch {
+    return null;
+  }
+}, st = (t, o, s, n) => {
+  const a = (n - 90) * Math.PI / 180, r = Math.cos(a), i = Math.sin(a), l = o / 2 - r * (o / 2), e = s / 2 - i * (s / 2), c = o / 2 + r * (o / 2), h = s / 2 + i * (s / 2);
+  return t.createLinearGradient(l, e, c, h);
+}, St = (t, o, s) => {
+  const n = Math.min(o, s) / 2;
+  if (typeof t == "number") {
+    const c = Math.max(0, Math.min(t, n));
+    return { tl: c, tr: c, br: c, bl: c };
+  }
+  const a = t, r = Math.max(0, Math.min((a == null ? void 0 : a.tl) ?? 0, n)), i = Math.max(0, Math.min((a == null ? void 0 : a.tr) ?? 0, n)), l = Math.max(0, Math.min((a == null ? void 0 : a.br) ?? 0, n)), e = Math.max(0, Math.min((a == null ? void 0 : a.bl) ?? 0, n));
+  return { tl: r, tr: i, br: l, bl: e };
+}, N = (t, o, s, n, a, r) => {
+  const { tl: i, tr: l, br: e, bl: c } = St(r, n, a);
+  if (i === 0 && l === 0 && e === 0 && c === 0) {
+    t.rect(o, s, n, a);
+    return;
+  }
+  t.moveTo(o + i, s), t.lineTo(o + n - l, s), t.arcTo(o + n, s, o + n, s + l, l), t.lineTo(o + n, s + a - e), t.arcTo(o + n, s + a, o + n - e, s + a, e), t.lineTo(o + c, s + a), t.arcTo(o, s + a, o, s + a - c, c), t.lineTo(o, s + i), t.arcTo(o, s, o + i, s, i), t.closePath();
+}, et = (t, o, s, n) => {
+  const a = t.split(" ").map((e) => {
+    const [c, h] = e.split(",").map(Number);
+    return { x: c / 100 * s, y: h / 100 * n };
+  }), r = typeof o == "number";
+  if (r && o <= 0)
+    return `M ${a.map((e) => `${e.x},${e.y}`).join(" L ")} Z`;
+  const i = a.length;
+  let l = "";
+  for (let e = 0; e < i; e++) {
+    const c = a[(e - 1 + i) % i], h = a[e], d = a[(e + 1) % i], p = { x: c.x - h.x, y: c.y - h.y }, u = { x: d.x - h.x, y: d.y - h.y }, f = Math.sqrt(p.x * p.x + p.y * p.y), g = Math.sqrt(u.x * u.x + u.y * u.y), b = Math.min(f, g) / 2;
+    let v = 0;
+    r ? v = o : v = o[`p${e}`] ?? 0;
+    const w = Math.min(v, b);
+    if (w <= 0) {
+      e === 0 ? l += `M ${h.x},${h.y} ` : l += `L ${h.x},${h.y} `;
+      continue;
+    }
+    const M = { x: h.x + p.x / f * w, y: h.y + p.y / f * w }, T = { x: h.x + u.x / g * w, y: h.y + u.y / g * w };
+    e === 0 ? l += `M ${M.x},${M.y} ` : l += `L ${M.x},${M.y} `, l += `Q ${h.x},${h.y} ${T.x},${T.y} `;
+  }
+  return l += "Z", l;
+}, Ct = (t) => {
+  const o = t.clip;
+  if (!o) return null;
+  const s = Math.max(0, o.left ?? 0), n = Math.max(0, o.top ?? 0), a = Math.max(0, o.right ?? 0), r = Math.max(0, o.bottom ?? 0);
+  if (!(n > 0 || a > 0 || r > 0 || s > 0)) return null;
+  const l = t.width - s - a, e = t.height - n - r;
+  return l <= 0 || e <= 0 ? null : {
+    left: s,
+    top: n,
+    width: l,
+    height: e,
+    originX: s + l / 2,
+    originY: n + e / 2
+  };
+}, vt = (t) => {
+  var a, r, i, l;
+  const o = (r = (a = t.effect) == null ? void 0 : a.style) == null ? void 0 : r.type, s = ((l = (i = t.effect) == null ? void 0 : i.style) == null ? void 0 : l.params) || {};
+  if (!o || o === "none") return 0;
+  const n = (e, c) => e ?? c;
+  switch (o) {
+    case "shadow": {
+      const e = n(s.blur, 10), c = n(s.offset, 50) / 5;
+      return e + c + 10;
+    }
+    case "lift": {
+      const e = n(s.intensity, 50) / 50, c = 20 * e, h = 10 * e;
+      return c + h + 10;
+    }
+    case "neon":
+      return J(s) * 5 + 6;
+    case "outline":
+      return m(s) * 2 + 2;
+    case "hollow":
+      return K(s) * 2 + 2;
+    case "splice": {
+      const e = Q(s), { offsetX: c, offsetY: h } = R(s);
+      return Math.max(Math.abs(c), Math.abs(h)) + e * 2 + 4;
+    }
+    case "echo": {
+      const { offsetX: e, offsetY: c } = R(s);
+      return Math.max(Math.abs(e), Math.abs(c)) * 2 + 4;
+    }
+    case "glitch":
+      return Math.abs(Z(s)) + 4;
+    case "blur":
+      return n(s.blurAmount, 5) * 2 + 4;
+    case "duotone":
+    case "gradient_overlay":
+    case "background":
+      return 2;
+    case "reflection": {
+      const e = n(s.reflectionDistance, 5), c = e, h = e + 10;
+      return Math.abs(h) + c + 6;
+    }
+    default:
+      return 0;
+  }
+}, rt = (t) => {
+  const o = [], s = /d=\"([^\"]+)\"/g;
+  let n = null;
+  for (; (n = s.exec(t)) !== null; )
+    o.push(n[1]);
+  return o;
+}, Mt = (t, o, s) => {
+  if (t.type === "shape") {
+    const n = t.content, a = tt(n);
+    if (a && typeof DOMMatrix < "u") {
+      const r = rt(a.markup);
+      if (r.length > 0) {
+        const { x: i, y: l, width: e, height: c } = z(a.viewBox), h = e > 0 ? o / e : 1, d = c > 0 ? s / c : 1, p = new Path2D();
+        return r.forEach((u) => {
+          const f = new Path2D(u), g = new DOMMatrix().translate(-i, -l).scale(h, d);
+          p.addPath(f, g);
+        }), p;
+      }
+    }
+    if (n === "rect") {
+      const r = new Path2D(), i = t.cornerRadius || 0;
+      return N(r, 0, 0, o, s, i), r;
+    }
+    if (n === "circle") {
+      const r = new Path2D();
+      return r.ellipse(o / 2, s / 2, o / 2, s / 2, 0, 0, Math.PI * 2), r;
+    }
+    if (n === "line") {
+      const r = new Path2D();
+      return r.moveTo(0, s / 2), r.lineTo(o, s / 2), r;
+    }
+    if (E[n]) {
+      const r = t.cornerRadius || 0, i = et(E[n], r, o, s);
+      return new Path2D(i);
+    }
+  }
+  return null;
+}, $ = (t, o, s) => {
+  if (t.type === "image" && t.clipShape) {
+    const n = tt(t.clipShape);
+    if (n) {
+      const a = rt(n.markup);
+      if (a.length > 0 && typeof DOMMatrix < "u") {
+        const { x: r, y: i, width: l, height: e } = z(n.viewBox), c = l > 0 ? o / l : 1, h = e > 0 ? s / e : 1, d = new Path2D();
+        return a.forEach((p) => {
+          const u = new Path2D(p), f = new DOMMatrix().translate(-r, -i).scale(c, h);
+          d.addPath(u, f);
+        }), d;
+      }
+    }
+    if (t.clipShape === "circle") {
+      const a = new Path2D();
+      return a.ellipse(o / 2, s / 2, o / 2, s / 2, 0, 0, Math.PI * 2), a;
+    }
+    if (t.clipShape === "path" && t.path) {
+      const a = ot(t.path);
+      return new Path2D(a);
+    }
+    if (E[t.clipShape]) {
+      const a = t.cornerRadius || 0, r = et(E[t.clipShape], a, o, s);
+      return new Path2D(r);
+    }
+  }
+  return null;
+}, Pt = (t, o, s, n) => {
+  const a = o.backgroundColor || "transparent", r = a.includes("gradient") ? kt(a) : null;
+  if (r)
+    if (r.type === "radial") {
+      const c = t.createRadialGradient(s / 2, n / 2, 0, s / 2, n / 2, Math.max(s, n) / 2);
+      r.stops.forEach((h, d) => {
+        const p = r.stops.length > 1 ? d / (r.stops.length - 1) : 0, u = h.offset ? Number.parseFloat(h.offset) / 100 : p;
+        c.addColorStop(Number.isFinite(u) ? u : p, h.color);
+      }), t.fillStyle = c;
+    } else {
+      const c = st(t, s, n, r.angle);
+      r.stops.forEach((h, d) => {
+        const p = r.stops.length > 1 ? d / (r.stops.length - 1) : 0, u = h.offset ? Number.parseFloat(h.offset) / 100 : p;
+        c.addColorStop(Number.isFinite(u) ? u : p, h.color);
+      }), t.fillStyle = c;
+    }
+  else
+    t.fillStyle = a;
+  const i = Mt(o, s, n);
+  i ? t.fill(i) : t.fillRect(0, 0, s, n);
+  const l = o.content === "line" ? Math.max(2, o.strokeWidth || 4) : o.strokeWidth || 0, e = o.strokeColor || "transparent";
+  l > 0 && e !== "transparent" && (t.save(), t.strokeStyle = e, t.lineWidth = l, t.lineJoin = "round", t.lineCap = o.strokeStyle === "round" ? "round" : "butt", o.strokeStyle === "dashed" ? t.setLineDash([6, 4]) : o.strokeStyle === "dotted" ? t.setLineDash([2, 2]) : t.setLineDash([]), i ? t.stroke(i) : t.strokeRect(0, 0, s, n), t.restore());
+}, Tt = (t, o, s) => {
+  if (o === "none") return t;
+  const n = t.width / s, a = t.height / s, { canvas: r, ctx: i } = L(n, a, s);
+  return i.filter = o, i.drawImage(t, 0, 0, n, a), r;
+}, Ot = (t) => new Promise((o, s) => {
+  const n = new Image();
+  n.decoding = "async", n.crossOrigin = "anonymous", n.onload = () => o(n), n.onerror = (a) => s(a), n.src = t;
+}), Wt = async (t, o, s, n, a) => {
+  if (o.isIcon && o.iconPaths && o.iconPaths.length > 0) {
+    const { x: M, y: T, width: D, height: y } = z(
+      o.iconViewBox || `0 0 ${s} ${n}`
+    ), S = D > 0 ? s / D : 1, P = y > 0 ? n / y : 1;
+    t.save(), t.fillStyle = o.color || "#000000", t.translate(-M * S, -T * P), t.scale(S, P), o.iconPaths.forEach((X) => {
+      const k = new Path2D(X);
+      t.fill(k);
+    }), t.restore();
+    return;
+  }
+  const r = o.content;
+  if (!r) return;
+  let i = a.get(r);
+  i || (i = await Ot(r), a.set(r, i));
+  const l = i.naturalWidth || i.width || s, e = i.naturalHeight || i.height || n, c = ft(o.crop, s, n, l, e), h = c.width * l, d = c.height * e, p = s / h, u = n / d, f = l * p, g = e * u, b = -(c.x * l) * p, v = -(c.y * e) * u, w = (o.imageRotation ?? 0) * (Math.PI / 180);
+  if (o.backgroundColor && o.backgroundColor !== "transparent" && (t.save(), t.fillStyle = o.backgroundColor, t.fillRect(0, 0, s, n), t.restore()), t.save(), w) {
+    const M = b + f / 2, T = v + g / 2;
+    t.translate(M, T), t.rotate(w), t.translate(-M, -T);
+  }
+  t.drawImage(i, b, v, f, g), t.restore();
+}, Dt = (t, o) => {
+  if (!o.path) return;
+  const s = ot(o.path);
+  if (!s) return;
+  const n = new Path2D(s), a = o.backgroundColor ?? o.path.fillColor ?? "transparent", r = o.strokeColor ?? o.path.strokeColor ?? "transparent", i = o.strokeWidth ?? o.path.strokeWidth ?? 0;
+  a && a !== "transparent" && (t.save(), t.fillStyle = a, t.fill(n), t.restore()), i > 0 && r && r !== "transparent" && (t.save(), t.strokeStyle = r, t.lineWidth = i, t.lineCap = o.path.lineCap, t.lineJoin = o.path.lineJoin, o.strokeStyle === "dashed" ? t.setLineDash([6, 4]) : o.strokeStyle === "dotted" ? t.setLineDash([2, 2]) : t.setLineDash([]), t.stroke(n), t.restore());
+}, Xt = async (t, o, s) => {
+  var D, y, S, P, X;
+  const n = vt(t), a = typeof n == "number" ? n : 0, r = t.width + a * 2, i = t.height + a * 2, { canvas: l, ctx: e } = L(r, i, o);
+  e.save(), e.translate(a, a);
+  const c = Ct(t), h = ((y = (D = t.effect) == null ? void 0 : D.style) == null ? void 0 : y.type) ?? "none", d = ((P = (S = t.effect) == null ? void 0 : S.style) == null ? void 0 : P.params) ?? {}, p = q((X = t.effect) == null ? void 0 : X.adjustments), { canvas: u, ctx: f } = L(t.width, t.height, o);
+  if (t.type === "text")
+    c ? (f.save(), f.beginPath(), f.rect(c.left, c.top, c.width, c.height), f.clip(), j(f, t, t.width, t.height, h, d), f.restore()) : j(f, t, t.width, t.height, h, d);
+  else {
+    if (f.save(), c)
+      f.beginPath(), f.rect(c.left, c.top, c.width, c.height), f.clip();
+    else {
+      const k = $(t, t.width, t.height);
+      k ? (f.beginPath(), f.addPath(k), f.clip()) : t.type === "image" && t.cornerRadius && (f.beginPath(), N(f, 0, 0, t.width, t.height, t.cornerRadius), f.clip());
+    }
+    if (t.type === "shape" ? Pt(f, t, t.width, t.height) : t.type === "image" ? await Wt(f, t, t.width, t.height, s) : t.type === "path" ? Dt(f, t) : (f.fillStyle = t.backgroundColor || "transparent", f.fillRect(0, 0, t.width, t.height)), f.restore(), t.type === "image" && (t.strokeWidth || 0) > 0) {
+      const k = $(t, t.width, t.height);
+      f.save(), f.strokeStyle = t.strokeColor || "#000000", f.lineWidth = t.strokeWidth || 0, f.lineJoin = "round", f.lineCap = t.strokeStyle === "round" ? "round" : "butt", t.strokeStyle === "dashed" ? f.setLineDash([6, 4]) : t.strokeStyle === "dotted" ? f.setLineDash([2, 2]) : f.setLineDash([]), k ? f.stroke(k) : t.cornerRadius ? (f.beginPath(), N(f, 0, 0, t.width, t.height, t.cornerRadius), f.stroke()) : f.strokeRect(0, 0, t.width, t.height), f.restore();
+    }
+  }
+  const g = t.type === "text", b = [];
+  if (!g) {
+    if (p && b.push(p), h === "blur") {
+      const k = d.blurAmount ?? 5;
+      b.push(`blur(${k}px)`);
+    }
+    h === "duotone" && b.push("grayscale(100%)");
+  }
+  const v = b.join(" ").trim() || "none", w = !g && h === "blur", M = g || w ? u : Tt(u, v, o);
+  if (!g && (h === "shadow" || h === "lift" || h === "neon")) {
+    if (e.save(), e.filter = "none", h === "shadow") {
+      const { offsetX: k, offsetY: W } = R(d), O = d.blur ?? 0, A = B(d);
+      e.shadowColor = I(V(d, "#000000"), A), e.shadowBlur = O, e.shadowOffsetX = k, e.shadowOffsetY = W, e.drawImage(M, 0, 0, t.width, t.height);
+    } else if (h === "lift") {
+      const k = x(d);
+      e.shadowColor = `rgba(0,0,0, ${0.5 * k})`, e.shadowBlur = 20 * k, e.shadowOffsetX = 0, e.shadowOffsetY = 10 * k, e.drawImage(M, 0, 0, t.width, t.height);
+    } else if (h === "neon") {
+      const k = J(d), W = d.color || "#00ff00";
+      [k * 5, k * 3, k].forEach((O) => {
+        e.shadowColor = W, e.shadowBlur = O, e.shadowOffsetX = 0, e.shadowOffsetY = 0, e.drawImage(M, 0, 0, t.width, t.height);
+      });
+    }
+    e.restore();
+  }
+  if (!g && h === "reflection") {
+    const k = (d.reflectionOpacity ?? 50) / 100, W = d.reflectionDistance ?? 5, O = 0.35;
+    e.save(), e.drawImage(M, 0, 0, t.width, t.height), e.translate(0, t.height + W), e.scale(1, -1), e.globalAlpha = k, e.drawImage(
+      M,
+      0,
+      t.height - t.height * O,
+      t.width,
+      t.height * O,
+      0,
+      0,
+      t.width,
+      t.height * O
+    ), e.restore();
+  } else
+    w ? (e.save(), e.filter = v, e.drawImage(u, 0, 0, t.width, t.height), e.restore()) : e.drawImage(M, 0, 0, t.width, t.height);
+  if (!g && h === "gradient_overlay") {
+    const k = d.gradientColor1 || "#667eea", W = d.gradientColor2 || "#764ba2", O = d.gradientAngle || 135, A = (d.transparency ?? 80) / 100;
+    e.save(), e.globalAlpha = A, e.filter = p || "none", e.globalCompositeOperation = "overlay";
+    const F = st(e, t.width, t.height, O);
+    F.addColorStop(0, k), F.addColorStop(1, W), e.fillStyle = F;
+    const G = $(t, t.width, t.height);
+    G ? (e.save(), e.beginPath(), e.addPath(G), e.clip(), e.fillRect(0, 0, t.width, t.height), e.restore()) : e.fillRect(0, 0, t.width, t.height), e.restore();
+  }
+  if (!g && h === "duotone") {
+    const k = d.duotoneLight || "#f472b6", W = d.duotoneDark || "#1e40af", O = $(t, t.width, t.height);
+    e.save(), e.filter = p || "none", O && (e.beginPath(), e.addPath(O), e.clip()), e.globalCompositeOperation = "multiply", e.fillStyle = W, e.fillRect(0, 0, t.width, t.height), e.globalCompositeOperation = "screen", e.globalAlpha = 0.6, e.fillStyle = k, e.fillRect(0, 0, t.width, t.height), e.restore();
+  }
+  e.restore();
+  const T = c ? { x: c.originX, y: c.originY } : { x: t.width / 2, y: t.height / 2 };
+  return {
+    canvas: l,
+    padding: a,
+    origin: T,
+    width: r,
+    height: i
+  };
+}, U = async (t, o) => {
+  const { page: s, settings: n, bleed: a, backgroundColor: r, pixelRatio: i } = o, l = o.width, e = o.height, c = a, h = a;
+  r !== "transparent" && (t.save(), t.fillStyle = r || n.backgroundColor || "#ffffff", t.fillRect(0, 0, l, e), t.restore());
+  const d = [...s.elements].filter((u) => u.visible !== !1).sort((u, f) => u.zIndex - f.zIndex), p = /* @__PURE__ */ new Map();
+  for (const u of d) {
+    const { canvas: f, padding: g, origin: b, width: v, height: w } = await Xt(
+      u,
+      i,
+      p
+    );
+    t.save(), t.globalCompositeOperation = dt(u.blendMode), t.globalAlpha = u.opacity ?? 1, t.translate(c + u.x, h + u.y), t.translate(b.x, b.y), t.rotate((u.rotation ?? 0) * Math.PI / 180), t.scale(u.flipX ? -1 : 1, u.flipY ? -1 : 1), t.translate(-b.x, -b.y), t.drawImage(f, -g, -g, v, w), t.restore();
+  }
+}, Rt = async (t) => {
+  await at(document);
+  const o = t.width, s = t.height;
+  if (!it(
+    o,
+    s,
+    t.pixelRatio,
+    8192,
+    67108864
+  )) {
+    const { canvas: i, ctx: l } = L(o, s, t.pixelRatio);
+    return await U(l, t), i;
+  }
+  const a = lt(o, s, {
+    tileWidth: H.tileSize,
+    tileHeight: H.tileSize,
+    overlap: H.tileOverlap
+  }), r = [];
+  for (const i of a.tiles) {
+    const { canvas: l, ctx: e } = L(i.width, i.height, t.pixelRatio);
+    e.translate(-i.x, -i.y), await U(e, t), r.push({ rect: i, canvas: l });
+  }
+  return ct(r, o, s, t.pixelRatio);
+};
+export {
+  Rt as capturePageCanvas
+};

package/dist/exportFromWebGL-BVSssqCv.js

@@ -0,0 +1,32 @@
+import { F as b } from "./index-D8e-pyQj.js";
+const u = (n) => new Promise((o, r) => {
+  const t = new FileReader();
+  t.onload = () => o(t.result), t.onerror = () => r(t.error), t.readAsDataURL(n);
+}), g = async (n, o) => {
+  const { width: r, height: t, pixelRatio: p } = o, c = Math.max(0.1, p || 1), d = Math.max(1, Math.round(r * c)), f = Math.max(1, Math.round(t * c)), a = typeof OffscreenCanvas < "u" ? new OffscreenCanvas(d, f) : (() => {
+    const e = document.createElement("canvas");
+    return e.width = d, e.height = f, e;
+  })(), i = new b(a);
+  if (i.resize(r, t, c), await i.prefetchTextures(n), i.render(n), "convertToBlob" in a)
+    return a.convertToBlob({ type: "image/png" });
+  const s = a;
+  if (!s.toBlob) {
+    const e = s.toDataURL("image/png", 1);
+    return (await fetch(e)).blob();
+  }
+  const h = await new Promise((e) => {
+    s.toBlob((l) => e(l), "image/png", 1);
+  });
+  if (!h) {
+    const e = s.toDataURL("image/png", 1);
+    return (await fetch(e)).blob();
+  }
+  return h;
+}, x = async (n, o) => {
+  const r = await g(n, o);
+  return u(r);
+};
+export {
+  x as exportSceneToDataUrl,
+  g as exportSceneToPng
+};

package/dist/fraczled-sdk.es.js

@@ -1,9 +1,9 @@
 import "react";
 import "react-dom/client";
-import { S as o, b as p, a as c, d } from "./index-DBpUREnv.js";
+import { S as o, w as p, v as c, x as i } from "./index-D8e-pyQj.js";
 export {
   o as Store,
   p as createFraczledEditor,
   c as createOurEditorApp,
-  d as createStore
+  i as createStore
 };