@pixldocs/canvas-renderer 0.3.28 → 0.4.1

package/dist/index.js

@@ -7,6 +7,8 @@ import { flushSync } from "react-dom";
 import { create } from "zustand";
 import * as fabric from "fabric";
 import { createRoot } from "react-dom/client";
+import { jsPDF, ShadingPattern } from "jspdf";
+import { svg2pdf } from "svg2pdf.js";
 let API_URL = "";
 function setPackageApiUrl(imageProxyUrl) {
   if (!imageProxyUrl) {
@@ -10747,8 +10749,38 @@ class PixldocsRenderer {
     return this.renderAllPageSvgs(configToRender);
   }
   /**
-   * Convenience: fetch by ID with simple flat data and render.
+   * Render a pre-resolved template config to a vector PDF.
+   * Returns a Blob and ArrayBuffer.
    */
+  async renderPdf(templateConfig, options) {
+    const svgs = await this.renderAllPageSvgs(templateConfig);
+    const { assemblePdfFromSvgs: assemblePdfFromSvgs2 } = await Promise.resolve().then(() => pdfExport);
+    return assemblePdfFromSvgs2(svgs, { title: options == null ? void 0 : options.title, fontBaseUrl: options == null ? void 0 : options.fontBaseUrl });
+  }
+  /**
+   * Resolve from V2 sectionState and render a vector PDF.
+   * This is the primary PDF export API — mirrors renderFromForm() but returns a PDF.
+   */
+  async renderPdfFromForm(options) {
+    const { templateId, formSchemaId, sectionState, themeId, watermark, title, fontBaseUrl } = options;
+    const resolved = await resolveFromForm({
+      templateId,
+      formSchemaId,
+      sectionState,
+      themeId,
+      supabaseUrl: this.config.supabaseUrl,
+      supabaseAnonKey: this.config.supabaseAnonKey
+    });
+    const shouldWatermark = watermark ?? resolved.price > 0;
+    let configToRender = resolved.config;
+    if (shouldWatermark) {
+      const { injectWatermark } = await import("./canvasWatermark-CM85x4k7.js");
+      configToRender = injectWatermark(configToRender);
+    }
+    const svgs = await this.renderAllPageSvgs(configToRender);
+    const { assemblePdfFromSvgs: assemblePdfFromSvgs2 } = await Promise.resolve().then(() => pdfExport);
+    return assemblePdfFromSvgs2(svgs, { title: title ?? resolved.config.name, fontBaseUrl });
+  }
   async renderById(templateId, formData, options) {
     const resolved = await resolveTemplateData({
       templateId,
@@ -11201,6 +11233,1841 @@ class PixldocsRenderer {
     return null;
   }
 }
+const FONT_WEIGHT_LABELS = {
+  300: "Light",
+  400: "Regular",
+  500: "Medium",
+  600: "SemiBold",
+  700: "Bold"
+};
+function resolveFontWeight(weight) {
+  if (weight <= 350) return 300;
+  if (weight <= 450) return 400;
+  if (weight <= 550) return 500;
+  if (weight <= 650) return 600;
+  return 700;
+}
+const FONT_FALLBACK_SYMBOLS = "Noto Sans";
+const FONT_FALLBACK_DEVANAGARI = "Hind";
+const FONT_FILES = {
+  "Playfair Display": {
+    regular: "PlayfairDisplay-Regular.ttf",
+    bold: "PlayfairDisplay-Bold.ttf",
+    italic: "PlayfairDisplay-Italic.ttf",
+    boldItalic: "PlayfairDisplay-BoldItalic.ttf"
+  },
+  "Merriweather": {
+    regular: "Merriweather-Regular.ttf",
+    bold: "Merriweather-Bold.ttf",
+    light: "Merriweather-Light.ttf",
+    italic: "Merriweather-Italic.ttf",
+    boldItalic: "Merriweather-BoldItalic.ttf",
+    lightItalic: "Merriweather-LightItalic.ttf"
+  },
+  "Lora": {
+    regular: "Lora-Regular.ttf",
+    bold: "Lora-Bold.ttf",
+    italic: "Lora-Italic.ttf",
+    boldItalic: "Lora-BoldItalic.ttf"
+  },
+  "Montserrat": {
+    regular: "Montserrat-Regular.ttf",
+    bold: "Montserrat-Bold.ttf",
+    light: "Montserrat-Light.ttf",
+    medium: "Montserrat-Medium.ttf",
+    semibold: "Montserrat-SemiBold.ttf",
+    italic: "Montserrat-Italic.ttf",
+    boldItalic: "Montserrat-BoldItalic.ttf",
+    lightItalic: "Montserrat-LightItalic.ttf",
+    mediumItalic: "Montserrat-MediumItalic.ttf",
+    semiboldItalic: "Montserrat-SemiBoldItalic.ttf"
+  },
+  "Open Sans": {
+    regular: "OpenSans-Regular.ttf",
+    bold: "OpenSans-Bold.ttf",
+    light: "OpenSans-Light.ttf",
+    semibold: "OpenSans-SemiBold.ttf",
+    italic: "OpenSans-Italic.ttf",
+    boldItalic: "OpenSans-BoldItalic.ttf",
+    lightItalic: "OpenSans-LightItalic.ttf",
+    semiboldItalic: "OpenSans-SemiBoldItalic.ttf"
+  },
+  "Roboto": {
+    regular: "Roboto-Regular.ttf",
+    bold: "Roboto-Bold.ttf",
+    light: "Roboto-Light.ttf",
+    medium: "Roboto-Medium.ttf",
+    italic: "Roboto-Italic.ttf",
+    boldItalic: "Roboto-BoldItalic.ttf",
+    lightItalic: "Roboto-LightItalic.ttf",
+    mediumItalic: "Roboto-MediumItalic.ttf"
+  },
+  "Lato": {
+    regular: "Lato-Regular.ttf",
+    bold: "Lato-Bold.ttf",
+    light: "Lato-Light.ttf",
+    italic: "Lato-Italic.ttf",
+    boldItalic: "Lato-BoldItalic.ttf",
+    lightItalic: "Lato-LightItalic.ttf"
+  },
+  "Raleway": {
+    regular: "Raleway-Regular.ttf",
+    bold: "Raleway-Bold.ttf",
+    light: "Raleway-Light.ttf",
+    medium: "Raleway-Medium.ttf",
+    semibold: "Raleway-SemiBold.ttf",
+    italic: "Raleway-Italic.ttf",
+    boldItalic: "Raleway-BoldItalic.ttf",
+    lightItalic: "Raleway-LightItalic.ttf"
+  },
+  "Poppins": {
+    regular: "Poppins-Regular.ttf",
+    bold: "Poppins-Bold.ttf",
+    light: "Poppins-Light.ttf",
+    medium: "Poppins-Medium.ttf",
+    semibold: "Poppins-SemiBold.ttf",
+    italic: "Poppins-Italic.ttf",
+    boldItalic: "Poppins-BoldItalic.ttf",
+    lightItalic: "Poppins-LightItalic.ttf",
+    mediumItalic: "Poppins-MediumItalic.ttf",
+    semiboldItalic: "Poppins-SemiBoldItalic.ttf"
+  },
+  "Inter": {
+    regular: "Inter-Regular.ttf",
+    bold: "Inter-Bold.ttf",
+    italic: "Inter-Italic.ttf",
+    boldItalic: "Inter-BoldItalic.ttf"
+  },
+  "Nunito": {
+    regular: "Nunito-Regular.ttf",
+    bold: "Nunito-Bold.ttf",
+    light: "Nunito-Light.ttf",
+    medium: "Nunito-Medium.ttf",
+    semibold: "Nunito-SemiBold.ttf",
+    italic: "Nunito-Italic.ttf",
+    boldItalic: "Nunito-BoldItalic.ttf"
+  },
+  "Source Sans Pro": {
+    regular: "SourceSansPro-Regular.ttf",
+    bold: "SourceSansPro-Bold.ttf",
+    light: "SourceSansPro-Light.ttf",
+    italic: "SourceSansPro-Italic.ttf",
+    boldItalic: "SourceSansPro-BoldItalic.ttf"
+  },
+  "Work Sans": {
+    regular: "WorkSans-Regular.ttf",
+    bold: "WorkSans-Bold.ttf",
+    italic: "WorkSans-Italic.ttf",
+    boldItalic: "WorkSans-BoldItalic.ttf"
+  },
+  "Oswald": { regular: "Oswald-Regular.ttf", bold: "Oswald-Bold.ttf" },
+  "Bebas Neue": { regular: "BebasNeue-Regular.ttf" },
+  "Abril Fatface": { regular: "AbrilFatface-Regular.ttf" },
+  "Dancing Script": { regular: "DancingScript-Regular.ttf", bold: "DancingScript-Bold.ttf" },
+  "Pacifico": { regular: "Pacifico-Regular.ttf" },
+  "Great Vibes": { regular: "GreatVibes-Regular.ttf" },
+  "DM Sans": {
+    regular: "DMSans-Regular.ttf",
+    bold: "DMSans-Bold.ttf",
+    light: "DMSans-Light.ttf",
+    medium: "DMSans-Medium.ttf",
+    semibold: "DMSans-SemiBold.ttf",
+    italic: "DMSans-RegularItalic.ttf",
+    boldItalic: "DMSans-BoldItalic.ttf",
+    lightItalic: "DMSans-LightItalic.ttf",
+    mediumItalic: "DMSans-MediumItalic.ttf",
+    semiboldItalic: "DMSans-SemiBoldItalic.ttf"
+  },
+  "Outfit": {
+    regular: "Outfit-Regular.ttf",
+    bold: "Outfit-Bold.ttf",
+    light: "Outfit-Light.ttf",
+    medium: "Outfit-Medium.ttf",
+    semibold: "Outfit-SemiBold.ttf"
+  },
+  "Figtree": {
+    regular: "Figtree-Regular.ttf",
+    bold: "Figtree-Bold.ttf",
+    light: "Figtree-Light.ttf",
+    medium: "Figtree-Medium.ttf",
+    semibold: "Figtree-SemiBold.ttf",
+    italic: "Figtree-RegularItalic.ttf",
+    boldItalic: "Figtree-BoldItalic.ttf",
+    lightItalic: "Figtree-LightItalic.ttf",
+    mediumItalic: "Figtree-MediumItalic.ttf",
+    semiboldItalic: "Figtree-SemiBoldItalic.ttf"
+  },
+  "Manrope": {
+    regular: "Manrope-Regular.ttf",
+    bold: "Manrope-Bold.ttf",
+    light: "Manrope-Light.ttf",
+    medium: "Manrope-Medium.ttf",
+    semibold: "Manrope-SemiBold.ttf"
+  },
+  "Space Grotesk": {
+    regular: "SpaceGrotesk-Regular.ttf",
+    bold: "SpaceGrotesk-Bold.ttf",
+    light: "SpaceGrotesk-Light.ttf",
+    medium: "SpaceGrotesk-Medium.ttf",
+    semibold: "SpaceGrotesk-SemiBold.ttf"
+  },
+  "League Spartan": {
+    regular: "LeagueSpartan-Regular.ttf",
+    bold: "LeagueSpartan-Bold.ttf",
+    light: "LeagueSpartan-Light.ttf",
+    medium: "LeagueSpartan-Medium.ttf",
+    semibold: "LeagueSpartan-SemiBold.ttf"
+  },
+  "EB Garamond": {
+    regular: "EBGaramond-Regular.ttf",
+    bold: "EBGaramond-Bold.ttf",
+    medium: "EBGaramond-Medium.ttf",
+    semibold: "EBGaramond-SemiBold.ttf",
+    italic: "EBGaramond-RegularItalic.ttf",
+    boldItalic: "EBGaramond-BoldItalic.ttf",
+    mediumItalic: "EBGaramond-MediumItalic.ttf",
+    semiboldItalic: "EBGaramond-SemiBoldItalic.ttf"
+  },
+  "Libre Baskerville": {
+    regular: "LibreBaskerville-Regular.ttf",
+    bold: "LibreBaskerville-Bold.ttf",
+    italic: "LibreBaskerville-RegularItalic.ttf",
+    boldItalic: "LibreBaskerville-BoldItalic.ttf"
+  },
+  "Crimson Text": {
+    regular: "CrimsonText-Regular.ttf",
+    bold: "CrimsonText-Bold.ttf",
+    italic: "CrimsonText-Italic.ttf",
+    boldItalic: "CrimsonText-BoldItalic.ttf"
+  },
+  "DM Serif Display": {
+    regular: "DMSerifDisplay-Regular.ttf",
+    italic: "DMSerifDisplay-Italic.ttf"
+  },
+  "Libre Franklin": {
+    regular: "LibreFranklin-Regular.ttf",
+    bold: "LibreFranklin-Bold.ttf",
+    light: "LibreFranklin-Light.ttf",
+    medium: "LibreFranklin-Medium.ttf",
+    semibold: "LibreFranklin-SemiBold.ttf",
+    italic: "LibreFranklin-RegularItalic.ttf",
+    boldItalic: "LibreFranklin-BoldItalic.ttf",
+    lightItalic: "LibreFranklin-LightItalic.ttf",
+    mediumItalic: "LibreFranklin-MediumItalic.ttf",
+    semiboldItalic: "LibreFranklin-SemiBoldItalic.ttf"
+  },
+  "Mulish": {
+    regular: "Mulish-Regular.ttf",
+    bold: "Mulish-Bold.ttf",
+    light: "Mulish-Light.ttf",
+    medium: "Mulish-Medium.ttf",
+    semibold: "Mulish-SemiBold.ttf",
+    italic: "Mulish-RegularItalic.ttf",
+    boldItalic: "Mulish-BoldItalic.ttf",
+    lightItalic: "Mulish-LightItalic.ttf",
+    mediumItalic: "Mulish-MediumItalic.ttf",
+    semiboldItalic: "Mulish-SemiBoldItalic.ttf"
+  },
+  "Quicksand": {
+    regular: "Quicksand-Regular.ttf",
+    bold: "Quicksand-Bold.ttf",
+    light: "Quicksand-Light.ttf",
+    medium: "Quicksand-Medium.ttf",
+    semibold: "Quicksand-SemiBold.ttf"
+  },
+  "Rubik": {
+    regular: "Rubik-Regular.ttf",
+    bold: "Rubik-Bold.ttf",
+    light: "Rubik-Light.ttf",
+    medium: "Rubik-Medium.ttf",
+    semibold: "Rubik-SemiBold.ttf",
+    italic: "Rubik-RegularItalic.ttf",
+    boldItalic: "Rubik-BoldItalic.ttf",
+    lightItalic: "Rubik-LightItalic.ttf",
+    mediumItalic: "Rubik-MediumItalic.ttf",
+    semiboldItalic: "Rubik-SemiBoldItalic.ttf"
+  },
+  "Karla": {
+    regular: "Karla-Regular.ttf",
+    bold: "Karla-Bold.ttf",
+    light: "Karla-Light.ttf",
+    medium: "Karla-Medium.ttf",
+    semibold: "Karla-SemiBold.ttf",
+    italic: "Karla-RegularItalic.ttf",
+    boldItalic: "Karla-BoldItalic.ttf",
+    lightItalic: "Karla-LightItalic.ttf",
+    mediumItalic: "Karla-MediumItalic.ttf",
+    semiboldItalic: "Karla-SemiBoldItalic.ttf"
+  },
+  "Plus Jakarta Sans": {
+    regular: "PlusJakartaSans-Regular.ttf",
+    bold: "PlusJakartaSans-Bold.ttf",
+    light: "PlusJakartaSans-Light.ttf",
+    medium: "PlusJakartaSans-Medium.ttf",
+    semibold: "PlusJakartaSans-SemiBold.ttf",
+    italic: "PlusJakartaSans-RegularItalic.ttf",
+    boldItalic: "PlusJakartaSans-BoldItalic.ttf",
+    lightItalic: "PlusJakartaSans-LightItalic.ttf",
+    mediumItalic: "PlusJakartaSans-MediumItalic.ttf",
+    semiboldItalic: "PlusJakartaSans-SemiBoldItalic.ttf"
+  },
+  "Sora": {
+    regular: "Sora-Regular.ttf",
+    bold: "Sora-Bold.ttf",
+    light: "Sora-Light.ttf",
+    medium: "Sora-Medium.ttf",
+    semibold: "Sora-SemiBold.ttf"
+  },
+  "Urbanist": {
+    regular: "Urbanist-Regular.ttf",
+    bold: "Urbanist-Bold.ttf",
+    light: "Urbanist-Light.ttf",
+    medium: "Urbanist-Medium.ttf",
+    semibold: "Urbanist-SemiBold.ttf",
+    italic: "Urbanist-RegularItalic.ttf",
+    boldItalic: "Urbanist-BoldItalic.ttf",
+    lightItalic: "Urbanist-LightItalic.ttf",
+    mediumItalic: "Urbanist-MediumItalic.ttf",
+    semiboldItalic: "Urbanist-SemiBoldItalic.ttf"
+  },
+  "Lexend": {
+    regular: "Lexend-Regular.ttf",
+    bold: "Lexend-Bold.ttf",
+    light: "Lexend-Light.ttf",
+    medium: "Lexend-Medium.ttf",
+    semibold: "Lexend-SemiBold.ttf"
+  },
+  "Albert Sans": {
+    regular: "AlbertSans-Regular.ttf",
+    bold: "AlbertSans-Bold.ttf",
+    light: "AlbertSans-Light.ttf",
+    medium: "AlbertSans-Medium.ttf",
+    semibold: "AlbertSans-SemiBold.ttf",
+    italic: "AlbertSans-RegularItalic.ttf",
+    boldItalic: "AlbertSans-BoldItalic.ttf",
+    lightItalic: "AlbertSans-LightItalic.ttf",
+    mediumItalic: "AlbertSans-MediumItalic.ttf",
+    semiboldItalic: "AlbertSans-SemiBoldItalic.ttf"
+  },
+  "Noto Sans": {
+    regular: "NotoSans-Regular.ttf",
+    bold: "NotoSans-Bold.ttf",
+    light: "NotoSans-Light.ttf",
+    medium: "NotoSans-Medium.ttf",
+    semibold: "NotoSans-SemiBold.ttf",
+    italic: "NotoSans-RegularItalic.ttf",
+    boldItalic: "NotoSans-BoldItalic.ttf",
+    lightItalic: "NotoSans-LightItalic.ttf",
+    mediumItalic: "NotoSans-MediumItalic.ttf",
+    semiboldItalic: "NotoSans-SemiBoldItalic.ttf"
+  },
+  "Cabin": {
+    regular: "Cabin-Regular.ttf",
+    bold: "Cabin-Bold.ttf",
+    medium: "Cabin-Medium.ttf",
+    semibold: "Cabin-SemiBold.ttf",
+    italic: "Cabin-RegularItalic.ttf",
+    boldItalic: "Cabin-BoldItalic.ttf",
+    mediumItalic: "Cabin-MediumItalic.ttf",
+    semiboldItalic: "Cabin-SemiBoldItalic.ttf"
+  },
+  "Barlow": {
+    regular: "Barlow-Regular.ttf",
+    bold: "Barlow-Bold.ttf",
+    light: "Barlow-Light.ttf",
+    medium: "Barlow-Medium.ttf",
+    semibold: "Barlow-SemiBold.ttf",
+    italic: "Barlow-Italic.ttf",
+    boldItalic: "Barlow-BoldItalic.ttf"
+  },
+  "Josefin Sans": {
+    regular: "JosefinSans-Regular.ttf",
+    bold: "JosefinSans-Bold.ttf",
+    light: "JosefinSans-Light.ttf",
+    medium: "JosefinSans-Medium.ttf",
+    semibold: "JosefinSans-SemiBold.ttf",
+    italic: "JosefinSans-RegularItalic.ttf",
+    boldItalic: "JosefinSans-BoldItalic.ttf",
+    lightItalic: "JosefinSans-LightItalic.ttf",
+    mediumItalic: "JosefinSans-MediumItalic.ttf",
+    semiboldItalic: "JosefinSans-SemiBoldItalic.ttf"
+  },
+  "Archivo": {
+    regular: "Archivo-Regular.ttf",
+    bold: "Archivo-Bold.ttf",
+    light: "Archivo-Light.ttf",
+    medium: "Archivo-Medium.ttf",
+    semibold: "Archivo-SemiBold.ttf",
+    italic: "Archivo-RegularItalic.ttf",
+    boldItalic: "Archivo-BoldItalic.ttf",
+    lightItalic: "Archivo-LightItalic.ttf",
+    mediumItalic: "Archivo-MediumItalic.ttf",
+    semiboldItalic: "Archivo-SemiBoldItalic.ttf"
+  },
+  "Overpass": {
+    regular: "Overpass-Regular.ttf",
+    bold: "Overpass-Bold.ttf",
+    light: "Overpass-Light.ttf",
+    medium: "Overpass-Medium.ttf",
+    semibold: "Overpass-SemiBold.ttf",
+    italic: "Overpass-RegularItalic.ttf",
+    boldItalic: "Overpass-BoldItalic.ttf",
+    lightItalic: "Overpass-LightItalic.ttf",
+    mediumItalic: "Overpass-MediumItalic.ttf",
+    semiboldItalic: "Overpass-SemiBoldItalic.ttf"
+  },
+  "Exo 2": {
+    regular: "Exo2-Regular.ttf",
+    bold: "Exo2-Bold.ttf",
+    light: "Exo2-Light.ttf",
+    medium: "Exo2-Medium.ttf",
+    semibold: "Exo2-SemiBold.ttf",
+    italic: "Exo2-RegularItalic.ttf",
+    boldItalic: "Exo2-BoldItalic.ttf",
+    lightItalic: "Exo2-LightItalic.ttf",
+    mediumItalic: "Exo2-MediumItalic.ttf",
+    semiboldItalic: "Exo2-SemiBoldItalic.ttf"
+  },
+  "Roboto Mono": {
+    regular: "RobotoMono-Regular.ttf",
+    bold: "RobotoMono-Bold.ttf",
+    light: "RobotoMono-Light.ttf",
+    medium: "RobotoMono-Medium.ttf",
+    semibold: "RobotoMono-SemiBold.ttf",
+    italic: "RobotoMono-RegularItalic.ttf",
+    boldItalic: "RobotoMono-BoldItalic.ttf",
+    lightItalic: "RobotoMono-LightItalic.ttf",
+    mediumItalic: "RobotoMono-MediumItalic.ttf",
+    semiboldItalic: "RobotoMono-SemiBoldItalic.ttf"
+  },
+  "Fira Code": {
+    regular: "FiraCode-Regular.ttf",
+    bold: "FiraCode-Bold.ttf",
+    light: "FiraCode-Light.ttf",
+    medium: "FiraCode-Medium.ttf",
+    semibold: "FiraCode-SemiBold.ttf"
+  },
+  "JetBrains Mono": {
+    regular: "JetBrainsMono-Regular.ttf",
+    bold: "JetBrainsMono-Bold.ttf",
+    light: "JetBrainsMono-Light.ttf",
+    medium: "JetBrainsMono-Medium.ttf",
+    semibold: "JetBrainsMono-SemiBold.ttf",
+    italic: "JetBrainsMono-RegularItalic.ttf",
+    boldItalic: "JetBrainsMono-BoldItalic.ttf",
+    lightItalic: "JetBrainsMono-LightItalic.ttf",
+    mediumItalic: "JetBrainsMono-MediumItalic.ttf",
+    semiboldItalic: "JetBrainsMono-SemiBoldItalic.ttf"
+  },
+  "Source Code Pro": {
+    regular: "SourceCodePro-Regular.ttf",
+    bold: "SourceCodePro-Bold.ttf",
+    light: "SourceCodePro-Light.ttf",
+    medium: "SourceCodePro-Medium.ttf",
+    semibold: "SourceCodePro-SemiBold.ttf",
+    italic: "SourceCodePro-RegularItalic.ttf",
+    boldItalic: "SourceCodePro-BoldItalic.ttf",
+    lightItalic: "SourceCodePro-LightItalic.ttf",
+    mediumItalic: "SourceCodePro-MediumItalic.ttf",
+    semiboldItalic: "SourceCodePro-SemiBoldItalic.ttf"
+  },
+  "IBM Plex Mono": {
+    regular: "IBMPlexMono-Regular.ttf",
+    bold: "IBMPlexMono-Bold.ttf"
+  },
+  "Space Mono": {
+    regular: "SpaceMono-Regular.ttf",
+    bold: "SpaceMono-Bold.ttf",
+    italic: "SpaceMono-Italic.ttf",
+    boldItalic: "SpaceMono-BoldItalic.ttf"
+  },
+  "Sacramento": { regular: "Sacramento-Regular.ttf" },
+  "Alex Brush": { regular: "AlexBrush-Regular.ttf" },
+  "Allura": { regular: "Allura-Regular.ttf" },
+  "Caveat": {
+    regular: "Caveat-Regular.ttf",
+    bold: "Caveat-Bold.ttf",
+    medium: "Caveat-Medium.ttf",
+    semibold: "Caveat-SemiBold.ttf"
+  },
+  "Lobster": { regular: "Lobster-Regular.ttf" },
+  "Comfortaa": {
+    regular: "Comfortaa-Regular.ttf",
+    bold: "Comfortaa-Bold.ttf",
+    light: "Comfortaa-Light.ttf",
+    medium: "Comfortaa-Medium.ttf",
+    semibold: "Comfortaa-SemiBold.ttf"
+  },
+  "Anton": { regular: "Anton-Regular.ttf" },
+  "Teko": {
+    regular: "Teko-Regular.ttf",
+    bold: "Teko-Bold.ttf",
+    light: "Teko-Light.ttf",
+    medium: "Teko-Medium.ttf",
+    semibold: "Teko-SemiBold.ttf"
+  },
+  "Noto Sans Devanagari": {
+    regular: "NotoSansDevanagari-Regular.ttf",
+    bold: "NotoSansDevanagari-Bold.ttf",
+    light: "NotoSansDevanagari-Light.ttf",
+    medium: "NotoSansDevanagari-Medium.ttf",
+    semibold: "NotoSansDevanagari-SemiBold.ttf"
+  },
+  "Hind": {
+    regular: "Hind-Regular.ttf",
+    bold: "Hind-Bold.ttf",
+    light: "Hind-Light.ttf",
+    medium: "Hind-Medium.ttf",
+    semibold: "Hind-SemiBold.ttf"
+  },
+  "Cinzel": { regular: "Cinzel-Regular.ttf", bold: "Cinzel-Bold.ttf" },
+  "Cormorant Garamond": {
+    regular: "CormorantGaramond-Regular.ttf",
+    bold: "CormorantGaramond-Bold.ttf",
+    light: "CormorantGaramond-Light.ttf",
+    medium: "CormorantGaramond-Medium.ttf",
+    semibold: "CormorantGaramond-SemiBold.ttf",
+    italic: "CormorantGaramond-Italic.ttf",
+    boldItalic: "CormorantGaramond-BoldItalic.ttf"
+  }
+};
+const WEIGHT_TO_KEYS = {
+  300: ["light", "regular"],
+  400: ["regular"],
+  500: ["medium", "regular"],
+  600: ["semibold", "bold", "regular"],
+  700: ["bold", "regular"]
+};
+const WEIGHT_TO_ITALIC_KEYS = {
+  300: ["lightItalic", "italic", "light", "regular"],
+  400: ["italic", "regular"],
+  500: ["mediumItalic", "italic", "medium", "regular"],
+  600: ["semiboldItalic", "boldItalic", "italic", "semibold", "bold", "regular"],
+  700: ["boldItalic", "italic", "bold", "regular"]
+};
+function getFontPathForWeight(files, weight, isItalic = false) {
+  const keys = isItalic ? WEIGHT_TO_ITALIC_KEYS[weight] : WEIGHT_TO_KEYS[weight];
+  if (!keys) return files.regular;
+  for (const k of keys) {
+    const path = files[k];
+    if (path) return path;
+  }
+  return files.regular;
+}
+function isItalicPath(files, path) {
+  return path === files.italic || path === files.boldItalic || path === files.lightItalic || path === files.mediumItalic || path === files.semiboldItalic;
+}
+function getJsPDFFontName(fontName) {
+  return fontName.replace(/\s+/g, "");
+}
+function getEmbeddedJsPDFFontName(fontName, weight, isItalic = false) {
+  const resolved = resolveFontWeight(weight);
+  const label = FONT_WEIGHT_LABELS[resolved];
+  const italicSuffix = isItalic ? "Italic" : "";
+  return `${getJsPDFFontName(fontName)}-${label}${italicSuffix}`;
+}
+function isFontAvailable(fontName) {
+  return fontName in FONT_FILES;
+}
+const ttfCache = /* @__PURE__ */ new Map();
+async function fetchTTFAsBase64(url) {
+  const cached = ttfCache.get(url);
+  if (cached) return cached;
+  try {
+    const res = await fetch(url);
+    if (!res.ok) return null;
+    const buf = await res.arrayBuffer();
+    const bytes = new Uint8Array(buf);
+    let binary = "";
+    for (let i = 0; i < bytes.length; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    const b64 = btoa(binary);
+    ttfCache.set(url, b64);
+    return b64;
+  } catch {
+    return null;
+  }
+}
+async function embedFont(pdf, fontName, weight, fontBaseUrl, isItalic = false) {
+  const fontFiles = FONT_FILES[fontName];
+  if (!fontFiles) return false;
+  const baseUrl = fontBaseUrl.endsWith("/") ? fontBaseUrl : fontBaseUrl + "/";
+  const resolvedWeight = resolveFontWeight(weight);
+  const fontPath = getFontPathForWeight(fontFiles, resolvedWeight, isItalic);
+  if (!fontPath) return false;
+  const hasItalicFile = isItalic && isItalicPath(fontFiles, fontPath);
+  const jsPdfFontName = getEmbeddedJsPDFFontName(fontName, weight, hasItalicFile);
+  const label = FONT_WEIGHT_LABELS[resolvedWeight];
+  const italicSuffix = hasItalicFile ? "Italic" : "";
+  const fileName = `${getJsPDFFontName(fontName)}-${label}${italicSuffix}.ttf`;
+  const url = baseUrl + fontPath;
+  try {
+    const b64 = await fetchTTFAsBase64(url);
+    if (!b64) return false;
+    pdf.addFileToVFS(fileName, b64);
+    pdf.addFont(fileName, jsPdfFontName, "normal");
+    if (fontName !== jsPdfFontName) {
+      try {
+        pdf.addFont(fileName, fontName, "normal");
+      } catch {
+      }
+    }
+    return true;
+  } catch (e) {
+    console.warn(`[pdf-fonts] Failed to embed ${fontName} w${weight}:`, e);
+    return false;
+  }
+}
+async function embedFontsForConfig(pdf, config, fontBaseUrl) {
+  const fontKeys = /* @__PURE__ */ new Set();
+  const SEP = "";
+  const walkElements = (elements) => {
+    for (const el of elements) {
+      if (el.fontFamily) {
+        const w = resolveFontWeight(el.fontWeight ?? 400);
+        fontKeys.add(`${el.fontFamily}${SEP}${w}`);
+      }
+      if (el.styles && typeof el.styles === "object") {
+        for (const lineKey of Object.keys(el.styles)) {
+          const lineStyles = el.styles[lineKey];
+          if (lineStyles && typeof lineStyles === "object") {
+            for (const charKey of Object.keys(lineStyles)) {
+              const s = lineStyles[charKey];
+              if (s == null ? void 0 : s.fontFamily) {
+                const w = resolveFontWeight(s.fontWeight ?? 400);
+                fontKeys.add(`${s.fontFamily}${SEP}${w}`);
+              }
+            }
+          }
+        }
+      }
+      if (el.children) walkElements(el.children);
+      if (el.objects) walkElements(el.objects);
+    }
+  };
+  for (const page of (config == null ? void 0 : config.pages) || []) {
+    if (page.children) walkElements(page.children);
+    if (page.elements) walkElements(page.elements);
+  }
+  fontKeys.add(`${FONT_FALLBACK_SYMBOLS}${SEP}400`);
+  for (const w of [300, 400, 500, 600, 700]) {
+    fontKeys.add(`${FONT_FALLBACK_DEVANAGARI}${SEP}${w}`);
+  }
+  const embedded = /* @__PURE__ */ new Set();
+  const tasks = [];
+  for (const key of fontKeys) {
+    const sep = key.indexOf(SEP);
+    const fontName = key.slice(0, sep);
+    const weight = parseInt(key.slice(sep + 1), 10);
+    if (!isFontAvailable(fontName)) continue;
+    tasks.push(
+      embedFont(pdf, fontName, weight, fontBaseUrl).then((ok) => {
+        if (ok) embedded.add(key);
+      })
+    );
+  }
+  await Promise.all(tasks);
+  console.log(`[pdf-fonts] Embedded ${embedded.size} font variants from config`);
+  return embedded;
+}
+function rewriteSvgFontsForJsPDF(svgStr) {
+  var _a;
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(svgStr, "image/svg+xml");
+  const textEls = 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;
+  };
+  for (const el of textEls) {
+    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 (!isFontAvailable(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 resolved = resolveFontWeight(weight);
+    const isItalic = /italic|oblique/i.test(styleRaw);
+    const jsPdfName = getEmbeddedJsPDFFontName(clean, resolved, isItalic);
+    el.setAttribute("font-family", jsPdfName);
+    el.setAttribute("font-weight", "normal");
+    el.setAttribute("font-style", "normal");
+    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));
+    stylePairs.push(`font-family: ${jsPdfName}`);
+    stylePairs.push(`font-weight: normal`);
+    stylePairs.push(`font-style: normal`);
+    el.setAttribute("style", stylePairs.join("; "));
+  }
+  return new XMLSerializer().serializeToString(doc.documentElement);
+}
+function extractFontFamiliesFromSvgs(svgs) {
+  const families = /* @__PURE__ */ new Set();
+  const regex = /font-family[=:]\s*["']?([^"';},]+)/gi;
+  for (const svg of svgs) {
+    let m;
+    while ((m = regex.exec(svg)) !== null) {
+      const raw = m[1].trim().split(",")[0].trim().replace(/^['"]|['"]$/g, "");
+      if (raw && raw !== "serif" && raw !== "sans-serif" && raw !== "monospace") {
+        families.add(raw);
+      }
+    }
+  }
+  return families;
+}
+async function embedFontsInPdf(pdf, fontFamilies, fontBaseUrl) {
+  const embedded = /* @__PURE__ */ new Set();
+  const weights = [300, 400, 500, 600, 700];
+  const tasks = [];
+  for (const family of fontFamilies) {
+    if (!isFontAvailable(family)) {
+      console.warn(`[pdf-fonts] No TTF mapping for "${family}" — will use Helvetica fallback`);
+      continue;
+    }
+    for (const w of weights) {
+      tasks.push(
+        embedFont(pdf, family, w, fontBaseUrl).then((ok) => {
+          if (ok) embedded.add(`${family}${w}`);
+        })
+      );
+    }
+  }
+  await Promise.all(tasks);
+  console.log(`[pdf-fonts] Embedded ${embedded.size} font variants for ${fontFamilies.size} families`);
+  return embedded;
+}
+const pdfFonts = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  FONT_FALLBACK_DEVANAGARI,
+  FONT_FALLBACK_SYMBOLS,
+  FONT_FILES,
+  FONT_WEIGHT_LABELS,
+  embedFont,
+  embedFontsForConfig,
+  embedFontsInPdf,
+  extractFontFamiliesFromSvgs,
+  getEmbeddedJsPDFFontName,
+  isFontAvailable,
+  resolveFontWeight,
+  rewriteSvgFontsForJsPDF
+}, Symbol.toStringTag, { value: "Module" }));
+const SVG_DRAWABLE_TAGS = /* @__PURE__ */ new Set([
+  "path",
+  "rect",
+  "circle",
+  "ellipse",
+  "polygon",
+  "polyline",
+  "line",
+  "text",
+  "tspan"
+]);
+const SVG_DEFINITION_CONTAINER_TAGS = /* @__PURE__ */ new Set([
+  "defs",
+  "clippath",
+  "mask",
+  "pattern",
+  "marker",
+  "symbol",
+  "filter",
+  "lineargradient",
+  "radialgradient"
+]);
+const SVG_STYLE_PROPS = /* @__PURE__ */ new Set([
+  "fill",
+  "stroke",
+  "color",
+  "opacity",
+  "fill-opacity",
+  "stroke-opacity",
+  "fill-rule",
+  "stroke-width",
+  "stroke-linecap",
+  "stroke-linejoin",
+  "stroke-miterlimit",
+  "stroke-dasharray",
+  "stroke-dashoffset",
+  "display",
+  "visibility",
+  "stop-color",
+  "stop-opacity",
+  "clip-rule",
+  "clip-path",
+  "mask",
+  "filter"
+]);
+const GRADIENT_ATTRS_LINEAR = ["x1", "y1", "x2", "y2", "gradientUnits", "gradientTransform", "spreadMethod"];
+const GRADIENT_ATTRS_RADIAL = ["cx", "cy", "r", "fx", "fy", "gradientUnits", "gradientTransform", "spreadMethod"];
+const URL_GRADIENT_RE = /^\s*url\s*\(\s*(['"]?)([^)]+?)\1\s*\)/i;
+function parseColor(color) {
+  if (!color) return null;
+  const raw = color.trim().toLowerCase();
+  if (!raw || raw === "transparent" || raw === "none") return null;
+  const clamp2 = (value) => Math.max(0, Math.min(255, Math.round(value)));
+  const parseNumeric = (token) => {
+    const value = parseFloat(token);
+    return Number.isFinite(value) ? value : NaN;
+  };
+  const parseRgbComponent = (token) => {
+    const value = parseNumeric(token);
+    if (!Number.isFinite(value)) return NaN;
+    return token.endsWith("%") ? value / 100 * 255 : value;
+  };
+  const parseAlpha = (token) => {
+    if (!token) return 1;
+    const value = parseNumeric(token);
+    if (!Number.isFinite(value)) return 1;
+    return token.endsWith("%") ? value / 100 : value;
+  };
+  const toRgbFromHsl = (h, s, l) => {
+    const hue = (h % 360 + 360) % 360;
+    const sat = Math.max(0, Math.min(1, s));
+    const light = Math.max(0, Math.min(1, l));
+    if (sat === 0) {
+      const gray = clamp2(light * 255);
+      return { r: gray, g: gray, b: gray };
+    }
+    const q = light < 0.5 ? light * (1 + sat) : light + sat - light * sat;
+    const p = 2 * light - q;
+    const hueToRgb = (t) => {
+      let tt = t;
+      if (tt < 0) tt += 1;
+      if (tt > 1) tt -= 1;
+      if (tt < 1 / 6) return p + (q - p) * 6 * tt;
+      if (tt < 1 / 2) return q;
+      if (tt < 2 / 3) return p + (q - p) * (2 / 3 - tt) * 6;
+      return p;
+    };
+    return {
+      r: clamp2(hueToRgb(hue / 360 + 1 / 3) * 255),
+      g: clamp2(hueToRgb(hue / 360) * 255),
+      b: clamp2(hueToRgb(hue / 360 - 1 / 3) * 255)
+    };
+  };
+  if (raw.startsWith("#")) {
+    const hex = raw.slice(1);
+    const expanded = hex.length === 3 || hex.length === 4 ? hex.split("").map((char) => char + char).join("") : hex;
+    if (expanded.length !== 6 && expanded.length !== 8) return null;
+    const intValue = parseInt(expanded.slice(0, 6), 16);
+    if (!Number.isFinite(intValue)) return null;
+    if (expanded.length === 8) {
+      const alphaHex = parseInt(expanded.slice(6, 8), 16);
+      if (Number.isFinite(alphaHex) && alphaHex <= 0) return null;
+    }
+    return { r: intValue >> 16 & 255, g: intValue >> 8 & 255, b: intValue & 255 };
+  }
+  const rgbMatch = raw.match(/^rgba?\((.+)\)$/);
+  if (rgbMatch) {
+    const normalized = rgbMatch[1].replace(/\//g, " ").replace(/,/g, " ");
+    const parts = normalized.split(/\s+/).filter(Boolean);
+    if (parts.length >= 3) {
+      const alpha = parseAlpha(parts[3]);
+      if (alpha <= 0) return null;
+      const r = parseRgbComponent(parts[0]);
+      const g = parseRgbComponent(parts[1]);
+      const b = parseRgbComponent(parts[2]);
+      if (Number.isFinite(r) && Number.isFinite(g) && Number.isFinite(b)) {
+        return { r: clamp2(r), g: clamp2(g), b: clamp2(b) };
+      }
+    }
+  }
+  const hslMatch = raw.match(/^hsla?\((.+)\)$/);
+  if (hslMatch) {
+    const normalized = hslMatch[1].replace(/\//g, " ").replace(/,/g, " ");
+    const parts = normalized.split(/\s+/).filter(Boolean);
+    if (parts.length >= 3) {
+      const alpha = parseAlpha(parts[3]);
+      if (alpha <= 0) return null;
+      const h = parseNumeric(parts[0].replace(/deg$/, ""));
+      const sRaw = parseNumeric(parts[1].replace(/%$/, ""));
+      const lRaw = parseNumeric(parts[2].replace(/%$/, ""));
+      if (Number.isFinite(h) && Number.isFinite(sRaw) && Number.isFinite(lRaw)) {
+        return toRgbFromHsl(h, sRaw / 100, lRaw / 100);
+      }
+    }
+  }
+  return null;
+}
+function rgbToHex(r, g, b) {
+  return "#" + [r, g, b].map((x) => Math.max(0, Math.min(255, Math.round(x))).toString(16).padStart(2, "0")).join("");
+}
+function cssColorToHex(css) {
+  var _a;
+  const s = css.trim();
+  if (/^#[0-9a-f]{3}$/i.test(s)) {
+    const r = s[1] + s[1], g = s[2] + s[2], b = s[3] + s[3];
+    return "#" + r + g + b;
+  }
+  if (/^#[0-9a-f]{6}$/i.test(s)) return s;
+  if (/^#[0-9a-f]{8}$/i.test(s)) return "#" + s.slice(1, 7);
+  const rgb = s.match(/^rgba?\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/i);
+  if (rgb) {
+    const r = Number(rgb[1]).toString(16).padStart(2, "0");
+    const g = Number(rgb[2]).toString(16).padStart(2, "0");
+    const b = Number(rgb[3]).toString(16).padStart(2, "0");
+    return "#" + r + g + b;
+  }
+  if (typeof document === "undefined") return null;
+  const div = document.createElement("div");
+  div.style.color = s;
+  const computed = (_a = document.defaultView) == null ? void 0 : _a.getComputedStyle(div).color;
+  if (!computed || !computed.startsWith("rgb")) return null;
+  const m = computed.match(/\d+/g);
+  if (!m || m.length < 3) return null;
+  return "#" + [m[0], m[1], m[2]].map((v) => Number(v).toString(16).padStart(2, "0")).join("");
+}
+function isInSvgDefinitionSubtree(el) {
+  var _a;
+  let current = el;
+  while (current) {
+    if (SVG_DEFINITION_CONTAINER_TAGS.has(((_a = current.tagName) == null ? void 0 : _a.toLowerCase()) ?? "")) return true;
+    current = current.parentElement;
+  }
+  return false;
+}
+function parseInlineSvgStyleDeclarations(styleText) {
+  return styleText.split(";").map((part) => part.trim()).filter(Boolean).map((part) => {
+    const idx = part.indexOf(":");
+    if (idx <= 0) return null;
+    return { key: part.slice(0, idx).trim().toLowerCase(), value: part.slice(idx + 1).trim() };
+  }).filter((x) => !!x);
+}
+function extractGradientIdFromPaint(value) {
+  if (!value) return null;
+  const match = value.trim().match(URL_GRADIENT_RE);
+  if (!match) return null;
+  const rawRef = (match[2] || "").trim();
+  if (!rawRef) return null;
+  const hashIdx = rawRef.lastIndexOf("#");
+  if (hashIdx < 0 || hashIdx === rawRef.length - 1) return null;
+  const id = rawRef.slice(hashIdx + 1).trim();
+  if (!id) return null;
+  return id.replace(/[\s"')].*$/, "");
+}
+function normalizeGradientPaintRef(value) {
+  const id = extractGradientIdFromPaint(value);
+  return id ? `url(#${id})` : value;
+}
+function findGradientInTree(svgRoot, gradientId) {
+  for (const el of svgRoot.querySelectorAll("[id]")) {
+    if (el.getAttribute("id") === gradientId) return el;
+  }
+  return null;
+}
+function getInlineStyleValue(el, key) {
+  const style = el.getAttribute("style") || "";
+  if (!style) return null;
+  const hit = parseInlineSvgStyleDeclarations(style).find((decl) => decl.key === key);
+  return (hit == null ? void 0 : hit.value) ?? null;
+}
+function isTransparentColorToken(value) {
+  if (!value) return false;
+  const s = value.trim().toLowerCase();
+  if (!s || s === "none" || s === "transparent") return true;
+  if (/^#[0-9a-f]{8}$/i.test(s)) {
+    return Number.parseInt(s.slice(7, 9), 16) === 0;
+  }
+  const rgba = s.match(/^rgba\s*\(([^)]+)\)$/i);
+  if (rgba) {
+    const parts = rgba[1].split(",").map((part) => part.trim());
+    if (parts.length >= 4) {
+      const alpha = parseSvgOpacity(parts[3]);
+      return alpha != null && alpha <= 1e-4;
+    }
+  }
+  return false;
+}
+function parseSvgOpacity(value) {
+  if (!value) return null;
+  const raw = value.trim();
+  if (!raw) return null;
+  if (raw.endsWith("%")) {
+    const pct = Number.parseFloat(raw.slice(0, -1));
+    if (!Number.isFinite(pct)) return null;
+    return Math.max(0, Math.min(1, pct / 100));
+  }
+  const n = Number.parseFloat(raw);
+  if (!Number.isFinite(n)) return null;
+  return Math.max(0, Math.min(1, n));
+}
+function formatSvgOpacity(value) {
+  return Number(Math.max(0, Math.min(1, value)).toFixed(4)).toString();
+}
+function multiplySvgOpacityAttr(el, attr, factor) {
+  const existing = parseSvgOpacity(el.getAttribute(attr));
+  el.setAttribute(attr, formatSvgOpacity((existing ?? 1) * factor));
+}
+function inlineSvgStyleBlockDeclarations(svg) {
+  const styleNodes = Array.from(svg.querySelectorAll("style"));
+  if (styleNodes.length === 0) return;
+  const cssText = styleNodes.map((node) => node.textContent || "").join("\n").replace(/\/\*[\s\S]*?\*\//g, " ");
+  if (!cssText.trim()) return;
+  const allElements = [svg, ...Array.from(svg.querySelectorAll("*"))];
+  const classIndex = /* @__PURE__ */ new Map();
+  allElements.forEach((el) => {
+    (el.getAttribute("class") || "").split(/\s+/).map((t) => t.trim()).filter(Boolean).forEach((token) => {
+      const list = classIndex.get(token) ?? [];
+      list.push(el);
+      classIndex.set(token, list);
+    });
+  });
+  const normalizePresentationValue = (key, value) => {
+    if (["fill", "stroke", "clip-path", "mask", "filter"].includes(key)) return normalizeGradientPaintRef(value);
+    return value;
+  };
+  const applyDeclarations = (elements, declarations) => {
+    for (const el of elements) {
+      const inlineDeclMap = new Map(
+        parseInlineSvgStyleDeclarations(el.getAttribute("style") || "").map(({ key, value }) => [key, value])
+      );
+      for (const { key, value } of declarations) {
+        if (!value || inlineDeclMap.has(key)) continue;
+        el.setAttribute(key, normalizePresentationValue(key, value));
+      }
+    }
+  };
+  const ruleRegex = /([^{}]+)\{([^}]*)\}/g;
+  let ruleMatch;
+  while (ruleMatch = ruleRegex.exec(cssText)) {
+    const selectors = ruleMatch[1].split(",").map((s) => s.trim()).filter(Boolean);
+    const declarations = parseInlineSvgStyleDeclarations(ruleMatch[2]).filter((d) => SVG_STYLE_PROPS.has(d.key));
+    if (selectors.length === 0 || declarations.length === 0) continue;
+    for (const selector of selectors) {
+      if (!selector || selector.startsWith("@")) continue;
+      const classOnlyMatch = selector.match(/^\.([A-Za-z_][\w-]*)$/);
+      if (classOnlyMatch) {
+        applyDeclarations(classIndex.get(classOnlyMatch[1]) ?? [], declarations);
+        continue;
+      }
+      try {
+        applyDeclarations(svg.querySelectorAll(selector), declarations);
+      } catch {
+        const classMatch = selector.match(/\.([A-Za-z0-9_-]+)/);
+        if (classMatch) applyDeclarations(classIndex.get(classMatch[1]) ?? [], declarations);
+      }
+    }
+  }
+  for (const el of allElements) {
+    const style = el.getAttribute("style");
+    if (!style) continue;
+    const keptDecls = [];
+    let changed = false;
+    for (const { key, value } of parseInlineSvgStyleDeclarations(style)) {
+      if (SVG_STYLE_PROPS.has(key)) {
+        el.setAttribute(key, normalizePresentationValue(key, value));
+        changed = true;
+      } else {
+        keptDecls.push(`${key}: ${value}`);
+      }
+    }
+    if (changed) {
+      if (keptDecls.length > 0) el.setAttribute("style", keptDecls.join("; "));
+      else el.removeAttribute("style");
+    }
+  }
+  for (const styleNode of styleNodes) {
+    const css = styleNode.textContent || "";
+    let cleaned = css;
+    for (const prop of SVG_STYLE_PROPS) {
+      const regex = new RegExp(`${prop.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&")}\\s*:\\s*[^;}{]+;?`, "gi");
+      cleaned = cleaned.replace(regex, "");
+    }
+    styleNode.textContent = cleaned.replace(/;\s*;/g, ";").replace(/\{\s*;/g, "{").replace(/;\s*}/g, "}").replace(/\{\s*}/g, "{}");
+  }
+}
+function normalizeSvgExplicitColors(svg) {
+  const clone = svg.cloneNode(true);
+  inlineSvgStyleBlockDeclarations(clone);
+  const getAttr = (el, attr) => {
+    var _a;
+    const v = el.getAttribute(attr) ?? ((_a = el.style) == null ? void 0 : _a.getPropertyValue(attr));
+    if (!v) return null;
+    const s = v.trim().toLowerCase();
+    if (!s || s === "none" || s === "transparent" || s === "currentcolor") return null;
+    return normalizeGradientPaintRef(v);
+  };
+  const hasExplicitNonePaint = (el, attr) => {
+    var _a, _b;
+    const raw = (el.getAttribute(attr) ?? ((_a = el.style) == null ? void 0 : _a.getPropertyValue(attr)) ?? "").trim().toLowerCase();
+    if (raw === "none" || raw === "transparent") return true;
+    const rawOpacity = (el.getAttribute(`${attr}-opacity`) ?? ((_b = el.style) == null ? void 0 : _b.getPropertyValue(`${attr}-opacity`)) ?? "").trim().toLowerCase();
+    return rawOpacity === "0" || rawOpacity === "0%" || rawOpacity === "0.0";
+  };
+  function walk(el, parentFill, parentStroke, parentColor) {
+    var _a;
+    if (isInSvgDefinitionSubtree(el)) {
+      for (let i = 0; i < el.children.length; i++) walk(el.children[i], null, null, null);
+      return;
+    }
+    const tag = ((_a = el.tagName) == null ? void 0 : _a.toLowerCase()) ?? "";
+    const isDrawable = SVG_DRAWABLE_TAGS.has(tag);
+    let fill = getAttr(el, "fill");
+    let stroke = getAttr(el, "stroke");
+    const color = getAttr(el, "color") ?? parentColor;
+    const fillNone = hasExplicitNonePaint(el, "fill");
+    const strokeNone = hasExplicitNonePaint(el, "stroke");
+    const inheritedFill = parentFill === "none" ? null : parentFill;
+    const inheritedStroke = parentStroke === "none" ? null : parentStroke;
+    if (isDrawable) {
+      if (fillNone) {
+        el.setAttribute("fill", "none");
+        fill = null;
+      } else {
+        const resolved = fill ?? color ?? inheritedFill;
+        if (resolved) {
+          el.setAttribute("fill", resolved);
+          fill = resolved;
+        } else if (tag !== "text" && tag !== "tspan") {
+          el.setAttribute("fill", "none");
+          fill = null;
+        }
+      }
+    }
+    if (isDrawable) {
+      if (strokeNone) {
+        el.setAttribute("stroke", "none");
+        stroke = null;
+      } else if (stroke != null || color != null || inheritedStroke != null) {
+        const resolved = stroke ?? color ?? inheritedStroke;
+        if (resolved) {
+          el.setAttribute("stroke", resolved);
+          stroke = resolved;
+        }
+      }
+    }
+    const nextColor = color ?? parentColor;
+    const nextFill = fillNone ? "none" : fill ?? inheritedFill;
+    const nextStroke = strokeNone ? "none" : stroke ?? inheritedStroke;
+    for (let i = 0; i < el.children.length; i++) walk(el.children[i], nextFill, nextStroke, nextColor);
+  }
+  const rootColor = getAttr(clone, "color") ?? (clone.getAttribute("color") || null);
+  const rootFill = getAttr(clone, "fill") ?? rootColor;
+  const rootStroke = getAttr(clone, "stroke") ?? rootColor;
+  const rootFillNone = hasExplicitNonePaint(clone, "fill");
+  const rootStrokeNone = hasExplicitNonePaint(clone, "stroke");
+  if (rootFillNone) clone.setAttribute("fill", "none");
+  else if (rootFill) clone.setAttribute("fill", rootFill);
+  if (rootStrokeNone) clone.setAttribute("stroke", "none");
+  else if (rootStroke) clone.setAttribute("stroke", rootStroke);
+  for (let i = 0; i < clone.children.length; i++) {
+    walk(clone.children[i], rootFillNone ? "none" : rootFill ?? null, rootStrokeNone ? "none" : rootStroke ?? null, rootColor);
+  }
+  return clone;
+}
+function bakeGroupOpacityIntoChildren(svg) {
+  const DRAWABLE = /* @__PURE__ */ new Set(["path", "rect", "circle", "ellipse", "polygon", "polyline", "line", "text", "tspan"]);
+  function walkAndBake(el, inheritedOpacity) {
+    var _a, _b, _c;
+    if (isInSvgDefinitionSubtree(el)) {
+      for (let i = 0; i < el.children.length; i++) walkAndBake(el.children[i], 1);
+      return;
+    }
+    const tag = ((_a = el.tagName) == null ? void 0 : _a.toLowerCase()) ?? "";
+    const opacityAttr = parseSvgOpacity(el.getAttribute("opacity"));
+    const styleOpacity = parseSvgOpacity(((_b = el.style) == null ? void 0 : _b.getPropertyValue("opacity")) || null);
+    const ownOpacity = opacityAttr ?? styleOpacity ?? 1;
+    const combinedOpacity = inheritedOpacity * ownOpacity;
+    if (ownOpacity < 0.999) {
+      el.removeAttribute("opacity");
+      if ((_c = el.style) == null ? void 0 : _c.opacity) el.style.removeProperty("opacity");
+    }
+    if (DRAWABLE.has(tag) && combinedOpacity < 0.999) {
+      multiplySvgOpacityAttr(el, "fill-opacity", combinedOpacity);
+      multiplySvgOpacityAttr(el, "stroke-opacity", combinedOpacity);
+    }
+    if (tag === "stop" && ownOpacity < 0.999) {
+      multiplySvgOpacityAttr(el, "stop-opacity", ownOpacity);
+    }
+    for (let i = 0; i < el.children.length; i++) walkAndBake(el.children[i], combinedOpacity);
+  }
+  walkAndBake(svg, 1);
+}
+function hasInvalidSvgNumericToken(value) {
+  return typeof value === "string" && /\b(?:NaN|-?Infinity)\b/.test(value);
+}
+function sanitizeSvgNumericTokens(value) {
+  return value.replace(/\bNaN\b/g, "0").replace(/\b-?Infinity\b/g, "0");
+}
+function sanitizeSvgTreeForPdf(svg) {
+  const attrsToSanitize = [
+    "d",
+    "points",
+    "transform",
+    "gradientTransform",
+    "patternTransform",
+    "viewBox",
+    "x",
+    "y",
+    "x1",
+    "y1",
+    "x2",
+    "y2",
+    "cx",
+    "cy",
+    "r",
+    "rx",
+    "ry",
+    "width",
+    "height",
+    "dx",
+    "dy",
+    "opacity",
+    "fill-opacity",
+    "stroke-opacity",
+    "stroke-width",
+    "stroke-dashoffset",
+    "font-size",
+    "letter-spacing",
+    "word-spacing"
+  ];
+  const nodes = [svg, ...Array.from(svg.querySelectorAll("*"))];
+  for (const node of nodes) {
+    for (const attr of attrsToSanitize) {
+      const value = node.getAttribute(attr);
+      if (!hasInvalidSvgNumericToken(value)) continue;
+      node.setAttribute(attr, sanitizeSvgNumericTokens(value));
+    }
+  }
+}
+function normalizeSvgGradientStopOffsets(svg) {
+  for (const stop of svg.querySelectorAll("linearGradient stop, radialGradient stop")) {
+    const offset = stop.getAttribute("offset");
+    if (!offset) continue;
+    const trimmed = offset.trim();
+    if (trimmed.endsWith("%")) {
+      const num = parseFloat(trimmed.slice(0, -1)) / 100;
+      if (Number.isFinite(num)) stop.setAttribute("offset", String(Math.max(0, Math.min(1, num))));
+    }
+  }
+}
+function copyGradientAttrsFromRef(gradient, ref) {
+  var _a;
+  const tag = (_a = gradient.tagName) == null ? void 0 : _a.toLowerCase();
+  const attrs = tag === "radialgradient" ? GRADIENT_ATTRS_RADIAL : GRADIENT_ATTRS_LINEAR;
+  for (const name of attrs) {
+    if (!gradient.hasAttribute(name) && ref.hasAttribute(name)) {
+      gradient.setAttribute(name, ref.getAttribute(name));
+    }
+  }
+}
+function expandSvgGradientHrefs(svg) {
+  const visited = /* @__PURE__ */ new Set();
+  function expand(gradient) {
+    const id = gradient.getAttribute("id");
+    if (!id || visited.has(id)) return;
+    visited.add(id);
+    if (gradient.querySelectorAll("stop").length > 0) return;
+    const href = (gradient.getAttribute("href") || gradient.getAttribute("xlink:href") || "").trim();
+    if (!href.startsWith("#")) return;
+    const ref = findGradientInTree(svg, href.slice(1));
+    if (!ref) return;
+    expand(ref);
+    copyGradientAttrsFromRef(gradient, ref);
+    for (const stop of ref.querySelectorAll("stop")) gradient.appendChild(stop.cloneNode(true));
+    gradient.removeAttribute("href");
+    gradient.removeAttribute("xlink:href");
+  }
+  for (const g of svg.querySelectorAll("linearGradient, radialGradient")) expand(g);
+}
+function expandSvgUseElements(svg) {
+  var _a;
+  const doc = svg.ownerDocument;
+  for (const use of Array.from(svg.querySelectorAll("use"))) {
+    const ref = (use.getAttribute("href") || use.getAttribute("xlink:href") || "").trim();
+    if (!ref.startsWith("#")) continue;
+    const target = doc.getElementById(ref.slice(1));
+    if (!target) continue;
+    const x = parseFloat(use.getAttribute("x") || "0") || 0;
+    const y = parseFloat(use.getAttribute("y") || "0") || 0;
+    const w = parseFloat(use.getAttribute("width") || "0") || 0;
+    const h = parseFloat(use.getAttribute("height") || "0") || 0;
+    const g = doc.createElementNS("http://www.w3.org/2000/svg", "g");
+    if (((_a = target.tagName) == null ? void 0 : _a.toLowerCase()) === "symbol") {
+      const viewBox = target.getAttribute("viewBox");
+      for (let i = 0; i < target.children.length; i++) g.appendChild(target.children[i].cloneNode(true));
+      if (viewBox && w && h) {
+        const parts = viewBox.split(/\s+/).map(Number);
+        const vbW = parts[2];
+        const vbH = parts[3];
+        if (vbW && vbH) g.setAttribute("transform", `translate(${x},${y}) scale(${w / vbW},${h / vbH})`);
+        else g.setAttribute("transform", `translate(${x},${y})`);
+      } else if (x || y) g.setAttribute("transform", `translate(${x},${y})`);
+    } else {
+      const clone = target.cloneNode(true);
+      if (x || y) g.setAttribute("transform", `translate(${x},${y})`);
+      g.appendChild(clone);
+    }
+    if (use.parentNode) use.parentNode.replaceChild(g, use);
+  }
+}
+function normalizeSvgViewBoxOrigin(svg) {
+  const viewBox = svg.getAttribute("viewBox");
+  if (!viewBox) return;
+  const parts = viewBox.split(/[\s,]+/).map(Number.parseFloat).filter(Number.isFinite);
+  if (parts.length !== 4) return;
+  const [vx, vy, vw, vh] = parts;
+  if (vw <= 0 || vh <= 0) return;
+  if (Math.abs(vx) < 1e-3 && Math.abs(vy) < 1e-3) return;
+  const doc = svg.ownerDocument;
+  if (!doc) return;
+  const keepAtRoot = /* @__PURE__ */ new Set(["defs", "style", "title", "desc", "metadata"]);
+  const translatableChildren = Array.from(svg.children).filter((c) => !keepAtRoot.has(c.tagName.toLowerCase()));
+  if (translatableChildren.length === 0) {
+    svg.setAttribute("viewBox", `0 0 ${vw} ${vh}`);
+    return;
+  }
+  const wrapper = doc.createElementNS("http://www.w3.org/2000/svg", "g");
+  wrapper.setAttribute("transform", `translate(${-vx} ${-vy})`);
+  for (const child of translatableChildren) wrapper.appendChild(child);
+  svg.appendChild(wrapper);
+  svg.setAttribute("viewBox", `0 0 ${vw} ${vh}`);
+}
+function stripRootPageBackgroundFromSvg(svg) {
+  for (const child of Array.from(svg.children)) {
+    const tag = child.tagName.toLowerCase();
+    if (tag !== "rect" && tag !== "path") continue;
+    const x = Number.parseFloat(child.getAttribute("x") || "0");
+    const y = Number.parseFloat(child.getAttribute("y") || "0");
+    const width = Number.parseFloat(child.getAttribute("width") || "0");
+    const height = Number.parseFloat(child.getAttribute("height") || "0");
+    const fill = child.getAttribute("fill") || getInlineStyleValue(child, "fill");
+    const stroke = child.getAttribute("stroke") || getInlineStyleValue(child, "stroke");
+    const opacity = parseSvgOpacity(child.getAttribute("opacity")) ?? 1;
+    const isFullPageRect = tag === "rect" && Math.abs(x) < 0.01 && Math.abs(y) < 0.01 && Math.abs(width - Number.parseFloat(svg.getAttribute("width") || "0")) < 0.5 && Math.abs(height - Number.parseFloat(svg.getAttribute("height") || "0")) < 0.5;
+    const isVisiblePaint = opacity > 1e-4 && !isTransparentColorToken(fill) && (!stroke || isTransparentColorToken(stroke));
+    if (isFullPageRect && isVisiblePaint) {
+      child.remove();
+      return;
+    }
+  }
+}
+function stripSuspiciousFullPageOverlayNodes(svg) {
+  const pageWidth = Number.parseFloat(svg.getAttribute("width") || "0");
+  const pageHeight = Number.parseFloat(svg.getAttribute("height") || "0");
+  if (!(pageWidth > 0 && pageHeight > 0)) return;
+  const isNear = (a, b, tolerance = 0.75) => Math.abs(a - b) <= tolerance;
+  const isDarkPaint = (value) => {
+    const rgb = value ? parseColor(value) : null;
+    return rgb ? rgb.r <= 32 && rgb.g <= 32 && rgb.b <= 32 : false;
+  };
+  const removeIfSuspicious = (el) => {
+    const opacity = parseSvgOpacity(el.getAttribute("opacity")) ?? parseSvgOpacity(getInlineStyleValue(el, "opacity")) ?? 1;
+    if (opacity <= 1e-3) return;
+    const fill = el.getAttribute("fill") || getInlineStyleValue(el, "fill");
+    const stroke = el.getAttribute("stroke") || getInlineStyleValue(el, "stroke");
+    if (!isDarkPaint(fill) && !isDarkPaint(stroke)) return;
+    const w = Number.parseFloat(el.getAttribute("width") || "0");
+    const h = Number.parseFloat(el.getAttribute("height") || "0");
+    const x = Number.parseFloat(el.getAttribute("x") || "0");
+    const y = Number.parseFloat(el.getAttribute("y") || "0");
+    const isRectLike = el.tagName.toLowerCase() === "rect" && isNear(x, 0) && isNear(y, 0) && isNear(w, pageWidth, 1.5) && isNear(h, pageHeight, 1.5);
+    if (isRectLike) el.remove();
+  };
+  for (const child of Array.from(svg.children)) {
+    const tag = child.tagName.toLowerCase();
+    if (["defs", "style", "title", "desc", "metadata"].includes(tag)) continue;
+    if (tag === "g") {
+      for (const gc of Array.from(child.children)) removeIfSuspicious(gc);
+    }
+    removeIfSuspicious(child);
+  }
+}
+function decodeSvgDataUri(href) {
+  if (!href.startsWith("data:image/svg+xml")) return null;
+  const commaIdx = href.indexOf(",");
+  if (commaIdx < 0) return null;
+  const meta = href.slice(0, commaIdx).toLowerCase();
+  const payload = href.slice(commaIdx + 1);
+  try {
+    if (meta.includes(";base64")) {
+      const binary = atob(payload);
+      const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+      return new TextDecoder("utf-8").decode(bytes);
+    }
+    return decodeURIComponent(payload);
+  } catch {
+    try {
+      return atob(payload);
+    } catch {
+      return null;
+    }
+  }
+}
+function inlineNestedSvgImageDataUris(svgString, domParser = new DOMParser()) {
+  var _a;
+  try {
+    const doc = domParser.parseFromString(svgString, "image/svg+xml");
+    if (doc.querySelector("parsererror")) return svgString;
+    const root = doc.documentElement;
+    if (!root || root.tagName.toLowerCase() !== "svg") return svgString;
+    let changed = false;
+    for (const img of Array.from(doc.querySelectorAll("image"))) {
+      const href = img.getAttribute("href") || img.getAttributeNS("http://www.w3.org/1999/xlink", "href");
+      if (!href || !href.startsWith("data:image/svg+xml")) continue;
+      try {
+        const svgContent = decodeSvgDataUri(href);
+        if (!svgContent || !/<svg[\s>]/i.test(svgContent)) continue;
+        const innerDoc = domParser.parseFromString(svgContent, "image/svg+xml");
+        if (innerDoc.querySelector("parsererror")) continue;
+        const innerSvg = innerDoc.documentElement;
+        if (!innerSvg || innerSvg.tagName.toLowerCase() !== "svg") continue;
+        const ix = parseFloat(img.getAttribute("x") || "0") || 0;
+        const iy = parseFloat(img.getAttribute("y") || "0") || 0;
+        const iw = parseFloat(img.getAttribute("width") || "0");
+        const ih = parseFloat(img.getAttribute("height") || "0");
+        if (!(iw > 0 && ih > 0)) continue;
+        const nestedSvg = doc.importNode(innerSvg, true);
+        if (!nestedSvg.getAttribute("viewBox")) nestedSvg.setAttribute("viewBox", `0 0 ${iw} ${ih}`);
+        nestedSvg.setAttribute("x", "0");
+        nestedSvg.setAttribute("y", "0");
+        nestedSvg.setAttribute("width", String(iw));
+        nestedSvg.setAttribute("height", String(ih));
+        nestedSvg.setAttribute("preserveAspectRatio", img.getAttribute("preserveAspectRatio") || nestedSvg.getAttribute("preserveAspectRatio") || "xMidYMid meet");
+        const g = doc.createElementNS("http://www.w3.org/2000/svg", "g");
+        const existingTransform = img.getAttribute("transform") || "";
+        g.setAttribute("transform", `${existingTransform}${existingTransform ? " " : ""}translate(${ix},${iy})`);
+        for (const attr of Array.from(img.attributes)) {
+          if (["id", "class", "style", "opacity", "display", "visibility", "clip-path", "mask", "filter", "pointer-events"].includes(attr.name)) {
+            g.setAttribute(attr.name, attr.value);
+          }
+        }
+        g.appendChild(nestedSvg);
+        (_a = img.parentNode) == null ? void 0 : _a.replaceChild(g, img);
+        changed = true;
+      } catch {
+      }
+    }
+    return changed ? new XMLSerializer().serializeToString(doc.documentElement) : svgString;
+  } catch {
+    return svgString;
+  }
+}
+function inlineComputedStyles(svg) {
+  if (typeof document === "undefined") return;
+  const wrap = document.createElement("div");
+  wrap.style.cssText = "position:fixed;left:-9999px;top:0;width:400px;height:400px;overflow:hidden;pointer-events:none";
+  const root = svg;
+  if (!root.hasAttribute("width")) root.setAttribute("width", "400");
+  if (!root.hasAttribute("height")) root.setAttribute("height", "400");
+  wrap.appendChild(root);
+  document.body.appendChild(wrap);
+  try {
+    let walk = function(el) {
+      var _a;
+      const tag = (_a = el.tagName) == null ? void 0 : _a.toLowerCase();
+      if (drawableTags.includes(tag)) {
+        const cs = window.getComputedStyle(el);
+        const fill = cs.fill;
+        const stroke = cs.stroke;
+        if (fill && fill !== "none" && fill !== "rgba(0, 0, 0, 0)") {
+          const parsed = parseColor(fill);
+          if (parsed) el.setAttribute("fill", rgbToHex(parsed.r, parsed.g, parsed.b));
+        } else if (fill === "rgba(0, 0, 0, 0)" || fill === "transparent") {
+          el.setAttribute("fill", "none");
+        }
+        if (stroke && stroke !== "none" && stroke !== "rgba(0, 0, 0, 0)") {
+          const parsed = parseColor(stroke);
+          if (parsed) el.setAttribute("stroke", rgbToHex(parsed.r, parsed.g, parsed.b));
+        }
+      }
+      for (let i = 0; i < el.children.length; i++) walk(el.children[i]);
+    };
+    const drawableTags = ["path", "rect", "circle", "ellipse", "polygon", "polyline", "line", "text", "tspan"];
+    walk(root);
+    root.remove();
+  } finally {
+    if (wrap.parentNode) document.body.removeChild(wrap);
+  }
+}
+function prefixSvgIds(svg, prefix) {
+  const safePrefix = String(prefix).replace(/[^a-zA-Z0-9-]/g, "_");
+  const idMap = /* @__PURE__ */ new Map();
+  svg.querySelectorAll("[id]").forEach((el) => {
+    const id = el.getAttribute("id");
+    if (id) idMap.set(id, `${safePrefix}_${id}`);
+  });
+  if (idMap.size === 0) return;
+  idMap.forEach((newId, oldId) => {
+    svg.querySelectorAll(`[id="${oldId}"]`).forEach((el) => el.setAttribute("id", newId));
+  });
+  const replaceUrlRefs = (value) => {
+    return value.replace(/url\(\s*(['"]?)([^)]+?)\1\s*\)/gi, (full, quoteRaw, refRaw) => {
+      const ref = String(refRaw || "").trim();
+      const hashIdx = ref.lastIndexOf("#");
+      if (hashIdx < 0 || hashIdx === ref.length - 1) return full;
+      const base = ref.slice(0, hashIdx + 1);
+      const oldId = ref.slice(hashIdx + 1).trim().replace(/[\s"')].*$/, "");
+      const mapped = idMap.get(oldId);
+      if (!mapped) return full;
+      const quote = String(quoteRaw || "");
+      return `url(${quote}${base}${mapped}${quote})`;
+    });
+  };
+  const replaceHrefRef = (value) => {
+    const trimmed = value.trim();
+    if (trimmed.startsWith("#")) {
+      const mapped = idMap.get(trimmed.slice(1));
+      return mapped ? `#${mapped}` : value;
+    }
+    return replaceUrlRefs(value);
+  };
+  const refAttrs = ["fill", "stroke", "clip-path", "mask", "filter", "href", "xlink:href", "marker-start", "marker-mid", "marker-end"];
+  svg.querySelectorAll("*").forEach((el) => {
+    refAttrs.forEach((attr) => {
+      const val = el.getAttribute(attr);
+      if (!val) return;
+      const next = attr === "href" || attr === "xlink:href" ? replaceHrefRef(val) : replaceUrlRefs(val);
+      if (next !== val) el.setAttribute(attr, next);
+    });
+    const style = el.getAttribute("style");
+    if (style) {
+      const nextStyle = replaceUrlRefs(style);
+      if (nextStyle !== style) el.setAttribute("style", nextStyle);
+    }
+  });
+  svg.querySelectorAll("style").forEach((styleNode) => {
+    const text = styleNode.textContent || "";
+    const next = replaceUrlRefs(text);
+    if (next !== text) styleNode.textContent = next;
+  });
+}
+function getFirstExplicitColorFromSvg(svg) {
+  let fill = null;
+  let stroke = null;
+  const isRealColor = (v) => {
+    if (!v || v === "none") return false;
+    const s = v.trim().toLowerCase();
+    return s !== "currentcolor" && s !== "inherit" && (s.startsWith("#") || s.startsWith("rgb"));
+  };
+  const resolveUrl = (v) => {
+    if (!v || v === "none") return null;
+    const gradientId = extractGradientIdFromPaint(v);
+    if (!gradientId) return null;
+    return getGradientStopColorAsHex(svg, gradientId);
+  };
+  function walk(el) {
+    var _a, _b;
+    if (fill && stroke) return;
+    const f = el.getAttribute("fill") ?? ((_a = el.style) == null ? void 0 : _a.getPropertyValue("fill"));
+    const s = el.getAttribute("stroke") ?? ((_b = el.style) == null ? void 0 : _b.getPropertyValue("stroke"));
+    if (!fill) {
+      if (isRealColor(f)) fill = f;
+      else if (f) {
+        const resolved = resolveUrl(f);
+        if (resolved) fill = resolved;
+      }
+    }
+    if (!stroke) {
+      if (isRealColor(s)) stroke = s;
+      else if (s) {
+        const resolved = resolveUrl(s);
+        if (resolved) stroke = resolved;
+      }
+    }
+    for (let i = 0; i < el.children.length; i++) walk(el.children[i]);
+  }
+  walk(svg);
+  return { fill, stroke };
+}
+function isNearWhite(hex) {
+  if (!/^#[0-9a-f]{6}$/i.test(hex)) return false;
+  const r = parseInt(hex.slice(1, 3), 16);
+  const g = parseInt(hex.slice(3, 5), 16);
+  const b = parseInt(hex.slice(5, 7), 16);
+  return r >= 250 && g >= 250 && b >= 250;
+}
+function getStopColorRaw(stop) {
+  var _a, _b;
+  return stop.getAttribute("stop-color") ?? ((_b = (_a = stop.style) == null ? void 0 : _a.getPropertyValue("stop-color")) == null ? void 0 : _b.trim()) ?? getInlineStyleValue(stop, "stop-color");
+}
+function getGradientStopColorAsHex(svgRoot, gradientId, visited = /* @__PURE__ */ new Set()) {
+  var _a;
+  if (visited.has(gradientId)) return null;
+  visited.add(gradientId);
+  const gradient = findGradientInTree(svgRoot, gradientId);
+  if (!gradient) return null;
+  const tag = (_a = gradient.tagName) == null ? void 0 : _a.toLowerCase();
+  if (tag !== "lineargradient" && tag !== "radialgradient") return null;
+  const stops = Array.from(gradient.querySelectorAll("stop"));
+  if (stops.length > 0) {
+    const first = getStopColorRaw(stops[0]);
+    const last = getStopColorRaw(stops[stops.length - 1]);
+    const firstHex = first ? cssColorToHex(first) : null;
+    const lastHex = last ? cssColorToHex(last) : null;
+    if (firstHex && !isNearWhite(firstHex)) return firstHex;
+    if (lastHex && !isNearWhite(lastHex)) return lastHex;
+    return firstHex ?? lastHex;
+  }
+  const href = (gradient.getAttribute("href") || gradient.getAttribute("xlink:href") || "").trim();
+  if (href.startsWith("#")) return getGradientStopColorAsHex(svgRoot, href.slice(1), visited);
+  return null;
+}
+function setPdfColorFromSvg(pdf, svg, _elementId) {
+  const { fill, stroke } = getFirstExplicitColorFromSvg(svg);
+  const setColor = (hex, setter) => {
+    if (!hex) return;
+    const c = parseColor(hex);
+    if (c) pdf[setter](c.r, c.g, c.b);
+  };
+  setColor(fill, "setFillColor");
+  setColor(stroke ?? fill, "setDrawColor");
+}
+function svg2pdfOpts(x, y, width, height) {
+  const sanitize = (value, fallback) => Number.isFinite(value) ? Number(value.toFixed(3)) : fallback;
+  const w = Math.max(1e-3, sanitize(width, 1));
+  const h = Math.max(1e-3, sanitize(height, 1));
+  return { x: sanitize(x, 0), y: sanitize(y, 0), width: w, height: h };
+}
+async function svg2pdfWithDomMount(svg, pdf, opts) {
+  const wrap = document.createElement("div");
+  wrap.style.cssText = "position:fixed;left:-9999px;top:0;width:0;height:0;overflow:hidden;pointer-events:none;opacity:0";
+  wrap.appendChild(svg);
+  document.body.appendChild(wrap);
+  try {
+    await svg2pdf(svg, pdf, opts);
+  } finally {
+    svg.remove();
+    if (wrap.parentNode) document.body.removeChild(wrap);
+  }
+}
+function convertTextDecorationsToLines(svg) {
+  const doc = svg.ownerDocument;
+  if (!doc) return;
+  let measureCanvas = null;
+  let ctx = null;
+  try {
+    measureCanvas = doc.createElement("canvas");
+    ctx = measureCanvas.getContext("2d");
+  } catch {
+  }
+  const textEls = Array.from(svg.querySelectorAll("text"));
+  for (const textEl of textEls) {
+    const tspans = Array.from(textEl.querySelectorAll("tspan"));
+    if (tspans.length === 0) continue;
+    const textDecOnText = (textEl.getAttribute("text-decoration") || "").toLowerCase();
+    const textStyleDec = (getInlineStyleValue(textEl, "text-decoration") || "").toLowerCase();
+    const textHasUnderline = textDecOnText.includes("underline") || textStyleDec.includes("underline");
+    for (const tspan of tspans) {
+      const tspanDec = (tspan.getAttribute("text-decoration") || "").toLowerCase();
+      const tspanStyleDec = (getInlineStyleValue(tspan, "text-decoration") || "").toLowerCase();
+      const hasUnderline = tspanDec.includes("underline") || tspanStyleDec.includes("underline") || textHasUnderline;
+      if (!hasUnderline) 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("font-family") || textEl.getAttribute("font-family") || "sans-serif";
+      const fontWeight = tspan.getAttribute("font-weight") || textEl.getAttribute("font-weight") || "normal";
+      const fill = tspan.getAttribute("fill") || textEl.getAttribute("fill") || "#000000";
+      let textWidth;
+      if (ctx) {
+        ctx.font = `${fontWeight} ${fontSize}px ${fontFamily.replace(/'/g, "")}`;
+        textWidth = ctx.measureText(content).width;
+      } else {
+        textWidth = content.length * fontSize * 0.6;
+      }
+      const underlineY = y + fontSize * 0.15;
+      const thickness = Math.max(0.5, fontSize * 0.066667);
+      const line = doc.createElementNS("http://www.w3.org/2000/svg", "line");
+      line.setAttribute("x1", String(x));
+      line.setAttribute("y1", String(underlineY));
+      line.setAttribute("x2", String(x + textWidth));
+      line.setAttribute("y2", String(underlineY));
+      line.setAttribute("stroke", fill.startsWith("url(") ? "#000000" : fill);
+      line.setAttribute("stroke-width", String(thickness));
+      line.setAttribute("fill", "none");
+      if (textEl.parentElement) {
+        textEl.parentElement.insertBefore(line, textEl.nextSibling);
+      }
+    }
+  }
+}
+function prepareLiveCanvasSvgForPdf(rawSvg, pageWidth, pageHeight, pageKey, options) {
+  try {
+    const parser = new DOMParser();
+    const processedSvg = inlineNestedSvgImageDataUris(rawSvg, parser);
+    const doc = parser.parseFromString(processedSvg, "image/svg+xml");
+    if (doc.querySelector("parsererror")) return null;
+    const svg = doc.documentElement;
+    if (!svg || svg.tagName.toLowerCase() !== "svg") return null;
+    svg.setAttribute("xmlns", "http://www.w3.org/2000/svg");
+    if (/xlink:href/i.test(processedSvg) && !svg.getAttribute("xmlns:xlink")) {
+      svg.setAttribute("xmlns:xlink", "http://www.w3.org/1999/xlink");
+    }
+    svg.setAttribute("width", String(pageWidth));
+    svg.setAttribute("height", String(pageHeight));
+    svg.setAttribute("viewBox", `0 0 ${pageWidth} ${pageHeight}`);
+    sanitizeSvgTreeForPdf(svg);
+    normalizeSvgViewBoxOrigin(svg);
+    expandSvgUseElements(svg);
+    const svgToDraw = normalizeSvgExplicitColors(svg);
+    inlineComputedStyles(svgToDraw);
+    sanitizeSvgTreeForPdf(svgToDraw);
+    normalizeSvgGradientStopOffsets(svgToDraw);
+    expandSvgGradientHrefs(svgToDraw);
+    prefixSvgIds(svgToDraw, pageKey);
+    bakeGroupOpacityIntoChildren(svgToDraw);
+    stripSuspiciousFullPageOverlayNodes(svgToDraw);
+    if (options == null ? void 0 : options.stripPageBackground) stripRootPageBackgroundFromSvg(svgToDraw);
+    sanitizeSvgTreeForPdf(svgToDraw);
+    convertTextDecorationsToLines(svgToDraw);
+    return svgToDraw;
+  } catch {
+    return null;
+  }
+}
+function drawPageBackground(pdf, pageIndex, pageWidth, pageHeight, backgroundColor, backgroundGradient) {
+  var _a, _b;
+  if (backgroundGradient && ((_a = backgroundGradient.stops) == null ? void 0 : _a.length) >= 2) {
+    const grad = backgroundGradient;
+    const colorStops = grad.stops.map((s) => {
+      const c = parseColor(s.color);
+      return {
+        offset: Math.max(0, Math.min(1, Number(s.offset))),
+        color: c ? [c.r, c.g, c.b] : [0, 0, 0]
+      };
+    }).filter((s) => Number.isFinite(s.offset)).sort((a, b) => a.offset - b.offset);
+    const normalizedStops = [...colorStops];
+    if (normalizedStops.length > 0) {
+      if (normalizedStops[0].offset > 0) normalizedStops.unshift({ offset: 0, color: normalizedStops[0].color });
+      if (normalizedStops[normalizedStops.length - 1].offset < 1) normalizedStops.push({ offset: 1, color: normalizedStops[normalizedStops.length - 1].color });
+    }
+    const shadingColors = normalizedStops.map((s) => ({ offset: s.offset, color: s.color }));
+    const patternKey = `bg-grad-${pageIndex}`;
+    try {
+      pdf.advancedAPI((doc) => {
+        const isLinear = grad.type === "linear";
+        const isConic = grad.type === "conic";
+        if (isLinear || isConic) {
+          const angleDeg = grad.angle ?? (isConic ? 0 : 90);
+          const angleRad = angleDeg * Math.PI / 180;
+          const sinA = Math.sin(angleRad);
+          const cosA = Math.cos(angleRad);
+          const corners = [[0, 0], [pageWidth, 0], [pageWidth, pageHeight], [0, pageHeight]];
+          const projs = corners.map(([x, y]) => x * sinA - y * cosA);
+          const minP = Math.min(...projs);
+          const maxP = Math.max(...projs);
+          const halfLen = (maxP - minP) / 2;
+          const midX = pageWidth / 2;
+          const midY = pageHeight / 2;
+          let finalStops = shadingColors;
+          if (isConic && shadingColors.length >= 2) {
+            const reversed = [...shadingColors].reverse().map((s) => ({ offset: 0.5 + (1 - s.offset) * 0.5, color: s.color }));
+            const firstHalf = shadingColors.map((s) => ({ offset: s.offset * 0.5, color: s.color }));
+            finalStops = [...firstHalf, ...reversed.slice(1)];
+          }
+          doc.addShadingPattern(patternKey, new ShadingPattern("axial", [
+            midX - sinA * halfLen,
+            midY + cosA * halfLen,
+            midX + sinA * halfLen,
+            midY - cosA * halfLen
+          ], finalStops));
+        } else {
+          const cx = (grad.cx ?? 0.5) * pageWidth;
+          const cy = (grad.cy ?? 0.5) * pageHeight;
+          const maxR = (grad.r ?? 0.5) * Math.max(pageWidth, pageHeight);
+          doc.addShadingPattern(patternKey, new ShadingPattern("radial", [cx, cy, 0, cx, cy, maxR], shadingColors));
+        }
+        doc.rect(0, 0, pageWidth, pageHeight);
+        doc.fill({ key: patternKey, matrix: doc.Matrix(1, 0, 0, 1, 0, 0) });
+      });
+    } catch {
+      const fallback = ((_b = colorStops[0]) == null ? void 0 : _b.color) || [255, 255, 255];
+      pdf.setFillColor(fallback[0], fallback[1], fallback[2]);
+      pdf.rect(0, 0, pageWidth, pageHeight, "F");
+    }
+  } else {
+    const bgColor = parseColor(backgroundColor && backgroundColor !== "transparent" ? backgroundColor : "#ffffff");
+    if (bgColor) {
+      pdf.setFillColor(bgColor.r, bgColor.g, bgColor.b);
+      pdf.rect(0, 0, pageWidth, pageHeight, "F");
+    }
+  }
+}
+async function assemblePdfFromSvgs(svgResults, options = {}) {
+  var _a, _b;
+  if (svgResults.length === 0) throw new Error("No pages to export");
+  const { title, stripPageBackground } = options;
+  const firstPage = svgResults[0];
+  const orientation = firstPage.width > firstPage.height ? "landscape" : "portrait";
+  const pdf = new jsPDF({
+    orientation,
+    unit: "px",
+    format: [firstPage.width, firstPage.height],
+    hotfixes: ["px_scaling"],
+    compress: true
+  });
+  if (title) pdf.setProperties({ title, creator: "Pixldocs" });
+  const fontBaseUrl = options.fontBaseUrl ?? (typeof window !== "undefined" ? window.location.origin + "/fonts/" : "/fonts/");
+  const { extractFontFamiliesFromSvgs: extractFontFamiliesFromSvgs2 } = await Promise.resolve().then(() => pdfFonts);
+  const fontFamilies = extractFontFamiliesFromSvgs2(svgResults.map((s) => s.svg));
+  if (fontFamilies.size > 0) {
+    await embedFontsInPdf(pdf, fontFamilies, fontBaseUrl);
+  }
+  for (let i = 0; i < svgResults.length; i++) {
+    const page = svgResults[i];
+    if (i > 0) {
+      const pageOrientation = page.width > page.height ? "landscape" : "portrait";
+      pdf.addPage([page.width, page.height], pageOrientation);
+    }
+    const hasGradient = !!((_b = (_a = page.backgroundGradient) == null ? void 0 : _a.stops) == null ? void 0 : _b.length);
+    drawPageBackground(pdf, i, page.width, page.height, page.backgroundColor, page.backgroundGradient);
+    const shouldStripBg = stripPageBackground ?? hasGradient;
+    let processedSvg = prepareLiveCanvasSvgForPdf(page.svg, page.width, page.height, `page-${i + 1}`, {
+      stripPageBackground: shouldStripBg
+    });
+    if (processedSvg) {
+      const svgStr = new XMLSerializer().serializeToString(processedSvg);
+      const rewrittenSvg = rewriteSvgFontsForJsPDF(svgStr);
+      const reParser = new DOMParser();
+      const reDoc = reParser.parseFromString(rewrittenSvg, "image/svg+xml");
+      processedSvg = reDoc.documentElement;
+    }
+    if (processedSvg) {
+      pdf.setFillColor(0, 0, 0);
+      pdf.setDrawColor(0, 0, 0);
+      pdf.saveGraphicsState();
+      setPdfColorFromSvg(pdf, processedSvg);
+      await svg2pdfWithDomMount(processedSvg, pdf, svg2pdfOpts(0, 0, page.width, page.height));
+      pdf.restoreGraphicsState();
+      pdf.setFillColor(0, 0, 0);
+      pdf.setDrawColor(0, 0, 0);
+    }
+  }
+  const arrayBuffer = pdf.output("arraybuffer");
+  const blob = new Blob([arrayBuffer], { type: "application/pdf" });
+  return {
+    blob,
+    arrayBuffer,
+    totalPages: svgResults.length,
+    pages: svgResults.map((p) => ({ width: p.width, height: p.height }))
+  };
+}
+const pdfExport = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  assemblePdfFromSvgs
+}, Symbol.toStringTag, { value: "Module" }));
 function collectImageUrls(config) {
   const urls = [];
   const walk = (nodes) => {
@@ -11278,17 +13145,29 @@ async function warmTemplateFromForm(options) {
   await warmResolvedTemplateForPreview(resolved.config, { signal, imageProxyUrl });
 }
 export {
+  FONT_FALLBACK_DEVANAGARI,
+  FONT_FALLBACK_SYMBOLS,
+  FONT_FILES,
   PixldocsPreview,
   PixldocsRenderer,
   applyThemeToConfig,
+  assemblePdfFromSvgs,
   collectFontDescriptorsFromConfig,
   collectFontsFromConfig,
   collectImageUrls,
+  embedFont,
+  embedFontsForConfig,
+  embedFontsInPdf,
   ensureFontsForResolvedConfig,
+  extractFontFamiliesFromSvgs,
+  getEmbeddedJsPDFFontName,
+  isFontAvailable,
   loadGoogleFontCSS,
   normalizeFontFamily,
+  resolveFontWeight,
   resolveFromForm,
   resolveTemplateData,
+  rewriteSvgFontsForJsPDF,
   warmResolvedTemplateForPreview,
   warmTemplateFromForm
 };