@pixldocs/canvas-renderer 0.3.27 → 0.4.0

package/dist/index.cjs

@@ -9,6 +9,8 @@ const reactDom = require("react-dom");
 const zustand = require("zustand");
 const fabric = require("fabric");
 const client = require("react-dom/client");
+const jspdf = require("jspdf");
+const svg2pdf_js = require("svg2pdf.js");
 function _interopNamespaceDefault(e) {
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
   if (e) {
@@ -10766,8 +10768,38 @@ class PixldocsRenderer {
     return this.renderAllPageSvgs(configToRender);
   }
   /**
-   * Convenience: fetch by ID with simple flat data and render.
+   * Render a pre-resolved template config to a vector PDF.
+   * Returns a Blob and ArrayBuffer.
    */
+  async renderPdf(templateConfig, options) {
+    const svgs = await this.renderAllPageSvgs(templateConfig);
+    const { assemblePdfFromSvgs: assemblePdfFromSvgs2 } = await Promise.resolve().then(() => pdfExport);
+    return assemblePdfFromSvgs2(svgs, { title: options == null ? void 0 : options.title });
+  }
+  /**
+   * Resolve from V2 sectionState and render a vector PDF.
+   * This is the primary PDF export API — mirrors renderFromForm() but returns a PDF.
+   */
+  async renderPdfFromForm(options) {
+    const { templateId, formSchemaId, sectionState, themeId, watermark, title } = options;
+    const resolved = await resolveFromForm({
+      templateId,
+      formSchemaId,
+      sectionState,
+      themeId,
+      supabaseUrl: this.config.supabaseUrl,
+      supabaseAnonKey: this.config.supabaseAnonKey
+    });
+    const shouldWatermark = watermark ?? resolved.price > 0;
+    let configToRender = resolved.config;
+    if (shouldWatermark) {
+      const { injectWatermark } = await Promise.resolve().then(() => require("./canvasWatermark-DAZIQ_IR.cjs"));
+      configToRender = injectWatermark(configToRender);
+    }
+    const svgs = await this.renderAllPageSvgs(configToRender);
+    const { assemblePdfFromSvgs: assemblePdfFromSvgs2 } = await Promise.resolve().then(() => pdfExport);
+    return assemblePdfFromSvgs2(svgs, { title: title ?? resolved.config.name });
+  }
   async renderById(templateId, formData, options) {
     const resolved = await resolveTemplateData({
       templateId,
@@ -11220,6 +11252,1036 @@ class PixldocsRenderer {
     return null;
   }
 }
+const SVG_DRAWABLE_TAGS = /* @__PURE__ */ new Set([
+  "path",
+  "rect",
+  "circle",
+  "ellipse",
+  "polygon",
+  "polyline",
+  "line",
+  "text",
+  "tspan"
+]);
+const SVG_DEFINITION_CONTAINER_TAGS = /* @__PURE__ */ new Set([
+  "defs",
+  "clippath",
+  "mask",
+  "pattern",
+  "marker",
+  "symbol",
+  "filter",
+  "lineargradient",
+  "radialgradient"
+]);
+const SVG_STYLE_PROPS = /* @__PURE__ */ new Set([
+  "fill",
+  "stroke",
+  "color",
+  "opacity",
+  "fill-opacity",
+  "stroke-opacity",
+  "fill-rule",
+  "stroke-width",
+  "stroke-linecap",
+  "stroke-linejoin",
+  "stroke-miterlimit",
+  "stroke-dasharray",
+  "stroke-dashoffset",
+  "display",
+  "visibility",
+  "stop-color",
+  "stop-opacity",
+  "clip-rule",
+  "clip-path",
+  "mask",
+  "filter"
+]);
+const GRADIENT_ATTRS_LINEAR = ["x1", "y1", "x2", "y2", "gradientUnits", "gradientTransform", "spreadMethod"];
+const GRADIENT_ATTRS_RADIAL = ["cx", "cy", "r", "fx", "fy", "gradientUnits", "gradientTransform", "spreadMethod"];
+const URL_GRADIENT_RE = /^\s*url\s*\(\s*(['"]?)([^)]+?)\1\s*\)/i;
+function parseColor(color) {
+  if (!color) return null;
+  const raw = color.trim().toLowerCase();
+  if (!raw || raw === "transparent" || raw === "none") return null;
+  const clamp2 = (value) => Math.max(0, Math.min(255, Math.round(value)));
+  const parseNumeric = (token) => {
+    const value = parseFloat(token);
+    return Number.isFinite(value) ? value : NaN;
+  };
+  const parseRgbComponent = (token) => {
+    const value = parseNumeric(token);
+    if (!Number.isFinite(value)) return NaN;
+    return token.endsWith("%") ? value / 100 * 255 : value;
+  };
+  const parseAlpha = (token) => {
+    if (!token) return 1;
+    const value = parseNumeric(token);
+    if (!Number.isFinite(value)) return 1;
+    return token.endsWith("%") ? value / 100 : value;
+  };
+  const toRgbFromHsl = (h, s, l) => {
+    const hue = (h % 360 + 360) % 360;
+    const sat = Math.max(0, Math.min(1, s));
+    const light = Math.max(0, Math.min(1, l));
+    if (sat === 0) {
+      const gray = clamp2(light * 255);
+      return { r: gray, g: gray, b: gray };
+    }
+    const q = light < 0.5 ? light * (1 + sat) : light + sat - light * sat;
+    const p = 2 * light - q;
+    const hueToRgb = (t) => {
+      let tt = t;
+      if (tt < 0) tt += 1;
+      if (tt > 1) tt -= 1;
+      if (tt < 1 / 6) return p + (q - p) * 6 * tt;
+      if (tt < 1 / 2) return q;
+      if (tt < 2 / 3) return p + (q - p) * (2 / 3 - tt) * 6;
+      return p;
+    };
+    return {
+      r: clamp2(hueToRgb(hue / 360 + 1 / 3) * 255),
+      g: clamp2(hueToRgb(hue / 360) * 255),
+      b: clamp2(hueToRgb(hue / 360 - 1 / 3) * 255)
+    };
+  };
+  if (raw.startsWith("#")) {
+    const hex = raw.slice(1);
+    const expanded = hex.length === 3 || hex.length === 4 ? hex.split("").map((char) => char + char).join("") : hex;
+    if (expanded.length !== 6 && expanded.length !== 8) return null;
+    const intValue = parseInt(expanded.slice(0, 6), 16);
+    if (!Number.isFinite(intValue)) return null;
+    if (expanded.length === 8) {
+      const alphaHex = parseInt(expanded.slice(6, 8), 16);
+      if (Number.isFinite(alphaHex) && alphaHex <= 0) return null;
+    }
+    return { r: intValue >> 16 & 255, g: intValue >> 8 & 255, b: intValue & 255 };
+  }
+  const rgbMatch = raw.match(/^rgba?\((.+)\)$/);
+  if (rgbMatch) {
+    const normalized = rgbMatch[1].replace(/\//g, " ").replace(/,/g, " ");
+    const parts = normalized.split(/\s+/).filter(Boolean);
+    if (parts.length >= 3) {
+      const alpha = parseAlpha(parts[3]);
+      if (alpha <= 0) return null;
+      const r = parseRgbComponent(parts[0]);
+      const g = parseRgbComponent(parts[1]);
+      const b = parseRgbComponent(parts[2]);
+      if (Number.isFinite(r) && Number.isFinite(g) && Number.isFinite(b)) {
+        return { r: clamp2(r), g: clamp2(g), b: clamp2(b) };
+      }
+    }
+  }
+  const hslMatch = raw.match(/^hsla?\((.+)\)$/);
+  if (hslMatch) {
+    const normalized = hslMatch[1].replace(/\//g, " ").replace(/,/g, " ");
+    const parts = normalized.split(/\s+/).filter(Boolean);
+    if (parts.length >= 3) {
+      const alpha = parseAlpha(parts[3]);
+      if (alpha <= 0) return null;
+      const h = parseNumeric(parts[0].replace(/deg$/, ""));
+      const sRaw = parseNumeric(parts[1].replace(/%$/, ""));
+      const lRaw = parseNumeric(parts[2].replace(/%$/, ""));
+      if (Number.isFinite(h) && Number.isFinite(sRaw) && Number.isFinite(lRaw)) {
+        return toRgbFromHsl(h, sRaw / 100, lRaw / 100);
+      }
+    }
+  }
+  return null;
+}
+function rgbToHex(r, g, b) {
+  return "#" + [r, g, b].map((x) => Math.max(0, Math.min(255, Math.round(x))).toString(16).padStart(2, "0")).join("");
+}
+function cssColorToHex(css) {
+  var _a;
+  const s = css.trim();
+  if (/^#[0-9a-f]{3}$/i.test(s)) {
+    const r = s[1] + s[1], g = s[2] + s[2], b = s[3] + s[3];
+    return "#" + r + g + b;
+  }
+  if (/^#[0-9a-f]{6}$/i.test(s)) return s;
+  if (/^#[0-9a-f]{8}$/i.test(s)) return "#" + s.slice(1, 7);
+  const rgb = s.match(/^rgba?\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/i);
+  if (rgb) {
+    const r = Number(rgb[1]).toString(16).padStart(2, "0");
+    const g = Number(rgb[2]).toString(16).padStart(2, "0");
+    const b = Number(rgb[3]).toString(16).padStart(2, "0");
+    return "#" + r + g + b;
+  }
+  if (typeof document === "undefined") return null;
+  const div = document.createElement("div");
+  div.style.color = s;
+  const computed = (_a = document.defaultView) == null ? void 0 : _a.getComputedStyle(div).color;
+  if (!computed || !computed.startsWith("rgb")) return null;
+  const m = computed.match(/\d+/g);
+  if (!m || m.length < 3) return null;
+  return "#" + [m[0], m[1], m[2]].map((v) => Number(v).toString(16).padStart(2, "0")).join("");
+}
+function isInSvgDefinitionSubtree(el) {
+  var _a;
+  let current = el;
+  while (current) {
+    if (SVG_DEFINITION_CONTAINER_TAGS.has(((_a = current.tagName) == null ? void 0 : _a.toLowerCase()) ?? "")) return true;
+    current = current.parentElement;
+  }
+  return false;
+}
+function parseInlineSvgStyleDeclarations(styleText) {
+  return styleText.split(";").map((part) => part.trim()).filter(Boolean).map((part) => {
+    const idx = part.indexOf(":");
+    if (idx <= 0) return null;
+    return { key: part.slice(0, idx).trim().toLowerCase(), value: part.slice(idx + 1).trim() };
+  }).filter((x) => !!x);
+}
+function extractGradientIdFromPaint(value) {
+  if (!value) return null;
+  const match = value.trim().match(URL_GRADIENT_RE);
+  if (!match) return null;
+  const rawRef = (match[2] || "").trim();
+  if (!rawRef) return null;
+  const hashIdx = rawRef.lastIndexOf("#");
+  if (hashIdx < 0 || hashIdx === rawRef.length - 1) return null;
+  const id = rawRef.slice(hashIdx + 1).trim();
+  if (!id) return null;
+  return id.replace(/[\s"')].*$/, "");
+}
+function normalizeGradientPaintRef(value) {
+  const id = extractGradientIdFromPaint(value);
+  return id ? `url(#${id})` : value;
+}
+function findGradientInTree(svgRoot, gradientId) {
+  for (const el of svgRoot.querySelectorAll("[id]")) {
+    if (el.getAttribute("id") === gradientId) return el;
+  }
+  return null;
+}
+function getInlineStyleValue(el, key) {
+  const style = el.getAttribute("style") || "";
+  if (!style) return null;
+  const hit = parseInlineSvgStyleDeclarations(style).find((decl) => decl.key === key);
+  return (hit == null ? void 0 : hit.value) ?? null;
+}
+function isTransparentColorToken(value) {
+  if (!value) return false;
+  const s = value.trim().toLowerCase();
+  if (!s || s === "none" || s === "transparent") return true;
+  if (/^#[0-9a-f]{8}$/i.test(s)) {
+    return Number.parseInt(s.slice(7, 9), 16) === 0;
+  }
+  const rgba = s.match(/^rgba\s*\(([^)]+)\)$/i);
+  if (rgba) {
+    const parts = rgba[1].split(",").map((part) => part.trim());
+    if (parts.length >= 4) {
+      const alpha = parseSvgOpacity(parts[3]);
+      return alpha != null && alpha <= 1e-4;
+    }
+  }
+  return false;
+}
+function parseSvgOpacity(value) {
+  if (!value) return null;
+  const raw = value.trim();
+  if (!raw) return null;
+  if (raw.endsWith("%")) {
+    const pct = Number.parseFloat(raw.slice(0, -1));
+    if (!Number.isFinite(pct)) return null;
+    return Math.max(0, Math.min(1, pct / 100));
+  }
+  const n = Number.parseFloat(raw);
+  if (!Number.isFinite(n)) return null;
+  return Math.max(0, Math.min(1, n));
+}
+function formatSvgOpacity(value) {
+  return Number(Math.max(0, Math.min(1, value)).toFixed(4)).toString();
+}
+function multiplySvgOpacityAttr(el, attr, factor) {
+  const existing = parseSvgOpacity(el.getAttribute(attr));
+  el.setAttribute(attr, formatSvgOpacity((existing ?? 1) * factor));
+}
+function inlineSvgStyleBlockDeclarations(svg) {
+  const styleNodes = Array.from(svg.querySelectorAll("style"));
+  if (styleNodes.length === 0) return;
+  const cssText = styleNodes.map((node) => node.textContent || "").join("\n").replace(/\/\*[\s\S]*?\*\//g, " ");
+  if (!cssText.trim()) return;
+  const allElements = [svg, ...Array.from(svg.querySelectorAll("*"))];
+  const classIndex = /* @__PURE__ */ new Map();
+  allElements.forEach((el) => {
+    (el.getAttribute("class") || "").split(/\s+/).map((t) => t.trim()).filter(Boolean).forEach((token) => {
+      const list = classIndex.get(token) ?? [];
+      list.push(el);
+      classIndex.set(token, list);
+    });
+  });
+  const normalizePresentationValue = (key, value) => {
+    if (["fill", "stroke", "clip-path", "mask", "filter"].includes(key)) return normalizeGradientPaintRef(value);
+    return value;
+  };
+  const applyDeclarations = (elements, declarations) => {
+    for (const el of elements) {
+      const inlineDeclMap = new Map(
+        parseInlineSvgStyleDeclarations(el.getAttribute("style") || "").map(({ key, value }) => [key, value])
+      );
+      for (const { key, value } of declarations) {
+        if (!value || inlineDeclMap.has(key)) continue;
+        el.setAttribute(key, normalizePresentationValue(key, value));
+      }
+    }
+  };
+  const ruleRegex = /([^{}]+)\{([^}]*)\}/g;
+  let ruleMatch;
+  while (ruleMatch = ruleRegex.exec(cssText)) {
+    const selectors = ruleMatch[1].split(",").map((s) => s.trim()).filter(Boolean);
+    const declarations = parseInlineSvgStyleDeclarations(ruleMatch[2]).filter((d) => SVG_STYLE_PROPS.has(d.key));
+    if (selectors.length === 0 || declarations.length === 0) continue;
+    for (const selector of selectors) {
+      if (!selector || selector.startsWith("@")) continue;
+      const classOnlyMatch = selector.match(/^\.([A-Za-z_][\w-]*)$/);
+      if (classOnlyMatch) {
+        applyDeclarations(classIndex.get(classOnlyMatch[1]) ?? [], declarations);
+        continue;
+      }
+      try {
+        applyDeclarations(svg.querySelectorAll(selector), declarations);
+      } catch {
+        const classMatch = selector.match(/\.([A-Za-z0-9_-]+)/);
+        if (classMatch) applyDeclarations(classIndex.get(classMatch[1]) ?? [], declarations);
+      }
+    }
+  }
+  for (const el of allElements) {
+    const style = el.getAttribute("style");
+    if (!style) continue;
+    const keptDecls = [];
+    let changed = false;
+    for (const { key, value } of parseInlineSvgStyleDeclarations(style)) {
+      if (SVG_STYLE_PROPS.has(key)) {
+        el.setAttribute(key, normalizePresentationValue(key, value));
+        changed = true;
+      } else {
+        keptDecls.push(`${key}: ${value}`);
+      }
+    }
+    if (changed) {
+      if (keptDecls.length > 0) el.setAttribute("style", keptDecls.join("; "));
+      else el.removeAttribute("style");
+    }
+  }
+  for (const styleNode of styleNodes) {
+    const css = styleNode.textContent || "";
+    let cleaned = css;
+    for (const prop of SVG_STYLE_PROPS) {
+      const regex = new RegExp(`${prop.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&")}\\s*:\\s*[^;}{]+;?`, "gi");
+      cleaned = cleaned.replace(regex, "");
+    }
+    styleNode.textContent = cleaned.replace(/;\s*;/g, ";").replace(/\{\s*;/g, "{").replace(/;\s*}/g, "}").replace(/\{\s*}/g, "{}");
+  }
+}
+function normalizeSvgExplicitColors(svg) {
+  const clone = svg.cloneNode(true);
+  inlineSvgStyleBlockDeclarations(clone);
+  const getAttr = (el, attr) => {
+    var _a;
+    const v = el.getAttribute(attr) ?? ((_a = el.style) == null ? void 0 : _a.getPropertyValue(attr));
+    if (!v) return null;
+    const s = v.trim().toLowerCase();
+    if (!s || s === "none" || s === "transparent" || s === "currentcolor") return null;
+    return normalizeGradientPaintRef(v);
+  };
+  const hasExplicitNonePaint = (el, attr) => {
+    var _a, _b;
+    const raw = (el.getAttribute(attr) ?? ((_a = el.style) == null ? void 0 : _a.getPropertyValue(attr)) ?? "").trim().toLowerCase();
+    if (raw === "none" || raw === "transparent") return true;
+    const rawOpacity = (el.getAttribute(`${attr}-opacity`) ?? ((_b = el.style) == null ? void 0 : _b.getPropertyValue(`${attr}-opacity`)) ?? "").trim().toLowerCase();
+    return rawOpacity === "0" || rawOpacity === "0%" || rawOpacity === "0.0";
+  };
+  function walk(el, parentFill, parentStroke, parentColor) {
+    var _a;
+    if (isInSvgDefinitionSubtree(el)) {
+      for (let i = 0; i < el.children.length; i++) walk(el.children[i], null, null, null);
+      return;
+    }
+    const tag = ((_a = el.tagName) == null ? void 0 : _a.toLowerCase()) ?? "";
+    const isDrawable = SVG_DRAWABLE_TAGS.has(tag);
+    let fill = getAttr(el, "fill");
+    let stroke = getAttr(el, "stroke");
+    const color = getAttr(el, "color") ?? parentColor;
+    const fillNone = hasExplicitNonePaint(el, "fill");
+    const strokeNone = hasExplicitNonePaint(el, "stroke");
+    const inheritedFill = parentFill === "none" ? null : parentFill;
+    const inheritedStroke = parentStroke === "none" ? null : parentStroke;
+    if (isDrawable) {
+      if (fillNone) {
+        el.setAttribute("fill", "none");
+        fill = null;
+      } else {
+        const resolved = fill ?? color ?? inheritedFill;
+        if (resolved) {
+          el.setAttribute("fill", resolved);
+          fill = resolved;
+        } else if (tag !== "text" && tag !== "tspan") {
+          el.setAttribute("fill", "none");
+          fill = null;
+        }
+      }
+    }
+    if (isDrawable) {
+      if (strokeNone) {
+        el.setAttribute("stroke", "none");
+        stroke = null;
+      } else if (stroke != null || color != null || inheritedStroke != null) {
+        const resolved = stroke ?? color ?? inheritedStroke;
+        if (resolved) {
+          el.setAttribute("stroke", resolved);
+          stroke = resolved;
+        }
+      }
+    }
+    const nextColor = color ?? parentColor;
+    const nextFill = fillNone ? "none" : fill ?? inheritedFill;
+    const nextStroke = strokeNone ? "none" : stroke ?? inheritedStroke;
+    for (let i = 0; i < el.children.length; i++) walk(el.children[i], nextFill, nextStroke, nextColor);
+  }
+  const rootColor = getAttr(clone, "color") ?? (clone.getAttribute("color") || null);
+  const rootFill = getAttr(clone, "fill") ?? rootColor;
+  const rootStroke = getAttr(clone, "stroke") ?? rootColor;
+  const rootFillNone = hasExplicitNonePaint(clone, "fill");
+  const rootStrokeNone = hasExplicitNonePaint(clone, "stroke");
+  if (rootFillNone) clone.setAttribute("fill", "none");
+  else if (rootFill) clone.setAttribute("fill", rootFill);
+  if (rootStrokeNone) clone.setAttribute("stroke", "none");
+  else if (rootStroke) clone.setAttribute("stroke", rootStroke);
+  for (let i = 0; i < clone.children.length; i++) {
+    walk(clone.children[i], rootFillNone ? "none" : rootFill ?? null, rootStrokeNone ? "none" : rootStroke ?? null, rootColor);
+  }
+  return clone;
+}
+function bakeGroupOpacityIntoChildren(svg) {
+  const DRAWABLE = /* @__PURE__ */ new Set(["path", "rect", "circle", "ellipse", "polygon", "polyline", "line", "text", "tspan"]);
+  function walkAndBake(el, inheritedOpacity) {
+    var _a, _b, _c;
+    if (isInSvgDefinitionSubtree(el)) {
+      for (let i = 0; i < el.children.length; i++) walkAndBake(el.children[i], 1);
+      return;
+    }
+    const tag = ((_a = el.tagName) == null ? void 0 : _a.toLowerCase()) ?? "";
+    const opacityAttr = parseSvgOpacity(el.getAttribute("opacity"));
+    const styleOpacity = parseSvgOpacity(((_b = el.style) == null ? void 0 : _b.getPropertyValue("opacity")) || null);
+    const ownOpacity = opacityAttr ?? styleOpacity ?? 1;
+    const combinedOpacity = inheritedOpacity * ownOpacity;
+    if (ownOpacity < 0.999) {
+      el.removeAttribute("opacity");
+      if ((_c = el.style) == null ? void 0 : _c.opacity) el.style.removeProperty("opacity");
+    }
+    if (DRAWABLE.has(tag) && combinedOpacity < 0.999) {
+      multiplySvgOpacityAttr(el, "fill-opacity", combinedOpacity);
+      multiplySvgOpacityAttr(el, "stroke-opacity", combinedOpacity);
+    }
+    if (tag === "stop" && ownOpacity < 0.999) {
+      multiplySvgOpacityAttr(el, "stop-opacity", ownOpacity);
+    }
+    for (let i = 0; i < el.children.length; i++) walkAndBake(el.children[i], combinedOpacity);
+  }
+  walkAndBake(svg, 1);
+}
+function hasInvalidSvgNumericToken(value) {
+  return typeof value === "string" && /\b(?:NaN|-?Infinity)\b/.test(value);
+}
+function sanitizeSvgNumericTokens(value) {
+  return value.replace(/\bNaN\b/g, "0").replace(/\b-?Infinity\b/g, "0");
+}
+function sanitizeSvgTreeForPdf(svg) {
+  const attrsToSanitize = [
+    "d",
+    "points",
+    "transform",
+    "gradientTransform",
+    "patternTransform",
+    "viewBox",
+    "x",
+    "y",
+    "x1",
+    "y1",
+    "x2",
+    "y2",
+    "cx",
+    "cy",
+    "r",
+    "rx",
+    "ry",
+    "width",
+    "height",
+    "dx",
+    "dy",
+    "opacity",
+    "fill-opacity",
+    "stroke-opacity",
+    "stroke-width",
+    "stroke-dashoffset",
+    "font-size",
+    "letter-spacing",
+    "word-spacing"
+  ];
+  const nodes = [svg, ...Array.from(svg.querySelectorAll("*"))];
+  for (const node of nodes) {
+    for (const attr of attrsToSanitize) {
+      const value = node.getAttribute(attr);
+      if (!hasInvalidSvgNumericToken(value)) continue;
+      node.setAttribute(attr, sanitizeSvgNumericTokens(value));
+    }
+  }
+}
+function normalizeSvgGradientStopOffsets(svg) {
+  for (const stop of svg.querySelectorAll("linearGradient stop, radialGradient stop")) {
+    const offset = stop.getAttribute("offset");
+    if (!offset) continue;
+    const trimmed = offset.trim();
+    if (trimmed.endsWith("%")) {
+      const num = parseFloat(trimmed.slice(0, -1)) / 100;
+      if (Number.isFinite(num)) stop.setAttribute("offset", String(Math.max(0, Math.min(1, num))));
+    }
+  }
+}
+function copyGradientAttrsFromRef(gradient, ref) {
+  var _a;
+  const tag = (_a = gradient.tagName) == null ? void 0 : _a.toLowerCase();
+  const attrs = tag === "radialgradient" ? GRADIENT_ATTRS_RADIAL : GRADIENT_ATTRS_LINEAR;
+  for (const name of attrs) {
+    if (!gradient.hasAttribute(name) && ref.hasAttribute(name)) {
+      gradient.setAttribute(name, ref.getAttribute(name));
+    }
+  }
+}
+function expandSvgGradientHrefs(svg) {
+  const visited = /* @__PURE__ */ new Set();
+  function expand(gradient) {
+    const id = gradient.getAttribute("id");
+    if (!id || visited.has(id)) return;
+    visited.add(id);
+    if (gradient.querySelectorAll("stop").length > 0) return;
+    const href = (gradient.getAttribute("href") || gradient.getAttribute("xlink:href") || "").trim();
+    if (!href.startsWith("#")) return;
+    const ref = findGradientInTree(svg, href.slice(1));
+    if (!ref) return;
+    expand(ref);
+    copyGradientAttrsFromRef(gradient, ref);
+    for (const stop of ref.querySelectorAll("stop")) gradient.appendChild(stop.cloneNode(true));
+    gradient.removeAttribute("href");
+    gradient.removeAttribute("xlink:href");
+  }
+  for (const g of svg.querySelectorAll("linearGradient, radialGradient")) expand(g);
+}
+function expandSvgUseElements(svg) {
+  var _a;
+  const doc = svg.ownerDocument;
+  for (const use of Array.from(svg.querySelectorAll("use"))) {
+    const ref = (use.getAttribute("href") || use.getAttribute("xlink:href") || "").trim();
+    if (!ref.startsWith("#")) continue;
+    const target = doc.getElementById(ref.slice(1));
+    if (!target) continue;
+    const x = parseFloat(use.getAttribute("x") || "0") || 0;
+    const y = parseFloat(use.getAttribute("y") || "0") || 0;
+    const w = parseFloat(use.getAttribute("width") || "0") || 0;
+    const h = parseFloat(use.getAttribute("height") || "0") || 0;
+    const g = doc.createElementNS("http://www.w3.org/2000/svg", "g");
+    if (((_a = target.tagName) == null ? void 0 : _a.toLowerCase()) === "symbol") {
+      const viewBox = target.getAttribute("viewBox");
+      for (let i = 0; i < target.children.length; i++) g.appendChild(target.children[i].cloneNode(true));
+      if (viewBox && w && h) {
+        const parts = viewBox.split(/\s+/).map(Number);
+        const vbW = parts[2];
+        const vbH = parts[3];
+        if (vbW && vbH) g.setAttribute("transform", `translate(${x},${y}) scale(${w / vbW},${h / vbH})`);
+        else g.setAttribute("transform", `translate(${x},${y})`);
+      } else if (x || y) g.setAttribute("transform", `translate(${x},${y})`);
+    } else {
+      const clone = target.cloneNode(true);
+      if (x || y) g.setAttribute("transform", `translate(${x},${y})`);
+      g.appendChild(clone);
+    }
+    if (use.parentNode) use.parentNode.replaceChild(g, use);
+  }
+}
+function normalizeSvgViewBoxOrigin(svg) {
+  const viewBox = svg.getAttribute("viewBox");
+  if (!viewBox) return;
+  const parts = viewBox.split(/[\s,]+/).map(Number.parseFloat).filter(Number.isFinite);
+  if (parts.length !== 4) return;
+  const [vx, vy, vw, vh] = parts;
+  if (vw <= 0 || vh <= 0) return;
+  if (Math.abs(vx) < 1e-3 && Math.abs(vy) < 1e-3) return;
+  const doc = svg.ownerDocument;
+  if (!doc) return;
+  const keepAtRoot = /* @__PURE__ */ new Set(["defs", "style", "title", "desc", "metadata"]);
+  const translatableChildren = Array.from(svg.children).filter((c) => !keepAtRoot.has(c.tagName.toLowerCase()));
+  if (translatableChildren.length === 0) {
+    svg.setAttribute("viewBox", `0 0 ${vw} ${vh}`);
+    return;
+  }
+  const wrapper = doc.createElementNS("http://www.w3.org/2000/svg", "g");
+  wrapper.setAttribute("transform", `translate(${-vx} ${-vy})`);
+  for (const child of translatableChildren) wrapper.appendChild(child);
+  svg.appendChild(wrapper);
+  svg.setAttribute("viewBox", `0 0 ${vw} ${vh}`);
+}
+function stripRootPageBackgroundFromSvg(svg) {
+  for (const child of Array.from(svg.children)) {
+    const tag = child.tagName.toLowerCase();
+    if (tag !== "rect" && tag !== "path") continue;
+    const x = Number.parseFloat(child.getAttribute("x") || "0");
+    const y = Number.parseFloat(child.getAttribute("y") || "0");
+    const width = Number.parseFloat(child.getAttribute("width") || "0");
+    const height = Number.parseFloat(child.getAttribute("height") || "0");
+    const fill = child.getAttribute("fill") || getInlineStyleValue(child, "fill");
+    const stroke = child.getAttribute("stroke") || getInlineStyleValue(child, "stroke");
+    const opacity = parseSvgOpacity(child.getAttribute("opacity")) ?? 1;
+    const isFullPageRect = tag === "rect" && Math.abs(x) < 0.01 && Math.abs(y) < 0.01 && Math.abs(width - Number.parseFloat(svg.getAttribute("width") || "0")) < 0.5 && Math.abs(height - Number.parseFloat(svg.getAttribute("height") || "0")) < 0.5;
+    const isVisiblePaint = opacity > 1e-4 && !isTransparentColorToken(fill) && (!stroke || isTransparentColorToken(stroke));
+    if (isFullPageRect && isVisiblePaint) {
+      child.remove();
+      return;
+    }
+  }
+}
+function stripSuspiciousFullPageOverlayNodes(svg) {
+  const pageWidth = Number.parseFloat(svg.getAttribute("width") || "0");
+  const pageHeight = Number.parseFloat(svg.getAttribute("height") || "0");
+  if (!(pageWidth > 0 && pageHeight > 0)) return;
+  const isNear = (a, b, tolerance = 0.75) => Math.abs(a - b) <= tolerance;
+  const isDarkPaint = (value) => {
+    const rgb = value ? parseColor(value) : null;
+    return rgb ? rgb.r <= 32 && rgb.g <= 32 && rgb.b <= 32 : false;
+  };
+  const removeIfSuspicious = (el) => {
+    const opacity = parseSvgOpacity(el.getAttribute("opacity")) ?? parseSvgOpacity(getInlineStyleValue(el, "opacity")) ?? 1;
+    if (opacity <= 1e-3) return;
+    const fill = el.getAttribute("fill") || getInlineStyleValue(el, "fill");
+    const stroke = el.getAttribute("stroke") || getInlineStyleValue(el, "stroke");
+    if (!isDarkPaint(fill) && !isDarkPaint(stroke)) return;
+    const w = Number.parseFloat(el.getAttribute("width") || "0");
+    const h = Number.parseFloat(el.getAttribute("height") || "0");
+    const x = Number.parseFloat(el.getAttribute("x") || "0");
+    const y = Number.parseFloat(el.getAttribute("y") || "0");
+    const isRectLike = el.tagName.toLowerCase() === "rect" && isNear(x, 0) && isNear(y, 0) && isNear(w, pageWidth, 1.5) && isNear(h, pageHeight, 1.5);
+    if (isRectLike) el.remove();
+  };
+  for (const child of Array.from(svg.children)) {
+    const tag = child.tagName.toLowerCase();
+    if (["defs", "style", "title", "desc", "metadata"].includes(tag)) continue;
+    if (tag === "g") {
+      for (const gc of Array.from(child.children)) removeIfSuspicious(gc);
+    }
+    removeIfSuspicious(child);
+  }
+}
+function decodeSvgDataUri(href) {
+  if (!href.startsWith("data:image/svg+xml")) return null;
+  const commaIdx = href.indexOf(",");
+  if (commaIdx < 0) return null;
+  const meta = href.slice(0, commaIdx).toLowerCase();
+  const payload = href.slice(commaIdx + 1);
+  try {
+    if (meta.includes(";base64")) {
+      const binary = atob(payload);
+      const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+      return new TextDecoder("utf-8").decode(bytes);
+    }
+    return decodeURIComponent(payload);
+  } catch {
+    try {
+      return atob(payload);
+    } catch {
+      return null;
+    }
+  }
+}
+function inlineNestedSvgImageDataUris(svgString, domParser = new DOMParser()) {
+  var _a;
+  try {
+    const doc = domParser.parseFromString(svgString, "image/svg+xml");
+    if (doc.querySelector("parsererror")) return svgString;
+    const root = doc.documentElement;
+    if (!root || root.tagName.toLowerCase() !== "svg") return svgString;
+    let changed = false;
+    for (const img of Array.from(doc.querySelectorAll("image"))) {
+      const href = img.getAttribute("href") || img.getAttributeNS("http://www.w3.org/1999/xlink", "href");
+      if (!href || !href.startsWith("data:image/svg+xml")) continue;
+      try {
+        const svgContent = decodeSvgDataUri(href);
+        if (!svgContent || !/<svg[\s>]/i.test(svgContent)) continue;
+        const innerDoc = domParser.parseFromString(svgContent, "image/svg+xml");
+        if (innerDoc.querySelector("parsererror")) continue;
+        const innerSvg = innerDoc.documentElement;
+        if (!innerSvg || innerSvg.tagName.toLowerCase() !== "svg") continue;
+        const ix = parseFloat(img.getAttribute("x") || "0") || 0;
+        const iy = parseFloat(img.getAttribute("y") || "0") || 0;
+        const iw = parseFloat(img.getAttribute("width") || "0");
+        const ih = parseFloat(img.getAttribute("height") || "0");
+        if (!(iw > 0 && ih > 0)) continue;
+        const nestedSvg = doc.importNode(innerSvg, true);
+        if (!nestedSvg.getAttribute("viewBox")) nestedSvg.setAttribute("viewBox", `0 0 ${iw} ${ih}`);
+        nestedSvg.setAttribute("x", "0");
+        nestedSvg.setAttribute("y", "0");
+        nestedSvg.setAttribute("width", String(iw));
+        nestedSvg.setAttribute("height", String(ih));
+        nestedSvg.setAttribute("preserveAspectRatio", img.getAttribute("preserveAspectRatio") || nestedSvg.getAttribute("preserveAspectRatio") || "xMidYMid meet");
+        const g = doc.createElementNS("http://www.w3.org/2000/svg", "g");
+        const existingTransform = img.getAttribute("transform") || "";
+        g.setAttribute("transform", `${existingTransform}${existingTransform ? " " : ""}translate(${ix},${iy})`);
+        for (const attr of Array.from(img.attributes)) {
+          if (["id", "class", "style", "opacity", "display", "visibility", "clip-path", "mask", "filter", "pointer-events"].includes(attr.name)) {
+            g.setAttribute(attr.name, attr.value);
+          }
+        }
+        g.appendChild(nestedSvg);
+        (_a = img.parentNode) == null ? void 0 : _a.replaceChild(g, img);
+        changed = true;
+      } catch {
+      }
+    }
+    return changed ? new XMLSerializer().serializeToString(doc.documentElement) : svgString;
+  } catch {
+    return svgString;
+  }
+}
+function inlineComputedStyles(svg) {
+  if (typeof document === "undefined") return;
+  const wrap = document.createElement("div");
+  wrap.style.cssText = "position:fixed;left:-9999px;top:0;width:400px;height:400px;overflow:hidden;pointer-events:none";
+  const root = svg;
+  if (!root.hasAttribute("width")) root.setAttribute("width", "400");
+  if (!root.hasAttribute("height")) root.setAttribute("height", "400");
+  wrap.appendChild(root);
+  document.body.appendChild(wrap);
+  try {
+    let walk = function(el) {
+      var _a;
+      const tag = (_a = el.tagName) == null ? void 0 : _a.toLowerCase();
+      if (drawableTags.includes(tag)) {
+        const cs = window.getComputedStyle(el);
+        const fill = cs.fill;
+        const stroke = cs.stroke;
+        if (fill && fill !== "none" && fill !== "rgba(0, 0, 0, 0)") {
+          const parsed = parseColor(fill);
+          if (parsed) el.setAttribute("fill", rgbToHex(parsed.r, parsed.g, parsed.b));
+        } else if (fill === "rgba(0, 0, 0, 0)" || fill === "transparent") {
+          el.setAttribute("fill", "none");
+        }
+        if (stroke && stroke !== "none" && stroke !== "rgba(0, 0, 0, 0)") {
+          const parsed = parseColor(stroke);
+          if (parsed) el.setAttribute("stroke", rgbToHex(parsed.r, parsed.g, parsed.b));
+        }
+      }
+      for (let i = 0; i < el.children.length; i++) walk(el.children[i]);
+    };
+    const drawableTags = ["path", "rect", "circle", "ellipse", "polygon", "polyline", "line", "text", "tspan"];
+    walk(root);
+    root.remove();
+  } finally {
+    if (wrap.parentNode) document.body.removeChild(wrap);
+  }
+}
+function prefixSvgIds(svg, prefix) {
+  const safePrefix = String(prefix).replace(/[^a-zA-Z0-9-]/g, "_");
+  const idMap = /* @__PURE__ */ new Map();
+  svg.querySelectorAll("[id]").forEach((el) => {
+    const id = el.getAttribute("id");
+    if (id) idMap.set(id, `${safePrefix}_${id}`);
+  });
+  if (idMap.size === 0) return;
+  idMap.forEach((newId, oldId) => {
+    svg.querySelectorAll(`[id="${oldId}"]`).forEach((el) => el.setAttribute("id", newId));
+  });
+  const replaceUrlRefs = (value) => {
+    return value.replace(/url\(\s*(['"]?)([^)]+?)\1\s*\)/gi, (full, quoteRaw, refRaw) => {
+      const ref = String(refRaw || "").trim();
+      const hashIdx = ref.lastIndexOf("#");
+      if (hashIdx < 0 || hashIdx === ref.length - 1) return full;
+      const base = ref.slice(0, hashIdx + 1);
+      const oldId = ref.slice(hashIdx + 1).trim().replace(/[\s"')].*$/, "");
+      const mapped = idMap.get(oldId);
+      if (!mapped) return full;
+      const quote = String(quoteRaw || "");
+      return `url(${quote}${base}${mapped}${quote})`;
+    });
+  };
+  const replaceHrefRef = (value) => {
+    const trimmed = value.trim();
+    if (trimmed.startsWith("#")) {
+      const mapped = idMap.get(trimmed.slice(1));
+      return mapped ? `#${mapped}` : value;
+    }
+    return replaceUrlRefs(value);
+  };
+  const refAttrs = ["fill", "stroke", "clip-path", "mask", "filter", "href", "xlink:href", "marker-start", "marker-mid", "marker-end"];
+  svg.querySelectorAll("*").forEach((el) => {
+    refAttrs.forEach((attr) => {
+      const val = el.getAttribute(attr);
+      if (!val) return;
+      const next = attr === "href" || attr === "xlink:href" ? replaceHrefRef(val) : replaceUrlRefs(val);
+      if (next !== val) el.setAttribute(attr, next);
+    });
+    const style = el.getAttribute("style");
+    if (style) {
+      const nextStyle = replaceUrlRefs(style);
+      if (nextStyle !== style) el.setAttribute("style", nextStyle);
+    }
+  });
+  svg.querySelectorAll("style").forEach((styleNode) => {
+    const text = styleNode.textContent || "";
+    const next = replaceUrlRefs(text);
+    if (next !== text) styleNode.textContent = next;
+  });
+}
+function getFirstExplicitColorFromSvg(svg) {
+  let fill = null;
+  let stroke = null;
+  const isRealColor = (v) => {
+    if (!v || v === "none") return false;
+    const s = v.trim().toLowerCase();
+    return s !== "currentcolor" && s !== "inherit" && (s.startsWith("#") || s.startsWith("rgb"));
+  };
+  const resolveUrl = (v) => {
+    if (!v || v === "none") return null;
+    const gradientId = extractGradientIdFromPaint(v);
+    if (!gradientId) return null;
+    return getGradientStopColorAsHex(svg, gradientId);
+  };
+  function walk(el) {
+    var _a, _b;
+    if (fill && stroke) return;
+    const f = el.getAttribute("fill") ?? ((_a = el.style) == null ? void 0 : _a.getPropertyValue("fill"));
+    const s = el.getAttribute("stroke") ?? ((_b = el.style) == null ? void 0 : _b.getPropertyValue("stroke"));
+    if (!fill) {
+      if (isRealColor(f)) fill = f;
+      else if (f) {
+        const resolved = resolveUrl(f);
+        if (resolved) fill = resolved;
+      }
+    }
+    if (!stroke) {
+      if (isRealColor(s)) stroke = s;
+      else if (s) {
+        const resolved = resolveUrl(s);
+        if (resolved) stroke = resolved;
+      }
+    }
+    for (let i = 0; i < el.children.length; i++) walk(el.children[i]);
+  }
+  walk(svg);
+  return { fill, stroke };
+}
+function isNearWhite(hex) {
+  if (!/^#[0-9a-f]{6}$/i.test(hex)) return false;
+  const r = parseInt(hex.slice(1, 3), 16);
+  const g = parseInt(hex.slice(3, 5), 16);
+  const b = parseInt(hex.slice(5, 7), 16);
+  return r >= 250 && g >= 250 && b >= 250;
+}
+function getStopColorRaw(stop) {
+  var _a, _b;
+  return stop.getAttribute("stop-color") ?? ((_b = (_a = stop.style) == null ? void 0 : _a.getPropertyValue("stop-color")) == null ? void 0 : _b.trim()) ?? getInlineStyleValue(stop, "stop-color");
+}
+function getGradientStopColorAsHex(svgRoot, gradientId, visited = /* @__PURE__ */ new Set()) {
+  var _a;
+  if (visited.has(gradientId)) return null;
+  visited.add(gradientId);
+  const gradient = findGradientInTree(svgRoot, gradientId);
+  if (!gradient) return null;
+  const tag = (_a = gradient.tagName) == null ? void 0 : _a.toLowerCase();
+  if (tag !== "lineargradient" && tag !== "radialgradient") return null;
+  const stops = Array.from(gradient.querySelectorAll("stop"));
+  if (stops.length > 0) {
+    const first = getStopColorRaw(stops[0]);
+    const last = getStopColorRaw(stops[stops.length - 1]);
+    const firstHex = first ? cssColorToHex(first) : null;
+    const lastHex = last ? cssColorToHex(last) : null;
+    if (firstHex && !isNearWhite(firstHex)) return firstHex;
+    if (lastHex && !isNearWhite(lastHex)) return lastHex;
+    return firstHex ?? lastHex;
+  }
+  const href = (gradient.getAttribute("href") || gradient.getAttribute("xlink:href") || "").trim();
+  if (href.startsWith("#")) return getGradientStopColorAsHex(svgRoot, href.slice(1), visited);
+  return null;
+}
+function setPdfColorFromSvg(pdf, svg, _elementId) {
+  const { fill, stroke } = getFirstExplicitColorFromSvg(svg);
+  const setColor = (hex, setter) => {
+    if (!hex) return;
+    const c = parseColor(hex);
+    if (c) pdf[setter](c.r, c.g, c.b);
+  };
+  setColor(fill, "setFillColor");
+  setColor(stroke ?? fill, "setDrawColor");
+}
+function svg2pdfOpts(x, y, width, height) {
+  const sanitize = (value, fallback) => Number.isFinite(value) ? Number(value.toFixed(3)) : fallback;
+  const w = Math.max(1e-3, sanitize(width, 1));
+  const h = Math.max(1e-3, sanitize(height, 1));
+  return { x: sanitize(x, 0), y: sanitize(y, 0), width: w, height: h };
+}
+async function svg2pdfWithDomMount(svg, pdf, opts) {
+  const wrap = document.createElement("div");
+  wrap.style.cssText = "position:fixed;left:-9999px;top:0;width:0;height:0;overflow:hidden;pointer-events:none;opacity:0";
+  wrap.appendChild(svg);
+  document.body.appendChild(wrap);
+  try {
+    await svg2pdf_js.svg2pdf(svg, pdf, opts);
+  } finally {
+    svg.remove();
+    if (wrap.parentNode) document.body.removeChild(wrap);
+  }
+}
+function prepareLiveCanvasSvgForPdf(rawSvg, pageWidth, pageHeight, pageKey, options) {
+  try {
+    const parser = new DOMParser();
+    const processedSvg = inlineNestedSvgImageDataUris(rawSvg, parser);
+    const doc = parser.parseFromString(processedSvg, "image/svg+xml");
+    if (doc.querySelector("parsererror")) return null;
+    const svg = doc.documentElement;
+    if (!svg || svg.tagName.toLowerCase() !== "svg") return null;
+    svg.setAttribute("xmlns", "http://www.w3.org/2000/svg");
+    if (/xlink:href/i.test(processedSvg) && !svg.getAttribute("xmlns:xlink")) {
+      svg.setAttribute("xmlns:xlink", "http://www.w3.org/1999/xlink");
+    }
+    svg.setAttribute("width", String(pageWidth));
+    svg.setAttribute("height", String(pageHeight));
+    svg.setAttribute("viewBox", `0 0 ${pageWidth} ${pageHeight}`);
+    sanitizeSvgTreeForPdf(svg);
+    normalizeSvgViewBoxOrigin(svg);
+    expandSvgUseElements(svg);
+    const svgToDraw = normalizeSvgExplicitColors(svg);
+    inlineComputedStyles(svgToDraw);
+    sanitizeSvgTreeForPdf(svgToDraw);
+    normalizeSvgGradientStopOffsets(svgToDraw);
+    expandSvgGradientHrefs(svgToDraw);
+    prefixSvgIds(svgToDraw, pageKey);
+    bakeGroupOpacityIntoChildren(svgToDraw);
+    stripSuspiciousFullPageOverlayNodes(svgToDraw);
+    if (options == null ? void 0 : options.stripPageBackground) stripRootPageBackgroundFromSvg(svgToDraw);
+    sanitizeSvgTreeForPdf(svgToDraw);
+    return svgToDraw;
+  } catch {
+    return null;
+  }
+}
+function drawPageBackground(pdf, pageIndex, pageWidth, pageHeight, backgroundColor, backgroundGradient) {
+  var _a, _b;
+  if (backgroundGradient && ((_a = backgroundGradient.stops) == null ? void 0 : _a.length) >= 2) {
+    const grad = backgroundGradient;
+    const colorStops = grad.stops.map((s) => {
+      const c = parseColor(s.color);
+      return {
+        offset: Math.max(0, Math.min(1, Number(s.offset))),
+        color: c ? [c.r, c.g, c.b] : [0, 0, 0]
+      };
+    }).filter((s) => Number.isFinite(s.offset)).sort((a, b) => a.offset - b.offset);
+    const normalizedStops = [...colorStops];
+    if (normalizedStops.length > 0) {
+      if (normalizedStops[0].offset > 0) normalizedStops.unshift({ offset: 0, color: normalizedStops[0].color });
+      if (normalizedStops[normalizedStops.length - 1].offset < 1) normalizedStops.push({ offset: 1, color: normalizedStops[normalizedStops.length - 1].color });
+    }
+    const shadingColors = normalizedStops.map((s) => ({ offset: s.offset, color: s.color }));
+    const patternKey = `bg-grad-${pageIndex}`;
+    try {
+      pdf.advancedAPI((doc) => {
+        const isLinear = grad.type === "linear";
+        const isConic = grad.type === "conic";
+        if (isLinear || isConic) {
+          const angleDeg = grad.angle ?? (isConic ? 0 : 90);
+          const angleRad = angleDeg * Math.PI / 180;
+          const sinA = Math.sin(angleRad);
+          const cosA = Math.cos(angleRad);
+          const corners = [[0, 0], [pageWidth, 0], [pageWidth, pageHeight], [0, pageHeight]];
+          const projs = corners.map(([x, y]) => x * sinA - y * cosA);
+          const minP = Math.min(...projs);
+          const maxP = Math.max(...projs);
+          const halfLen = (maxP - minP) / 2;
+          const midX = pageWidth / 2;
+          const midY = pageHeight / 2;
+          let finalStops = shadingColors;
+          if (isConic && shadingColors.length >= 2) {
+            const reversed = [...shadingColors].reverse().map((s) => ({ offset: 0.5 + (1 - s.offset) * 0.5, color: s.color }));
+            const firstHalf = shadingColors.map((s) => ({ offset: s.offset * 0.5, color: s.color }));
+            finalStops = [...firstHalf, ...reversed.slice(1)];
+          }
+          doc.addShadingPattern(patternKey, new jspdf.ShadingPattern("axial", [
+            midX - sinA * halfLen,
+            midY + cosA * halfLen,
+            midX + sinA * halfLen,
+            midY - cosA * halfLen
+          ], finalStops));
+        } else {
+          const cx = (grad.cx ?? 0.5) * pageWidth;
+          const cy = (grad.cy ?? 0.5) * pageHeight;
+          const maxR = (grad.r ?? 0.5) * Math.max(pageWidth, pageHeight);
+          doc.addShadingPattern(patternKey, new jspdf.ShadingPattern("radial", [cx, cy, 0, cx, cy, maxR], shadingColors));
+        }
+        doc.rect(0, 0, pageWidth, pageHeight);
+        doc.fill({ key: patternKey, matrix: doc.Matrix(1, 0, 0, 1, 0, 0) });
+      });
+    } catch {
+      const fallback = ((_b = colorStops[0]) == null ? void 0 : _b.color) || [255, 255, 255];
+      pdf.setFillColor(fallback[0], fallback[1], fallback[2]);
+      pdf.rect(0, 0, pageWidth, pageHeight, "F");
+    }
+  } else {
+    const bgColor = parseColor(backgroundColor && backgroundColor !== "transparent" ? backgroundColor : "#ffffff");
+    if (bgColor) {
+      pdf.setFillColor(bgColor.r, bgColor.g, bgColor.b);
+      pdf.rect(0, 0, pageWidth, pageHeight, "F");
+    }
+  }
+}
+async function assemblePdfFromSvgs(svgResults, options = {}) {
+  var _a, _b;
+  if (svgResults.length === 0) throw new Error("No pages to export");
+  const { title, stripPageBackground } = options;
+  const firstPage = svgResults[0];
+  const orientation = firstPage.width > firstPage.height ? "landscape" : "portrait";
+  const pdf = new jspdf.jsPDF({
+    orientation,
+    unit: "px",
+    format: [firstPage.width, firstPage.height],
+    hotfixes: ["px_scaling"],
+    compress: true
+  });
+  if (title) pdf.setProperties({ title, creator: "Pixldocs" });
+  for (let i = 0; i < svgResults.length; i++) {
+    const page = svgResults[i];
+    if (i > 0) {
+      const pageOrientation = page.width > page.height ? "landscape" : "portrait";
+      pdf.addPage([page.width, page.height], pageOrientation);
+    }
+    const hasGradient = !!((_b = (_a = page.backgroundGradient) == null ? void 0 : _a.stops) == null ? void 0 : _b.length);
+    drawPageBackground(pdf, i, page.width, page.height, page.backgroundColor, page.backgroundGradient);
+    const shouldStripBg = stripPageBackground ?? hasGradient;
+    const svgToDraw = prepareLiveCanvasSvgForPdf(page.svg, page.width, page.height, `page-${i + 1}`, {
+      stripPageBackground: shouldStripBg
+    });
+    if (svgToDraw) {
+      pdf.setFillColor(0, 0, 0);
+      pdf.setDrawColor(0, 0, 0);
+      pdf.saveGraphicsState();
+      setPdfColorFromSvg(pdf, svgToDraw);
+      await svg2pdfWithDomMount(svgToDraw, pdf, svg2pdfOpts(0, 0, page.width, page.height));
+      pdf.restoreGraphicsState();
+      pdf.setFillColor(0, 0, 0);
+      pdf.setDrawColor(0, 0, 0);
+    }
+  }
+  const arrayBuffer = pdf.output("arraybuffer");
+  const blob = new Blob([arrayBuffer], { type: "application/pdf" });
+  return {
+    blob,
+    arrayBuffer,
+    totalPages: svgResults.length,
+    pages: svgResults.map((p) => ({ width: p.width, height: p.height }))
+  };
+}
+const pdfExport = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  assemblePdfFromSvgs
+}, Symbol.toStringTag, { value: "Module" }));
 function collectImageUrls(config) {
   const urls = [];
   const walk = (nodes) => {
@@ -11299,6 +12361,7 @@ async function warmTemplateFromForm(options) {
 exports.PixldocsPreview = PixldocsPreview;
 exports.PixldocsRenderer = PixldocsRenderer;
 exports.applyThemeToConfig = applyThemeToConfig;
+exports.assemblePdfFromSvgs = assemblePdfFromSvgs;
 exports.collectFontDescriptorsFromConfig = collectFontDescriptorsFromConfig;
 exports.collectFontsFromConfig = collectFontsFromConfig;
 exports.collectImageUrls = collectImageUrls;