@pixldocs/canvas-renderer 0.5.117 → 0.5.119

package/dist/vectorPdfExport-BrHHt_7L.js

@@ -0,0 +1,4749 @@
+import { jsPDF, ShadingPattern } from "jspdf";
+import { svg2pdf } from "svg2pdf.js";
+import * as fabric from "fabric";
+import { g as getCanvasForPage, f as findNodeById, a as getAbsoluteBounds, n as normalizeShapeType, r as renderSmartElementToSvg, h as hasEdgeFade, b as getProxiedImageUrl, c as bakeEdgeFade, i as isElement, d as isGroup, e as buildRoundedTrianglePath, A as API_URL, j as getImageProxyFetchOptions, k as getRoundedRectRadii, T as TRIANGLE_STROKE_MITER_LIMIT, l as getTrianglePoints } from "./index-CuTWdeXZ.js";
+import { F as FONT_FALLBACK_SYMBOLS, a as FONT_FALLBACK_MATH, b as FONT_FALLBACK_DEVANAGARI, e as embedFontWithGoogleFallback, i as isFontAvailable, c as isFamilyEmbedded, r as resolveBestRegisteredVariant, g as getEmbeddedJsPDFFontName, d as resolveFontWeight, f as doesVariantSupportChar } from "./pdfFonts-CB5z77qO.js";
+async function bakeEdgeFadeIntoDataUrl(dataUrl, element) {
+  const fade = element;
+  if (!hasEdgeFade(fade)) return null;
+  if (!dataUrl || typeof dataUrl !== "string") return null;
+  return await new Promise((resolve) => {
+    try {
+      const img = new Image();
+      img.crossOrigin = "anonymous";
+      img.onload = () => {
+        try {
+          const c = bakeEdgeFade(img, fade);
+          resolve(c.toDataURL("image/png"));
+        } catch {
+          resolve(null);
+        }
+      };
+      img.onerror = () => resolve(null);
+      img.src = dataUrl;
+    } catch {
+      resolve(null);
+    }
+  });
+}
+function elementHasFade(element) {
+  return hasEdgeFade(element);
+}
+const yieldToUI = () => new Promise((resolve) => {
+  requestAnimationFrame(() => setTimeout(resolve, 0));
+});
+const SHADOW_RASTER_ALPHA_COMPENSATION = 0.84;
+let debugSvgDrawSequence = 0;
+function debugLog(...args) {
+}
+function pdfWithColorLogging(pdf, seq, elementId) {
+  return pdf;
+}
+const FONT_KEY_SEP = "";
+function isBasicLatinOrLatin1(char) {
+  const c = char.codePointAt(0) ?? 0;
+  return c >= 32 && c <= 126 || c >= 160 && c <= 255;
+}
+function isCommonLatinPunctuation(char) {
+  const c = char.codePointAt(0) ?? 0;
+  if (c >= 8208 && c <= 8265) return true;
+  if (c === 8467 || c === 8482) return true;
+  return false;
+}
+function isMathOperator(char) {
+  const c = char.codePointAt(0) ?? 0;
+  if (c >= 8592 && c <= 8703) return true;
+  if (c >= 8704 && c <= 8959) return true;
+  if (c >= 8960 && c <= 9215) return true;
+  if (c >= 10176 && c <= 10223) return true;
+  if (c >= 10624 && c <= 10751) return true;
+  if (c >= 10752 && c <= 11007) return true;
+  if (c >= 11008 && c <= 11097) return true;
+  return false;
+}
+function isDevanagari(char) {
+  const c = char.codePointAt(0) ?? 0;
+  return c >= 2304 && c <= 2431 || c >= 43232 && c <= 43263 || c >= 7376 && c <= 7423;
+}
+function classifyChar(char, mainSupportsChar) {
+  if (isBasicLatinOrLatin1(char)) return "main";
+  if (isCommonLatinPunctuation(char)) return "main";
+  if (!isDevanagari(char) && (mainSupportsChar == null ? void 0 : mainSupportsChar(char))) return "main";
+  if (isDevanagari(char)) return "devanagari";
+  if (isMathOperator(char)) return "math";
+  return "symbol";
+}
+function isPureLatin(line) {
+  for (let i = 0; i < line.length; i++) {
+    const c = line.charCodeAt(i);
+    if (!(c >= 32 && c <= 126 || c >= 160 && c <= 255 || c >= 8208 && c <= 8265 || c === 8467 || c === 8482)) return false;
+  }
+  return true;
+}
+function splitLineIntoRuns(line, mainSupportsChar) {
+  if (!line) return [];
+  const runs = [];
+  const chars = [...line];
+  let current = "";
+  let currentType = "main";
+  for (const char of chars) {
+    const charType = classifyChar(char, mainSupportsChar);
+    if (current && charType !== currentType) {
+      runs.push({ text: current, runType: currentType });
+      current = "";
+    }
+    currentType = charType;
+    current += char;
+  }
+  if (current) runs.push({ text: current, runType: currentType });
+  return runs;
+}
+function loadNaturalDimensionsFromUrl(imageUrl) {
+  return new Promise((resolve) => {
+    if (!imageUrl) {
+      resolve(null);
+      return;
+    }
+    const img = new Image();
+    img.crossOrigin = imageUrl.startsWith("data:") || imageUrl.startsWith("blob:") ? void 0 : "anonymous";
+    img.onload = () => {
+      const w = img.naturalWidth || 0;
+      const h = img.naturalHeight || 0;
+      resolve(w > 0 && h > 0 ? { width: w, height: h } : null);
+    };
+    img.onerror = () => resolve(null);
+    try {
+      img.src = imageUrl.startsWith("data:") || imageUrl.startsWith("blob:") ? imageUrl : getProxiedImageUrl(imageUrl);
+    } catch {
+      resolve(null);
+    }
+  });
+}
+async function rasterizeStoredCropImageToPng(options) {
+  const {
+    imageUrl,
+    frameW,
+    frameH,
+    clipShape,
+    borderRadius = 0,
+    panX = 0.5,
+    panY = 0.5,
+    zoom = 1,
+    naturalWidth,
+    naturalHeight,
+    maintainResolution = true,
+    backgroundColor
+  } = options;
+  if (!imageUrl || frameW <= 0 || frameH <= 0) return null;
+  const img = await new Promise((resolve) => {
+    const el = new Image();
+    el.crossOrigin = imageUrl.startsWith("data:") || imageUrl.startsWith("blob:") ? void 0 : "anonymous";
+    el.onload = () => resolve(el);
+    el.onerror = () => resolve(null);
+    try {
+      el.src = imageUrl.startsWith("data:") || imageUrl.startsWith("blob:") ? imageUrl : getProxiedImageUrl(imageUrl);
+    } catch {
+      resolve(null);
+    }
+  });
+  if (!img) return null;
+  const natW = Math.max(1, naturalWidth || img.naturalWidth || frameW);
+  const natH = Math.max(1, naturalHeight || img.naturalHeight || frameH);
+  const baseScale = Math.max(frameW / natW, frameH / natH);
+  const finalScale = Math.max(1, zoom) * baseScale;
+  const drawW = natW * finalScale;
+  const drawH = natH * finalScale;
+  const clampedPanX = Math.max(0, Math.min(1, panX));
+  const clampedPanY = Math.max(0, Math.min(1, panY));
+  const overflowX = Math.max(0, drawW - frameW);
+  const overflowY = Math.max(0, drawH - frameH);
+  const offsetX = overflowX > 0 ? -overflowX * (clampedPanX - 0.5) : 0;
+  const offsetY = overflowY > 0 ? -overflowY * (clampedPanY - 0.5) : 0;
+  const imgX = frameW / 2 + offsetX - drawW / 2;
+  const imgY = frameH / 2 + offsetY - drawH / 2;
+  const outW = maintainResolution && natW > frameW ? Math.max(1, Math.round(natW)) : Math.max(1, Math.round(frameW * 2));
+  const outH = maintainResolution && natH > frameH ? Math.max(1, Math.round(natH)) : Math.max(1, Math.round(frameH * 2));
+  const canvas = document.createElement("canvas");
+  canvas.width = outW;
+  canvas.height = outH;
+  const ctx = canvas.getContext("2d");
+  if (!ctx) return null;
+  const bgFill = backgroundColor && backgroundColor !== "transparent" && backgroundColor !== "none" ? normalizeBgColor(backgroundColor) : void 0;
+  if (bgFill) {
+    ctx.fillStyle = bgFill;
+    ctx.fillRect(0, 0, outW, outH);
+  } else {
+    ctx.clearRect(0, 0, outW, outH);
+  }
+  const sx = outW / frameW;
+  const sy = outH / frameH;
+  ctx.save();
+  ctx.scale(sx, sy);
+  ctx.beginPath();
+  if (clipShape === "circle") {
+    ctx.ellipse(frameW / 2, frameH / 2, frameW / 2, frameH / 2, 0, 0, 2 * Math.PI);
+  } else {
+    const isRounded = clipShape === "rounded" || clipShape === "roundRect" || (borderRadius ?? 0) > 0;
+    const r = isRounded ? Math.max(0, Math.min(borderRadius, frameW / 2, frameH / 2)) : 0;
+    if (r > 0) {
+      ctx.moveTo(r, 0);
+      ctx.lineTo(frameW - r, 0);
+      ctx.quadraticCurveTo(frameW, 0, frameW, r);
+      ctx.lineTo(frameW, frameH - r);
+      ctx.quadraticCurveTo(frameW, frameH, frameW - r, frameH);
+      ctx.lineTo(r, frameH);
+      ctx.quadraticCurveTo(0, frameH, 0, frameH - r);
+      ctx.lineTo(0, r);
+      ctx.quadraticCurveTo(0, 0, r, 0);
+      ctx.closePath();
+    } else {
+      ctx.rect(0, 0, frameW, frameH);
+    }
+  }
+  ctx.clip();
+  ctx.drawImage(img, imgX, imgY, drawW, drawH);
+  ctx.restore();
+  return canvas.toDataURL("image/png");
+}
+function svg2pdfOpts(x, y, width, height) {
+  const sanitize = (value, fallback) => {
+    if (!Number.isFinite(value)) return fallback;
+    return Number(value.toFixed(3));
+  };
+  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
+  };
+}
+function getAxisAlignedSvgFrameFromMatrix(matrix, localX, localY, width, height) {
+  const [a, b, c, d, e, f] = matrix;
+  const EPS = 1e-5;
+  if (Math.abs(b) > EPS || Math.abs(c) > EPS) return null;
+  if (a < -EPS || d < -EPS) return null;
+  const x1 = a * localX + e;
+  const x2 = a * (localX + width) + e;
+  const y1 = d * localY + f;
+  const y2 = d * (localY + height) + f;
+  const left = Math.min(x1, x2);
+  const top = Math.min(y1, y2);
+  const frameW = Math.max(0, Math.abs(x2 - x1));
+  const frameH = Math.max(0, Math.abs(y2 - y1));
+  if (!Number.isFinite(left) || !Number.isFinite(top) || !Number.isFinite(frameW) || !Number.isFinite(frameH)) {
+    return null;
+  }
+  if (frameW < EPS || frameH < EPS) return null;
+  return { x: left, y: top, width: frameW, height: frameH };
+}
+function transformPointWithMatrix(matrix, x, y) {
+  const [a, b, c, d, e, f] = matrix;
+  return {
+    x: a * x + c * y + e,
+    y: b * x + d * y + f
+  };
+}
+function buildMatrixTransformedSvgForPage(svg, matrix, localX, localY, width, height) {
+  const EPS = 1e-5;
+  const corners = [
+    transformPointWithMatrix(matrix, localX, localY),
+    transformPointWithMatrix(matrix, localX + width, localY),
+    transformPointWithMatrix(matrix, localX, localY + height),
+    transformPointWithMatrix(matrix, localX + width, localY + height)
+  ];
+  const minX = Math.min(...corners.map((p) => p.x));
+  const minY = Math.min(...corners.map((p) => p.y));
+  const maxX = Math.max(...corners.map((p) => p.x));
+  const maxY = Math.max(...corners.map((p) => p.y));
+  const frameW = maxX - minX;
+  const frameH = maxY - minY;
+  if (!Number.isFinite(minX) || !Number.isFinite(minY) || !Number.isFinite(frameW) || !Number.isFinite(frameH)) {
+    return null;
+  }
+  if (frameW < EPS || frameH < EPS) return null;
+  const ns = "http://www.w3.org/2000/svg";
+  const wrapper = document.createElementNS(ns, "svg");
+  wrapper.setAttribute("xmlns", ns);
+  wrapper.setAttribute("width", String(frameW));
+  wrapper.setAttribute("height", String(frameH));
+  wrapper.setAttribute("viewBox", `0 0 ${frameW} ${frameH}`);
+  const g = document.createElementNS(ns, "g");
+  const [a, b, c, d, e, f] = matrix;
+  g.setAttribute("transform", `matrix(${a} ${b} ${c} ${d} ${e - minX} ${f - minY})`);
+  const nested = svg.cloneNode(true);
+  nested.setAttribute("x", String(localX));
+  nested.setAttribute("y", String(localY));
+  nested.setAttribute("width", String(width));
+  nested.setAttribute("height", String(height));
+  g.appendChild(nested);
+  wrapper.appendChild(g);
+  return {
+    svg: wrapper,
+    frame: { x: minX, y: minY, width: frameW, height: frameH }
+  };
+}
+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(svg, pdf, opts);
+  } finally {
+    svg.remove();
+    if (wrap.parentNode) document.body.removeChild(wrap);
+  }
+}
+function resetPdfColorState(pdf, label) {
+  pdf.setFillColor(0, 0, 0);
+  pdf.setDrawColor(0, 0, 0);
+  if (typeof pdf.setTextColor === "function") pdf.setTextColor(0, 0, 0);
+}
+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 setPdfColorFromSvg(pdf, svg, elementId) {
+  const { fill, stroke } = getFirstExplicitColorFromSvg(svg);
+  const rgbFill = fill ? parseColor(fill) : null;
+  const rgbStroke = stroke ? parseColor(stroke) : null;
+  if (rgbFill) pdf.setFillColor(rgbFill.r, rgbFill.g, rgbFill.b);
+  else pdf.setFillColor(0, 0, 0);
+  if (rgbStroke) pdf.setDrawColor(rgbStroke.r, rgbStroke.g, rgbStroke.b);
+  else pdf.setDrawColor(0, 0, 0);
+}
+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"
+]);
+function isInSvgDefinitionSubtree(el) {
+  var _a;
+  let current = el;
+  while (current) {
+    const tag = ((_a = current.tagName) == null ? void 0 : _a.toLowerCase()) ?? "";
+    if (SVG_DEFINITION_CONTAINER_TAGS.has(tag)) 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 logGradientBindingDiagnostics(svg) {
+  const gradientCount = svg.querySelectorAll("linearGradient, radialGradient").length;
+  if (gradientCount === 0) return;
+  let gradientRefCount = 0;
+  svg.querySelectorAll("*").forEach((el) => {
+    const fill = el.getAttribute("fill");
+    const stroke = el.getAttribute("stroke");
+    const style = el.getAttribute("style");
+    if (extractGradientIdFromPaint(fill) || extractGradientIdFromPaint(stroke)) {
+      gradientRefCount++;
+      return;
+    }
+    if (style) {
+      const declarations = parseInlineSvgStyleDeclarations(style);
+      if (declarations.some(({ value }) => !!extractGradientIdFromPaint(value))) {
+        gradientRefCount++;
+      }
+    }
+  });
+  if (gradientRefCount === 0) {
+    console.warn("[PDF export] SVG gradient diagnostics: defs exist but no gradient refs bound after style inlining. Export may render black.", {
+      gradientCount,
+      drawableCount: svg.querySelectorAll("path, rect, circle, ellipse, polygon, polyline, line").length
+    });
+  }
+}
+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"
+]);
+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) => {
+    const raw = el.getAttribute("class") || "";
+    raw.split(/\s+/).map((token) => token.trim()).filter(Boolean).forEach((token) => {
+      const list = classIndex.get(token) ?? [];
+      list.push(el);
+      classIndex.set(token, list);
+    });
+  });
+  const normalizePresentationValue = (key, value) => {
+    const cleaned = value.replace(/\s*!important\s*$/i, "").trim();
+    if (["fill", "stroke", "clip-path", "mask", "filter"].includes(key)) {
+      return normalizeGradientPaintRef(cleaned);
+    }
+    return cleaned;
+  };
+  const applyDeclarations = (elements, declarations) => {
+    for (const el of elements) {
+      const inlineStyle = el.getAttribute("style") || "";
+      const inlineDeclMap = new Map(
+        parseInlineSvgStyleDeclarations(inlineStyle).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((decl) => SVG_STYLE_PROPS.has(decl.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);
+  logGradientBindingDiagnostics(clone);
+  const parseColorAttr = (v) => {
+    if (!v) return null;
+    const s = v.trim().toLowerCase();
+    if (!s || s === "none" || s === "transparent" || s === "currentcolor") return null;
+    return normalizeGradientPaintRef(v);
+  };
+  const getRawAttr = (el, attr) => {
+    var _a;
+    return (el.getAttribute(attr) ?? ((_a = el.style) == null ? void 0 : _a.getPropertyValue(attr)) ?? "").trim().toLowerCase();
+  };
+  const getRawOpacityAttr = (el, attr) => {
+    var _a;
+    if (attr === "color") return "";
+    return (el.getAttribute(`${attr}-opacity`) ?? ((_a = el.style) == null ? void 0 : _a.getPropertyValue(`${attr}-opacity`)) ?? "").trim().toLowerCase();
+  };
+  const hasExplicitNonePaint = (el, attr) => {
+    const raw = getRawAttr(el, attr);
+    if (raw === "none" || raw === "transparent") return true;
+    const rawOpacity = getRawOpacityAttr(el, attr);
+    return rawOpacity === "0" || rawOpacity === "0%" || rawOpacity === "0.0";
+  };
+  const getAttr = (el, attr) => {
+    var _a;
+    const v = el.getAttribute(attr) ?? ((_a = el.style) == null ? void 0 : _a.getPropertyValue(attr));
+    return parseColorAttr(v);
+  };
+  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 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) {
+  const clamped = Math.max(0, Math.min(1, value));
+  return Number(clamped.toFixed(4)).toString();
+}
+function multiplySvgOpacityAttr(el, attr, factor) {
+  const existing = parseSvgOpacity(el.getAttribute(attr));
+  const next = (existing ?? 1) * factor;
+  el.setAttribute(attr, formatSvgOpacity(next));
+}
+function injectOpacityIntoSvg(svg, opacity) {
+  if (opacity >= 0.999) return;
+  const factor = Math.max(0, Math.min(1, opacity));
+  const drawable = svg.querySelectorAll("path, rect, circle, ellipse, polygon, polyline, line, text, tspan");
+  drawable.forEach((el) => {
+    multiplySvgOpacityAttr(el, "fill-opacity", factor);
+    multiplySvgOpacityAttr(el, "stroke-opacity", factor);
+  });
+  svg.querySelectorAll("stop").forEach((stop) => {
+    multiplySvgOpacityAttr(stop, "stop-opacity", factor);
+  });
+}
+function bakeGroupOpacityIntoChildren(svg) {
+  const DRAWABLE_TAGS = /* @__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_TAGS.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);
+}
+const URL_GRADIENT_RE = /^\s*url\s*\(\s*(['"]?)([^)]+?)\1\s*\)/i;
+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 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 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;
+    const images = Array.from(doc.querySelectorAll("image"));
+    for (const img of images) {
+      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);
+        const vb = nestedSvg.getAttribute("viewBox");
+        if (!vb) {
+          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") || "";
+        let transform = existingTransform;
+        transform += `${transform ? " " : ""}translate(${ix},${iy})`;
+        if (transform) {
+          g.setAttribute("transform", transform);
+        }
+        const passthroughAttrs = /* @__PURE__ */ new Set([
+          "id",
+          "class",
+          "style",
+          "opacity",
+          "display",
+          "visibility",
+          "clip-path",
+          "mask",
+          "filter",
+          "pointer-events"
+        ]);
+        Array.from(img.attributes).forEach((attr) => {
+          if (passthroughAttrs.has(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 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 stripRootPageBackgroundFromSvg(svg) {
+  const rootChildren = Array.from(svg.children);
+  for (const child of rootChildren) {
+    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 rootWidth = Number.parseFloat(svg.getAttribute("width") || "0");
+  const rootHeight = Number.parseFloat(svg.getAttribute("height") || "0");
+  const viewBox = (svg.getAttribute("viewBox") || "").trim().split(/[\s,]+/).map((n) => Number.parseFloat(n));
+  const pageWidth = Number.isFinite(rootWidth) && rootWidth > 0 ? rootWidth : viewBox[2] || 0;
+  const pageHeight = Number.isFinite(rootHeight) && rootHeight > 0 ? rootHeight : viewBox[3] || 0;
+  if (!(pageWidth > 0 && pageHeight > 0)) return;
+  const isNear = (a, b, tolerance = 0.75) => Math.abs(a - b) <= tolerance;
+  const hasVisibleStyleToken = (value, token) => {
+    if (!value) return false;
+    return new RegExp(`(?:^|;)\\s*${token}\\s*:\\s*([^;]+)`, "i").test(value);
+  };
+  const hasHiddenDisplay = (el) => {
+    const display = (el.getAttribute("display") || getInlineStyleValue(el, "display") || "").trim().toLowerCase();
+    const visibility = (el.getAttribute("visibility") || getInlineStyleValue(el, "visibility") || "").trim().toLowerCase();
+    return display === "none" || visibility === "hidden";
+  };
+  const getNodeOpacity = (el) => {
+    return parseSvgOpacity(el.getAttribute("opacity")) ?? parseSvgOpacity(getInlineStyleValue(el, "opacity")) ?? 1;
+  };
+  const isDarkPaint = (value) => {
+    const rgb = value ? parseColor(value) : null;
+    if (!rgb) return false;
+    return rgb.r <= 32 && rgb.g <= 32 && rgb.b <= 32;
+  };
+  const removeIfSuspicious = (el) => {
+    if (hasHiddenDisplay(el)) return;
+    const opacity = getNodeOpacity(el);
+    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 width = Number.parseFloat(el.getAttribute("width") || "0");
+    const height = 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(width, pageWidth, 1.5) && isNear(height, pageHeight, 1.5);
+    let isPathLike = false;
+    if (el.tagName.toLowerCase() === "path") {
+      const d = (el.getAttribute("d") || "").replace(/\s+/g, " ").trim();
+      isPathLike = !!d && (new RegExp(`^Ms*0(?:.0+)?s+0(?:.0+)?s*Hs*${Math.round(pageWidth)}(?:.0+)?s*Vs*${Math.round(pageHeight)}(?:.0+)?s*Hs*0(?:.0+)?s*Z?$`, "i").test(d) || new RegExp(`^Ms*0(?:.0+)?s+0(?:.0+)?s*Ls*${Math.round(pageWidth)}(?:.0+)?s+0(?:.0+)?s*Ls*${Math.round(pageWidth)}(?:.0+)?s+${Math.round(pageHeight)}(?:.0+)?s*Ls*0(?:.0+)?s+${Math.round(pageHeight)}(?:.0+)?s*Z?$`, "i").test(d));
+    }
+    const inlineStyle = el.getAttribute("style") || "";
+    const likelyOverlay = isRectLike || isPathLike || hasVisibleStyleToken(inlineStyle, "mix-blend-mode");
+    if (likelyOverlay) {
+      el.remove();
+    }
+  };
+  const candidates = [];
+  for (const child of Array.from(svg.children)) {
+    const tag = child.tagName.toLowerCase();
+    if (tag === "defs" || tag === "style" || tag === "title" || tag === "desc" || tag === "metadata") continue;
+    if (tag === "g") {
+      for (const grandchild of Array.from(child.children)) {
+        candidates.push(grandchild);
+      }
+    }
+    candidates.push(child);
+  }
+  for (const el of candidates) {
+    removeIfSuspicious(el);
+  }
+}
+async function convertTextDecorationsToLines(svg) {
+  const doc = svg.ownerDocument;
+  if (!doc) return;
+  const resolveInheritedSvgValue = (el, attr, styleProp = attr) => {
+    var _a, _b;
+    let current = el;
+    while (current) {
+      const attrValue = (_a = current.getAttribute(attr)) == null ? void 0 : _a.trim();
+      if (attrValue) return attrValue;
+      const styleValue = (_b = getInlineStyleValue(current, styleProp)) == null ? void 0 : _b.trim();
+      if (styleValue) return styleValue;
+      current = current.parentElement;
+    }
+    return null;
+  };
+  if (typeof document !== "undefined" && document.fonts) {
+    const fontFamilies = /* @__PURE__ */ new Set();
+    for (const textEl of svg.querySelectorAll("text")) {
+      const ff = textEl.getAttribute("data-source-font-family") || textEl.getAttribute("font-family");
+      if (ff) fontFamilies.add(ff.replace(/'/g, ""));
+      for (const tspan of textEl.querySelectorAll("tspan")) {
+        const tff = tspan.getAttribute("data-source-font-family") || tspan.getAttribute("font-family");
+        if (tff) fontFamilies.add(tff.replace(/'/g, ""));
+      }
+    }
+    const loadPromises = [];
+    for (const ff of fontFamilies) {
+      if (!document.fonts.check(`16px "${ff}"`)) {
+        loadPromises.push(
+          document.fonts.load(`16px "${ff}"`).then(() => {
+          }).catch(() => {
+          })
+        );
+        loadPromises.push(
+          document.fonts.load(`bold 16px "${ff}"`).then(() => {
+          }).catch(() => {
+          })
+        );
+      }
+    }
+    if (loadPromises.length > 0) {
+      await Promise.all(loadPromises);
+    }
+    await document.fonts.ready;
+  }
+  let tempContainer = null;
+  let liveSvg = null;
+  try {
+    if (typeof document !== "undefined") {
+      tempContainer = document.createElement("div");
+      tempContainer.style.cssText = "position:fixed;left:-9999px;top:-9999px;visibility:hidden;pointer-events:none;";
+      document.body.appendChild(tempContainer);
+      const clone = svg.cloneNode(true);
+      for (const textNode of clone.querySelectorAll("text, tspan, textPath")) {
+        const sourceFamily = textNode.getAttribute("data-source-font-family");
+        const sourceWeight = textNode.getAttribute("data-source-font-weight");
+        const sourceStyle = textNode.getAttribute("data-source-font-style");
+        if (sourceFamily) textNode.setAttribute("font-family", sourceFamily);
+        if (sourceWeight) textNode.setAttribute("font-weight", sourceWeight);
+        if (sourceStyle) textNode.setAttribute("font-style", sourceStyle);
+        const inlineStyle = textNode.getAttribute("style") || "";
+        const stylePairs = inlineStyle.split(";").map((part) => part.trim()).filter(Boolean).filter((part) => !/^font-family\s*:/i.test(part) && !/^font-weight\s*:/i.test(part) && !/^font-style\s*:/i.test(part));
+        if (sourceFamily) stylePairs.push(`font-family: ${sourceFamily}`);
+        if (sourceWeight) stylePairs.push(`font-weight: ${sourceWeight}`);
+        if (sourceStyle) stylePairs.push(`font-style: ${sourceStyle}`);
+        if (stylePairs.length > 0) textNode.setAttribute("style", stylePairs.join("; "));
+      }
+      tempContainer.appendChild(clone);
+      liveSvg = clone;
+    }
+  } catch {
+  }
+  let ctx = null;
+  try {
+    const realDoc = typeof document !== "undefined" ? document : doc;
+    const measureCanvas = realDoc.createElement("canvas");
+    ctx = measureCanvas.getContext("2d");
+  } catch {
+  }
+  const textEls = Array.from(svg.querySelectorAll("text"));
+  const liveTextEls = liveSvg ? Array.from(liveSvg.querySelectorAll("text")) : null;
+  for (let ti = 0; ti < textEls.length; ti++) {
+    const textEl = textEls[ti];
+    const liveTextEl = liveTextEls == null ? void 0 : liveTextEls[ti];
+    const tspans = Array.from(textEl.querySelectorAll("tspan"));
+    if (tspans.length === 0) continue;
+    const liveTspans = liveTextEl ? Array.from(liveTextEl.querySelectorAll("tspan")) : null;
+    const textDecOnText = (textEl.getAttribute("text-decoration") || "").toLowerCase();
+    const textStyleDec = (getInlineStyleValue(textEl, "text-decoration") || "").toLowerCase();
+    const textHasUnderline = textDecOnText.includes("underline") || textStyleDec.includes("underline");
+    const textHasLinethrough = textDecOnText.includes("line-through") || textStyleDec.includes("line-through");
+    for (let si = 0; si < tspans.length; si++) {
+      const tspan = tspans[si];
+      const liveTspan = liveTspans == null ? void 0 : liveTspans[si];
+      const tspanDec = (tspan.getAttribute("text-decoration") || "").toLowerCase();
+      const tspanStyleDec = (getInlineStyleValue(tspan, "text-decoration") || "").toLowerCase();
+      const hasUnderline = tspanDec.includes("underline") || tspanStyleDec.includes("underline") || textHasUnderline;
+      const hasLinethrough = tspanDec.includes("line-through") || tspanStyleDec.includes("line-through") || textHasLinethrough;
+      if (!hasUnderline && !hasLinethrough) continue;
+      const content = tspan.textContent || "";
+      if (!content.trim()) continue;
+      const xAttr = tspan.getAttribute("x") ?? textEl.getAttribute("x") ?? "0";
+      const yAttr = tspan.getAttribute("y") ?? textEl.getAttribute("y") ?? "0";
+      const x = parseFloat(xAttr) || 0;
+      const y = parseFloat(yAttr) || 0;
+      const fontSize = parseFloat(
+        tspan.getAttribute("font-size") || textEl.getAttribute("font-size") || "16"
+      );
+      const fontFamily = tspan.getAttribute("data-source-font-family") || textEl.getAttribute("data-source-font-family") || resolveInheritedSvgValue(tspan, "font-family") || "sans-serif";
+      const fontWeight = tspan.getAttribute("data-source-font-weight") || textEl.getAttribute("data-source-font-weight") || resolveInheritedSvgValue(tspan, "font-weight") || "normal";
+      const fontStyle = tspan.getAttribute("data-source-font-style") || textEl.getAttribute("data-source-font-style") || resolveInheritedSvgValue(tspan, "font-style") || "normal";
+      const fill = tspan.getAttribute("fill") || getInlineStyleValue(tspan, "fill") || resolveInheritedSvgValue(tspan, "fill") || textEl.getAttribute("fill") || getInlineStyleValue(textEl, "fill") || "#000000";
+      const fillOpacity = tspan.getAttribute("fill-opacity") || getInlineStyleValue(tspan, "fill-opacity") || resolveInheritedSvgValue(tspan, "fill-opacity") || textEl.getAttribute("fill-opacity") || getInlineStyleValue(textEl, "fill-opacity") || null;
+      let textWidth = content.length * fontSize * 0.6;
+      if (ctx) {
+        ctx.font = `${fontStyle} ${fontWeight} ${fontSize}px ${fontFamily.replace(/'/g, "")}`;
+        textWidth = ctx.measureText(content).width;
+      }
+      const textAnchorRaw = (resolveInheritedSvgValue(tspan, "text-anchor") || "start").toLowerCase();
+      const textAnchor = textAnchorRaw === "middle" || textAnchorRaw === "end" ? textAnchorRaw : "start";
+      let lineStartX = x - (textAnchor === "middle" ? textWidth / 2 : textAnchor === "end" ? textWidth : 0);
+      let lineEndX = lineStartX + textWidth;
+      let baselineY = y;
+      if (liveTspan) {
+        try {
+          const liveCharCount = liveTspan.getNumberOfChars();
+          if (liveCharCount > 0) {
+            const start = liveTspan.getStartPositionOfChar(0);
+            const end = liveTspan.getEndPositionOfChar(liveCharCount - 1);
+            if (Number.isFinite(start.x)) lineStartX = start.x;
+            if (Number.isFinite(start.y)) baselineY = start.y;
+            if (Number.isFinite(end.x)) lineEndX = end.x;
+            if (Number.isFinite(end.y) && !Number.isFinite(baselineY)) baselineY = end.y;
+          } else {
+            const svgWidth = liveTspan.getComputedTextLength();
+            if (Number.isFinite(svgWidth) && svgWidth > 0) {
+              textWidth = svgWidth;
+              lineEndX = lineStartX + textWidth;
+            }
+          }
+        } catch {
+        }
+      }
+      if (!(lineEndX > lineStartX)) {
+        lineStartX = x - (textAnchor === "middle" ? textWidth / 2 : textAnchor === "end" ? textWidth : 0);
+        lineEndX = lineStartX + textWidth;
+      }
+      const thickness = Math.max(0.5, fontSize * 0.066667);
+      const strokeColor = fill.startsWith("url(") ? "#000000" : fill;
+      const decorations = [];
+      if (hasUnderline) decorations.push(baselineY + fontSize * 0.15);
+      if (hasLinethrough) decorations.push(baselineY - fontSize * 0.3);
+      for (const decoY of decorations) {
+        const line = doc.createElementNS("http://www.w3.org/2000/svg", "line");
+        line.setAttribute("x1", String(lineStartX));
+        line.setAttribute("y1", String(decoY));
+        line.setAttribute("x2", String(lineEndX));
+        line.setAttribute("y2", String(decoY));
+        line.setAttribute("stroke", strokeColor);
+        line.setAttribute("stroke-width", String(thickness));
+        line.setAttribute("stroke-linecap", "butt");
+        line.setAttribute("fill", "none");
+        if (fillOpacity) line.setAttribute("stroke-opacity", fillOpacity);
+        if (textEl.parentElement) {
+          textEl.parentElement.insertBefore(line, textEl.nextSibling);
+        }
+      }
+    }
+  }
+  if (tempContainer) {
+    try {
+      document.body.removeChild(tempContainer);
+    } catch {
+    }
+  }
+}
+async function convertSvgTextDecorationsToLinesString(svgStr) {
+  if (typeof DOMParser === "undefined" || typeof XMLSerializer === "undefined") {
+    return svgStr;
+  }
+  if (!/text-decoration/i.test(svgStr) && !/underline/i.test(svgStr)) {
+    return svgStr;
+  }
+  try {
+    const parser = new DOMParser();
+    const docEl = parser.parseFromString(svgStr, "image/svg+xml");
+    const rootSvg = docEl.documentElement;
+    if (!rootSvg) return svgStr;
+    await convertTextDecorationsToLines(rootSvg);
+    const serializer = new XMLSerializer();
+    return serializer.serializeToString(rootSvg);
+  } catch {
+    return svgStr;
+  }
+}
+async function rasterizeShadowMarkers(svg) {
+  var _a, _b, _c, _d, _e;
+  if (typeof window === "undefined" || typeof document === "undefined") return;
+  const markers = Array.from(svg.querySelectorAll("g.__pdShadowRaster"));
+  if (markers.length === 0) return;
+  const SVG_NS = "http://www.w3.org/2000/svg";
+  const XLINK_NS = "http://www.w3.org/1999/xlink";
+  try {
+    if ((_a = document.fonts) == null ? void 0 : _a.ready) await document.fonts.ready;
+  } catch {
+  }
+  const fontFaceCss = await collectInlinedFontFaceCss();
+  for (const marker of markers) {
+    try {
+      const blur = parseFloat(marker.getAttribute("data-blur") || "0");
+      const ox = parseFloat(marker.getAttribute("data-ox") || "0");
+      const oy = parseFloat(marker.getAttribute("data-oy") || "0");
+      const bx = parseFloat(marker.getAttribute("data-bx") || "0");
+      const by = parseFloat(marker.getAttribute("data-by") || "0");
+      const bw = parseFloat(marker.getAttribute("data-bw") || "0");
+      const bh = parseFloat(marker.getAttribute("data-bh") || "0");
+      if (!Number.isFinite(bw) || !Number.isFinite(bh) || bw <= 0 || bh <= 0) {
+        (_b = marker.parentNode) == null ? void 0 : _b.removeChild(marker);
+        continue;
+      }
+      const innerXml = restoreSourceFontsForShadowRaster(
+        Array.from(marker.childNodes).map((n) => n instanceof Element ? new XMLSerializer().serializeToString(n) : "").join("")
+      );
+      const scale = 2;
+      const pxW = Math.min(4096, Math.max(8, Math.ceil(bw * scale)));
+      const pxH = Math.min(4096, Math.max(8, Math.ceil(bh * scale)));
+      const stdDev = Math.max(0, blur / 2);
+      const filterId = `pdShadowBlur_${Math.random().toString(36).slice(2, 9)}`;
+      const styleBlock = fontFaceCss ? `<style>${fontFaceCss}</style>` : "";
+      const miniSvg = `<svg xmlns="${SVG_NS}" xmlns:xlink="${XLINK_NS}" width="${pxW}" height="${pxH}" viewBox="${bx} ${by} ${bw} ${bh}">${styleBlock}<defs><filter id="${filterId}" filterUnits="userSpaceOnUse" x="${bx}" y="${by}" width="${bw}" height="${bh}" color-interpolation-filters="sRGB"><feOffset dx="${ox}" dy="${oy}" result="offsetShadow" /><feGaussianBlur in="offsetShadow" stdDeviation="${stdDev}" /></filter></defs><g filter="url(#${filterId})">${innerXml}</g></svg>`;
+      const dataUrl = await rasterSvgToPngDataUrl(miniSvg, pxW, pxH);
+      if (!dataUrl) {
+        (_c = marker.parentNode) == null ? void 0 : _c.removeChild(marker);
+        continue;
+      }
+      const img = svg.ownerDocument.createElementNS(SVG_NS, "image");
+      img.setAttribute("x", String(bx));
+      img.setAttribute("y", String(by));
+      img.setAttribute("width", String(bw));
+      img.setAttribute("height", String(bh));
+      img.setAttribute("opacity", String(SHADOW_RASTER_ALPHA_COMPENSATION));
+      img.setAttribute("preserveAspectRatio", "none");
+      img.setAttributeNS(XLINK_NS, "xlink:href", dataUrl);
+      img.setAttribute("href", dataUrl);
+      (_d = marker.parentNode) == null ? void 0 : _d.replaceChild(img, marker);
+    } catch (error) {
+      console.warn("[Vector PDF] text shadow rasterization failed for one marker:", error);
+      try {
+        (_e = marker.parentNode) == null ? void 0 : _e.removeChild(marker);
+      } catch {
+      }
+    }
+  }
+}
+function restoreSourceFontsForShadowRaster(markup) {
+  try {
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(`<svg xmlns="http://www.w3.org/2000/svg">${markup}</svg>`, "image/svg+xml");
+    if (doc.querySelector("parsererror")) return markup;
+    for (const node of Array.from(doc.querySelectorAll("text, tspan, textPath"))) {
+      const family = node.getAttribute("data-source-font-family");
+      const weight = node.getAttribute("data-source-font-weight");
+      const style = node.getAttribute("data-source-font-style");
+      if (!family && !weight && !style) continue;
+      const stylePairs = (node.getAttribute("style") || "").split(";").map((part) => part.trim()).filter(Boolean).filter((part) => !/^font-family\s*:/i.test(part) && !/^font-weight\s*:/i.test(part) && !/^font-style\s*:/i.test(part));
+      if (family) {
+        node.setAttribute("font-family", family);
+        stylePairs.push(`font-family: ${family}`);
+      }
+      if (weight) {
+        node.setAttribute("font-weight", weight);
+        stylePairs.push(`font-weight: ${weight}`);
+      }
+      if (style) {
+        node.setAttribute("font-style", style);
+        stylePairs.push(`font-style: ${style}`);
+      }
+      if (stylePairs.length > 0) node.setAttribute("style", stylePairs.join("; "));
+    }
+    const root = doc.documentElement;
+    return Array.from(root.childNodes).map((n) => n instanceof Element ? new XMLSerializer().serializeToString(n) : n.textContent || "").join("");
+  } catch {
+    return markup;
+  }
+}
+function rasterSvgToPngDataUrl(svgMarkup, pxW, pxH) {
+  return new Promise((resolve) => {
+    try {
+      const blob = new Blob([svgMarkup], { type: "image/svg+xml;charset=utf-8" });
+      const url = URL.createObjectURL(blob);
+      const img = new Image();
+      const cleanup = () => {
+        try {
+          URL.revokeObjectURL(url);
+        } catch {
+        }
+      };
+      img.onload = () => {
+        try {
+          const canvas = document.createElement("canvas");
+          canvas.width = pxW;
+          canvas.height = pxH;
+          const ctx = canvas.getContext("2d");
+          if (!ctx) {
+            cleanup();
+            resolve(null);
+            return;
+          }
+          ctx.clearRect(0, 0, pxW, pxH);
+          ctx.drawImage(img, 0, 0, pxW, pxH);
+          const dataUrl = canvas.toDataURL("image/png");
+          cleanup();
+          resolve(dataUrl);
+        } catch {
+          cleanup();
+          resolve(null);
+        }
+      };
+      img.onerror = () => {
+        cleanup();
+        resolve(null);
+      };
+      img.src = url;
+    } catch {
+      resolve(null);
+    }
+  });
+}
+let cachedShadowFontFaceCss = null;
+function collectDocumentFontFaceCss() {
+  if (cachedShadowFontFaceCss !== null) return cachedShadowFontFaceCss;
+  const out = [];
+  try {
+    for (const sheet of Array.from(document.styleSheets)) {
+      let rules = null;
+      try {
+        rules = sheet.cssRules;
+      } catch {
+        rules = null;
+      }
+      if (!rules) continue;
+      for (const rule of Array.from(rules)) {
+        const r = rule;
+        if (r && (r.type === 5 || /@font-face/i.test(r.cssText || "")) && r.cssText) out.push(r.cssText);
+      }
+    }
+  } catch {
+  }
+  cachedShadowFontFaceCss = out.join("\n");
+  return cachedShadowFontFaceCss;
+}
+let cachedInlinedFontFaceCss = null;
+const fontUrlDataCache = /* @__PURE__ */ new Map();
+async function fetchFontAsDataUri(url) {
+  if (fontUrlDataCache.has(url)) return fontUrlDataCache.get(url) ?? null;
+  try {
+    const resp = await fetch(url, { mode: "cors", credentials: "omit" });
+    if (!resp.ok) {
+      fontUrlDataCache.set(url, null);
+      return null;
+    }
+    const blob = await resp.blob();
+    const dataUri = await new Promise((resolve, reject) => {
+      const fr = new FileReader();
+      fr.onload = () => resolve(String(fr.result));
+      fr.onerror = () => reject(fr.error);
+      fr.readAsDataURL(blob);
+    });
+    fontUrlDataCache.set(url, dataUri);
+    return dataUri;
+  } catch {
+    fontUrlDataCache.set(url, null);
+    return null;
+  }
+}
+async function inlineUrlsInCss(css) {
+  const urlRe = /url\((['"]?)([^'")]+)\1\)/gi;
+  const matches = [];
+  let m;
+  while ((m = urlRe.exec(css)) !== null) {
+    const raw = m[2].trim();
+    if (raw.startsWith("data:")) continue;
+    let abs = raw;
+    try {
+      abs = new URL(raw, document.baseURI).toString();
+    } catch {
+    }
+    matches.push({ full: m[0], url: abs });
+  }
+  if (matches.length === 0) return css;
+  const unique = Array.from(new Set(matches.map((m2) => m2.url)));
+  const results = await Promise.all(unique.map((u) => fetchFontAsDataUri(u)));
+  const map = /* @__PURE__ */ new Map();
+  unique.forEach((u, i) => map.set(u, results[i]));
+  let out = css;
+  for (const { full, url } of matches) {
+    const data = map.get(url);
+    if (!data) continue;
+    const safeFull = full.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    out = out.replace(new RegExp(safeFull, "g"), `url("${data}")`);
+  }
+  return out;
+}
+async function collectInlinedFontFaceCss() {
+  if (cachedInlinedFontFaceCss !== null) return cachedInlinedFontFaceCss;
+  const raw = collectDocumentFontFaceCss();
+  if (!raw) {
+    cachedInlinedFontFaceCss = "";
+    return "";
+  }
+  try {
+    cachedInlinedFontFaceCss = await inlineUrlsInCss(raw);
+  } catch {
+    cachedInlinedFontFaceCss = raw;
+  }
+  return cachedInlinedFontFaceCss;
+}
+async function prepareLiveCanvasSvgForPdf(rawSvg, pageWidth, pageHeight, pageKey, options) {
+  var _a;
+  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);
+    disambiguateNestedSvgIds(svg);
+    expandSvgUseElements(svg, pageKey);
+    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);
+    await rasterizeShadowMarkers(svgToDraw);
+    await convertTextDecorationsToLines(svgToDraw);
+    const rewritten = rewriteSvgFontsForJsPDFWithSourceMeta(new XMLSerializer().serializeToString(svgToDraw));
+    const rewrittenDoc = parser.parseFromString(rewritten, "image/svg+xml");
+    if (!rewrittenDoc.querySelector("parsererror") && ((_a = rewrittenDoc.documentElement) == null ? void 0 : _a.tagName.toLowerCase()) === "svg") {
+      return rewrittenDoc.documentElement;
+    }
+    return svgToDraw;
+  } catch {
+    return null;
+  }
+}
+async function drawPreparedLiveCanvasSvgPageToPdf(options) {
+  const { rawSvg, pdf, pageWidth, pageHeight, pageKey, stripPageBackground } = options;
+  const svgToDraw = await prepareLiveCanvasSvgForPdf(rawSvg, pageWidth, pageHeight, pageKey, {
+    stripPageBackground
+  });
+  if (!svgToDraw) return false;
+  ++debugSvgDrawSequence;
+  pdf.setFillColor(0, 0, 0);
+  pdf.setDrawColor(0, 0, 0);
+  pdf.saveGraphicsState();
+  setPdfColorFromSvg(pdf, svgToDraw);
+  const pdfToUse = pdfWithColorLogging(pdf);
+  await svg2pdfWithDomMount(svgToDraw, pdfToUse, svg2pdfOpts(0, 0, pageWidth, pageHeight));
+  pdf.restoreGraphicsState();
+  pdf.setFillColor(0, 0, 0);
+  pdf.setDrawColor(0, 0, 0);
+  return true;
+}
+function rewriteSvgFontsForJsPDFWithSourceMeta(svgStr) {
+  var _a, _b;
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(svgStr, "image/svg+xml");
+  const allTextEls = Array.from(doc.querySelectorAll("text, tspan, textPath"));
+  const readStyleToken = (style, prop) => {
+    var _a2;
+    const match = style.match(new RegExp(`${prop}\\s*:\\s*([^;]+)`, "i"));
+    return ((_a2 = match == null ? void 0 : match[1]) == null ? void 0 : _a2.trim()) || null;
+  };
+  const resolveInheritedValue = (el, attr, styleProp = attr) => {
+    var _a2;
+    let current = el;
+    while (current) {
+      const attrVal = (_a2 = current.getAttribute(attr)) == null ? void 0 : _a2.trim();
+      if (attrVal) return attrVal;
+      const styleVal = readStyleToken(current.getAttribute("style") || "", styleProp);
+      if (styleVal) return styleVal;
+      current = current.parentElement;
+    }
+    return null;
+  };
+  const getDepth = (el) => {
+    let depth = 0;
+    let current = el.parentElement;
+    while (current) {
+      depth++;
+      current = current.parentElement;
+    }
+    return depth;
+  };
+  const setRunFontAttrs = (target, fontName, baseStyle = target.getAttribute("style") || "") => {
+    target.setAttribute("font-family", fontName);
+    target.setAttribute("font-weight", "normal");
+    target.setAttribute("font-style", "normal");
+    const stylePairs = baseStyle.split(";").map((part) => part.trim()).filter(Boolean).filter((part) => !/^font-family\s*:/i.test(part) && !/^font-weight\s*:/i.test(part) && !/^font-style\s*:/i.test(part));
+    stylePairs.push(`font-family: ${fontName}`);
+    stylePairs.push("font-weight: normal");
+    stylePairs.push("font-style: normal");
+    target.setAttribute("style", stylePairs.join("; "));
+  };
+  const needsSyntheticBold = (requestedWeight, actualWeight) => requestedWeight >= 600 && actualWeight < 600;
+  const needsSyntheticItalic = (requestedItalic, actualItalic) => requestedItalic && !actualItalic;
+  const SYNTHETIC_ITALIC_SKEW_DEG = 12;
+  const applySyntheticItalicTransform = (el) => {
+    const xRaw = resolveInheritedValue(el, "x") ?? "0";
+    const yRaw = resolveInheritedValue(el, "y") ?? "0";
+    const x = Number.parseFloat(xRaw) || 0;
+    const y = Number.parseFloat(yRaw) || 0;
+    const existing = el.getAttribute("transform") || "";
+    const synth = `translate(${x} ${y}) skewX(-${SYNTHETIC_ITALIC_SKEW_DEG}) translate(${-x} ${-y})`;
+    el.setAttribute("transform", existing ? `${existing} ${synth}` : synth);
+  };
+  const sourceMeta = /* @__PURE__ */ new Map();
+  for (const el of allTextEls) {
+    const inlineStyle = el.getAttribute("style") || "";
+    const rawFf = resolveInheritedValue(el, "font-family");
+    if (!rawFf) continue;
+    const clean = (_a = rawFf.split(",")[0]) == null ? void 0 : _a.replace(/['"]/g, "").trim();
+    if (!clean) continue;
+    if (!isFontAvailable(clean) && !isFamilyEmbedded(clean)) continue;
+    const weightRaw = resolveInheritedValue(el, "font-weight") || "400";
+    const styleRaw = resolveInheritedValue(el, "font-style") || "normal";
+    const parsedWeight = Number.parseInt(weightRaw, 10);
+    const weight = Number.isFinite(parsedWeight) ? parsedWeight : /bold/i.test(weightRaw) ? 700 : /medium/i.test(weightRaw) ? 500 : /semi/i.test(weightRaw) ? 600 : /light/i.test(weightRaw) ? 300 : 400;
+    const resolvedWeight = resolveFontWeight(weight);
+    const italic = /italic|oblique/i.test(styleRaw);
+    const best = resolveBestRegisteredVariant(clean, resolvedWeight, italic);
+    if (!best) {
+      continue;
+    }
+    const jsPdfName = getEmbeddedJsPDFFontName(clean, best.weight, best.italic);
+    sourceMeta.set(el, {
+      clean,
+      requestedWeight: resolvedWeight,
+      resolvedWeight: best.weight,
+      requestedItalic: italic,
+      italic: best.italic,
+      jsPdfName,
+      inlineStyle
+    });
+  }
+  const textEls = allTextEls.sort((a, b) => getDepth(b) - getDepth(a));
+  for (const el of textEls) {
+    if (!el.isConnected) continue;
+    const meta = sourceMeta.get(el);
+    if (!meta) continue;
+    const { clean, requestedWeight, resolvedWeight, requestedItalic, italic, jsPdfName, inlineStyle } = meta;
+    el.setAttribute("data-source-font-family", clean);
+    el.setAttribute("data-source-font-weight", String(requestedWeight));
+    el.setAttribute("data-source-font-style", requestedItalic ? "italic" : "normal");
+    if (needsSyntheticBold(requestedWeight, resolvedWeight)) {
+      const fill = resolveInheritedValue(el, "fill") || readStyleToken(inlineStyle, "fill") || "#000000";
+      el.setAttribute("stroke", fill);
+      el.setAttribute("stroke-width", String(Math.max(0.35, Math.min(1.2, requestedWeight === 700 ? 0.7 : 0.5))));
+      el.setAttribute("stroke-linejoin", "round");
+    }
+    const hasOwnItalicStyle = /italic|oblique/i.test(
+      `${el.getAttribute("font-style") || ""};${readStyleToken(inlineStyle, "font-style") || ""}`
+    );
+    if (needsSyntheticItalic(requestedItalic, italic) && hasOwnItalicStyle) {
+      applySyntheticItalicTransform(el);
+    }
+    const directTextChildren = Array.from(el.childNodes).filter((n) => n.nodeType === 3);
+    if (directTextChildren.length === 0) {
+      setRunFontAttrs(el, jsPdfName, inlineStyle);
+      continue;
+    }
+    const symbolJsPdfName = isFontAvailable(FONT_FALLBACK_SYMBOLS) ? getEmbeddedJsPDFFontName(FONT_FALLBACK_SYMBOLS, 400) : jsPdfName;
+    const devanagariJsPdfName = isFontAvailable(FONT_FALLBACK_DEVANAGARI) ? getEmbeddedJsPDFFontName(FONT_FALLBACK_DEVANAGARI, resolvedWeight) : jsPdfName;
+    const mathJsPdfName = isFontAvailable(FONT_FALLBACK_MATH) ? getEmbeddedJsPDFFontName(FONT_FALLBACK_MATH, 400) : symbolJsPdfName;
+    const mainSupportsChar = (char) => doesVariantSupportChar(clean, resolvedWeight, italic, char);
+    for (const node of directTextChildren) {
+      const txt = node.textContent || "";
+      if (!txt) continue;
+      const runs = splitLineIntoRuns(txt, mainSupportsChar);
+      if (runs.length === 1 && runs[0].runType === "main") continue;
+      const fragment = doc.createDocumentFragment();
+      for (const run of runs) {
+        const tspan = doc.createElementNS("http://www.w3.org/2000/svg", "tspan");
+        let runFont = jsPdfName;
+        if (run.runType === "symbol") runFont = symbolJsPdfName;
+        else if (run.runType === "devanagari") runFont = devanagariJsPdfName;
+        else if (run.runType === "math") runFont = mathJsPdfName;
+        tspan.setAttribute("font-family", runFont);
+        tspan.setAttribute("font-weight", "normal");
+        tspan.setAttribute("font-style", "normal");
+        tspan.textContent = run.text;
+        fragment.appendChild(tspan);
+      }
+      el.replaceChild(fragment, node);
+    }
+    setRunFontAttrs(el, jsPdfName, inlineStyle);
+  }
+  const SVG_NS = "http://www.w3.org/2000/svg";
+  const transformedTspans = Array.from(doc.querySelectorAll("tspan[transform]"));
+  for (const tspan of transformedTspans) {
+    const parentText = tspan.parentElement;
+    if (!parentText || parentText.tagName.toLowerCase() !== "text") continue;
+    const transformVal = tspan.getAttribute("transform") || "";
+    if (!/skewX/i.test(transformVal)) continue;
+    const wrapper = doc.createElementNS(SVG_NS, "text");
+    let parentTransform = "";
+    for (const attr of Array.from(parentText.attributes)) {
+      if (attr.name === "transform") {
+        parentTransform = attr.value;
+        continue;
+      }
+      wrapper.setAttribute(attr.name, attr.value);
+    }
+    const combined = parentTransform ? `${parentTransform} ${transformVal}` : transformVal;
+    wrapper.setAttribute("transform", combined);
+    tspan.removeAttribute("transform");
+    wrapper.appendChild(tspan);
+    (_b = parentText.parentNode) == null ? void 0 : _b.insertBefore(wrapper, parentText.nextSibling);
+  }
+  return new XMLSerializer().serializeToString(doc.documentElement);
+}
+function findGradientInTree(svgRoot, gradientId) {
+  for (const el of svgRoot.querySelectorAll("[id]")) {
+    if (el.getAttribute("id") === gradientId) return el;
+  }
+  return null;
+}
+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 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)) {
+    const alphaHex = s.slice(7, 9);
+    return Number.parseInt(alphaHex, 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 getStopOpacity(stop) {
+  var _a;
+  const fromAttr = parseSvgOpacity(stop.getAttribute("stop-opacity"));
+  if (fromAttr != null) return fromAttr;
+  const fromStyleObj = parseSvgOpacity(((_a = stop.style) == null ? void 0 : _a.getPropertyValue("stop-opacity")) || null);
+  if (fromStyleObj != null) return fromStyleObj;
+  const fromStyleAttr = parseSvgOpacity(getInlineStyleValue(stop, "stop-opacity"));
+  return fromStyleAttr;
+}
+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 isGradientStopFullyTransparent(stop) {
+  const stopOpacity = getStopOpacity(stop);
+  if (stopOpacity != null && stopOpacity <= 1e-4) return true;
+  const stopColor = getStopColorRaw(stop);
+  return isTransparentColorToken(stopColor);
+}
+function isGradientFullyTransparent(svgRoot, gradientId, visited = /* @__PURE__ */ new Set()) {
+  var _a;
+  if (visited.has(gradientId)) return false;
+  visited.add(gradientId);
+  const gradient = findGradientInTree(svgRoot, gradientId);
+  if (!gradient) return false;
+  const tag = (_a = gradient.tagName) == null ? void 0 : _a.toLowerCase();
+  if (tag !== "lineargradient" && tag !== "radialgradient") return false;
+  const stops = Array.from(gradient.querySelectorAll("stop"));
+  if (stops.length > 0) {
+    return stops.every((stop) => isGradientStopFullyTransparent(stop));
+  }
+  const href = (gradient.getAttribute("href") || gradient.getAttribute("xlink:href") || "").trim();
+  if (href.startsWith("#")) {
+    return isGradientFullyTransparent(svgRoot, href.slice(1), visited);
+  }
+  return false;
+}
+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 href = (gradient.getAttribute("href") || gradient.getAttribute("xlink:href") || "").trim();
+    if (href.startsWith("#")) {
+      const refId = href.slice(1);
+      return getGradientStopColorAsHex(svgRoot, refId, visited);
+    }
+    return null;
+  }
+  const getStopColor = (stop) => {
+    if (isGradientStopFullyTransparent(stop)) return null;
+    const stopColor = getStopColorRaw(stop);
+    return stopColor ? cssColorToHex(stopColor) : null;
+  };
+  const firstHex = getStopColor(stops[0]);
+  if (firstHex && !isNearWhite(firstHex)) return firstHex;
+  const lastStop = stops[stops.length - 1];
+  if (lastStop !== stops[0]) {
+    const lastHex = getStopColor(lastStop);
+    if (lastHex) return lastHex;
+  }
+  return firstHex;
+}
+const GRADIENT_ATTRS_LINEAR = ["x1", "y1", "x2", "y2", "gradientUnits", "gradientTransform", "spreadMethod"];
+const GRADIENT_ATTRS_RADIAL = ["cx", "cy", "r", "fx", "fy", "gradientUnits", "gradientTransform", "spreadMethod"];
+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);
+    const stops = gradient.querySelectorAll("stop");
+    if (stops.length > 0) return;
+    const href = (gradient.getAttribute("href") || gradient.getAttribute("xlink:href") || "").trim();
+    if (!href.startsWith("#")) return;
+    const refId = href.slice(1);
+    const ref = findGradientInTree(svg, refId);
+    if (!ref) return;
+    expand(ref);
+    copyGradientAttrsFromRef(gradient, ref);
+    const refStops = ref.querySelectorAll("stop");
+    for (const stop of refStops) gradient.appendChild(stop.cloneNode(true));
+    gradient.removeAttribute("href");
+    gradient.removeAttribute("xlink:href");
+  }
+  for (const g of svg.querySelectorAll("linearGradient, radialGradient")) {
+    expand(g);
+  }
+}
+function cssColorToHex(css) {
+  var _a;
+  const s = css.trim();
+  if (/^#[0-9a-f]{3}$/i.test(s)) {
+    const r2 = s[1] + s[1], g2 = s[2] + s[2], b2 = s[3] + s[3];
+    return "#" + r2 + g2 + b2;
+  }
+  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 r2 = Number(rgb[1]).toString(16).padStart(2, "0");
+    const g2 = Number(rgb[2]).toString(16).padStart(2, "0");
+    const b2 = Number(rgb[3]).toString(16).padStart(2, "0");
+    return "#" + r2 + g2 + b2;
+  }
+  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;
+  const r = Number(m[0]).toString(16).padStart(2, "0");
+  const g = Number(m[1]).toString(16).padStart(2, "0");
+  const b = Number(m[2]).toString(16).padStart(2, "0");
+  return "#" + r + g + b;
+}
+function gradientHasStops(svgRoot, gradientId) {
+  const gradient = findGradientInTree(svgRoot, gradientId);
+  if (!gradient) return false;
+  return gradient.querySelectorAll("stop").length > 0;
+}
+function resolveSvgGradientRefsToSolid(svg, elementId) {
+  svg.querySelectorAll("path, rect, circle, ellipse, polygon, polyline, line");
+  const all = svg.querySelectorAll("*");
+  let fallbackHex = null;
+  for (const el of all) {
+    for (const attr of ["fill", "stroke"]) {
+      const val = el.getAttribute(attr);
+      if (!val) continue;
+      const id = extractGradientIdFromPaint(val);
+      if (!id) continue;
+      const normalizedRef = `url(#${id})`;
+      if (val !== normalizedRef) el.setAttribute(attr, normalizedRef);
+      if (isGradientFullyTransparent(svg, id)) {
+        el.setAttribute(attr, "none");
+        continue;
+      }
+      if (gradientHasStops(svg, id)) continue;
+      let hex = getGradientStopColorAsHex(svg, id);
+      if (!hex && fallbackHex) hex = fallbackHex;
+      if (!hex) {
+        const firstGradient = svg.querySelector("linearGradient[id], radialGradient[id]");
+        if (firstGradient) {
+          const firstId = firstGradient.getAttribute("id");
+          if (firstId) hex = getGradientStopColorAsHex(svg, firstId);
+        }
+        if (!hex) hex = "#000000";
+      }
+      if (hex) {
+        el.setAttribute(attr, hex);
+        if (!fallbackHex) fallbackHex = hex;
+      }
+    }
+  }
+}
+function disambiguateNestedSvgIds(rootSvg) {
+  const nestedSvgs = Array.from(rootSvg.querySelectorAll("svg"));
+  const toProcess = nestedSvgs.filter((s) => s !== rootSvg);
+  if (toProcess.length < 2) return;
+  toProcess.forEach((nested, idx) => {
+    prefixSvgIds(nested, `n${idx}`);
+  });
+}
+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 oldId = trimmed.slice(1);
+      const mapped = idMap.get(oldId);
+      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 expandSvgUseElements(svg, elementId) {
+  var _a;
+  const doc = svg.ownerDocument;
+  const uses = Array.from(svg.querySelectorAll("use"));
+  for (const use of uses) {
+    const ref = (use.getAttribute("href") || use.getAttribute("xlink:href") || "").trim();
+    if (!ref.startsWith("#")) {
+      continue;
+    }
+    const id = ref.slice(1);
+    const target = doc.getElementById(id);
+    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((n) => Number.parseFloat(n)).filter((n) => Number.isFinite(n));
+  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(
+    (child) => !keepAtRoot.has(child.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}`);
+}
+async function fetchSvgAsElement(imageUrl, colorMap) {
+  if (!imageUrl) return null;
+  const isSvgUrl = imageUrl.toLowerCase().includes(".svg") || imageUrl.startsWith("data:image/svg+xml");
+  if (!isSvgUrl) return null;
+  try {
+    let text;
+    if (imageUrl.startsWith("data:image/svg+xml;base64,")) {
+      const b64 = imageUrl.slice("data:image/svg+xml;base64,".length);
+      const binary = atob(b64);
+      try {
+        text = decodeURIComponent(
+          Array.from(binary).map((ch) => `%${ch.charCodeAt(0).toString(16).padStart(2, "0")}`).join("")
+        );
+      } catch {
+        text = binary;
+      }
+    } else if (imageUrl.startsWith("data:image/svg+xml,")) {
+      text = decodeURIComponent(imageUrl.slice("data:image/svg+xml,".length).replace(/\+/g, " "));
+    } else if (imageUrl.startsWith("data:") || imageUrl.startsWith("blob:")) {
+      const res = await fetch(imageUrl);
+      if (!res.ok) return null;
+      text = await res.text();
+    } else {
+      const url = getProxiedImageUrl(imageUrl);
+      const res = await fetch(url);
+      if (!res.ok) return null;
+      text = await res.text();
+    }
+    text = text.trim().replace(/^\uFEFF/, "").replace(/<(\/?)\s*svg:svg\b/gi, "<$1svg").replace(/<(\/?)\s*svg:/gi, "<$1").replace(/(\s)svg:([a-zA-Z_][\w:.-]*)(\s*=)/gi, "$1$2$3").replace(/\s+xmlns:svg\s*=\s*"[^"]*"/gi, "").replace(/\s+xmlns:svg\s*=\s*'[^']*'/gi, "");
+    if (!/\sxmlns\s*=\s*["'][^"']+["']/i.test(text)) {
+      text = text.replace(/<svg\b/i, '<svg xmlns="http://www.w3.org/2000/svg"');
+    }
+    if (colorMap && Object.keys(colorMap).length > 0) {
+      const { applySvgColorMap } = await import("./svgColorUtils-CIehRL4U.js");
+      text = applySvgColorMap(text, colorMap);
+    }
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(text, "image/svg+xml");
+    if (doc.querySelector("parsererror")) return null;
+    const svg = doc.documentElement;
+    if (!svg || svg.tagName.toUpperCase() !== "SVG") return null;
+    if (/xlink:href/i.test(text) && !svg.getAttribute("xmlns:xlink")) {
+      svg.setAttribute("xmlns:xlink", "http://www.w3.org/1999/xlink");
+    }
+    normalizeSvgViewBoxOrigin(svg);
+    return svg;
+  } catch {
+    return null;
+  }
+}
+async function getRecoloredSvgDataUrl(imageUrl, colorMap) {
+  if (!colorMap || Object.keys(colorMap).length === 0) return null;
+  try {
+    const { getNormalizedSvgUrl } = await import("./index-CuTWdeXZ.js").then((n) => n.Y);
+    return await getNormalizedSvgUrl(imageUrl, colorMap);
+  } catch {
+    return null;
+  }
+}
+function normalizeElement(el) {
+  var _a, _b, _c, _d, _e;
+  const baseW = el.width ?? ((_a = el.size) == null ? void 0 : _a.width) ?? 100;
+  const baseH = el.height ?? ((_b = el.size) == null ? void 0 : _b.height) ?? 100;
+  const scaleX = el.scaleX ?? 1;
+  const scaleY = el.scaleY ?? 1;
+  const w = baseW * scaleX;
+  const h = baseH * scaleY;
+  const originX = el.originX ?? "left";
+  const originY = el.originY ?? "top";
+  const rawX = el.left ?? ((_c = el.position) == null ? void 0 : _c.x) ?? 0;
+  const rawY = el.top ?? ((_d = el.position) == null ? void 0 : _d.y) ?? 0;
+  let x = rawX;
+  let y = rawY;
+  if (originX === "center") x = rawX - w / 2;
+  else if (originX === "right") x = rawX - w;
+  if (originY === "center") y = rawY - h / 2;
+  else if (originY === "bottom") y = rawY - h;
+  const angle = el.angle ?? el.rotation ?? 0;
+  const skewX = el.skewX ?? 0;
+  const skewY = el.skewY ?? 0;
+  const style = el.style || {};
+  const opacity = el.opacity ?? style.opacity ?? 1;
+  const fill = el.fill || style.fill || "";
+  const stroke = el.stroke || style.stroke || "";
+  const strokeWidth = el.strokeWidth ?? style.strokeWidth ?? 0;
+  const strokeDashArray = ((_e = el.strokeDashArray) == null ? void 0 : _e.join(",")) || style.strokeDasharray;
+  const text = el.text || el.content || "";
+  const fontSize = el.fontSize ?? style.fontSize ?? 16;
+  const fontFamily = el.fontFamily || style.fontFamily || "Open Sans";
+  const fontWeightRaw = el.fontWeight ?? style.fontWeight ?? 400;
+  const fontWeight = typeof fontWeightRaw === "number" ? fontWeightRaw : parseInt(String(fontWeightRaw), 10) || 400;
+  const fontStyleRaw = el.fontStyle || style.fontStyle || "normal";
+  const fontStyle = fontStyleRaw === "italic" ? "italic" : "normal";
+  const underline = el.underline ?? false;
+  const letterSpacing = el.charSpacing ?? el.letterSpacing ?? style.letterSpacing ?? 0;
+  const rawTextAlign = el.textAlign || style.textAlign || "left";
+  const textAlign = rawTextAlign === "left" || rawTextAlign === "center" || rawTextAlign === "right" ? rawTextAlign : "left";
+  const lineHeight = el.lineHeight ?? style.lineHeight ?? 1.2;
+  const splitByGrapheme = el.splitByGrapheme ?? el.wordWrap === "break-word";
+  const normalizedShapeType = normalizeShapeType(el.shapeType);
+  const shapeType = normalizedShapeType === "unsupported" ? el.shapeType || "rounded-rect" : normalizedShapeType;
+  const borderRadius = el.rx ?? style.borderRadius ?? 0;
+  const rxTL = el.rxTL;
+  const rxTR = el.rxTR;
+  const rxBR = el.rxBR;
+  const rxBL = el.rxBL;
+  const triRTop = el.triRTop;
+  const triRBR = el.triRBR;
+  const triRBL = el.triRBL;
+  const imageUrl = el.src || el.imageUrl;
+  return {
+    x,
+    y,
+    w,
+    h,
+    angle,
+    skewX,
+    skewY,
+    opacity,
+    fill,
+    stroke,
+    strokeWidth,
+    strokeDashArray,
+    text,
+    fontSize,
+    fontFamily,
+    fontWeight,
+    fontStyle,
+    underline,
+    letterSpacing,
+    textAlign,
+    lineHeight,
+    splitByGrapheme,
+    shapeType,
+    borderRadius,
+    rxTL,
+    rxTR,
+    rxBR,
+    rxBL,
+    triRTop,
+    triRBR,
+    triRBL,
+    imageUrl,
+    originX,
+    originY
+  };
+}
+function parseColor(color) {
+  if (!color) return null;
+  const raw = color.trim().toLowerCase();
+  if (!raw || raw === "transparent" || raw === "none") return null;
+  const clamp = (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 = clamp(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: clamp(hueToRgb(hue / 360 + 1 / 3) * 255),
+      g: clamp(hueToRgb(hue / 360) * 255),
+      b: clamp(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: clamp(r), g: clamp(g), b: clamp(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 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 (drawable.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 drawable = ["path", "rect", "circle", "ellipse", "polygon", "polyline", "line", "text", "tspan"];
+    walk(root);
+    root.remove();
+  } finally {
+    if (wrap.parentNode) document.body.removeChild(wrap);
+  }
+}
+function applyPaintStyle(pdf, style) {
+  if (style === "FD") {
+    pdf.fillStroke();
+    return;
+  }
+  if (style === "F") {
+    pdf.fill();
+    return;
+  }
+  pdf.stroke();
+}
+function drawPathWithStyle(pdf, pathOps, style) {
+  const anyPdf = pdf;
+  if (typeof anyPdf.path !== "function") return false;
+  try {
+    anyPdf.path(pathOps);
+    applyPaintStyle(pdf, style);
+    return true;
+  } catch {
+  }
+  try {
+    anyPdf.path(pathOps, style);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function drawRect(pdf, x, y, w, h, fill, stroke, strokeWidth, borderRadius, rxTL, rxTR, rxBR, rxBL) {
+  const fillColor = parseColor(fill);
+  const strokeColor = parseColor(stroke);
+  if (fillColor) {
+    pdf.setFillColor(fillColor.r, fillColor.g, fillColor.b);
+  }
+  if (strokeColor && strokeWidth > 0) {
+    pdf.setDrawColor(strokeColor.r, strokeColor.g, strokeColor.b);
+    pdf.setLineWidth(strokeWidth);
+    const hasIndividualVals = rxTL != null && rxTL > 0 || rxTR != null && rxTR > 0 || rxBR != null && rxBR > 0 || rxBL != null && rxBL > 0;
+    const hasUniformRounding = !hasIndividualVals && borderRadius != null && borderRadius > 0;
+    if (typeof pdf.setLineJoin === "function") pdf.setLineJoin(hasUniformRounding ? "round" : "miter");
+    if (typeof pdf.setLineCap === "function") pdf.setLineCap(hasUniformRounding ? "round" : "butt");
+  }
+  const style = fillColor && strokeColor && strokeWidth > 0 ? "FD" : fillColor ? "F" : strokeColor && strokeWidth > 0 ? "S" : void 0;
+  if (!style) return;
+  const hasIndividualCorners = rxTL != null && rxTL > 0 || rxTR != null && rxTR > 0 || rxBR != null && rxBR > 0 || rxBL != null && rxBL > 0;
+  if (hasIndividualCorners) {
+    const { tl, tr, br, bl } = getRoundedRectRadii(w, h, {
+      rx: borderRadius ?? 0,
+      rxTL,
+      rxTR,
+      rxBR,
+      rxBL
+    });
+    const k = 0.5522847498307936;
+    const pathOps = [
+      { op: "m", c: [x + tl, y] },
+      { op: "l", c: [x + w - tr, y] },
+      ...tr > 0 ? [{ op: "c", c: [x + w - tr + tr * k, y, x + w, y + tr - tr * k, x + w, y + tr] }] : [{ op: "l", c: [x + w, y] }],
+      { op: "l", c: [x + w, y + h - br] },
+      ...br > 0 ? [{ op: "c", c: [x + w, y + h - br + br * k, x + w - br + br * k, y + h, x + w - br, y + h] }] : [{ op: "l", c: [x + w, y + h] }],
+      { op: "l", c: [x + bl, y + h] },
+      ...bl > 0 ? [{ op: "c", c: [x + bl - bl * k, y + h, x, y + h - bl + bl * k, x, y + h - bl] }] : [{ op: "l", c: [x, y + h] }],
+      { op: "l", c: [x, y + tl] },
+      ...tl > 0 ? [{ op: "c", c: [x, y + tl - tl * k, x + tl - tl * k, y, x + tl, y] }] : [{ op: "l", c: [x, y] }],
+      { op: "h", c: [] }
+    ];
+    if (drawPathWithStyle(pdf, pathOps, style)) return;
+  }
+  if (borderRadius && borderRadius > 0) {
+    const r = Math.min(borderRadius, w / 2, h / 2);
+    pdf.roundedRect(x, y, w, h, r, r, style);
+  } else {
+    pdf.rect(x, y, w, h, style);
+  }
+}
+function drawEllipse(pdf, cx, cy, rx, ry, fill, stroke, strokeWidth) {
+  const fillColor = parseColor(fill);
+  const strokeColor = parseColor(stroke);
+  if (fillColor) {
+    pdf.setFillColor(fillColor.r, fillColor.g, fillColor.b);
+  }
+  if (strokeColor && strokeWidth > 0) {
+    pdf.setDrawColor(strokeColor.r, strokeColor.g, strokeColor.b);
+    pdf.setLineWidth(strokeWidth);
+    if (typeof pdf.setLineJoin === "function") pdf.setLineJoin("round");
+    if (typeof pdf.setLineCap === "function") pdf.setLineCap("round");
+  }
+  const style = fillColor && strokeColor && strokeWidth > 0 ? "FD" : fillColor ? "F" : strokeColor && strokeWidth > 0 ? "S" : void 0;
+  if (!style) return;
+  if (!Number.isFinite(rx) || !Number.isFinite(ry) || rx <= 0 || ry <= 0) return;
+  const k = 0.5522847498307936;
+  const ox = rx * k;
+  const oy = ry * k;
+  const pathOps = [
+    { op: "m", c: [cx - rx, cy] },
+    { op: "c", c: [cx - rx, cy - oy, cx - ox, cy - ry, cx, cy - ry] },
+    { op: "c", c: [cx + ox, cy - ry, cx + rx, cy - oy, cx + rx, cy] },
+    { op: "c", c: [cx + rx, cy + oy, cx + ox, cy + ry, cx, cy + ry] },
+    { op: "c", c: [cx - ox, cy + ry, cx - rx, cy + oy, cx - rx, cy] },
+    { op: "h", c: [] }
+  ];
+  if (drawPathWithStyle(pdf, pathOps, style)) return;
+  pdf.ellipse(cx, cy, rx, ry, style);
+}
+function drawLine(pdf, x1, y1, x2, y2, stroke, strokeWidth, dashArray) {
+  const strokeColor = parseColor(stroke);
+  if (!strokeColor || strokeWidth <= 0) return;
+  pdf.setDrawColor(strokeColor.r, strokeColor.g, strokeColor.b);
+  pdf.setLineWidth(strokeWidth);
+  if (typeof pdf.setLineCap === "function") pdf.setLineCap("round");
+  if (typeof pdf.setLineJoin === "function") pdf.setLineJoin("round");
+  if (dashArray) {
+    const dashes = dashArray.split(/[\s,]+/).map(Number).filter((n) => !isNaN(n));
+    if (dashes.length > 0) {
+      pdf.setLineDashPattern(dashes, 0);
+    }
+  }
+  pdf.line(x1, y1, x2, y2);
+  if (dashArray) {
+    pdf.setLineDashPattern([], 0);
+  }
+}
+function drawRoundedTrianglePdf(pdf, x, y, w, h, svgPath, fill, stroke, strokeWidth) {
+  const fillColor = parseColor(fill);
+  const strokeColor = parseColor(stroke);
+  if (fillColor) pdf.setFillColor(fillColor.r, fillColor.g, fillColor.b);
+  if (strokeColor && strokeWidth > 0) {
+    pdf.setDrawColor(strokeColor.r, strokeColor.g, strokeColor.b);
+    pdf.setLineWidth(strokeWidth);
+    if (typeof pdf.setLineJoin === "function") pdf.setLineJoin("miter");
+    if (typeof pdf.setLineCap === "function") pdf.setLineCap("butt");
+    if (typeof pdf.setMiterLimit === "function") pdf.setMiterLimit(TRIANGLE_STROKE_MITER_LIMIT);
+  }
+  const style = fillColor && strokeColor && strokeWidth > 0 ? "FD" : fillColor ? "F" : strokeColor && strokeWidth > 0 ? "S" : void 0;
+  if (!style) return;
+  const pathOps = [];
+  const tokens = svgPath.match(/[MLQZmlqz]|[-+]?[0-9]*\.?[0-9]+/g) || [];
+  let i = 0;
+  while (i < tokens.length) {
+    const cmd = tokens[i];
+    if (cmd === "M" || cmd === "m") {
+      i++;
+      pathOps.push({ op: "m", c: [x + parseFloat(tokens[i]), y + parseFloat(tokens[i + 1])] });
+      i += 2;
+    } else if (cmd === "L" || cmd === "l") {
+      i++;
+      pathOps.push({ op: "l", c: [x + parseFloat(tokens[i]), y + parseFloat(tokens[i + 1])] });
+      i += 2;
+    } else if (cmd === "Q" || cmd === "q") {
+      i++;
+      const qcx = x + parseFloat(tokens[i]);
+      const qcy = y + parseFloat(tokens[i + 1]);
+      const qex = x + parseFloat(tokens[i + 2]);
+      const qey = y + parseFloat(tokens[i + 3]);
+      const lastOp = pathOps[pathOps.length - 1];
+      const px = lastOp ? lastOp.c[lastOp.c.length - 2] : x;
+      const py = lastOp ? lastOp.c[lastOp.c.length - 1] : y;
+      const cp1x = px + 2 / 3 * (qcx - px);
+      const cp1y = py + 2 / 3 * (qcy - py);
+      const cp2x = qex + 2 / 3 * (qcx - qex);
+      const cp2y = qey + 2 / 3 * (qcy - qey);
+      pathOps.push({ op: "c", c: [cp1x, cp1y, cp2x, cp2y, qex, qey] });
+      i += 4;
+    } else if (cmd === "Z" || cmd === "z") {
+      pathOps.push({ op: "h", c: [] });
+      i++;
+    } else {
+      i++;
+    }
+  }
+  if (drawPathWithStyle(pdf, pathOps, style)) return;
+}
+function drawPolygon(pdf, points, fill, stroke, strokeWidth) {
+  if (points.length < 3) return;
+  const fillColor = parseColor(fill);
+  const strokeColor = parseColor(stroke);
+  if (fillColor) {
+    pdf.setFillColor(fillColor.r, fillColor.g, fillColor.b);
+  }
+  if (strokeColor && strokeWidth > 0) {
+    pdf.setDrawColor(strokeColor.r, strokeColor.g, strokeColor.b);
+    pdf.setLineWidth(strokeWidth);
+    if (typeof pdf.setLineJoin === "function") pdf.setLineJoin("miter");
+    if (typeof pdf.setLineCap === "function") pdf.setLineCap("butt");
+    if (typeof pdf.setMiterLimit === "function") pdf.setMiterLimit(TRIANGLE_STROKE_MITER_LIMIT);
+  }
+  const style = fillColor && strokeColor && strokeWidth > 0 ? "FD" : fillColor ? "F" : strokeColor && strokeWidth > 0 ? "S" : void 0;
+  if (!style) return;
+  const pathOps = [
+    { op: "m", c: [points[0].x, points[0].y] },
+    ...points.slice(1).map((point) => ({ op: "l", c: [point.x, point.y] })),
+    { op: "h", c: [] }
+  ];
+  if (drawPathWithStyle(pdf, pathOps, style)) return;
+  pdf.moveTo(points[0].x, points[0].y);
+  for (let i = 1; i < points.length; i++) {
+    pdf.lineTo(points[i].x, points[i].y);
+  }
+  pdf.lineTo(points[0].x, points[0].y);
+  applyPaintStyle(pdf, style);
+}
+function addLinkAnnotation(pdf, url, x, y, w, h, canvasHeight) {
+  if (!url || !url.trim()) return;
+  try {
+    pdf.link(x, y, w, h, { url: url.trim() });
+  } catch {
+  }
+}
+const PX_TO_PT = 72 / 96;
+const FIRST_LINE_BASELINE_MULT = 1.18;
+const TEXT_UP_NUDGE_PX = 2;
+const SYMBOL_FONT_SCALE = 0.78;
+function drawText(pdf, text, x, y, width, fontSizePx, fontFamily, fontWeight, fontStyle, underline, letterSpacing, fill, textAlign, lineHeight, embeddedFonts, splitByGrapheme = true, liveFabricText) {
+  var _a, _b, _c, _d, _e, _f;
+  const fillColor = parseColor(fill);
+  if (!fillColor) return;
+  const fontSizePt = fontSizePx * PX_TO_PT;
+  pdf.setTextColor(fillColor.r, fillColor.g, fillColor.b);
+  pdf.setFontSize(fontSizePt);
+  const isItalic = fontStyle === "italic";
+  const resolvedWeight = resolveFontWeight(fontWeight);
+  const fontKey = `${fontFamily}${FONT_KEY_SEP}${resolvedWeight}`;
+  const italicFontKey = `${fontFamily}${FONT_KEY_SEP}${resolvedWeight}${FONT_KEY_SEP}italic`;
+  const hasEmbeddedItalic = isItalic && embeddedFonts.has(italicFontKey);
+  const mainJsPdfFontName = hasEmbeddedItalic ? embeddedFonts.has(italicFontKey) ? getEmbeddedJsPDFFontName(fontFamily, fontWeight, true) : null : embeddedFonts.has(fontKey) ? getEmbeddedJsPDFFontName(fontFamily, fontWeight) : null;
+  const mainStyle = fontWeight >= 600 ? "bold" : "normal";
+  if (mainJsPdfFontName) {
+    try {
+      pdf.setFont(mainJsPdfFontName, "normal");
+    } catch {
+      pdf.setFont("helvetica", mainStyle);
+    }
+  } else {
+    pdf.setFont("helvetica", mainStyle);
+  }
+  const useSkewForItalic = isItalic && !hasEmbeddedItalic;
+  const fallbackFontKey = `${FONT_FALLBACK_SYMBOLS}${FONT_KEY_SEP}400`;
+  const fallbackJsPdfName = embeddedFonts.has(fallbackFontKey) ? getEmbeddedJsPDFFontName(FONT_FALLBACK_SYMBOLS, 400) : null;
+  const devanagariWeight = resolveFontWeight(fontWeight);
+  const devanagariFontKey = `${FONT_FALLBACK_DEVANAGARI}${FONT_KEY_SEP}${devanagariWeight}`;
+  const devanagariJsPdfName = embeddedFonts.has(devanagariFontKey) ? getEmbeddedJsPDFFontName(FONT_FALLBACK_DEVANAGARI, devanagariWeight) : null;
+  function setRunFont(runType) {
+    if (runType === "devanagari" && devanagariJsPdfName) {
+      try {
+        pdf.setFont(devanagariJsPdfName, "normal");
+      } catch {
+        if (mainJsPdfFontName) pdf.setFont(mainJsPdfFontName, "normal");
+        else pdf.setFont("helvetica", mainStyle);
+      }
+    } else if (runType === "symbol" && fallbackJsPdfName) {
+      try {
+        pdf.setFont(fallbackJsPdfName, "normal");
+      } catch {
+        if (mainJsPdfFontName) pdf.setFont(mainJsPdfFontName, "normal");
+        else pdf.setFont("helvetica", mainStyle);
+      }
+    } else if (mainJsPdfFontName) {
+      try {
+        pdf.setFont(mainJsPdfFontName, "normal");
+      } catch {
+        pdf.setFont("helvetica", mainStyle);
+      }
+    } else {
+      pdf.setFont("helvetica", mainStyle);
+    }
+  }
+  const charSpacePt = letterSpacing !== 0 ? letterSpacing / 1e3 * fontSizePt : 0;
+  if (letterSpacing !== 0) {
+    try {
+      (_a = pdf.setCharSpace) == null ? void 0 : _a.call(pdf, charSpacePt);
+    } catch {
+    }
+  }
+  let textLines = [];
+  let getBaselineFromTopPx;
+  let getLineLeftOffset;
+  let baselineInPoints = false;
+  if (liveFabricText && typeof liveFabricText.getHeightOfLine === "function") {
+    const live = liveFabricText;
+    textLines = (live.textLines && Array.isArray(live.textLines) ? live.textLines : []).map((line) => Array.isArray(line) ? line.join("") : line);
+    const lh = (live.lineHeight ?? lineHeight) || 1.2;
+    baselineInPoints = true;
+    getBaselineFromTopPx = (lineIndex) => {
+      let sum = 0;
+      for (let j = 0; j < lineIndex; j++) {
+        sum += live.getHeightOfLine(j);
+      }
+      const lineH = live.getHeightOfLine(lineIndex);
+      return sum + lineH / lh;
+    };
+    getLineLeftOffset = (i) => (typeof live._getLineLeftOffset === "function" ? live._getLineLeftOffset(i) : 0) ?? 0;
+  } else {
+    const textbox = new fabric.Textbox(text, {
+      width,
+      fontSize: fontSizePx,
+      fontFamily,
+      fontWeight: String(fontWeight),
+      charSpacing: letterSpacing,
+      textAlign,
+      lineHeight: lineHeight || 1.2,
+      splitByGrapheme,
+      left: 0,
+      top: 0,
+      originX: "left",
+      originY: "top"
+    });
+    textbox.initDimensions();
+    textLines = textbox.textLines || [];
+    const lh = lineHeight || 1.2;
+    getBaselineFromTopPx = (lineIndex) => {
+      var _a2, _b2;
+      let sum = 0;
+      for (let j = 0; j < lineIndex; j++) {
+        sum += ((_a2 = textbox.getHeightOfLine) == null ? void 0 : _a2.call(textbox, j)) ?? fontSizePx * lh;
+      }
+      const lineH = ((_b2 = textbox.getHeightOfLine) == null ? void 0 : _b2.call(textbox, lineIndex)) ?? fontSizePx * lh;
+      return sum + lineH / lh;
+    };
+    getLineLeftOffset = (i) => {
+      var _a2;
+      return ((_a2 = textbox._getLineLeftOffset) == null ? void 0 : _a2.call(textbox, i)) ?? 0;
+    };
+  }
+  if (textLines.length === 0) return;
+  const italicSkewAngle = isItalic ? -0.21 : 0;
+  for (let i = 0; i < textLines.length; i++) {
+    const lineText = textLines[i];
+    if (!lineText) continue;
+    const pureLatin = isPureLatin(lineText);
+    let totalLineWidth;
+    if (pureLatin) {
+      setRunFont("main");
+      totalLineWidth = pdf.getTextWidth(lineText);
+    } else {
+      const runs = splitLineIntoRuns(lineText);
+      totalLineWidth = 0;
+      for (let r = 0; r < runs.length; r++) {
+        const rt = runs[r].runType;
+        if (rt === "symbol") pdf.setFontSize(fontSizePt * SYMBOL_FONT_SCALE);
+        setRunFont(rt);
+        totalLineWidth += pdf.getTextWidth(runs[r].text);
+        if (rt === "symbol") pdf.setFontSize(fontSizePt);
+        if (letterSpacing !== 0 && r < runs.length - 1) totalLineWidth += charSpacePt;
+      }
+      lineText.__runs = runs;
+    }
+    let lineLeftOffset = getLineLeftOffset(i);
+    if (lineLeftOffset === 0 && (textAlign === "center" || textAlign === "right")) {
+      if (textAlign === "center") {
+        lineLeftOffset = (width - totalLineWidth) / 2;
+      } else if (textAlign === "right") {
+        lineLeftOffset = width - totalLineWidth;
+      }
+    }
+    const rawBaseline = getBaselineFromTopPx(i);
+    const firstLineRaw = getBaselineFromTopPx(0);
+    const baselineFromTop = i === 0 ? rawBaseline / FIRST_LINE_BASELINE_MULT : firstLineRaw / FIRST_LINE_BASELINE_MULT + (rawBaseline - firstLineRaw);
+    const lineY = y + (baselineInPoints ? baselineFromTop : baselineFromTop * PX_TO_PT) - TEXT_UP_NUDGE_PX;
+    const lineX = x + lineLeftOffset;
+    if (pureLatin) {
+      setRunFont("main");
+      if (useSkewForItalic) {
+        (_b = pdf.saveGraphicsState) == null ? void 0 : _b.call(pdf);
+        try {
+          const pdfInternal = pdf.internal;
+          if (pdfInternal == null ? void 0 : pdfInternal.write) {
+            pdfInternal.write("q");
+            pdfInternal.write(`1 0 ${italicSkewAngle.toFixed(4)} 1 ${lineX.toFixed(2)} ${lineY.toFixed(2)} cm`);
+            pdf.text(lineText, 0, 0);
+            pdfInternal.write("Q");
+          } else {
+            pdf.text(lineText, lineX, lineY);
+          }
+        } catch {
+          pdf.text(lineText, lineX, lineY);
+        }
+        (_c = pdf.restoreGraphicsState) == null ? void 0 : _c.call(pdf);
+      } else {
+        pdf.text(lineText, lineX, lineY);
+      }
+    } else {
+      const runs = lineText.__runs || splitLineIntoRuns(lineText);
+      let runX = lineX;
+      if (useSkewForItalic) {
+        (_d = pdf.saveGraphicsState) == null ? void 0 : _d.call(pdf);
+        try {
+          const pdfInternal = pdf.internal;
+          if (pdfInternal == null ? void 0 : pdfInternal.write) {
+            pdfInternal.write("q");
+            pdfInternal.write(`1 0 ${italicSkewAngle.toFixed(4)} 1 ${lineX.toFixed(2)} ${lineY.toFixed(2)} cm`);
+            runX = 0;
+            for (let r = 0; r < runs.length; r++) {
+              const rt = runs[r].runType;
+              if (rt === "symbol") pdf.setFontSize(fontSizePt * SYMBOL_FONT_SCALE);
+              setRunFont(rt);
+              pdf.text(runs[r].text, runX, 0);
+              runX += pdf.getTextWidth(runs[r].text);
+              if (rt === "symbol") pdf.setFontSize(fontSizePt);
+              if (letterSpacing !== 0 && r < runs.length - 1) runX += charSpacePt;
+            }
+            pdfInternal.write("Q");
+          } else {
+            for (let r = 0; r < runs.length; r++) {
+              const rt = runs[r].runType;
+              if (rt === "symbol") pdf.setFontSize(fontSizePt * SYMBOL_FONT_SCALE);
+              setRunFont(rt);
+              pdf.text(runs[r].text, runX, lineY);
+              runX += pdf.getTextWidth(runs[r].text);
+              if (rt === "symbol") pdf.setFontSize(fontSizePt);
+              if (letterSpacing !== 0 && r < runs.length - 1) runX += charSpacePt;
+            }
+          }
+        } catch {
+          for (let r = 0; r < runs.length; r++) {
+            const rt = runs[r].runType;
+            if (rt === "symbol") pdf.setFontSize(fontSizePt * SYMBOL_FONT_SCALE);
+            setRunFont(rt);
+            pdf.text(runs[r].text, runX, lineY);
+            runX += pdf.getTextWidth(runs[r].text);
+            if (rt === "symbol") pdf.setFontSize(fontSizePt);
+            if (letterSpacing !== 0 && r < runs.length - 1) runX += charSpacePt;
+          }
+        }
+        (_e = pdf.restoreGraphicsState) == null ? void 0 : _e.call(pdf);
+      } else {
+        for (let r = 0; r < runs.length; r++) {
+          const rt = runs[r].runType;
+          if (rt === "symbol") pdf.setFontSize(fontSizePt * SYMBOL_FONT_SCALE);
+          setRunFont(rt);
+          pdf.text(runs[r].text, runX, lineY);
+          runX += pdf.getTextWidth(runs[r].text);
+          if (rt === "symbol") pdf.setFontSize(fontSizePt);
+          if (letterSpacing !== 0 && r < runs.length - 1) runX += charSpacePt;
+        }
+      }
+    }
+    if (underline && lineText.trim()) {
+      const underlineY = lineY + fontSizePt * 0.15;
+      const underlineThickness = Math.max(0.5, fontSizePt * 0.066667);
+      pdf.setDrawColor(fillColor.r, fillColor.g, fillColor.b);
+      pdf.setLineWidth(underlineThickness);
+      pdf.line(lineX, underlineY, lineX + totalLineWidth, underlineY);
+    }
+  }
+  if (letterSpacing !== 0) {
+    try {
+      (_f = pdf.setCharSpace) == null ? void 0 : _f.call(pdf, 0);
+    } catch {
+    }
+  }
+}
+function normalizeBgColor(bg) {
+  if (!bg || bg === "transparent" || bg === "none") return "#ffffff";
+  return bg;
+}
+function blobToDataUrl(blob) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onloadend = () => resolve(reader.result);
+    reader.onerror = () => reject(new Error("Failed to read blob"));
+    reader.readAsDataURL(blob);
+  });
+}
+function readPngHeader(buf) {
+  try {
+    const bytes = new Uint8Array(buf);
+    if (bytes[0] !== 137 || bytes[1] !== 80 || bytes[2] !== 78 || bytes[3] !== 71) {
+      return null;
+    }
+    const type = String.fromCharCode(bytes[12], bytes[13], bytes[14], bytes[15]);
+    if (type !== "IHDR") return null;
+    const bitDepth = bytes[24];
+    const colorType = bytes[25];
+    return { bitDepth, colorType };
+  } catch {
+    return null;
+  }
+}
+async function detectAlpha(blob) {
+  const bitmap = await createImageBitmap(blob);
+  const w = 32;
+  const h = 32;
+  const c = document.createElement("canvas");
+  c.width = w;
+  c.height = h;
+  const ctx = c.getContext("2d");
+  if (!ctx) return false;
+  ctx.clearRect(0, 0, w, h);
+  ctx.drawImage(bitmap, 0, 0, w, h);
+  const data = ctx.getImageData(0, 0, w, h).data;
+  for (let i = 3; i < data.length; i += 4) {
+    if (data[i] !== 255) return true;
+  }
+  return false;
+}
+function getTargetPixelSize(bitmap, opts) {
+  const dpiScale = 1.5 * (opts.resolutionMultiplier ?? 1);
+  const maxPx = opts.resolutionMultiplier && opts.resolutionMultiplier > 1 ? 4400 : 2200;
+  const capByBitmap = !(opts.resolutionMultiplier && opts.resolutionMultiplier > 1);
+  const desiredW = Math.max(1, Math.round((opts.targetWidthPt ?? bitmap.width) * dpiScale));
+  const desiredH = Math.max(1, Math.round((opts.targetHeightPt ?? bitmap.height) * dpiScale));
+  return {
+    w: Math.min(maxPx, desiredW, capByBitmap ? bitmap.width : Infinity),
+    h: Math.min(maxPx, desiredH, capByBitmap ? bitmap.height : Infinity)
+  };
+}
+async function rasterizeToDataUrl(blob, opts, out, flattenBackground) {
+  const bitmap = await createImageBitmap(blob);
+  const { w, h } = getTargetPixelSize(bitmap, opts);
+  const canvas = document.createElement("canvas");
+  canvas.width = w;
+  canvas.height = h;
+  const ctx = canvas.getContext("2d");
+  if (!ctx) throw new Error("Canvas context not available");
+  if (flattenBackground) {
+    ctx.fillStyle = normalizeBgColor(opts.backgroundColor);
+    ctx.fillRect(0, 0, w, h);
+  } else {
+    ctx.clearRect(0, 0, w, h);
+  }
+  ctx.imageSmoothingEnabled = true;
+  try {
+    ctx.imageSmoothingQuality = "high";
+  } catch {
+  }
+  ctx.drawImage(bitmap, 0, 0, w, h);
+  if (out === "JPEG") {
+    return canvas.toDataURL("image/jpeg", 0.82);
+  }
+  return canvas.toDataURL("image/png");
+}
+async function fetchImageAsBase64(imageUrl, opts = {}) {
+  try {
+    const forcePreserveAlpha = opts.preserveAlpha === true;
+    if (imageUrl.startsWith("data:")) {
+      const res = await fetch(imageUrl);
+      const blob2 = await res.blob();
+      const type2 = (blob2.type || "").toLowerCase();
+      if (type2 === "image/jpeg" || type2 === "image/jpg") {
+        return { data: imageUrl, format: "JPEG" };
+      }
+      if (forcePreserveAlpha) {
+        const pngUrl = await rasterizeToDataUrl(blob2, opts, "PNG", false);
+        return { data: pngUrl, format: "PNG" };
+      }
+      const hasAlpha2 = await detectAlpha(blob2);
+      if (hasAlpha2) {
+        const pngUrl = await rasterizeToDataUrl(blob2, opts, "PNG", false);
+        return { data: pngUrl, format: "PNG" };
+      }
+      const jpegUrl2 = await rasterizeToDataUrl(blob2, opts, "JPEG", true);
+      return { data: jpegUrl2, format: "JPEG" };
+    }
+    let fetchUrl = imageUrl;
+    if (imageUrl.startsWith("http://") || imageUrl.startsWith("https://")) {
+      const { isPrivateUrl } = await import("./index-CuTWdeXZ.js").then((n) => n.Y);
+      if (isPrivateUrl(imageUrl)) return null;
+      const proxyUrl = new URL(`${API_URL}/image-proxy`);
+      proxyUrl.searchParams.set("url", imageUrl);
+      fetchUrl = proxyUrl.toString();
+    }
+    const response = await fetch(fetchUrl, { cache: "no-store", ...getImageProxyFetchOptions() });
+    if (!response.ok) return null;
+    const blob = await response.blob();
+    const type = (blob.type || "").toLowerCase();
+    if (type === "image/jpeg" || type === "image/jpg") {
+      const dataUrl = await blobToDataUrl(blob);
+      return { data: dataUrl, format: "JPEG" };
+    }
+    if (type === "image/png") {
+      const buf = await blob.arrayBuffer();
+      const hdr = readPngHeader(buf);
+      if ((hdr == null ? void 0 : hdr.bitDepth) === 16) {
+        const flattenWithBg2 = !forcePreserveAlpha && !!(opts.backgroundColor && opts.backgroundColor !== "transparent" && opts.backgroundColor !== "none");
+        const pngUrl = await rasterizeToDataUrl(new Blob([buf], { type: "image/png" }), opts, "PNG", flattenWithBg2);
+        return { data: pngUrl, format: "PNG" };
+      }
+      if (forcePreserveAlpha) {
+        const dataUrl2 = await blobToDataUrl(blob);
+        return { data: dataUrl2, format: "PNG" };
+      }
+      const flattenWithBg = !!(opts.backgroundColor && opts.backgroundColor !== "transparent" && opts.backgroundColor !== "none");
+      if (flattenWithBg) {
+        const hasAlpha2 = (hdr == null ? void 0 : hdr.colorType) === 4 || (hdr == null ? void 0 : hdr.colorType) === 6;
+        if (hasAlpha2) {
+          const pngUrl = await rasterizeToDataUrl(blob, opts, "PNG", true);
+          return { data: pngUrl, format: "PNG" };
+        }
+      }
+      const dataUrl = await blobToDataUrl(blob);
+      return { data: dataUrl, format: "PNG" };
+    }
+    if (forcePreserveAlpha) {
+      const pngUrl = await rasterizeToDataUrl(blob, opts, "PNG", false);
+      return { data: pngUrl, format: "PNG" };
+    }
+    const hasAlpha = await detectAlpha(blob);
+    if (hasAlpha) {
+      const flattenWithBg = !!(opts.backgroundColor && opts.backgroundColor !== "transparent" && opts.backgroundColor !== "none");
+      const pngUrl = await rasterizeToDataUrl(blob, opts, "PNG", flattenWithBg);
+      return { data: pngUrl, format: "PNG" };
+    }
+    const jpegUrl = await rasterizeToDataUrl(blob, opts, "JPEG", true);
+    return { data: jpegUrl, format: "JPEG" };
+  } catch {
+    return null;
+  }
+}
+function getShapePoints(shapeType, x, y, w, h) {
+  const cx = x + w / 2;
+  const cy = y + h / 2;
+  switch (shapeType) {
+    case "triangle":
+      return getTrianglePoints(x, y, w, h);
+    case "diamond":
+      return [
+        { x: cx, y },
+        { x: x + w, y: cy },
+        { x: cx, y: y + h },
+        { x, y: cy }
+      ];
+    case "pentagon":
+      return generateRegularPolygon(5, cx, cy, Math.min(w, h) / 2);
+    case "hexagon":
+      return generateRegularPolygon(6, cx, cy, Math.min(w, h) / 2);
+    case "octagon":
+      return generateRegularPolygon(8, cx, cy, Math.min(w, h) / 2);
+    case "star":
+      return generateStar(5, cx, cy, Math.min(w, h) / 2);
+    case "arrow":
+      return [
+        { x, y: y + h * 0.3 },
+        { x: x + w * 0.6, y: y + h * 0.3 },
+        { x: x + w * 0.6, y },
+        { x: x + w, y: cy },
+        { x: x + w * 0.6, y: y + h },
+        { x: x + w * 0.6, y: y + h * 0.7 },
+        { x, y: y + h * 0.7 }
+      ];
+    case "parallelogram":
+      return [
+        { x: x + w * 0.2, y },
+        { x: x + w, y },
+        { x: x + w * 0.8, y: y + h },
+        { x, y: y + h }
+      ];
+    case "trapezoid":
+      return [
+        { x: x + w * 0.2, y },
+        { x: x + w * 0.8, y },
+        { x: x + w, y: y + h },
+        { x, y: y + h }
+      ];
+    case "cross":
+      const t = 0.35;
+      return [
+        { x: x + w * t, y },
+        { x: x + w * (1 - t), y },
+        { x: x + w * (1 - t), y: y + h * t },
+        { x: x + w, y: y + h * t },
+        { x: x + w, y: y + h * (1 - t) },
+        { x: x + w * (1 - t), y: y + h * (1 - t) },
+        { x: x + w * (1 - t), y: y + h },
+        { x: x + w * t, y: y + h },
+        { x: x + w * t, y: y + h * (1 - t) },
+        { x, y: y + h * (1 - t) },
+        { x, y: y + h * t },
+        { x: x + w * t, y: y + h * t }
+      ];
+    default:
+      return null;
+  }
+}
+function generateRegularPolygon(sides, cx, cy, radius) {
+  const points = [];
+  const angleOffset = -Math.PI / 2;
+  for (let i = 0; i < sides; i++) {
+    const angle = angleOffset + 2 * Math.PI * i / sides;
+    points.push({
+      x: cx + radius * Math.cos(angle),
+      y: cy + radius * Math.sin(angle)
+    });
+  }
+  return points;
+}
+function generateStar(points, cx, cy, outerRadius) {
+  const result = [];
+  const innerRadius = outerRadius * 0.4;
+  const angleOffset = -Math.PI / 2;
+  for (let i = 0; i < points * 2; i++) {
+    const radius = i % 2 === 0 ? outerRadius : innerRadius;
+    const angle = angleOffset + Math.PI * i / points;
+    result.push({
+      x: cx + radius * Math.cos(angle),
+      y: cy + radius * Math.sin(angle)
+    });
+  }
+  return result;
+}
+function getMatrixScaleFactors(matrix) {
+  if (!matrix || matrix.length !== 6) return { sx: 1, sy: 1 };
+  const [a, b, c, d] = matrix;
+  const sx = Math.hypot(a, b);
+  const sy = Math.hypot(c, d);
+  return {
+    sx: Number.isFinite(sx) && sx > 0 ? sx : 1,
+    sy: Number.isFinite(sy) && sy > 0 ? sy : 1
+  };
+}
+function getStrokeScaleCompensationForMatrix(element, matrix) {
+  if (element.type !== "shape" && element.type !== "line") return 1;
+  const { sx, sy } = getMatrixScaleFactors(matrix);
+  if (sx <= 0 || sy <= 0) return 1;
+  const isUniformScale = Math.abs(sx - sy) < 1e-4;
+  const referenceScale = isUniformScale ? sx : Math.max(sx, sy);
+  if (!Number.isFinite(referenceScale) || referenceScale <= 0) return 1;
+  const compensation = 1 / referenceScale;
+  return Math.max(1e-4, Math.min(1e3, compensation));
+}
+function withCompensatedStrokeWidth(norm, element, matrix) {
+  if (norm.strokeWidth <= 0) return norm;
+  const compensation = getStrokeScaleCompensationForMatrix(element, matrix);
+  if (Math.abs(compensation - 1) < 1e-4) return norm;
+  return {
+    ...norm,
+    strokeWidth: Number((norm.strokeWidth * compensation).toFixed(4))
+  };
+}
+function fabricMatrixToJsPdfAdvancedMatrix(fabricM, _pageHeight) {
+  return fabricM.length === 6 ? fabricM : [1, 0, 0, 1, 0, 0];
+}
+async function rasterizeCropGroupToPng(liveGroup, frameW, frameH, multiplier = 2, maintainResolution = false, imageUrl, forceBlobReplace = false, stored, backgroundColor) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  const bgFill = backgroundColor && backgroundColor !== "transparent" && backgroundColor !== "none" ? normalizeBgColor(backgroundColor) : void 0;
+  const cropData = liveGroup.__cropData;
+  const rxRatio = (cropData == null ? void 0 : cropData.rx) || 0;
+  const minFrameDim = Math.min(frameW, frameH);
+  const clipRx = Math.min(rxRatio > 0.5 ? rxRatio : rxRatio * minFrameDim, frameW / 2, frameH / 2);
+  const shape = (cropData == null ? void 0 : cropData.shape) || "rect";
+  const panX = Math.max(0, Math.min(1, (stored == null ? void 0 : stored.panX) ?? ((_b = (_a = cropData == null ? void 0 : cropData._img) == null ? void 0 : _a._ct) == null ? void 0 : _b.panX) ?? 0.5));
+  const panY = Math.max(0, Math.min(1, (stored == null ? void 0 : stored.panY) ?? ((_d = (_c = cropData == null ? void 0 : cropData._img) == null ? void 0 : _c._ct) == null ? void 0 : _d.panY) ?? 0.5));
+  const zoom = Math.max(1, (stored == null ? void 0 : stored.zoom) ?? ((_f = (_e = cropData == null ? void 0 : cropData._img) == null ? void 0 : _e._ct) == null ? void 0 : _f.zoom) ?? 1);
+  if (maintainResolution && imageUrl) {
+    const dims = await loadNaturalDimensionsFromUrl(imageUrl);
+    const natW = (dims == null ? void 0 : dims.width) ?? (stored == null ? void 0 : stored.naturalWidth) ?? frameW;
+    const natH = (dims == null ? void 0 : dims.height) ?? (stored == null ? void 0 : stored.naturalHeight) ?? frameH;
+    const useNatW = natW > 0 && natH > 0 ? natW : frameW;
+    const useNatH = natW > 0 && natH > 0 ? natH : frameH;
+    if (useNatW > frameW || useNatH > frameH) {
+      let htmlImg = null;
+      if (imageUrl.startsWith("data:") || imageUrl.startsWith("blob:")) {
+        try {
+          htmlImg = await new Promise((resolve, reject) => {
+            const im = new Image();
+            im.onload = () => resolve(im);
+            im.onerror = () => reject(new Error("Image load failed"));
+            im.src = imageUrl;
+          });
+        } catch {
+          htmlImg = null;
+        }
+      } else {
+        try {
+          const proxied = getProxiedImageUrl(imageUrl);
+          const res = await fetch(proxied);
+          if (!res.ok) throw new Error("Fetch failed");
+          const blob = await res.blob();
+          const blobUrl = URL.createObjectURL(blob);
+          try {
+            htmlImg = await new Promise((resolve, reject) => {
+              const im = new Image();
+              im.crossOrigin = "anonymous";
+              im.onload = () => resolve(im);
+              im.onerror = () => reject(new Error("Image load failed"));
+              im.src = blobUrl;
+            });
+          } finally {
+            URL.revokeObjectURL(blobUrl);
+          }
+        } catch {
+          htmlImg = null;
+        }
+      }
+      if (htmlImg) {
+        const iw = htmlImg.naturalWidth || useNatW;
+        const ih = htmlImg.naturalHeight || useNatH;
+        const baseScale = Math.max(frameW / iw, frameH / ih);
+        const finalScale = baseScale * zoom;
+        const drawW = iw * finalScale;
+        const drawH = ih * finalScale;
+        const overflowX = Math.max(0, drawW - frameW);
+        const overflowY = Math.max(0, drawH - frameH);
+        const offsetX = overflowX > 0 ? -overflowX * (panX - 0.5) : 0;
+        const offsetY = overflowY > 0 ? -overflowY * (panY - 0.5) : 0;
+        const imageLeft = frameW / 2 + offsetX - iw * finalScale / 2;
+        const imageTop = frameH / 2 + offsetY - ih * finalScale / 2;
+        const srcX = Math.max(0, Math.floor(-imageLeft / finalScale));
+        const srcY = Math.max(0, Math.floor(-imageTop / finalScale));
+        const srcW = Math.min(Math.ceil(frameW / finalScale), iw - srcX);
+        const srcH = Math.min(Math.ceil(frameH / finalScale), ih - srcY);
+        if (srcW >= 1 && srcH >= 1) {
+          const cropCanvas = document.createElement("canvas");
+          cropCanvas.width = srcW;
+          cropCanvas.height = srcH;
+          const ctx = cropCanvas.getContext("2d");
+          if (ctx) {
+            if (bgFill) {
+              ctx.fillStyle = bgFill;
+              ctx.fillRect(0, 0, srcW, srcH);
+            } else {
+              ctx.clearRect(0, 0, srcW, srcH);
+            }
+            ctx.drawImage(htmlImg, srcX, srcY, srcW, srcH, 0, 0, srcW, srcH);
+            if (shape === "circle" || shape === "roundRect" || shape === "rect") {
+              ctx.globalCompositeOperation = "destination-in";
+              if (shape === "circle") {
+                ctx.beginPath();
+                ctx.ellipse(srcW / 2, srcH / 2, srcW / 2, srcH / 2, 0, 0, 2 * Math.PI);
+                ctx.fill();
+              } else {
+                const rx2 = Math.min(
+                  (rxRatio > 0.5 ? rxRatio : rxRatio * minFrameDim) * (srcW / frameW),
+                  srcW / 2,
+                  srcH / 2
+                );
+                const r = Math.max(0, rx2);
+                ctx.beginPath();
+                ctx.moveTo(r, 0);
+                ctx.lineTo(srcW - r, 0);
+                if (r > 0) ctx.quadraticCurveTo(srcW, 0, srcW, r);
+                ctx.lineTo(srcW, srcH - r);
+                if (r > 0) ctx.quadraticCurveTo(srcW, srcH, srcW - r, srcH);
+                ctx.lineTo(r, srcH);
+                if (r > 0) ctx.quadraticCurveTo(0, srcH, 0, srcH - r);
+                ctx.lineTo(0, r);
+                if (r > 0) ctx.quadraticCurveTo(0, 0, r, 0);
+                ctx.closePath();
+                ctx.fill();
+              }
+            }
+            return cropCanvas.toDataURL("image/png");
+          }
+        }
+      }
+    }
+  }
+  if (forceBlobReplace && imageUrl && !imageUrl.startsWith("data:") && !imageUrl.startsWith("blob:")) {
+    const dims = await loadNaturalDimensionsFromUrl(imageUrl);
+    const natW = (dims == null ? void 0 : dims.width) ?? (stored == null ? void 0 : stored.naturalWidth) ?? frameW;
+    const natH = (dims == null ? void 0 : dims.height) ?? (stored == null ? void 0 : stored.naturalHeight) ?? frameH;
+    const useNatW = natW > 0 && natH > 0 ? natW : frameW;
+    const useNatH = natW > 0 && natH > 0 ? natH : frameH;
+    const outW2 = maintainResolution && useNatW > frameW ? Math.max(1, Math.round(useNatW)) : Math.max(1, Math.round(frameW * multiplier));
+    const outH2 = maintainResolution && useNatH > frameH ? Math.max(1, Math.round(useNatH)) : Math.max(1, Math.round(frameH * multiplier));
+    const proxied = getProxiedImageUrl(imageUrl);
+    const res = await fetch(proxied);
+    if (!res.ok) throw new Error(`Export blob fetch failed: ${res.status}`);
+    const blob = await res.blob();
+    const blobUrl = URL.createObjectURL(blob);
+    try {
+      const img = await fabric.FabricImage.fromURL(blobUrl, { crossOrigin: "anonymous" });
+      img.set({ width: useNatW, height: useNatH, originX: "center", originY: "center", objectCaching: false, dirty: true });
+      const baseScale = Math.max(frameW / useNatW, frameH / useNatH);
+      const finalScale = baseScale * zoom;
+      img.set({ scaleX: finalScale, scaleY: finalScale });
+      const dispW = useNatW * finalScale;
+      const dispH = useNatH * finalScale;
+      const overflowX = Math.max(0, dispW - frameW);
+      const overflowY = Math.max(0, dispH - frameH);
+      img.set({ left: overflowX > 0 ? -overflowX * (panX - 0.5) : 0, top: overflowY > 0 ? -overflowY * (panY - 0.5) : 0 });
+      img.setCoords();
+      const clip = shape === "circle" ? new fabric.Ellipse({ rx: frameW / 2, ry: frameH / 2, left: 0, top: 0, originX: "center", originY: "center", selectable: false, evented: false }) : new fabric.Rect({ width: frameW, height: frameH, rx: clipRx, ry: clipRx, left: 0, top: 0, originX: "center", originY: "center", selectable: false, evented: false });
+      clip.absolutePositioned = false;
+      clip.excludeFromExport = false;
+      const group = new fabric.Group([img], { left: outW2 / 2, top: outH2 / 2, originX: "center", originY: "center", width: frameW, height: frameH, scaleX: outW2 / frameW, scaleY: outH2 / frameH, angle: 0, opacity: liveGroup.opacity ?? 1, objectCaching: false });
+      group.clipPath = clip;
+      group.clipPath.absolutePositioned = false;
+      group.clipPath.excludeFromExport = false;
+      group.set({ width: frameW, height: frameH });
+      group.setCoords();
+      if (group.clipPath) group.clipPath.setCoords();
+      const el2 = document.createElement("canvas");
+      el2.width = outW2;
+      el2.height = outH2;
+      const exportCanvas2 = new fabric.StaticCanvas(el2, {
+        width: outW2,
+        height: outH2,
+        backgroundColor: bgFill ?? "transparent",
+        renderOnAddRemove: false
+      });
+      exportCanvas2.add(group);
+      exportCanvas2.renderAll();
+      const png2 = exportCanvas2.toDataURL({ format: "png", multiplier: 1, enableRetinaScaling: false });
+      exportCanvas2.dispose();
+      return png2;
+    } finally {
+      URL.revokeObjectURL(blobUrl);
+    }
+  }
+  let outW;
+  let outH;
+  let exportNaturalW = 0;
+  let exportNaturalH = 0;
+  let urlDims = null;
+  if (imageUrl && (forceBlobReplace || maintainResolution)) {
+    urlDims = await loadNaturalDimensionsFromUrl(imageUrl);
+  }
+  if (maintainResolution) {
+    let naturalWidth = (urlDims == null ? void 0 : urlDims.width) ?? (((stored == null ? void 0 : stored.naturalWidth) ?? 0) > 0 && ((stored == null ? void 0 : stored.naturalHeight) ?? 0) > 0 ? stored.naturalWidth : 0);
+    let naturalHeight = (urlDims == null ? void 0 : urlDims.height) ?? (naturalWidth > 0 ? stored.naturalHeight : 0);
+    if (naturalWidth <= 0 || naturalHeight <= 0) {
+      let img = cropData == null ? void 0 : cropData._img;
+      if (!img || typeof img.getElement !== "function" && !img._element) {
+        const objects = liveGroup.getObjects();
+        img = objects.find((o) => o instanceof fabric.FabricImage || o.getElement);
+      }
+      if (img && (typeof img.getElement === "function" || img._element)) {
+        const orig = typeof img.getOriginalSize === "function" ? img.getOriginalSize() : null;
+        const htmlImg = orig ? null : typeof img.getElement === "function" ? img.getElement() : img._element;
+        naturalWidth = ((orig == null ? void 0 : orig.width) ?? (htmlImg == null ? void 0 : htmlImg.naturalWidth) ?? img.width) || 0;
+        naturalHeight = ((orig == null ? void 0 : orig.height) ?? (htmlImg == null ? void 0 : htmlImg.naturalHeight) ?? img.height) || 0;
+      }
+    }
+    const fromFabricLooksBaked = naturalWidth > 0 && naturalHeight > 0 && naturalWidth <= frameW + 2 && naturalHeight <= frameH + 2;
+    if (imageUrl && (naturalWidth <= 0 || naturalHeight <= 0 || fromFabricLooksBaked)) {
+      const dims = await loadNaturalDimensionsFromUrl(imageUrl);
+      if (dims && dims.width > 0 && dims.height > 0) {
+        naturalWidth = dims.width;
+        naturalHeight = dims.height;
+      } else if (fromFabricLooksBaked) {
+        naturalWidth = Math.max(naturalWidth, Math.round(frameW * 4));
+        naturalHeight = Math.max(naturalHeight, Math.round(frameH * 4));
+      }
+    }
+    if (naturalWidth > 0 && naturalHeight > 0) {
+      exportNaturalW = naturalWidth;
+      exportNaturalH = naturalHeight;
+      let scaleUp = Math.max(naturalWidth / frameW, naturalHeight / frameH, multiplier);
+      if (imageUrl && imageUrl.toLowerCase().includes(".svg")) {
+        scaleUp = Math.max(scaleUp, 4);
+      }
+      outW = Math.max(1, Math.round(frameW * scaleUp));
+      outH = Math.max(1, Math.round(frameH * scaleUp));
+    } else {
+      outW = Math.max(1, Math.round(frameW * multiplier));
+      outH = Math.max(1, Math.round(frameH * multiplier));
+    }
+  } else {
+    outW = Math.max(1, Math.round(frameW * multiplier));
+    outH = Math.max(1, Math.round(frameH * multiplier));
+  }
+  const el = document.createElement("canvas");
+  el.width = outW;
+  el.height = outH;
+  const exportCanvas = new fabric.StaticCanvas(el, {
+    width: outW,
+    height: outH,
+    backgroundColor: bgFill ?? "transparent",
+    renderOnAddRemove: false
+  });
+  const clonedGroup = await liveGroup.clone();
+  clonedGroup.set({
+    objectCaching: false,
+    dirty: true,
+    opacity: liveGroup.opacity ?? 1
+    // Preserve opacity
+  });
+  (_g = clonedGroup._objects) == null ? void 0 : _g.forEach((o) => o.set({ objectCaching: false, dirty: true }));
+  const groupScaleX = maintainResolution ? 1 : multiplier;
+  const groupScaleY = maintainResolution ? 1 : multiplier;
+  const clipW = maintainResolution ? outW : frameW;
+  const clipH = maintainResolution ? outH : frameH;
+  const scaledClipRx = maintainResolution ? Math.min(clipRx * (outW / frameW), outW / 2, outH / 2) : Math.min(clipRx, clipW / 2, clipH / 2);
+  if (!clonedGroup.clipPath && liveGroup.clipPath) {
+    if (shape === "circle") {
+      clonedGroup.clipPath = new fabric.Ellipse({
+        rx: clipW / 2,
+        ry: clipH / 2,
+        left: 0,
+        top: 0,
+        originX: "center",
+        originY: "center",
+        selectable: false,
+        evented: false,
+        hasControls: false,
+        hasBorders: false
+      });
+    } else {
+      clonedGroup.clipPath = new fabric.Rect({
+        width: clipW,
+        height: clipH,
+        rx: scaledClipRx,
+        ry: scaledClipRx,
+        left: 0,
+        top: 0,
+        originX: "center",
+        originY: "center",
+        selectable: false,
+        evented: false,
+        hasControls: false,
+        hasBorders: false
+      });
+    }
+    clonedGroup.clipPath.absolutePositioned = false;
+    clonedGroup.clipPath.excludeFromExport = false;
+  } else if (clonedGroup.clipPath) {
+    if (shape === "circle" && clonedGroup.clipPath instanceof fabric.Ellipse) {
+      clonedGroup.clipPath.set({
+        rx: clipW / 2,
+        ry: clipH / 2
+      });
+    } else if (clonedGroup.clipPath instanceof fabric.Rect) {
+      clonedGroup.clipPath.set({
+        width: clipW,
+        height: clipH,
+        rx: scaledClipRx,
+        ry: scaledClipRx
+      });
+    }
+  }
+  if (clonedGroup.clipPath) {
+    clonedGroup.clipPath.set({
+      excludeFromExport: false,
+      objectCaching: false,
+      dirty: true,
+      absolutePositioned: false
+    });
+    clonedGroup.clipPath.setCoords();
+  }
+  if (clonedGroup.clipPath) {
+    clonedGroup.clipPath.set({
+      excludeFromExport: false,
+      absolutePositioned: false,
+      objectCaching: false,
+      dirty: true
+    });
+    clonedGroup.clipPath.setCoords();
+  }
+  clonedGroup.set({ width: clipW, height: clipH });
+  clonedGroup.setCoords();
+  clonedGroup.set({
+    left: outW / 2,
+    top: outH / 2,
+    originX: "center",
+    originY: "center",
+    scaleX: groupScaleX,
+    scaleY: groupScaleY,
+    angle: 0,
+    skewX: 0,
+    skewY: 0,
+    flipX: false,
+    flipY: false
+  });
+  clonedGroup.setCoords();
+  if (clonedGroup.clipPath) {
+    clonedGroup.clipPath.setCoords();
+  }
+  if (forceBlobReplace && imageUrl && !imageUrl.startsWith("data:") && !imageUrl.startsWith("blob:")) {
+    const objects = clonedGroup.getObjects();
+    const imgIndex = objects.findIndex((o) => o instanceof fabric.FabricImage);
+    if (imgIndex >= 0) {
+      const oldImg = objects[imgIndex];
+      try {
+        const dims = urlDims ?? await loadNaturalDimensionsFromUrl(imageUrl);
+        const natW = (dims == null ? void 0 : dims.width) ?? (stored == null ? void 0 : stored.naturalWidth) ?? 0;
+        const natH = (dims == null ? void 0 : dims.height) ?? (stored == null ? void 0 : stored.naturalHeight) ?? 0;
+        const useNatW = natW > 0 && natH > 0 ? natW : frameW;
+        const useNatH = natW > 0 && natH > 0 ? natH : frameH;
+        const proxied = getProxiedImageUrl(imageUrl);
+        const res = await fetch(proxied);
+        if (!res.ok) {
+        } else {
+          const blob = await res.blob();
+          const blobUrl = URL.createObjectURL(blob);
+          try {
+            const newImg = await fabric.FabricImage.fromURL(blobUrl, { crossOrigin: "anonymous" });
+            exportNaturalW = useNatW;
+            exportNaturalH = useNatH;
+            newImg.set({
+              width: useNatW,
+              height: useNatH,
+              left: 0,
+              top: 0,
+              scaleX: 1,
+              scaleY: 1,
+              angle: oldImg.angle ?? 0,
+              originX: "center",
+              originY: "center",
+              objectCaching: false,
+              dirty: true
+            });
+            newImg.setCoords();
+            clonedGroup.remove(oldImg);
+            clonedGroup.insertAt(imgIndex, newImg);
+          } finally {
+            URL.revokeObjectURL(blobUrl);
+          }
+        }
+      } catch (_e2) {
+      }
+    }
+  }
+  const cloneImg = clonedGroup.getObjects().find((o) => o instanceof fabric.FabricImage);
+  if (cloneImg) {
+    let natW = exportNaturalW;
+    let natH = exportNaturalH;
+    if (natW <= 0 || natH <= 0) {
+      const el2 = ((_h = cloneImg.getElement) == null ? void 0 : _h.call(cloneImg)) ?? cloneImg._element;
+      natW = (el2 == null ? void 0 : el2.naturalWidth) ?? (stored == null ? void 0 : stored.naturalWidth) ?? 0;
+      natH = (el2 == null ? void 0 : el2.naturalHeight) ?? (stored == null ? void 0 : stored.naturalHeight) ?? 0;
+    }
+    if (natW > 0 && natH > 0) {
+      const _ct = (_i = cropData == null ? void 0 : cropData._img) == null ? void 0 : _i._ct;
+      const panX2 = Math.max(0, Math.min(1, (stored == null ? void 0 : stored.panX) ?? (_ct == null ? void 0 : _ct.panX) ?? 0.5));
+      const panY2 = Math.max(0, Math.min(1, (stored == null ? void 0 : stored.panY) ?? (_ct == null ? void 0 : _ct.panY) ?? 0.5));
+      const zoom2 = Math.max(1, (stored == null ? void 0 : stored.zoom) ?? (_ct == null ? void 0 : _ct.zoom) ?? 1);
+      const layoutW = maintainResolution ? outW : frameW;
+      const layoutH = maintainResolution ? outH : frameH;
+      const baseScale = Math.max(layoutW / natW, layoutH / natH);
+      const finalScale = baseScale * zoom2;
+      cloneImg.set({
+        width: natW,
+        height: natH,
+        scaleX: finalScale,
+        scaleY: finalScale,
+        originX: "center",
+        originY: "center",
+        objectCaching: false,
+        dirty: true
+      });
+      const dispW = natW * finalScale;
+      const dispH = natH * finalScale;
+      const overflowX = Math.max(0, dispW - layoutW);
+      const overflowY = Math.max(0, dispH - layoutH);
+      const offsetX = overflowX > 0 ? -overflowX * (panX2 - 0.5) : 0;
+      const offsetY = overflowY > 0 ? -overflowY * (panY2 - 0.5) : 0;
+      cloneImg.set({ left: offsetX, top: offsetY });
+      cloneImg.setCoords();
+    }
+  }
+  clonedGroup.set({ width: clipW, height: clipH });
+  clonedGroup.setCoords();
+  exportCanvas.add(clonedGroup);
+  exportCanvas.renderAll();
+  const png = exportCanvas.toDataURL({
+    format: "png",
+    multiplier: 1,
+    enableRetinaScaling: false
+  });
+  exportCanvas.dispose();
+  return png;
+}
+async function drawElement(pdf, element, embeddedFonts, canvasWidth, canvasHeight, backgroundColor, fabricMatrix, fabricIntrinsic, pageId, liveFabricText, pageChildren) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  if (!element.visible) return;
+  debugLog(`drawElement START id=${element.id} type=${element.type}`);
+  const norm = normalizeElement(element);
+  if (!fabricMatrix && (pageChildren == null ? void 0 : pageChildren.length)) {
+    const node = findNodeById(pageChildren, element.id);
+    if (node) {
+      const abs = getAbsoluteBounds(node, pageChildren);
+      norm.x = abs.left;
+      norm.y = abs.top;
+      norm.w = abs.width;
+      norm.h = abs.height;
+    }
+  }
+  if (element.smartElementType && element.smartProps && norm.w > 0 && norm.h > 0) {
+    const propsWithFont = {
+      ...element.smartProps,
+      fontFamily: element.smartProps.fontFamily || element.fontFamily || "sans-serif"
+    };
+    const freshSvg = renderSmartElementToSvg(element.smartElementType, propsWithFont, norm.w, norm.h);
+    if (freshSvg) {
+      element = {
+        ...element,
+        sourceFormat: "svg",
+        src: `data:image/svg+xml;charset=utf-8,${encodeURIComponent(freshSvg)}`,
+        imageUrl: `data:image/svg+xml;charset=utf-8,${encodeURIComponent(freshSvg)}`
+      };
+      Object.assign(norm, { imageUrl: element.src });
+      debugLog(`Smart element regenerated: type=${element.smartElementType} id=${element.id}`);
+    }
+  }
+  if (element.type === "image" && pageId) {
+    const liveCanvas = getCanvasForPage(pageId);
+    if (liveCanvas) {
+      const liveGroup = liveCanvas.getObjects().find(
+        (obj) => obj.__docuforgeId === element.id && obj.__cropGroup
+      );
+      if (liveGroup) {
+        const cropData = liveGroup.__cropData;
+        const frameW = (cropData == null ? void 0 : cropData.frameW) || liveGroup.width || norm.w;
+        const frameH = (cropData == null ? void 0 : cropData.frameH) || liveGroup.height || norm.h;
+        (cropData == null ? void 0 : cropData.shape) || "rect";
+        (cropData == null ? void 0 : cropData.rx) || 0;
+        const maintainResolution = element.maintainResolution !== false;
+        let exportMultiplier = 2;
+        if (maintainResolution) {
+          let img = cropData == null ? void 0 : cropData._img;
+          if (!img || typeof img.getElement !== "function" && !img._element) {
+            const objects = liveGroup.getObjects();
+            img = objects.find((o) => o instanceof fabric.FabricImage || o.getElement);
+          }
+          if (img && (typeof img.getElement === "function" || img._element)) {
+            const orig = typeof img.getOriginalSize === "function" ? img.getOriginalSize() : null;
+            const htmlImg = orig ? null : typeof img.getElement === "function" ? img.getElement() : img._element;
+            const naturalWidth = ((orig == null ? void 0 : orig.width) ?? (htmlImg == null ? void 0 : htmlImg.naturalWidth) ?? img.width) || frameW;
+            const naturalHeight = ((orig == null ? void 0 : orig.height) ?? (htmlImg == null ? void 0 : htmlImg.naturalHeight) ?? img.height) || frameH;
+            const scaleX2 = naturalWidth / frameW;
+            const scaleY2 = naturalHeight / frameH;
+            exportMultiplier = Math.max(scaleX2, scaleY2, 2);
+          }
+        }
+        const imageUrlForRaster = element.src || element.imageUrl || liveGroup.__imageSrc;
+        const isSvgSource = element.sourceFormat === "svg" || imageUrlForRaster && imageUrlForRaster.toLowerCase().includes(".svg");
+        if (isSvgSource) {
+          exportMultiplier = Math.max(exportMultiplier, 4);
+        }
+        const canVectorizeSvg = isSvgSource && !!imageUrlForRaster && !elementHasFade(element);
+        if (canVectorizeSvg) {
+          const svgEl = await fetchSvgAsElement(imageUrlForRaster, element.svgColorMap);
+          if (svgEl) {
+            expandSvgUseElements(svgEl, element.id);
+            const svgToDraw = normalizeSvgExplicitColors(svgEl);
+            inlineComputedStyles(svgToDraw);
+            normalizeSvgGradientStopOffsets(svgToDraw);
+            expandSvgGradientHrefs(svgToDraw);
+            resolveSvgGradientRefsToSolid(svgToDraw, element.id);
+            prefixSvgIds(svgToDraw, element.id);
+            bakeGroupOpacityIntoChildren(svgToDraw);
+            injectOpacityIntoSvg(svgToDraw, norm.opacity);
+            try {
+              const anyPdf3 = pdf;
+              const canUseAdvancedTransforms3 = typeof anyPdf3.advancedAPI === "function" && typeof anyPdf3.setCurrentTransformationMatrix === "function" && typeof anyPdf3.Matrix === "function";
+              pdf.setGState(pdf.GState({ opacity: 1, "stroke-opacity": 1 }));
+              const cropZoomVal = cropData ? Math.max(1, ((_b = (_a = cropData._img) == null ? void 0 : _a._ct) == null ? void 0 : _b.zoom) ?? element.cropZoom ?? 1) : 1;
+              const cropPanXVal = cropData ? Math.max(0, Math.min(1, ((_d = (_c = cropData._img) == null ? void 0 : _c._ct) == null ? void 0 : _d.panX) ?? element.cropPanX ?? 0.5)) : 0.5;
+              const cropPanYVal = cropData ? Math.max(0, Math.min(1, ((_f = (_e = cropData._img) == null ? void 0 : _e._ct) == null ? void 0 : _f.panY) ?? element.cropPanY ?? 0.5)) : 0.5;
+              const naturalW = Math.max(1, Number(element.imageNaturalWidth ?? 0) || Number(((_g = cropData == null ? void 0 : cropData._img) == null ? void 0 : _g.width) ?? 0) || frameW);
+              const naturalH = Math.max(1, Number(element.imageNaturalHeight ?? 0) || Number(((_h = cropData == null ? void 0 : cropData._img) == null ? void 0 : _h.height) ?? 0) || frameH);
+              const fitContain = ((cropData == null ? void 0 : cropData.fit) ?? element.imageFit ?? "cover") === "contain";
+              const cropSvgRect = (clipX, clipY, clipW, clipH) => {
+                const baseScale = fitContain ? Math.min(clipW / naturalW, clipH / naturalH) : Math.max(clipW / naturalW, clipH / naturalH);
+                const finalScale = baseScale * (fitContain ? 1 : cropZoomVal);
+                const drawW = naturalW * finalScale;
+                const drawH = naturalH * finalScale;
+                const overflowX = Math.max(0, drawW - clipW);
+                const overflowY = Math.max(0, drawH - clipH);
+                const offX = overflowX > 0 ? -overflowX * (cropPanXVal - 0.5) : 0;
+                const offY = overflowY > 0 ? -overflowY * (cropPanYVal - 0.5) : 0;
+                return {
+                  x: clipX + clipW / 2 + offX - drawW / 2,
+                  y: clipY + clipH / 2 + offY - drawH / 2,
+                  width: drawW,
+                  height: drawH
+                };
+              };
+              const localX = -frameW / 2;
+              const localY = -frameH / 2;
+              if (canUseAdvancedTransforms3 && fabricMatrix && fabricMatrix.length === 6) {
+                const mPdf = fabricMatrixToJsPdfAdvancedMatrix(fabricMatrix, canvasHeight);
+                const axisFrame = getAxisAlignedSvgFrameFromMatrix(mPdf, localX, localY, frameW, frameH);
+                if (axisFrame) {
+                  const svgDrawRect = cropSvgRect(axisFrame.x, axisFrame.y, axisFrame.width, axisFrame.height);
+                  const seq = ++debugSvgDrawSequence;
+                  debugLog(`svg2pdf START #${seq} elementId=${element.id} path=cropGroup-axis`);
+                  resetPdfColorState(pdf, `before save #${seq} ${element.id}`);
+                  pdf.saveGraphicsState();
+                  resetPdfColorState(pdf, `after save #${seq} ${element.id}`);
+                  pdf.setLineWidth(0);
+                  pdf.rect(axisFrame.x, axisFrame.y, axisFrame.width, axisFrame.height, null);
+                  pdf.clip();
+                  if (typeof pdf.discardPath === "function") pdf.discardPath();
+                  resetPdfColorState(pdf, `immediately before svg2pdf #${seq} ${element.id}`);
+                  setPdfColorFromSvg(pdf, svgToDraw, element.id);
+                  const pdfToUse = pdfWithColorLogging(pdf, seq, element.id);
+                  await svg2pdfWithDomMount(svgToDraw, pdfToUse, svg2pdfOpts(svgDrawRect.x, svgDrawRect.y, svgDrawRect.width, svgDrawRect.height));
+                  debugLog(`svg2pdf DONE #${seq} elementId=${element.id}`);
+                  resetPdfColorState(pdf, `after svg2pdf #${seq} ${element.id}`);
+                  pdf.restoreGraphicsState();
+                  resetPdfColorState(pdf, `after restore #${seq} ${element.id}`);
+                } else {
+                  const transformed = buildMatrixTransformedSvgForPage(svgToDraw, mPdf, localX, localY, frameW, frameH);
+                  if (transformed) {
+                    const seq = ++debugSvgDrawSequence;
+                    debugLog(`svg2pdf START #${seq} elementId=${element.id} path=cropGroup-matrix-wrapper`);
+                    resetPdfColorState(pdf, `before save #${seq} ${element.id} matrix-wrapper`);
+                    pdf.saveGraphicsState();
+                    resetPdfColorState(pdf, `after save #${seq} ${element.id}`);
+                    pdf.setLineWidth(0);
+                    pdf.rect(transformed.frame.x, transformed.frame.y, transformed.frame.width, transformed.frame.height, null);
+                    pdf.clip();
+                    if (typeof pdf.discardPath === "function") pdf.discardPath();
+                    resetPdfColorState(pdf, `immediately before svg2pdf #${seq} ${element.id}`);
+                    setPdfColorFromSvg(pdf, transformed.svg, element.id);
+                    const tfCropRect = cropSvgRect(transformed.frame.x, transformed.frame.y, transformed.frame.width, transformed.frame.height);
+                    await svg2pdfWithDomMount(
+                      transformed.svg,
+                      pdfWithColorLogging(pdf, seq, element.id),
+                      svg2pdfOpts(tfCropRect.x, tfCropRect.y, tfCropRect.width, tfCropRect.height)
+                    );
+                    debugLog(`svg2pdf DONE #${seq} elementId=${element.id}`);
+                    resetPdfColorState(pdf, `after svg2pdf #${seq} ${element.id}`);
+                    pdf.restoreGraphicsState();
+                    resetPdfColorState(pdf, `after restore #${seq} ${element.id}`);
+                  } else {
+                    const pdfForSvg = new Proxy(pdf, {
+                      get(target, prop) {
+                        if (prop === "advancedAPI") return () => {
+                        };
+                        return target[prop];
+                      }
+                    });
+                    await new Promise((resolve, reject) => {
+                      anyPdf3.advancedAPI(async () => {
+                        try {
+                          const seq = ++debugSvgDrawSequence;
+                          debugLog(`svg2pdf START #${seq} elementId=${element.id} path=cropGroup-matrix-fallback`);
+                          resetPdfColorState(pdf, `before save #${seq} ${element.id} matrix`);
+                          pdf.saveGraphicsState();
+                          resetPdfColorState(pdf, `after save #${seq} ${element.id}`);
+                          anyPdf3.setCurrentTransformationMatrix(anyPdf3.Matrix(...mPdf));
+                          pdf.setLineWidth(0);
+                          pdf.rect(localX, localY, frameW, frameH, null);
+                          pdf.clip();
+                          if (typeof pdf.discardPath === "function") pdf.discardPath();
+                          resetPdfColorState(pdf, `immediately before svg2pdf #${seq} ${element.id}`);
+                          setPdfColorFromSvg(pdf, svgToDraw, element.id);
+                          const mfCropRect = cropSvgRect(localX, localY, frameW, frameH);
+                          await svg2pdfWithDomMount(svgToDraw, pdfWithColorLogging(pdf, seq, element.id), svg2pdfOpts(mfCropRect.x, mfCropRect.y, mfCropRect.width, mfCropRect.height));
+                          debugLog(`svg2pdf DONE #${seq} elementId=${element.id}`);
+                          resetPdfColorState(pdf, `after svg2pdf #${seq} ${element.id}`);
+                          pdf.restoreGraphicsState();
+                          resetPdfColorState(pdf, `after restore #${seq} ${element.id}`);
+                          resolve();
+                        } catch (err) {
+                          reject(err);
+                        }
+                      });
+                    });
+                  }
+                }
+              } else {
+                const angle2 = norm.angle ?? 0;
+                const hasRotation2 = Math.abs(angle2) > 0.01;
+                const cx = norm.x + frameW / 2;
+                const cy = norm.y + frameH / 2;
+                if (hasRotation2 && canUseAdvancedTransforms3) {
+                  const rad = angle2 * Math.PI / 180;
+                  const cos = Math.cos(rad);
+                  const sin = Math.sin(rad);
+                  const computedM = [cos, sin, -sin, cos, cx, cy];
+                  const localX2 = -frameW / 2;
+                  const localY2 = -frameH / 2;
+                  const pdfForSvg = new Proxy(pdf, {
+                    get(target, prop) {
+                      if (prop === "advancedAPI") return () => {
+                      };
+                      return target[prop];
+                    }
+                  });
+                  await new Promise((resolve, reject) => {
+                    anyPdf3.advancedAPI(async () => {
+                      try {
+                        const seq2 = ++debugSvgDrawSequence;
+                        debugLog(`svg2pdf START #${seq2} elementId=${element.id} path=cropGroup-rotation`);
+                        resetPdfColorState(pdf, `before save #${seq2} ${element.id} rotation`);
+                        pdf.saveGraphicsState();
+                        resetPdfColorState(pdf, `after save #${seq2} ${element.id}`);
+                        anyPdf3.setCurrentTransformationMatrix(anyPdf3.Matrix(...computedM));
+                        pdf.setLineWidth(0);
+                        pdf.rect(localX2, localY2, frameW, frameH, null);
+                        pdf.clip();
+                        if (typeof pdf.discardPath === "function") pdf.discardPath();
+                        resetPdfColorState(pdf, `immediately before svg2pdf #${seq2} ${element.id}`);
+                        setPdfColorFromSvg(pdf, svgToDraw, element.id);
+                        const rotCropRect = cropSvgRect(localX2, localY2, frameW, frameH);
+                        await svg2pdfWithDomMount(svgToDraw, pdfWithColorLogging(pdf, seq2, element.id), svg2pdfOpts(rotCropRect.x, rotCropRect.y, rotCropRect.width, rotCropRect.height));
+                        debugLog(`svg2pdf DONE #${seq2} elementId=${element.id}`);
+                        resetPdfColorState(pdf, `after svg2pdf #${seq2} ${element.id}`);
+                        pdf.restoreGraphicsState();
+                        resetPdfColorState(pdf, `after restore #${seq2} ${element.id}`);
+                        resolve();
+                      } catch (e) {
+                        reject(e);
+                      }
+                    });
+                  });
+                } else {
+                  const seq3 = ++debugSvgDrawSequence;
+                  debugLog(`svg2pdf START #${seq3} elementId=${element.id} path=cropGroup-norm`);
+                  resetPdfColorState(pdf, `before save #${seq3} ${element.id} norm`);
+                  pdf.saveGraphicsState();
+                  resetPdfColorState(pdf, `after save #${seq3} ${element.id}`);
+                  pdf.setLineWidth(0);
+                  pdf.rect(norm.x, norm.y, frameW, frameH, null);
+                  pdf.clip();
+                  if (typeof pdf.discardPath === "function") pdf.discardPath();
+                  resetPdfColorState(pdf, `immediately before svg2pdf #${seq3} ${element.id}`);
+                  setPdfColorFromSvg(pdf, svgToDraw, element.id);
+                  const normCropRect = cropSvgRect(norm.x, norm.y, frameW, frameH);
+                  await svg2pdfWithDomMount(svgToDraw, pdfWithColorLogging(pdf, seq3, element.id), svg2pdfOpts(normCropRect.x, normCropRect.y, normCropRect.width, normCropRect.height));
+                  debugLog(`svg2pdf DONE #${seq3} elementId=${element.id}`);
+                  resetPdfColorState(pdf, `after svg2pdf #${seq3} ${element.id}`);
+                  pdf.restoreGraphicsState();
+                  resetPdfColorState(pdf, `after restore #${seq3} ${element.id}`);
+                }
+              }
+              pdf.setGState(pdf.GState({ opacity: 1, "stroke-opacity": 1 }));
+              return;
+            } catch {
+            }
+          }
+        }
+        const storedCrop = element.imageNaturalWidth != null && element.imageNaturalHeight != null ? {
+          naturalWidth: element.imageNaturalWidth,
+          naturalHeight: element.imageNaturalHeight,
+          panX: element.cropPanX,
+          panY: element.cropPanY,
+          zoom: element.cropZoom
+        } : void 0;
+        let png;
+        try {
+          png = await rasterizeCropGroupToPng(liveGroup, frameW, frameH, exportMultiplier, maintainResolution, imageUrlForRaster, false, storedCrop, backgroundColor);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          const isTainted = msg.includes("Tainted canvases") || (err == null ? void 0 : err.name) === "SecurityError";
+          if (isTainted && imageUrlForRaster && !imageUrlForRaster.startsWith("data:") && !imageUrlForRaster.startsWith("blob:")) {
+            png = await rasterizeCropGroupToPng(liveGroup, frameW, frameH, exportMultiplier, maintainResolution, imageUrlForRaster, true, storedCrop, backgroundColor);
+          } else {
+            throw err;
+          }
+        }
+        const anyPdf2 = pdf;
+        const canUseAdvancedTransforms2 = typeof anyPdf2.advancedAPI === "function" && typeof anyPdf2.setCurrentTransformationMatrix === "function" && typeof anyPdf2.Matrix === "function";
+        const clampedOpacity2 = Math.max(0, Math.min(1, norm.opacity));
+        pdf.setGState(pdf.GState({ opacity: clampedOpacity2 }));
+        if (!png || typeof png !== "string" || !png.startsWith("data:image/") || png.length < 200) {
+          return;
+        }
+        const fadedMasked = await bakeEdgeFadeIntoDataUrl(png, element);
+        if (fadedMasked) {
+          png = fadedMasked;
+        }
+        if (canUseAdvancedTransforms2 && fabricMatrix && fabricMatrix.length === 6) {
+          const mPdf = fabricMatrixToJsPdfAdvancedMatrix(fabricMatrix);
+          const localX = -frameW / 2;
+          const localY = -frameH / 2;
+          anyPdf2.advancedAPI(() => {
+            pdf.saveGraphicsState();
+            anyPdf2.setCurrentTransformationMatrix(anyPdf2.Matrix(...mPdf));
+            pdf.addImage(png, "PNG", localX, localY, frameW, frameH, void 0, "SLOW");
+            pdf.restoreGraphicsState();
+          });
+          pdf.setGState(pdf.GState({ opacity: 1, "stroke-opacity": 1 }));
+          return;
+        }
+        pdf.addImage(png, "PNG", norm.x, norm.y, frameW, frameH, void 0, "SLOW");
+        pdf.setGState(pdf.GState({ opacity: 1, "stroke-opacity": 1 }));
+        return;
+      }
+    }
+  }
+  const clampedOpacity = Math.max(0, Math.min(1, norm.opacity));
+  const isSvgImageElement = element.type === "image" && (element.sourceFormat === "svg" || (norm.imageUrl || "").toLowerCase().includes(".svg") || (norm.imageUrl || "").startsWith("data:image/svg+xml"));
+  pdf.setGState(pdf.GState({ opacity: isSvgImageElement ? 1 : clampedOpacity, "stroke-opacity": isSvgImageElement ? 1 : clampedOpacity }));
+  const { angle } = norm;
+  const hasRotation = Math.abs(angle) > 0.01;
+  const intrinsicW = ((fabricIntrinsic == null ? void 0 : fabricIntrinsic.w) ?? 0) > 0 ? fabricIntrinsic.w : element.width ?? norm.w;
+  const intrinsicH = ((fabricIntrinsic == null ? void 0 : fabricIntrinsic.h) ?? 0) > 0 ? fabricIntrinsic.h : element.height ?? norm.h;
+  const scaleX = element.scaleX ?? 1;
+  const scaleY = element.scaleY ?? 1;
+  const visualW = intrinsicW * scaleX;
+  const visualH = intrinsicH * scaleY;
+  const anyPdf = pdf;
+  const canUseAdvancedTransforms = typeof anyPdf.advancedAPI === "function" && typeof anyPdf.setCurrentTransformationMatrix === "function" && typeof anyPdf.Matrix === "function";
+  const drawWithMatrixAdvanced = async (fabricM) => {
+    const mPdf = fabricMatrixToJsPdfAdvancedMatrix(fabricM);
+    if (element.type === "image") {
+      const imageUrl = norm.imageUrl;
+      if (!imageUrl) return;
+      const isSvg = element.sourceFormat === "svg" || imageUrl && imageUrl.toLowerCase().includes(".svg");
+      const canVectorizeSvg = isSvg && !elementHasFade(element);
+      if (canVectorizeSvg) {
+        const svgElement = await fetchSvgAsElement(imageUrl, element.svgColorMap);
+        if (svgElement) {
+          expandSvgUseElements(svgElement, element.id);
+          const svgToDraw = normalizeSvgExplicitColors(svgElement);
+          inlineComputedStyles(svgToDraw);
+          normalizeSvgGradientStopOffsets(svgToDraw);
+          expandSvgGradientHrefs(svgToDraw);
+          resolveSvgGradientRefsToSolid(svgToDraw, element.id);
+          prefixSvgIds(svgToDraw, element.id);
+          bakeGroupOpacityIntoChildren(svgToDraw);
+          injectOpacityIntoSvg(svgToDraw, norm.opacity);
+          try {
+            const localX = -intrinsicW / 2;
+            const localY = -intrinsicH / 2;
+            const axisFrame = getAxisAlignedSvgFrameFromMatrix(mPdf, localX, localY, intrinsicW, intrinsicH);
+            const seq4 = ++debugSvgDrawSequence;
+            debugLog(`svg2pdf START #${seq4} elementId=${element.id} path=${axisFrame ? "drawContentCore-image-axis" : "drawContentCore-image-matrix"}`);
+            resetPdfColorState(pdf, `before setPdfColor #${seq4} ${element.id}`);
+            if (axisFrame) {
+              pdf.saveGraphicsState();
+              pdf.setLineWidth(0);
+              pdf.rect(axisFrame.x, axisFrame.y, axisFrame.width, axisFrame.height, null);
+              pdf.clip();
+              if (typeof pdf.discardPath === "function") pdf.discardPath();
+              resetPdfColorState(pdf, `immediately before svg2pdf #${seq4} ${element.id}`);
+              setPdfColorFromSvg(pdf, svgToDraw, element.id);
+              await svg2pdfWithDomMount(
+                svgToDraw,
+                pdfWithColorLogging(pdf, seq4, element.id),
+                svg2pdfOpts(axisFrame.x, axisFrame.y, axisFrame.width, axisFrame.height)
+              );
+              debugLog(`svg2pdf DONE #${seq4} elementId=${element.id}`);
+              resetPdfColorState(pdf, `after svg2pdf #${seq4} ${element.id}`);
+              pdf.restoreGraphicsState();
+              resetPdfColorState(pdf, `after restore #${seq4} ${element.id}`);
+            } else {
+              const transformed = buildMatrixTransformedSvgForPage(svgToDraw, mPdf, localX, localY, intrinsicW, intrinsicH);
+              if (transformed) {
+                pdf.saveGraphicsState();
+                pdf.setLineWidth(0);
+                pdf.rect(transformed.frame.x, transformed.frame.y, transformed.frame.width, transformed.frame.height, null);
+                pdf.clip();
+                if (typeof pdf.discardPath === "function") pdf.discardPath();
+                resetPdfColorState(pdf, `immediately before svg2pdf #${seq4} ${element.id}`);
+                setPdfColorFromSvg(pdf, transformed.svg, element.id);
+                await svg2pdfWithDomMount(
+                  transformed.svg,
+                  pdfWithColorLogging(pdf, seq4, element.id),
+                  svg2pdfOpts(transformed.frame.x, transformed.frame.y, transformed.frame.width, transformed.frame.height)
+                );
+                debugLog(`svg2pdf DONE #${seq4} elementId=${element.id}`);
+                resetPdfColorState(pdf, `after svg2pdf #${seq4} ${element.id}`);
+                pdf.restoreGraphicsState();
+                resetPdfColorState(pdf, `after restore #${seq4} ${element.id}`);
+              } else {
+                await new Promise((resolve, reject) => {
+                  anyPdf.advancedAPI(async () => {
+                    try {
+                      pdf.saveGraphicsState();
+                      anyPdf.setCurrentTransformationMatrix(anyPdf.Matrix(...mPdf));
+                      resetPdfColorState(pdf, `immediately before svg2pdf #${seq4} ${element.id}`);
+                      setPdfColorFromSvg(pdf, svgToDraw, element.id);
+                      await svg2pdfWithDomMount(svgToDraw, pdfWithColorLogging(pdf, seq4, element.id), svg2pdfOpts(localX, localY, intrinsicW, intrinsicH));
+                      debugLog(`svg2pdf DONE #${seq4} elementId=${element.id}`);
+                      resetPdfColorState(pdf, `after svg2pdf #${seq4} ${element.id}`);
+                      pdf.restoreGraphicsState();
+                      resetPdfColorState(pdf, `after restore #${seq4} ${element.id}`);
+                      resolve();
+                    } catch (err) {
+                      reject(err);
+                    }
+                  });
+                });
+              }
+            }
+          } catch {
+            const imageData2 = await fetchImageAsBase64(imageUrl, {
+              backgroundColor,
+              targetWidthPt: visualW,
+              targetHeightPt: visualH,
+              preserveAlpha: isSvg || visualW > canvasWidth * 0.7 && visualH > canvasHeight * 0.7,
+              resolutionMultiplier: 4
+            });
+            if (imageData2) {
+              const fadedAdv = await bakeEdgeFadeIntoDataUrl(imageData2.data, element);
+              if (fadedAdv) {
+                imageData2.data = fadedAdv;
+                imageData2.format = "PNG";
+              }
+              anyPdf.advancedAPI(() => {
+                pdf.saveGraphicsState();
+                anyPdf.setCurrentTransformationMatrix(anyPdf.Matrix(...mPdf));
+                const localX = -intrinsicW / 2;
+                const localY = -intrinsicH / 2;
+                pdf.addImage(imageData2.data, imageData2.format, localX, localY, intrinsicW, intrinsicH, void 0, "SLOW");
+                pdf.restoreGraphicsState();
+              });
+            }
+          }
+          return;
+        }
+      }
+      const preserveAlpha = isSvg || visualW > canvasWidth * 0.7 && visualH > canvasHeight * 0.7;
+      const imageData = await fetchImageAsBase64(imageUrl, {
+        backgroundColor,
+        targetWidthPt: visualW,
+        targetHeightPt: visualH,
+        preserveAlpha: preserveAlpha || elementHasFade(element),
+        resolutionMultiplier: isSvg ? 4 : void 0
+      });
+      if (!imageData) return;
+      const fadedMain = await bakeEdgeFadeIntoDataUrl(imageData.data, element);
+      if (fadedMain) {
+        imageData.data = fadedMain;
+        imageData.format = "PNG";
+      }
+      anyPdf.advancedAPI(() => {
+        pdf.saveGraphicsState();
+        anyPdf.setCurrentTransformationMatrix(anyPdf.Matrix(...mPdf));
+        const localX = -intrinsicW / 2;
+        const localY = -intrinsicH / 2;
+        pdf.addImage(imageData.data, imageData.format, localX, localY, intrinsicW, intrinsicH, void 0, "SLOW");
+        pdf.restoreGraphicsState();
+      });
+      return;
+    }
+    anyPdf.advancedAPI(() => {
+      pdf.saveGraphicsState();
+      anyPdf.setCurrentTransformationMatrix(anyPdf.Matrix(...mPdf));
+      const localX = -intrinsicW / 2;
+      const localY = -intrinsicH / 2;
+      const normForMatrix = withCompensatedStrokeWidth(norm, element, fabricM);
+      void drawElementContentCore(
+        pdf,
+        element,
+        normForMatrix,
+        localX,
+        localY,
+        intrinsicW,
+        intrinsicH,
+        embeddedFonts,
+        canvasWidth,
+        canvasHeight,
+        backgroundColor,
+        1,
+        liveFabricText ?? void 0
+      );
+      pdf.restoreGraphicsState();
+    });
+  };
+  const hasIndividualRoundedCorners = element.type === "shape" && norm.shapeType === "rounded-rect" && (norm.rxTL != null || norm.rxTR != null || norm.rxBR != null || norm.rxBL != null);
+  const hasNonIdentityScale = Math.abs(scaleX - 1) > 1e-4 || Math.abs(scaleY - 1) > 1e-4;
+  const hasSkew = Math.abs(norm.skewX) > 0.01 || Math.abs(norm.skewY) > 0.01;
+  const hasLiveFabricMatrix = !!(fabricMatrix && fabricMatrix.length === 6);
+  const canDrawRoundedRectInPageSpace = hasIndividualRoundedCorners && !hasLiveFabricMatrix && !hasNonIdentityScale && !hasRotation && !hasSkew && !(element.flipX ?? false) && !(element.flipY ?? false);
+  if (canDrawRoundedRectInPageSpace) {
+    await drawElementContent(
+      pdf,
+      element,
+      norm,
+      norm.x,
+      norm.y,
+      visualW,
+      visualH,
+      embeddedFonts,
+      canvasWidth,
+      canvasHeight,
+      backgroundColor,
+      scaleY,
+      liveFabricText ?? void 0
+    );
+    pdf.setGState(pdf.GState({ opacity: 1, "stroke-opacity": 1 }));
+    const linkUrl2 = (_i = element.linkConfig) == null ? void 0 : _i.url;
+    if (linkUrl2) {
+      addLinkAnnotation(pdf, linkUrl2, norm.x, norm.y, visualW, visualH);
+    }
+    debugLog(`drawElement END id=${element.id}`);
+    return;
+  }
+  if (canUseAdvancedTransforms && fabricMatrix && fabricMatrix.length === 6) {
+    await drawWithMatrixAdvanced(fabricMatrix);
+  } else if (canUseAdvancedTransforms && hasIndividualRoundedCorners && hasNonIdentityScale) {
+    const cx = norm.x + visualW / 2;
+    const cy = norm.y + visualH / 2;
+    const computedFabricM = [scaleX, 0, 0, scaleY, cx, cy];
+    await drawWithMatrixAdvanced(computedFabricM);
+  } else if (canUseAdvancedTransforms && hasRotation) {
+    const cx = norm.x + visualW / 2;
+    const cy = norm.y + visualH / 2;
+    const radians = angle * Math.PI / 180;
+    const cos = Math.cos(radians);
+    const sin = Math.sin(radians);
+    const computedFabricM = [
+      scaleX * cos,
+      scaleX * sin,
+      -scaleY * sin,
+      scaleY * cos,
+      cx,
+      cy
+    ];
+    await drawWithMatrixAdvanced(computedFabricM);
+  } else if (fabricMatrix && fabricMatrix.length === 6) {
+    pdf.saveGraphicsState();
+    if (typeof anyPdf.setCurrentTransformationMatrix === "function" && typeof anyPdf.Matrix === "function") {
+      const [a, b, c, d, e, f] = fabricMatrix;
+      anyPdf.setCurrentTransformationMatrix(anyPdf.Matrix(a, b, c, d, e, f));
+    }
+    const localX = -intrinsicW / 2;
+    const localY = -intrinsicH / 2;
+    const normForMatrix = withCompensatedStrokeWidth(norm, element, fabricMatrix);
+    await drawElementContentWithIntrinsic(
+      pdf,
+      element,
+      normForMatrix,
+      localX,
+      localY,
+      intrinsicW,
+      intrinsicH,
+      embeddedFonts,
+      canvasWidth,
+      canvasHeight,
+      backgroundColor,
+      liveFabricText ?? void 0
+    );
+    pdf.restoreGraphicsState();
+  } else if (hasRotation) {
+    const cx = norm.x + visualW / 2;
+    const cy = norm.y + visualH / 2;
+    const radians = angle * Math.PI / 180;
+    const cos = Math.cos(radians);
+    const sin = Math.sin(radians);
+    const computedMatrix = [scaleX * cos, scaleX * sin, -scaleY * sin, scaleY * cos, cx, cy];
+    pdf.saveGraphicsState();
+    if (typeof anyPdf.setCurrentTransformationMatrix === "function" && typeof anyPdf.Matrix === "function") {
+      anyPdf.setCurrentTransformationMatrix(anyPdf.Matrix(...computedMatrix));
+    }
+    const localX = -intrinsicW / 2;
+    const localY = -intrinsicH / 2;
+    const normForMatrix = withCompensatedStrokeWidth(norm, element, computedMatrix);
+    await drawElementContentWithIntrinsic(
+      pdf,
+      element,
+      normForMatrix,
+      localX,
+      localY,
+      intrinsicW,
+      intrinsicH,
+      embeddedFonts,
+      canvasWidth,
+      canvasHeight,
+      backgroundColor,
+      liveFabricText ?? void 0
+    );
+    pdf.restoreGraphicsState();
+  } else {
+    await drawElementContent(
+      pdf,
+      element,
+      norm,
+      norm.x,
+      norm.y,
+      visualW,
+      visualH,
+      embeddedFonts,
+      canvasWidth,
+      canvasHeight,
+      backgroundColor,
+      scaleY,
+      liveFabricText ?? void 0
+    );
+  }
+  pdf.setGState(pdf.GState({ opacity: 1, "stroke-opacity": 1 }));
+  const linkUrl = (_j = element.linkConfig) == null ? void 0 : _j.url;
+  if (linkUrl) {
+    addLinkAnnotation(pdf, linkUrl, norm.x, norm.y, visualW, visualH);
+  }
+  debugLog(`drawElement END id=${element.id}`);
+}
+async function drawElementContent(pdf, element, norm, x, y, w, h, embeddedFonts, canvasWidth, canvasHeight, backgroundColor, fontScale = 1, liveFabricText) {
+  await drawElementContentCore(pdf, element, norm, x, y, w, h, embeddedFonts, canvasWidth, canvasHeight, backgroundColor, fontScale, liveFabricText);
+}
+async function drawElementContentWithIntrinsic(pdf, element, norm, x, y, intrinsicW, intrinsicH, embeddedFonts, canvasWidth, canvasHeight, backgroundColor, liveFabricText) {
+  await drawElementContentCore(pdf, element, norm, x, y, intrinsicW, intrinsicH, embeddedFonts, canvasWidth, canvasHeight, backgroundColor, 1, liveFabricText);
+}
+async function drawElementContentCore(pdf, element, norm, x, y, w, h, embeddedFonts, canvasWidth, canvasHeight, backgroundColor, fontScale = 1, liveFabricText) {
+  var _a;
+  switch (element.type) {
+    case "shape": {
+      const { shapeType, fill, stroke, strokeWidth, borderRadius, rxTL, rxTR, rxBR, rxBL } = norm;
+      const canonicalShape = normalizeShapeType(shapeType);
+      if (canonicalShape === "rounded-rect") {
+        drawRect(pdf, x, y, w, h, fill, stroke, strokeWidth, borderRadius, rxTL, rxTR, rxBR, rxBL);
+      } else if (canonicalShape === "circle") {
+        const diameter = Math.max(1, Math.min(w, h));
+        drawEllipse(pdf, x + diameter / 2, y + diameter / 2, diameter / 2, diameter / 2, fill, stroke, strokeWidth);
+      } else if (canonicalShape === "triangle") {
+        const rTop = Math.max(0, Number(norm.triRTop ?? 0));
+        const rBR = Math.max(0, Number(norm.triRBR ?? 0));
+        const rBL = Math.max(0, Number(norm.triRBL ?? 0));
+        const hasRounding = rTop > 0 || rBR > 0 || rBL > 0;
+        if (hasRounding) {
+          const pathStr = buildRoundedTrianglePath(w, h, rTop, rBR, rBL);
+          drawRoundedTrianglePdf(pdf, x, y, w, h, pathStr, fill, stroke, strokeWidth);
+        } else {
+          const points = getTrianglePoints(x, y, w, h);
+          drawPolygon(pdf, points, fill, stroke, strokeWidth);
+        }
+      } else {
+        const points = getShapePoints(shapeType, x, y, w, h);
+        if (points) {
+          drawPolygon(pdf, points, fill, stroke, strokeWidth);
+        }
+      }
+      break;
+    }
+    case "line": {
+      const { stroke, strokeWidth, strokeDashArray } = norm;
+      drawLine(pdf, x, y, x + w, y, stroke, strokeWidth || 2, strokeDashArray);
+      break;
+    }
+    case "text": {
+      const { text: originalText, fontSize, fontFamily, fontWeight, fontStyle, underline, letterSpacing, fill, textAlign, lineHeight, splitByGrapheme } = norm;
+      const overflowPolicy = element.overflowPolicy || "grow-and-push";
+      (element.minFontSize || 8) * fontScale;
+      const maxLines = element.maxLines || 3;
+      const effectiveSplitByGrapheme = overflowPolicy === "auto-shrink" ? false : splitByGrapheme;
+      let finalText = originalText;
+      let finalFontSize = fontSize * fontScale;
+      if (overflowPolicy === "auto-shrink") {
+        const explicitLineCount = Math.max(1, finalText.split("\n").length);
+        const measureWidth = Math.max(1, w / PX_TO_PT);
+        while (finalFontSize > 1) {
+          const testTextbox = new fabric.Textbox(finalText, {
+            width: measureWidth,
+            fontSize: finalFontSize / PX_TO_PT,
+            fontFamily,
+            fontWeight,
+            fontStyle,
+            lineHeight: lineHeight || 1.2,
+            charSpacing: letterSpacing || 0,
+            splitByGrapheme: false
+          });
+          testTextbox.initDimensions();
+          const textHeight = (testTextbox.height || 0) * PX_TO_PT;
+          const renderedLineCount = ((_a = testTextbox.textLines) == null ? void 0 : _a.length) || 1;
+          const hasNoImplicitWrap = renderedLineCount <= explicitLineCount;
+          const fitsHeight = h <= 0 || textHeight <= h;
+          const actualTextboxWidth = testTextbox.width ?? measureWidth;
+          const widthDidGrow = actualTextboxWidth > measureWidth + 0.5;
+          const lineWidths = testTextbox.__lineWidths;
+          const maxLineWidth = lineWidths && lineWidths.length > 0 ? Math.max(...lineWidths) : 0;
+          const fitsWidth = !widthDidGrow && maxLineWidth <= measureWidth + 1;
+          if (hasNoImplicitWrap && fitsHeight && fitsWidth) {
+            break;
+          }
+          finalFontSize--;
+        }
+      }
+      if (overflowPolicy === "max-lines-ellipsis") {
+        const testTextbox = new fabric.Textbox(originalText, {
+          width: w / PX_TO_PT,
+          fontSize: finalFontSize / PX_TO_PT,
+          fontFamily,
+          lineHeight: lineHeight || 1.2,
+          splitByGrapheme: effectiveSplitByGrapheme
+        });
+        testTextbox.initDimensions();
+        const lines = testTextbox.textLines || [];
+        if (lines.length > maxLines) {
+          const countLines = (testText) => {
+            var _a2;
+            const tb = new fabric.Textbox(testText, {
+              width: w / PX_TO_PT,
+              fontSize: finalFontSize / PX_TO_PT,
+              fontFamily,
+              lineHeight: lineHeight || 1.2,
+              splitByGrapheme: effectiveSplitByGrapheme
+            });
+            tb.initDimensions();
+            return ((_a2 = tb.textLines) == null ? void 0 : _a2.length) || 1;
+          };
+          let low = 0;
+          let high = originalText.length;
+          let result = originalText;
+          while (low < high) {
+            const mid = Math.floor((low + high + 1) / 2);
+            const testText = originalText.slice(0, mid) + "...";
+            const lineCount = countLines(testText);
+            if (lineCount <= maxLines) {
+              low = mid;
+              result = testText;
+            } else {
+              high = mid - 1;
+            }
+          }
+          if (result.endsWith("...") && result.length > 3) {
+            const beforeEllipsis = result.slice(0, -3).trimEnd();
+            result = beforeEllipsis + "...";
+          }
+          finalText = result;
+        }
+      }
+      drawText(pdf, finalText, x, y, w, finalFontSize, fontFamily, fontWeight, fontStyle, underline, letterSpacing, fill, textAlign, lineHeight, embeddedFonts, effectiveSplitByGrapheme, liveFabricText);
+      break;
+    }
+    case "image": {
+      const { imageUrl } = norm;
+      if (imageUrl) {
+        const isSvg = element.sourceFormat === "svg" || imageUrl.toLowerCase().includes(".svg");
+        const hasStoredCrop = Boolean(
+          element.useCropHandles || element.cropZoom != null || element.cropPanX != null || element.cropPanY != null
+        );
+        if (hasStoredCrop && isSvg && !elementHasFade(element)) {
+          const svgElement = await fetchSvgAsElement(imageUrl, element.svgColorMap);
+          if (svgElement) {
+            expandSvgUseElements(svgElement, element.id);
+            const svgToDraw = normalizeSvgExplicitColors(svgElement);
+            inlineComputedStyles(svgToDraw);
+            normalizeSvgGradientStopOffsets(svgToDraw);
+            expandSvgGradientHrefs(svgToDraw);
+            resolveSvgGradientRefsToSolid(svgToDraw, element.id);
+            prefixSvgIds(svgToDraw, element.id);
+            bakeGroupOpacityIntoChildren(svgToDraw);
+            injectOpacityIntoSvg(svgToDraw, norm.opacity);
+            const cropZoom = Math.max(1, Number(element.cropZoom ?? 1));
+            const cropPanX = Math.max(0, Math.min(1, Number(element.cropPanX ?? 0.5)));
+            const cropPanY = Math.max(0, Math.min(1, Number(element.cropPanY ?? 0.5)));
+            const naturalW = Math.max(1, Number(element.imageNaturalWidth ?? 0) || w);
+            const naturalH = Math.max(1, Number(element.imageNaturalHeight ?? 0) || h);
+            const fitContain = (element.imageFit ?? "cover") === "contain";
+            const baseScale = fitContain ? Math.min(w / naturalW, h / naturalH) : Math.max(w / naturalW, h / naturalH);
+            const finalScale = baseScale * (fitContain ? 1 : cropZoom);
+            const drawW = naturalW * finalScale;
+            const drawH = naturalH * finalScale;
+            const overflowX = Math.max(0, drawW - w);
+            const overflowY = Math.max(0, drawH - h);
+            const offsetX = overflowX > 0 ? -overflowX * (cropPanX - 0.5) : 0;
+            const offsetY = overflowY > 0 ? -overflowY * (cropPanY - 0.5) : 0;
+            const svgX = x + w / 2 + offsetX - drawW / 2;
+            const svgY = y + h / 2 + offsetY - drawH / 2;
+            try {
+              const seq6 = ++debugSvgDrawSequence;
+              debugLog(`svg2pdf START #${seq6} elementId=${element.id} path=drawElement-svg-crop`);
+              pdf.saveGraphicsState();
+              pdf.setLineWidth(0);
+              pdf.rect(x, y, w, h, null);
+              pdf.clip();
+              if (typeof pdf.discardPath === "function") pdf.discardPath();
+              resetPdfColorState(pdf, `before svg2pdf #${seq6} ${element.id}`);
+              setPdfColorFromSvg(pdf, svgToDraw, element.id);
+              pdf.setGState(pdf.GState({ opacity: 1, "stroke-opacity": 1 }));
+              await svg2pdfWithDomMount(svgToDraw, pdfWithColorLogging(pdf, seq6, element.id), svg2pdfOpts(svgX, svgY, drawW, drawH));
+              debugLog(`svg2pdf DONE #${seq6} elementId=${element.id}`);
+              resetPdfColorState(pdf, `after svg2pdf #${seq6} ${element.id}`);
+              pdf.restoreGraphicsState();
+              resetPdfColorState(pdf, `after restore #${seq6} ${element.id}`);
+              break;
+            } catch {
+              pdf.restoreGraphicsState();
+            }
+          }
+        }
+        if (hasStoredCrop && !isSvg) {
+          const croppedPng = await rasterizeStoredCropImageToPng({
+            imageUrl,
+            frameW: w,
+            frameH: h,
+            clipShape: element.clipShape,
+            borderRadius: Number(element.rx ?? element.borderRadius ?? norm.borderRadius ?? 0) || 0,
+            panX: Number(element.cropPanX ?? 0.5),
+            panY: Number(element.cropPanY ?? 0.5),
+            zoom: Number(element.cropZoom ?? 1),
+            naturalWidth: Number(element.imageNaturalWidth ?? 0),
+            naturalHeight: Number(element.imageNaturalHeight ?? 0),
+            maintainResolution: element.maintainResolution !== false,
+            backgroundColor
+          });
+          if (croppedPng) {
+            try {
+              const fadedCrop = await bakeEdgeFadeIntoDataUrl(croppedPng, element);
+              const finalCropPng = fadedCrop || croppedPng;
+              pdf.addImage(finalCropPng, "PNG", x, y, w, h, void 0, "SLOW");
+              break;
+            } catch {
+            }
+          }
+        }
+        const canVectorizeSvg = isSvg && !elementHasFade(element);
+        if (canVectorizeSvg) {
+          const svgElement = await fetchSvgAsElement(imageUrl, element.svgColorMap);
+          if (svgElement) {
+            expandSvgUseElements(svgElement, element.id);
+            const svgToDraw = normalizeSvgExplicitColors(svgElement);
+            inlineComputedStyles(svgToDraw);
+            normalizeSvgGradientStopOffsets(svgToDraw);
+            expandSvgGradientHrefs(svgToDraw);
+            resolveSvgGradientRefsToSolid(svgToDraw, element.id);
+            prefixSvgIds(svgToDraw, element.id);
+            bakeGroupOpacityIntoChildren(svgToDraw);
+            injectOpacityIntoSvg(svgToDraw, norm.opacity);
+            try {
+              const seq5 = ++debugSvgDrawSequence;
+              debugLog(`svg2pdf START #${seq5} elementId=${element.id} path=drawElement-image`);
+              pdf.saveGraphicsState();
+              resetPdfColorState(pdf, `before svg2pdf #${seq5} ${element.id}`);
+              resetPdfColorState(pdf, `immediately before svg2pdf #${seq5} ${element.id}`);
+              setPdfColorFromSvg(pdf, svgToDraw, element.id);
+              await svg2pdfWithDomMount(svgToDraw, pdfWithColorLogging(pdf, seq5, element.id), svg2pdfOpts(x, y, w, h));
+              debugLog(`svg2pdf DONE #${seq5} elementId=${element.id}`);
+              resetPdfColorState(pdf, `after svg2pdf #${seq5} ${element.id}`);
+              pdf.restoreGraphicsState();
+              resetPdfColorState(pdf, `after restore #${seq5} ${element.id}`);
+            } catch {
+              const rasterUrl = await getRecoloredSvgDataUrl(imageUrl, element.svgColorMap) || imageUrl;
+              const imageData2 = await fetchImageAsBase64(rasterUrl, {
+                backgroundColor,
+                targetWidthPt: w,
+                targetHeightPt: h,
+                preserveAlpha: true,
+                resolutionMultiplier: 4
+              });
+              if (imageData2) {
+                const fadedFallback = await bakeEdgeFadeIntoDataUrl(imageData2.data, element);
+                if (fadedFallback) {
+                  imageData2.data = fadedFallback;
+                  imageData2.format = "PNG";
+                }
+                try {
+                  pdf.addImage(imageData2.data, imageData2.format, x, y, w, h, void 0, "SLOW");
+                } catch {
+                }
+              }
+            }
+            break;
+          }
+        }
+        const rasterUrlFinal = isSvg ? await getRecoloredSvgDataUrl(imageUrl, element.svgColorMap) || imageUrl : imageUrl;
+        const preserveAlpha = isSvg || w > canvasWidth * 0.7 && h > canvasHeight * 0.7;
+        const imageData = await fetchImageAsBase64(rasterUrlFinal, {
+          backgroundColor,
+          targetWidthPt: w,
+          targetHeightPt: h,
+          preserveAlpha: preserveAlpha || elementHasFade(element),
+          resolutionMultiplier: isSvg ? 4 : void 0
+        });
+        if (imageData) {
+          const faded = await bakeEdgeFadeIntoDataUrl(imageData.data, element);
+          if (faded) {
+            imageData.data = faded;
+            imageData.format = "PNG";
+          }
+          try {
+            pdf.addImage(imageData.data, imageData.format, x, y, w, h, void 0, "SLOW");
+          } catch {
+          }
+        }
+      }
+      break;
+    }
+  }
+}
+async function exportFabricCanvasToVectorPdf(_fabricCanvas, options) {
+  const { filename = "document.pdf", width, height, title, elements, backgroundColor } = options;
+  const orientation = width > height ? "landscape" : "portrait";
+  const pdf = new jsPDF({
+    orientation,
+    unit: "px",
+    format: [width, height],
+    hotfixes: ["px_scaling"],
+    compress: true
+  });
+  if (title) {
+    pdf.setProperties({ title, creator: "DocuForge" });
+  }
+  if (backgroundColor && backgroundColor !== "transparent") {
+    const bgColor = parseColor(backgroundColor);
+    if (bgColor) {
+      pdf.setFillColor(bgColor.r, bgColor.g, bgColor.b);
+      pdf.rect(0, 0, width, height, "F");
+    }
+  }
+  const fontKeysNeeded = /* @__PURE__ */ new Set();
+  const italicKeysNeeded = /* @__PURE__ */ new Set();
+  elements.forEach((el) => {
+    var _a;
+    if (el.type === "text") {
+      const norm = normalizeElement(el);
+      const { fontFamily, fontWeight } = norm;
+      if (fontFamily) {
+        const resolved = resolveFontWeight(fontWeight ?? 400);
+        fontKeysNeeded.add(`${fontFamily}${FONT_KEY_SEP}${resolved}`);
+        const fontStyleRaw = el.fontStyle || ((_a = el.style) == null ? void 0 : _a.fontStyle) || "normal";
+        if (fontStyleRaw === "italic") {
+          italicKeysNeeded.add(`${fontFamily}${FONT_KEY_SEP}${resolved}${FONT_KEY_SEP}italic`);
+        }
+      }
+    }
+  });
+  fontKeysNeeded.add(`${FONT_FALLBACK_SYMBOLS}${FONT_KEY_SEP}400`);
+  fontKeysNeeded.add(`${FONT_FALLBACK_MATH}${FONT_KEY_SEP}400`);
+  for (const w of [300, 400, 500, 600, 700]) {
+    fontKeysNeeded.add(`${FONT_FALLBACK_DEVANAGARI}${FONT_KEY_SEP}${w}`);
+  }
+  const embeddedFonts = /* @__PURE__ */ new Set();
+  for (const key of fontKeysNeeded) {
+    const sep = key.indexOf(FONT_KEY_SEP);
+    const fontName = key.slice(0, sep);
+    const weight = parseInt(key.slice(sep + 1), 10);
+    const success = await embedFontWithGoogleFallback(pdf, fontName, weight);
+    if (success) embeddedFonts.add(key);
+  }
+  for (const key of italicKeysNeeded) {
+    const parts = key.split(FONT_KEY_SEP);
+    const fontName = parts[0];
+    const weight = parseInt(parts[1], 10);
+    const success = await embedFontWithGoogleFallback(pdf, fontName, weight, true);
+    if (success) embeddedFonts.add(key);
+  }
+  debugLog(`single-page export: drawing ${elements.length} elements (order = first=back, last=front)`);
+  elements.forEach((el, i) => debugLog(`  [${i}] id=${el.id} type=${el.type}`));
+  for (const element of elements) {
+    await drawElement(pdf, element, embeddedFonts, width, height, backgroundColor);
+  }
+  pdf.save(filename);
+}
+function isGroupBackgroundDrawable(item) {
+  return item.type === "groupBackground";
+}
+function buildPageDrawList(children, pageTree, visibilityFilter) {
+  const out = [];
+  function visit(nodes, reverseGroupChildren) {
+    const list = reverseGroupChildren ? [...nodes].reverse() : nodes;
+    for (const n of list) {
+      if (isElement(n)) {
+        if (visibilityFilter === "strict" ? n.visible !== false : n.visible) out.push(n);
+      } else if (isGroup(n)) {
+        const g = n;
+        if (g.backgroundColor && g.backgroundColor !== "transparent") {
+          const abs = getAbsoluteBounds(g, pageTree);
+          out.push({
+            type: "groupBackground",
+            id: g.id,
+            left: abs.left,
+            top: abs.top,
+            width: Math.max(1, abs.width),
+            height: Math.max(1, abs.height),
+            fill: g.backgroundColor
+          });
+        }
+        visit(g.children ?? [], true);
+      }
+    }
+  }
+  visit(children, false);
+  return out;
+}
+function preparePagesForExport(pages, canvasWidth, canvasHeight, options) {
+  const { sortByTop = false, visibilityFilter = "strict" } = options || {};
+  return pages.map((page) => {
+    var _a, _b;
+    const pageChildren = page.children || [];
+    const drawList = buildPageDrawList(pageChildren, pageChildren, visibilityFilter);
+    const elements = sortByTop && drawList.every((item) => !isGroupBackgroundDrawable(item)) ? [...drawList].sort((a, b) => {
+      var _a2, _b2;
+      const aTop = "top" in a ? a.top ?? ((_a2 = a.position) == null ? void 0 : _a2.y) ?? 0 : 0;
+      const bTop = "top" in b ? b.top ?? ((_b2 = b.position) == null ? void 0 : _b2.y) ?? 0 : 0;
+      return aTop - bTop;
+    }) : drawList;
+    return {
+      pageId: page.id,
+      elements,
+      pageChildren,
+      width: canvasWidth,
+      height: canvasHeight,
+      backgroundColor: ((_a = page.settings) == null ? void 0 : _a.backgroundColor) || "#ffffff",
+      backgroundGradient: (_b = page.settings) == null ? void 0 : _b.backgroundGradient
+    };
+  });
+}
+async function exportMultiPagePdf(pages, options) {
+  var _a, _b, _c, _d, _e;
+  const { filename = "document.pdf", title, watermark = false, returnBlob = false } = options;
+  if (pages.length === 0) {
+    throw new Error("No pages to export");
+  }
+  const firstPage = pages[0];
+  const orientation = firstPage.width > firstPage.height ? "landscape" : "portrait";
+  const pdf = new jsPDF({
+    orientation,
+    unit: "px",
+    format: [firstPage.width, firstPage.height],
+    hotfixes: ["px_scaling"],
+    compress: true
+  });
+  if (title) {
+    pdf.setProperties({ title, creator: "DocuForge" });
+  }
+  const fontKeysNeeded = /* @__PURE__ */ new Set();
+  const italicKeysNeeded = /* @__PURE__ */ new Set();
+  pages.forEach((page) => {
+    page.elements.forEach((item) => {
+      var _a2;
+      if (!isGroupBackgroundDrawable(item) && item.type === "text") {
+        const norm = normalizeElement(item);
+        const { fontFamily, fontWeight } = norm;
+        if (fontFamily) {
+          const resolved = resolveFontWeight(fontWeight ?? 400);
+          fontKeysNeeded.add(`${fontFamily}${FONT_KEY_SEP}${resolved}`);
+          const fontStyleRaw = item.fontStyle || ((_a2 = item.style) == null ? void 0 : _a2.fontStyle) || "normal";
+          if (fontStyleRaw === "italic") {
+            italicKeysNeeded.add(`${fontFamily}${FONT_KEY_SEP}${resolved}${FONT_KEY_SEP}italic`);
+          }
+        }
+      }
+    });
+  });
+  fontKeysNeeded.add(`${FONT_FALLBACK_SYMBOLS}${FONT_KEY_SEP}400`);
+  fontKeysNeeded.add(`${FONT_FALLBACK_MATH}${FONT_KEY_SEP}400`);
+  for (const w of [300, 400, 500, 600, 700]) {
+    fontKeysNeeded.add(`${FONT_FALLBACK_DEVANAGARI}${FONT_KEY_SEP}${w}`);
+  }
+  const embeddedFonts = /* @__PURE__ */ new Set();
+  for (const key of fontKeysNeeded) {
+    const sep = key.indexOf(FONT_KEY_SEP);
+    const fontName = key.slice(0, sep);
+    const weight = parseInt(key.slice(sep + 1), 10);
+    const success = await embedFontWithGoogleFallback(pdf, fontName, weight);
+    if (success) embeddedFonts.add(key);
+    await yieldToUI();
+  }
+  for (const key of italicKeysNeeded) {
+    const parts = key.split(FONT_KEY_SEP);
+    const fontName = parts[0];
+    const weight = parseInt(parts[1], 10);
+    const success = await embedFontWithGoogleFallback(pdf, fontName, weight, true);
+    if (success) embeddedFonts.add(key);
+    await yieldToUI();
+  }
+  await yieldToUI();
+  for (let pageIndex = 0; pageIndex < pages.length; pageIndex++) {
+    const page = pages[pageIndex];
+    if (pageIndex > 0) {
+      const pageOrientation = page.width > page.height ? "landscape" : "portrait";
+      pdf.addPage([page.width, page.height], pageOrientation);
+    }
+    if (page.backgroundGradient && ((_a = page.backgroundGradient.stops) == null ? void 0 : _a.length) >= 2) {
+      const grad = page.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) {
+          const last = normalizedStops[normalizedStops.length - 1];
+          normalizedStops.push({ offset: 1, color: last.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], [page.width, 0], [page.width, page.height], [0, page.height]];
+            const projs = corners.map(([x, y]) => x * sinA - y * cosA);
+            const minP = Math.min(...projs);
+            const maxP = Math.max(...projs);
+            const gradLen = maxP - minP;
+            const midX = page.width / 2;
+            const midY = page.height / 2;
+            const halfLen = gradLen / 2;
+            const x1 = midX - sinA * halfLen;
+            const y1 = midY + cosA * halfLen;
+            const x2 = midX + sinA * halfLen;
+            const y2 = midY - cosA * halfLen;
+            let finalStops = shadingColors;
+            if (isConic && shadingColors.length >= 2) {
+              const reversed = [...shadingColors].reverse().map((s, idx, arr) => ({
+                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 ShadingPattern("axial", [x1, y1, x2, y2], finalStops)
+            );
+          } else {
+            const cx = (grad.cx ?? 0.5) * page.width;
+            const cy = (grad.cy ?? 0.5) * page.height;
+            const maxR = (grad.r ?? 0.5) * Math.max(page.width, page.height);
+            doc.addShadingPattern(
+              patternKey,
+              new ShadingPattern("radial", [cx, cy, 0, cx, cy, maxR], shadingColors)
+            );
+          }
+          doc.rect(0, 0, page.width, page.height);
+          doc.fill({ key: patternKey, matrix: doc.Matrix(1, 0, 0, 1, 0, 0) });
+        });
+      } catch (e) {
+        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, page.width, page.height, "F");
+      }
+    } else {
+      const bgColor = parseColor(page.backgroundColor && page.backgroundColor !== "transparent" ? page.backgroundColor : "#ffffff");
+      debugLog(`page ${pageIndex + 1} background: ${page.backgroundColor ?? "default"} → rgb(${(bgColor == null ? void 0 : bgColor.r) ?? 0},${(bgColor == null ? void 0 : bgColor.g) ?? 0},${(bgColor == null ? void 0 : bgColor.b) ?? 0})`);
+      if (bgColor) {
+        pdf.setFillColor(bgColor.r, bgColor.g, bgColor.b);
+        pdf.rect(0, 0, page.width, page.height, "F");
+      }
+    }
+    const liveCanvasForPage = page.pageId ? getCanvasForPage(page.pageId) : null;
+    let allowLiveCanvasFallback = !!liveCanvasForPage;
+    if (liveCanvasForPage) {
+      let previousSvgViewportTransformation;
+      let previousViewportTransform;
+      try {
+        previousSvgViewportTransformation = liveCanvasForPage.svgViewportTransformation;
+        previousViewportTransform = liveCanvasForPage.viewportTransform ? [...liveCanvasForPage.viewportTransform] : void 0;
+        liveCanvasForPage.viewportTransform = [1, 0, 0, 1, 0, 0];
+        liveCanvasForPage.svgViewportTransformation = true;
+        const liveSvgString = liveCanvasForPage.toSVG();
+        const liveSvgWidth = page.width;
+        const liveSvgHeight = page.height;
+        const liveSvg = await prepareLiveCanvasSvgForPdf(
+          liveSvgString,
+          liveSvgWidth,
+          liveSvgHeight,
+          `page-${pageIndex + 1}`,
+          { stripPageBackground: !!page.backgroundGradient }
+        );
+        if (liveSvg) {
+          const seq = ++debugSvgDrawSequence;
+          console.log(`[client-pdf-export] live SVG path active for page ${pageIndex + 1}`);
+          debugLog(`live canvas svg2pdf START #${seq} page=${pageIndex + 1}`);
+          resetPdfColorState(pdf, `before live canvas svg2pdf page ${pageIndex + 1}`);
+          setPdfColorFromSvg(pdf, liveSvg, `page-${pageIndex + 1}`);
+          await svg2pdfWithDomMount(
+            liveSvg,
+            pdfWithColorLogging(pdf, seq, `page-${pageIndex + 1}`),
+            svg2pdfOpts(0, 0, page.width, page.height)
+          );
+          debugLog(`live canvas svg2pdf DONE #${seq} page=${pageIndex + 1}`);
+          resetPdfColorState(pdf, `after live canvas svg2pdf page ${pageIndex + 1}`);
+          await yieldToUI();
+          continue;
+        }
+        allowLiveCanvasFallback = false;
+        console.error(`[client-pdf-export] live SVG prep returned null for page ${pageIndex + 1}`, {
+          pageId: page.pageId,
+          hasLiveCanvas: !!liveCanvasForPage,
+          svgLength: (liveSvgString == null ? void 0 : liveSvgString.length) ?? 0
+        });
+      } catch (error) {
+        allowLiveCanvasFallback = false;
+        console.error(`[client-pdf-export] live SVG export failed for page ${pageIndex + 1}`, error);
+      } finally {
+        liveCanvasForPage.svgViewportTransformation = previousSvgViewportTransformation;
+        if (previousViewportTransform) {
+          liveCanvasForPage.viewportTransform = previousViewportTransform;
+        }
+      }
+    }
+    const matrixByElementId = /* @__PURE__ */ new Map();
+    const intrinsicByElementId = /* @__PURE__ */ new Map();
+    const getIntrinsic = (o) => {
+      if (o instanceof fabric.Circle) {
+        const r = o.radius ?? 0;
+        return { w: r * 2, h: r * 2 };
+      }
+      if (o instanceof fabric.Ellipse) {
+        return { w: (o.rx ?? 0) * 2, h: (o.ry ?? 0) * 2 };
+      }
+      return { w: o.width ?? 0, h: o.height ?? 0 };
+    };
+    const liveTextByElementId = /* @__PURE__ */ new Map();
+    if (page.pageId && allowLiveCanvasFallback) {
+      const liveCanvas = getCanvasForPage(page.pageId);
+      if (liveCanvas) {
+        const objects = liveCanvas.getObjects();
+        const isTextLike = (o) => {
+          var _a2, _b2;
+          return o instanceof fabric.Textbox || o instanceof fabric.IText || ((_a2 = o.constructor) == null ? void 0 : _a2.name) === "Textbox" || ((_b2 = o.constructor) == null ? void 0 : _b2.name) === "Text";
+        };
+        for (const obj of objects) {
+          const isCropGroup = obj instanceof fabric.Group && obj.__cropGroup;
+          if (isCropGroup) {
+            const id2 = obj.__docuforgeId;
+            if (!id2 || id2 === "__background__") continue;
+            obj.__exportAsRenderedImage = true;
+            intrinsicByElementId.set(id2, getIntrinsic(obj));
+            try {
+              matrixByElementId.set(id2, obj.calcTransformMatrix());
+            } catch {
+            }
+            continue;
+          }
+          const isSectionGroup = obj instanceof fabric.Group && obj.__docuforgeSectionGroup;
+          const groupId = obj.__docuforgeGroupId;
+          if ((groupId || isSectionGroup) && obj instanceof fabric.Group) {
+            const groupMatrix = obj.calcTransformMatrix();
+            const memberObjects = obj.getObjects();
+            for (const memberObj of memberObjects) {
+              const memberId = memberObj.__docuforgeId;
+              if (!memberId) continue;
+              intrinsicByElementId.set(memberId, getIntrinsic(memberObj));
+              if (isTextLike(memberObj)) {
+                liveTextByElementId.set(memberId, memberObj);
+              }
+              try {
+                const memberLocalMatrix = ((_c = memberObj.calcOwnMatrix) == null ? void 0 : _c.call(memberObj)) ?? ((_d = memberObj.calcTransformMatrix) == null ? void 0 : _d.call(memberObj));
+                if (memberLocalMatrix && memberLocalMatrix.length === 6) {
+                  const [a1, b1, c1, d1, e1, f1] = groupMatrix;
+                  const [a2, b2, c2, d2, e2, f2] = memberLocalMatrix;
+                  const absoluteMatrix = [
+                    a1 * a2 + c1 * b2,
+                    b1 * a2 + d1 * b2,
+                    a1 * c2 + c1 * d2,
+                    b1 * c2 + d1 * d2,
+                    a1 * e2 + c1 * f2 + e1,
+                    b1 * e2 + d1 * f2 + f1
+                  ];
+                  matrixByElementId.set(memberId, absoluteMatrix);
+                }
+              } catch {
+              }
+            }
+            continue;
+          }
+          const id = obj.__docuforgeId;
+          if (!id || id === "__background__") continue;
+          intrinsicByElementId.set(id, getIntrinsic(obj));
+          if (isTextLike(obj)) {
+            liveTextByElementId.set(id, obj);
+          }
+          try {
+            matrixByElementId.set(id, obj.calcTransformMatrix());
+          } catch {
+          }
+        }
+      }
+    }
+    let drawList = page.elements;
+    if (page.pageId && allowLiveCanvasFallback) {
+      const liveCanvas = getCanvasForPage(page.pageId);
+      const hasGroupBgs = page.elements.some((item) => isGroupBackgroundDrawable(item));
+      if (liveCanvas && !hasGroupBgs) {
+        const canvasOrderIds = liveCanvas.getObjects().map((o) => o.__docuforgeId).filter(Boolean);
+        const byId = new Map(page.elements.map((el) => [el.id, el]));
+        const reordered = [];
+        for (const id of canvasOrderIds) {
+          const el = byId.get(id);
+          if (el) reordered.push(el);
+        }
+        for (const item of page.elements) {
+          if (!reordered.includes(item)) reordered.push(item);
+        }
+        drawList = reordered.length ? reordered : page.elements;
+      }
+    }
+    const clientTextPositions = [];
+    for (const item of drawList) {
+      if (isGroupBackgroundDrawable(item)) continue;
+      const el = item;
+      if (el.type !== "text") continue;
+      const n = normalizeElement(el);
+      let absX = n.x, absY = n.y, absW = n.w, absH = n.h;
+      if ((_e = page.pageChildren) == null ? void 0 : _e.length) {
+        const node = findNodeById(page.pageChildren, el.id);
+        if (node) {
+          const abs = getAbsoluteBounds(node, page.pageChildren);
+          absX = abs.left;
+          absY = abs.top;
+          absW = abs.width;
+          absH = abs.height;
+        }
+      }
+      clientTextPositions.push({
+        p: pageIndex + 1,
+        id: el.id.slice(0, 50),
+        top: Math.round(absY * 100) / 100,
+        left: Math.round(absX * 100) / 100,
+        w: Math.round(absW * 100) / 100,
+        h: Math.round(absH * 100) / 100,
+        fs: n.fontSize,
+        lh: n.lineHeight,
+        angle: n.angle,
+        text: (n.text || "").replace(/\s+/g, " ").trim().slice(0, 60)
+      });
+    }
+    if (clientTextPositions.length > 0) {
+      console.log(`[client-pdf-export] page ${pageIndex + 1} textPositions (${clientTextPositions.length}):`, JSON.stringify(clientTextPositions));
+    }
+    debugSvgDrawSequence = 0;
+    debugLog(`page ${pageIndex + 1}: drawing ${drawList.length} items (order = first=back, last=front)`);
+    resetPdfColorState(pdf);
+    for (let drawIndex = 0; drawIndex < drawList.length; drawIndex++) {
+      const item = drawList[drawIndex];
+      if (isGroupBackgroundDrawable(item)) {
+        debugLog(`  [${drawIndex}] groupBg id=${item.id}`);
+        const c = parseColor(item.fill);
+        if (c) {
+          pdf.setFillColor(c.r, c.g, c.b);
+          pdf.rect(item.left, item.top, item.width, item.height, "F");
+        }
+        continue;
+      }
+      const element = item;
+      const imgUrl = element.type === "image" ? (element.imageUrl || element.src || "").slice(-40) : "";
+      debugLog(`  [${drawIndex}] element id=${element.id} type=${element.type} ${imgUrl ? `imageUrl=...${imgUrl}` : ""}`);
+      const liveMatrix = matrixByElementId.get(element.id);
+      const storedMatrix = element.transformMatrix;
+      const m = liveMatrix ?? storedMatrix ?? null;
+      let intrinsic = intrinsicByElementId.get(element.id) ?? null;
+      const liveText = element.type === "text" ? liveTextByElementId.get(element.id) : void 0;
+      await drawElement(pdf, element, embeddedFonts, page.width, page.height, page.backgroundColor, m, intrinsic, page.pageId, liveText, page.pageChildren);
+      if (drawIndex % 3 === 2) await yieldToUI();
+    }
+    await yieldToUI();
+  }
+  if (watermark) {
+    const { addWatermarkToAllPages } = await import("./pdfWatermark-CewmS9qQ.js");
+    addWatermarkToAllPages(pdf);
+  }
+  if (returnBlob) {
+    const arrayBuffer = pdf.output("arraybuffer");
+    const blob = new Blob([arrayBuffer], { type: "application/pdf" });
+    return {
+      blob,
+      arrayBuffer,
+      totalPages: pages.length,
+      pages: pages.map((p) => ({ width: p.width, height: p.height }))
+    };
+  }
+  pdf.save(filename);
+}
+export {
+  convertSvgTextDecorationsToLinesString,
+  drawPreparedLiveCanvasSvgPageToPdf,
+  exportFabricCanvasToVectorPdf,
+  exportMultiPagePdf,
+  preparePagesForExport,
+  rewriteSvgFontsForJsPDFWithSourceMeta
+};
+//# sourceMappingURL=vectorPdfExport-BrHHt_7L.js.map