@pixldocs/canvas-renderer 0.5.104 → 0.5.105

package/dist/index.cjs

@@ -6,6 +6,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const jsxRuntime = require("react/jsx-runtime");
 const react = require("react");
 const reactDom = require("react-dom");
+const sonner = require("sonner");
 const zustand = require("zustand");
 const fabric = require("fabric");
 const client = require("react-dom/client");
@@ -2506,9 +2507,17 @@ const useEditorStore = zustand.create((set, get) => ({
 }));
 let canvasRegistry = /* @__PURE__ */ new Map();
 function registerFabricCanvas(pageId, canvas) {
-  canvasRegistry.set(pageId, canvas);
-}
-function unregisterFabricCanvas(pageId) {
+  const existing = canvasRegistry.get(pageId);
+  const registryKey = existing && existing !== canvas ? `${pageId}#${Math.random().toString(36).slice(2, 10)}` : pageId;
+  canvasRegistry.set(registryKey, canvas);
+  return registryKey;
+}
+function unregisterFabricCanvas(pageId, canvas) {
+  if (canvas) {
+    const existing = canvasRegistry.get(pageId);
+    if (existing === canvas) canvasRegistry.delete(pageId);
+    return;
+  }
   canvasRegistry.delete(pageId);
 }
 const LOCAL_FONTS = /* @__PURE__ */ new Set([
@@ -2580,6 +2589,8 @@ const LOCAL_FONTS = /* @__PURE__ */ new Set([
 ]);
 const loadedGoogleFonts = /* @__PURE__ */ new Set();
 const failedGoogleFonts = /* @__PURE__ */ new Set();
+const loadedFontshareFonts = /* @__PURE__ */ new Set();
+const failedFontshareFonts = /* @__PURE__ */ new Set();
 const loadingPromises$1 = /* @__PURE__ */ new Map();
 async function loadGoogleFont(fontFamily, weights) {
   if (LOCAL_FONTS.has(fontFamily)) return true;
@@ -2639,6 +2650,346 @@ async function _doLoadGoogleFont(fontFamily, weights) {
   console.warn(`[GoogleFonts] Failed to load: ${fontFamily}`);
   return false;
 }
+async function loadFontshareFont(fontFamily, slug, weights) {
+  if (loadedFontshareFonts.has(fontFamily)) return true;
+  if (failedFontshareFonts.has(fontFamily)) return false;
+  const existing = loadingPromises$1.get(`fontshare:${fontFamily}`);
+  if (existing) return existing;
+  const promise = (async () => {
+    try {
+      const weightStr = (weights || [300, 400, 500, 700]).join(",");
+      const url = `https://api.fontshare.com/v2/css?f[]=${slug}@${weightStr}&display=swap`;
+      if (document.querySelector(`link[href="${url}"]`)) return true;
+      const link = document.createElement("link");
+      link.rel = "stylesheet";
+      link.href = url;
+      return await new Promise((resolve) => {
+        link.onload = async () => {
+          try {
+            await document.fonts.load(`16px "${fontFamily}"`);
+            await document.fonts.load(`bold 16px "${fontFamily}"`);
+          } catch {
+          }
+          resolve(true);
+        };
+        link.onerror = () => {
+          console.warn(`[Fontshare] Failed to load: ${fontFamily}`);
+          resolve(false);
+        };
+        document.head.appendChild(link);
+      });
+    } catch (e) {
+      console.warn(`[Fontshare] Error loading ${fontFamily}:`, e);
+      return false;
+    }
+  })();
+  loadingPromises$1.set(`fontshare:${fontFamily}`, promise);
+  try {
+    const result = await promise;
+    if (result) loadedFontshareFonts.add(fontFamily);
+    else failedFontshareFonts.add(fontFamily);
+    return result;
+  } finally {
+    loadingPromises$1.delete(`fontshare:${fontFamily}`);
+  }
+}
+async function loadFont(fontFamily) {
+  if (LOCAL_FONTS.has(fontFamily)) return true;
+  const entry = findFontEntry(fontFamily);
+  if ((entry == null ? void 0 : entry.source) === "fontshare" && entry.fontshareSlug) {
+    return loadFontshareFont(fontFamily, entry.fontshareSlug);
+  }
+  return loadGoogleFont(fontFamily);
+}
+const EXTENDED_FONT_LIST = [
+  // ═══════════════════════════════════════════════════════════════════
+  //  PREMIUM (Fontshare) — modern, professional aesthetic
+  // ═══════════════════════════════════════════════════════════════════
+  { name: "Satoshi", category: "Premium", local: false, source: "fontshare", fontshareSlug: "satoshi", popular: true },
+  { name: "Cabinet Grotesk", category: "Premium", local: false, source: "fontshare", fontshareSlug: "cabinet-grotesk", popular: true },
+  { name: "Clash Display", category: "Premium", local: false, source: "fontshare", fontshareSlug: "clash-display", popular: true },
+  { name: "Clash Grotesk", category: "Premium", local: false, source: "fontshare", fontshareSlug: "clash-grotesk", popular: true },
+  { name: "General Sans", category: "Premium", local: false, source: "fontshare", fontshareSlug: "general-sans", popular: true },
+  { name: "Switzer", category: "Premium", local: false, source: "fontshare", fontshareSlug: "switzer" },
+  { name: "Supreme", category: "Premium", local: false, source: "fontshare", fontshareSlug: "supreme" },
+  { name: "Author", category: "Premium", local: false, source: "fontshare", fontshareSlug: "author" },
+  { name: "Boska", category: "Premium", local: false, source: "fontshare", fontshareSlug: "boska" },
+  { name: "Excon", category: "Premium", local: false, source: "fontshare", fontshareSlug: "excon" },
+  { name: "Khand", category: "Premium", local: false, source: "fontshare", fontshareSlug: "khand" },
+  { name: "Sentient", category: "Premium", local: false, source: "fontshare", fontshareSlug: "sentient" },
+  { name: "Synonym", category: "Premium", local: false, source: "fontshare", fontshareSlug: "synonym" },
+  { name: "Erode", category: "Premium", local: false, source: "fontshare", fontshareSlug: "erode" },
+  { name: "Ranade", category: "Premium", local: false, source: "fontshare", fontshareSlug: "ranade" },
+  { name: "Tanker", category: "Premium", local: false, source: "fontshare", fontshareSlug: "tanker" },
+  { name: "Zodiak", category: "Premium", local: false, source: "fontshare", fontshareSlug: "zodiak" },
+  { name: "Gambarino", category: "Premium", local: false, source: "fontshare", fontshareSlug: "gambarino" },
+  { name: "Melodrama", category: "Premium", local: false, source: "fontshare", fontshareSlug: "melodrama" },
+  { name: "Bespoke Serif", category: "Premium", local: false, source: "fontshare", fontshareSlug: "bespoke-serif" },
+  { name: "Bespoke Stencil", category: "Premium", local: false, source: "fontshare", fontshareSlug: "bespoke-stencil" },
+  { name: "Panchang", category: "Premium", local: false, source: "fontshare", fontshareSlug: "panchang" },
+  { name: "Pally", category: "Premium", local: false, source: "fontshare", fontshareSlug: "pally" },
+  { name: "Tabular", category: "Premium", local: false, source: "fontshare", fontshareSlug: "tabular" },
+  { name: "Sharpie", category: "Premium", local: false, source: "fontshare", fontshareSlug: "sharpie" },
+  { name: "Stardom", category: "Premium", local: false, source: "fontshare", fontshareSlug: "stardom" },
+  { name: "Telma", category: "Premium", local: false, source: "fontshare", fontshareSlug: "telma" },
+  { name: "Nippo", category: "Premium", local: false, source: "fontshare", fontshareSlug: "nippo" },
+  // ═══════════════════════════════════════════════════════════════════
+  //  SERIF — editorial, classical, elegant
+  // ═══════════════════════════════════════════════════════════════════
+  { name: "Playfair Display", category: "Serif", local: true, popular: true },
+  { name: "Cormorant", category: "Serif", local: false, popular: true },
+  { name: "Cormorant Garamond", category: "Serif", local: false },
+  { name: "Cinzel", category: "Serif", local: false, popular: true },
+  { name: "Cinzel Decorative", category: "Serif", local: false },
+  { name: "Bodoni Moda", category: "Serif", local: false, popular: true },
+  { name: "DM Serif Display", category: "Serif", local: true },
+  { name: "DM Serif Text", category: "Serif", local: false },
+  { name: "Italiana", category: "Serif", local: false },
+  { name: "Marcellus", category: "Serif", local: false },
+  { name: "Marcellus SC", category: "Serif", local: false },
+  { name: "Yeseva One", category: "Serif", local: false },
+  { name: "Prata", category: "Serif", local: false },
+  { name: "Tenor Sans", category: "Serif", local: false },
+  { name: "Fraunces", category: "Serif", local: false, popular: true },
+  { name: "Newsreader", category: "Serif", local: false },
+  { name: "Source Serif Pro", category: "Serif", local: false },
+  { name: "Merriweather", category: "Serif", local: true },
+  { name: "Lora", category: "Serif", local: true },
+  { name: "EB Garamond", category: "Serif", local: true },
+  { name: "Libre Baskerville", category: "Serif", local: true },
+  { name: "Libre Caslon Text", category: "Serif", local: false },
+  { name: "Libre Caslon Display", category: "Serif", local: false },
+  { name: "Crimson Text", category: "Serif", local: true },
+  { name: "Crimson Pro", category: "Serif", local: false },
+  { name: "Noto Serif", category: "Serif", local: false },
+  { name: "Noto Serif Display", category: "Serif", local: false },
+  { name: "PT Serif", category: "Serif", local: false },
+  { name: "Bitter", category: "Serif", local: false },
+  { name: "Spectral", category: "Serif", local: false },
+  { name: "Cardo", category: "Serif", local: false },
+  { name: "Old Standard TT", category: "Serif", local: false },
+  { name: "Vollkorn", category: "Serif", local: false },
+  { name: "Cantata One", category: "Serif", local: false },
+  { name: "Domine", category: "Serif", local: false },
+  { name: "Gentium Plus", category: "Serif", local: false },
+  { name: "Tinos", category: "Serif", local: false },
+  { name: "Trirong", category: "Serif", local: false },
+  { name: "Sorts Mill Goudy", category: "Serif", local: false },
+  { name: "IM Fell English", category: "Serif", local: false },
+  { name: "IM Fell DW Pica", category: "Serif", local: false },
+  { name: "Petrona", category: "Serif", local: false },
+  { name: "Rozha One", category: "Serif", local: false },
+  { name: "Tiro Devanagari Hindi", category: "Serif", local: false },
+  // ═══════════════════════════════════════════════════════════════════
+  //  SANS-SERIF — clean, modern, workhorse
+  // ═══════════════════════════════════════════════════════════════════
+  { name: "Inter", category: "Sans-Serif", local: true, popular: true },
+  { name: "Montserrat", category: "Sans-Serif", local: true, popular: true },
+  { name: "Poppins", category: "Sans-Serif", local: true, popular: true },
+  { name: "Open Sans", category: "Sans-Serif", local: true },
+  { name: "Roboto", category: "Sans-Serif", local: true },
+  { name: "Lato", category: "Sans-Serif", local: true },
+  { name: "Raleway", category: "Sans-Serif", local: true },
+  { name: "Nunito", category: "Sans-Serif", local: true },
+  { name: "Source Sans Pro", category: "Sans-Serif", local: true },
+  { name: "Work Sans", category: "Sans-Serif", local: true },
+  { name: "DM Sans", category: "Sans-Serif", local: true, popular: true },
+  { name: "Outfit", category: "Sans-Serif", local: true, popular: true },
+  { name: "Figtree", category: "Sans-Serif", local: true },
+  { name: "Manrope", category: "Sans-Serif", local: true, popular: true },
+  { name: "Space Grotesk", category: "Sans-Serif", local: true, popular: true },
+  { name: "Mulish", category: "Sans-Serif", local: true },
+  { name: "Quicksand", category: "Sans-Serif", local: true },
+  { name: "Rubik", category: "Sans-Serif", local: true },
+  { name: "Karla", category: "Sans-Serif", local: true },
+  { name: "Plus Jakarta Sans", category: "Sans-Serif", local: true },
+  { name: "Libre Franklin", category: "Sans-Serif", local: true },
+  { name: "Sora", category: "Sans-Serif", local: true },
+  { name: "Urbanist", category: "Sans-Serif", local: true },
+  { name: "Lexend", category: "Sans-Serif", local: true },
+  { name: "Albert Sans", category: "Sans-Serif", local: true },
+  { name: "Noto Sans", category: "Sans-Serif", local: true },
+  { name: "Cabin", category: "Sans-Serif", local: true },
+  { name: "Barlow", category: "Sans-Serif", local: true },
+  { name: "Barlow Condensed", category: "Sans-Serif", local: false },
+  { name: "Josefin Sans", category: "Sans-Serif", local: true },
+  { name: "Archivo", category: "Sans-Serif", local: true },
+  { name: "Archivo Narrow", category: "Sans-Serif", local: false },
+  { name: "Overpass", category: "Sans-Serif", local: true },
+  { name: "Exo 2", category: "Sans-Serif", local: true },
+  { name: "Onest", category: "Sans-Serif", local: false, popular: true },
+  { name: "Be Vietnam Pro", category: "Sans-Serif", local: false },
+  { name: "Public Sans", category: "Sans-Serif", local: false },
+  { name: "Red Hat Display", category: "Sans-Serif", local: false },
+  { name: "Red Hat Text", category: "Sans-Serif", local: false },
+  { name: "Sen", category: "Sans-Serif", local: false },
+  { name: "Hanken Grotesk", category: "Sans-Serif", local: false },
+  { name: "Schibsted Grotesk", category: "Sans-Serif", local: false },
+  { name: "Reddit Sans", category: "Sans-Serif", local: false },
+  { name: "Instrument Sans", category: "Sans-Serif", local: false },
+  { name: "Geist", category: "Sans-Serif", local: false, popular: true },
+  { name: "Nunito Sans", category: "Sans-Serif", local: false },
+  { name: "PT Sans", category: "Sans-Serif", local: false },
+  { name: "PT Sans Narrow", category: "Sans-Serif", local: false },
+  { name: "Mukta", category: "Sans-Serif", local: false },
+  { name: "Anek Devanagari", category: "Sans-Serif", local: false },
+  { name: "Hind", category: "Sans-Serif", local: true },
+  { name: "Hind Vadodara", category: "Sans-Serif", local: false },
+  // ═══════════════════════════════════════════════════════════════════
+  //  DISPLAY — bold, attention-grabbing headlines
+  // ═══════════════════════════════════════════════════════════════════
+  { name: "Bebas Neue", category: "Display", local: true, popular: true },
+  { name: "Anton", category: "Display", local: true, popular: true },
+  { name: "Oswald", category: "Display", local: true },
+  { name: "Abril Fatface", category: "Display", local: true, popular: true },
+  { name: "League Spartan", category: "Display", local: true },
+  { name: "Teko", category: "Display", local: true },
+  { name: "Righteous", category: "Display", local: false },
+  { name: "Alfa Slab One", category: "Display", local: false, popular: true },
+  { name: "Archivo Black", category: "Display", local: false },
+  { name: "Fredoka", category: "Display", local: false },
+  { name: "Passion One", category: "Display", local: false },
+  { name: "Bowlby One", category: "Display", local: false },
+  { name: "Bowlby One SC", category: "Display", local: false },
+  { name: "Secular One", category: "Display", local: false },
+  { name: "Lilita One", category: "Display", local: false },
+  { name: "Titan One", category: "Display", local: false },
+  { name: "Russo One", category: "Display", local: false },
+  { name: "Staatliches", category: "Display", local: false, popular: true },
+  { name: "Dela Gothic One", category: "Display", local: false },
+  { name: "Ultra", category: "Display", local: false },
+  { name: "Sigmar One", category: "Display", local: false },
+  { name: "Sigmar", category: "Display", local: false },
+  { name: "Modak", category: "Display", local: false },
+  { name: "Bagel Fat One", category: "Display", local: false },
+  { name: "Climate Crisis", category: "Display", local: false },
+  { name: "Yatra One", category: "Display", local: false },
+  { name: "Bungee", category: "Display", local: false },
+  { name: "Bungee Shade", category: "Display", local: false },
+  { name: "Bungee Outline", category: "Display", local: false },
+  { name: "Bungee Inline", category: "Display", local: false },
+  { name: "Monoton", category: "Display", local: false, popular: true },
+  { name: "Black Ops One", category: "Display", local: false },
+  { name: "Faster One", category: "Display", local: false },
+  { name: "Rubik Glitch", category: "Display", local: false },
+  { name: "Rubik Mono One", category: "Display", local: false },
+  { name: "Rubik Wet Paint", category: "Display", local: false },
+  { name: "Rubik Bubbles", category: "Display", local: false },
+  { name: "Rubik Beastly", category: "Display", local: false },
+  { name: "Rubik Burned", category: "Display", local: false },
+  { name: "Rubik Distressed", category: "Display", local: false },
+  { name: "Rubik Iso", category: "Display", local: false },
+  { name: "Rubik Marker Hatch", category: "Display", local: false },
+  { name: "Rubik Maze", category: "Display", local: false },
+  { name: "Rubik Pixels", category: "Display", local: false },
+  { name: "Rubik Puddles", category: "Display", local: false },
+  { name: "Rubik Spray Paint", category: "Display", local: false },
+  { name: "Rubik Vinyl", category: "Display", local: false },
+  { name: "Saira Stencil One", category: "Display", local: false },
+  { name: "Audiowide", category: "Display", local: false },
+  { name: "Orbitron", category: "Display", local: false },
+  { name: "Plaster", category: "Display", local: false },
+  // ═══════════════════════════════════════════════════════════════════
+  //  HANDWRITING / SCRIPT — fluid, personal, calligraphic
+  // ═══════════════════════════════════════════════════════════════════
+  { name: "Dancing Script", category: "Handwriting", local: true, popular: true },
+  { name: "Pacifico", category: "Handwriting", local: true, popular: true },
+  { name: "Great Vibes", category: "Handwriting", local: true, popular: true },
+  { name: "Sacramento", category: "Handwriting", local: true },
+  { name: "Alex Brush", category: "Handwriting", local: true },
+  { name: "Allura", category: "Handwriting", local: true },
+  { name: "Caveat", category: "Handwriting", local: true },
+  { name: "Caveat Brush", category: "Handwriting", local: false },
+  { name: "Lobster", category: "Handwriting", local: true },
+  { name: "Lobster Two", category: "Handwriting", local: false },
+  { name: "Comfortaa", category: "Handwriting", local: true },
+  { name: "Tangerine", category: "Handwriting", local: false, popular: true },
+  { name: "Yellowtail", category: "Handwriting", local: false, popular: true },
+  { name: "Kaushan Script", category: "Handwriting", local: false, popular: true },
+  { name: "Parisienne", category: "Handwriting", local: false },
+  { name: "Petit Formal Script", category: "Handwriting", local: false },
+  { name: "Pinyon Script", category: "Handwriting", local: false },
+  { name: "Mrs Saint Delafield", category: "Handwriting", local: false },
+  { name: "Marck Script", category: "Handwriting", local: false },
+  { name: "Niconne", category: "Handwriting", local: false },
+  { name: "Homemade Apple", category: "Handwriting", local: false },
+  { name: "Permanent Marker", category: "Handwriting", local: false },
+  { name: "Reenie Beanie", category: "Handwriting", local: false },
+  { name: "Satisfy", category: "Handwriting", local: false },
+  { name: "Kalam", category: "Handwriting", local: false },
+  { name: "Indie Flower", category: "Handwriting", local: false },
+  { name: "Courgette", category: "Handwriting", local: false },
+  { name: "Cookie", category: "Handwriting", local: false },
+  { name: "Shadows Into Light", category: "Handwriting", local: false },
+  { name: "Patrick Hand", category: "Handwriting", local: false },
+  { name: "Amatic SC", category: "Handwriting", local: false },
+  { name: "Architects Daughter", category: "Handwriting", local: false },
+  { name: "Gloria Hallelujah", category: "Handwriting", local: false },
+  { name: "La Belle Aurore", category: "Handwriting", local: false },
+  { name: "Mr Dafoe", category: "Handwriting", local: false },
+  { name: "Italianno", category: "Handwriting", local: false },
+  { name: "Rouge Script", category: "Handwriting", local: false },
+  { name: "Grand Hotel", category: "Handwriting", local: false },
+  { name: "Bilbo Swash Caps", category: "Handwriting", local: false },
+  // ═══════════════════════════════════════════════════════════════════
+  //  DECORATIVE / FUN — quirky, themed, special-occasion
+  // ═══════════════════════════════════════════════════════════════════
+  { name: "Frijole", category: "Decorative", local: false },
+  { name: "Creepster", category: "Decorative", local: false },
+  { name: "Nosifer", category: "Decorative", local: false },
+  { name: "Ewert", category: "Decorative", local: false },
+  { name: "Lakki Reddy", category: "Decorative", local: false },
+  { name: "Henny Penny", category: "Decorative", local: false },
+  { name: "Special Elite", category: "Decorative", local: false, popular: true },
+  { name: "Vast Shadow", category: "Decorative", local: false },
+  { name: "Almendra Display", category: "Decorative", local: false },
+  { name: "Eater", category: "Decorative", local: false },
+  { name: "Butcherman", category: "Decorative", local: false },
+  { name: "Pirata One", category: "Decorative", local: false },
+  { name: "Metamorphous", category: "Decorative", local: false },
+  { name: "MedievalSharp", category: "Decorative", local: false },
+  { name: "Fascinate", category: "Decorative", local: false },
+  { name: "Fascinate Inline", category: "Decorative", local: false },
+  { name: "Sancreek", category: "Decorative", local: false },
+  { name: "Smokum", category: "Decorative", local: false },
+  { name: "Vampiro One", category: "Decorative", local: false },
+  { name: "Mountains of Christmas", category: "Decorative", local: false },
+  { name: "Caesar Dressing", category: "Decorative", local: false },
+  { name: "Megrim", category: "Decorative", local: false },
+  // ═══════════════════════════════════════════════════════════════════
+  //  BLACKLETTER — gothic, medieval, formal
+  // ═══════════════════════════════════════════════════════════════════
+  { name: "UnifrakturCook", category: "Blackletter", local: false },
+  { name: "UnifrakturMaguntia", category: "Blackletter", local: false },
+  // ═══════════════════════════════════════════════════════════════════
+  //  MONOSPACE — code, technical
+  // ═══════════════════════════════════════════════════════════════════
+  { name: "Roboto Mono", category: "Monospace", local: true },
+  { name: "Fira Code", category: "Monospace", local: true },
+  { name: "JetBrains Mono", category: "Monospace", local: true },
+  { name: "Source Code Pro", category: "Monospace", local: true },
+  { name: "IBM Plex Mono", category: "Monospace", local: true },
+  { name: "Space Mono", category: "Monospace", local: true },
+  { name: "Geist Mono", category: "Monospace", local: false },
+  { name: "DM Mono", category: "Monospace", local: false },
+  { name: "Inconsolata", category: "Monospace", local: false },
+  { name: "Cousine", category: "Monospace", local: false },
+  { name: "Anonymous Pro", category: "Monospace", local: false },
+  { name: "Cutive Mono", category: "Monospace", local: false },
+  { name: "Major Mono Display", category: "Monospace", local: false },
+  { name: "VT323", category: "Monospace", local: false },
+  { name: "Share Tech Mono", category: "Monospace", local: false }
+];
+const _fontLookupCache = /* @__PURE__ */ new Map();
+function findFontEntry(name) {
+  const key = name.toLowerCase().replace(/[\s\-_]/g, "");
+  if (_fontLookupCache.has(key)) return _fontLookupCache.get(key);
+  const entry = EXTENDED_FONT_LIST.find(
+    (f) => f.name.toLowerCase().replace(/[\s\-_]/g, "") === key
+  );
+  if (entry) _fontLookupCache.set(key, entry);
+  return entry;
+}
 const getObjectId = (obj) => obj.__docuforgeId;
 const setObjectData = (obj, id) => {
   obj.__docuforgeId = id;
@@ -2860,9 +3211,27 @@ const ensureFontLoaded = async (fontFamily) => {
     return;
   }
   try {
-    await loadGoogleFont(fontFamily);
+    await loadFont(fontFamily);
   } catch (e) {
-    console.warn(`Failed to load Google Font: ${fontFamily}`, e);
+    console.warn(`Failed to load font: ${fontFamily}`, e);
+    try {
+      await loadGoogleFont(fontFamily);
+    } catch {
+    }
+  }
+  try {
+    if (document.fonts) {
+      await Promise.race([
+        Promise.all([
+          document.fonts.load(`16px "${fontFamily}"`),
+          document.fonts.load(`bold 16px "${fontFamily}"`),
+          document.fonts.load(`italic 16px "${fontFamily}"`),
+          document.fonts.load(`bold italic 16px "${fontFamily}"`)
+        ]),
+        new Promise((r) => setTimeout(r, 2500))
+      ]);
+    }
+  } catch {
   }
 };
 const setupFontLoadingListener = (canvas, afterRerender) => {
@@ -5363,6 +5732,172 @@ function buildRoundedTrianglePath(w, h, rTop, rBR, rBL) {
   ];
   return parts.join(" ");
 }
+let activeThemeColors = {};
+function setMarkdownThemeColors(c) {
+  activeThemeColors = { ...c };
+}
+function resolveColorToken(token, theme) {
+  const raw = token.trim();
+  const t = raw.toLowerCase();
+  if (t === "primary") return theme.primary;
+  if (t === "secondary") return theme.secondary;
+  if (/^#([0-9a-f]{3,8})$/i.test(raw)) return raw;
+  if (/^(rgb|rgba|hsl|hsla)\(/i.test(raw)) return raw;
+  if (/^[a-z]+$/i.test(raw)) return raw;
+  return void 0;
+}
+function mergeStyle(a, b) {
+  return { ...a, ...b };
+}
+function tokenize(input, theme) {
+  const runs = [];
+  const stack = [];
+  let buf = "";
+  const activeStyle = () => {
+    let s = {};
+    for (const e of stack) s = mergeStyle(s, e.style);
+    return s;
+  };
+  const flush = () => {
+    if (buf.length === 0) return;
+    runs.push({ text: buf, style: activeStyle() });
+    buf = "";
+  };
+  let i = 0;
+  const n = input.length;
+  const peek = (s, at = i) => input.startsWith(s, at);
+  const findUnescaped = (needle, from) => {
+    let p = from;
+    while (p < n) {
+      if (input[p] === "\\" && p + 1 < n) {
+        p += 2;
+        continue;
+      }
+      if (input.startsWith(needle, p)) return p;
+      p++;
+    }
+    return -1;
+  };
+  const tryOpenBracket = () => {
+    if (input[i] !== "[") return -1;
+    const m = /^\[(c|bg)=([^\]]+)\]/.exec(input.slice(i));
+    if (!m) return -1;
+    const kind = m[1];
+    const tokenRaw = m[2];
+    const closer = kind === "c" ? "[/c]" : "[/bg]";
+    if (findUnescaped(closer, i + m[0].length) === -1) return -1;
+    const color = resolveColorToken(tokenRaw, theme);
+    const style = {};
+    if (color) {
+      if (kind === "c") style.fill = color;
+      else style.textBackgroundColor = color;
+    }
+    flush();
+    stack.push({ kind, style, closer });
+    return i + m[0].length;
+  };
+  const tryCloseBracket = () => {
+    for (let s = stack.length - 1; s >= 0; s--) {
+      const top = stack[s];
+      if (top.kind !== "c" && top.kind !== "bg") continue;
+      if (peek(top.closer)) {
+        if (s !== stack.length - 1) stack.length = s + 1;
+        flush();
+        stack.pop();
+        return i + top.closer.length;
+      }
+      break;
+    }
+    return -1;
+  };
+  const toggle = (delim, kind, style) => {
+    if (!peek(delim)) return null;
+    const topIdx = stack.findIndex((e) => e.kind === kind);
+    if (topIdx >= 0) {
+      if (topIdx !== stack.length - 1) return null;
+      flush();
+      stack.length = topIdx;
+      return i + delim.length;
+    }
+    if (findUnescaped(delim, i + delim.length) === -1) return null;
+    flush();
+    stack.push({ kind, style, closer: delim });
+    return i + delim.length;
+  };
+  while (i < n) {
+    const ch = input[i];
+    if (ch === "\\" && i + 1 < n) {
+      buf += input[i + 1];
+      i += 2;
+      continue;
+    }
+    if (ch === "[") {
+      const closed = tryCloseBracket();
+      if (closed > 0) {
+        i = closed;
+        continue;
+      }
+      const opened = tryOpenBracket();
+      if (opened > 0) {
+        i = opened;
+        continue;
+      }
+    }
+    let next;
+    if ((next = toggle("**", "bold", { fontWeight: 700 })) !== null) {
+      i = next;
+      continue;
+    }
+    if ((next = toggle("__", "under", { underline: true })) !== null) {
+      i = next;
+      continue;
+    }
+    if ((next = toggle("~~", "strike", { linethrough: true })) !== null) {
+      i = next;
+      continue;
+    }
+    if ((next = toggle("==", "highlight", { textBackgroundColor: theme.secondary || "#ffe066" })) !== null) {
+      i = next;
+      continue;
+    }
+    if ((next = toggle("*", "italic", { fontStyle: "italic" })) !== null) {
+      i = next;
+      continue;
+    }
+    buf += ch;
+    i++;
+  }
+  flush();
+  return runs;
+}
+function parseTextMarkdown(input, themeColors) {
+  const theme = activeThemeColors;
+  const runs = tokenize(input ?? "", theme);
+  let plain = "";
+  const styles = {};
+  let lineIdx = 0;
+  let charIdx = 0;
+  let hasFormatting = false;
+  for (const run of runs) {
+    const styleHasContent = Object.keys(run.style).length > 0;
+    if (styleHasContent) hasFormatting = true;
+    for (const ch of run.text) {
+      if (ch === "\n") {
+        plain += "\n";
+        lineIdx++;
+        charIdx = 0;
+        continue;
+      }
+      plain += ch;
+      if (styleHasContent) {
+        if (!styles[lineIdx]) styles[lineIdx] = {};
+        styles[lineIdx][charIdx] = { ...run.style };
+      }
+      charIdx++;
+    }
+  }
+  return { plainText: plain, styles, hasFormatting };
+}
 const roundDiag = (value) => {
   if (typeof value !== "number") return value;
   return Number.isFinite(value) ? Number(value.toFixed(3)) : value;
@@ -5501,6 +6036,13 @@ function createText(element) {
   let fontSize = element.fontSize || 16;
   const minFontSize = element.minFontSize || 8;
   const maxLines = element.maxLines || 3;
+  const formattingEnabled = element.formattingEnabled === true;
+  let parsedStyles = {};
+  if (formattingEnabled) {
+    const parsed = parseTextMarkdown(text);
+    text = parsed.plainText || " ";
+    parsedStyles = parsed.styles;
+  }
   const baseWidth = element.width && element.width > 0 ? element.width : 200;
   const baseHeight = element.height;
   const fixedWidth = Math.max(baseWidth, 1);
@@ -5521,7 +6063,8 @@ function createText(element) {
         fontStyle: element.fontStyle || "normal",
         lineHeight: element.lineHeight || 1.2,
         charSpacing: element.charSpacing || 0,
-        splitByGrapheme: false
+        splitByGrapheme: false,
+        ...formattingEnabled ? { styles: parsedStyles } : {}
       });
       testTextbox.initDimensions();
       const textHeight = testTextbox.height || 0;
@@ -5633,8 +6176,16 @@ function createText(element) {
     objectCaching: false,
     noScaleCache: true,
     splitByGrapheme,
-    ...element.styles ? { styles: element.styles } : {}
+    // When inline markdown formatting is enabled, the displayed text is the
+    // PARSED plain text (markdown source lives separately on the element).
+    // Allowing canvas inline editing would let the user edit that plain text
+    // and on commit we'd save it back as the new markdown source — wiping all
+    // formatting tokens (**, __, [c=...], etc). Disable inline edit and steer
+    // users to the right-panel text field which exposes the raw markdown.
+    editable: !formattingEnabled,
+    ...formattingEnabled ? { styles: parsedStyles } : element.styles ? { styles: element.styles } : {}
   });
+  textbox.__formattingEnabled = formattingEnabled;
   textbox.initDimensions();
   textbox.set({
     width: targetWidth,
@@ -5655,6 +6206,15 @@ function createText(element) {
     textbox.setCoords();
   }
   textbox.dirty = true;
+  if (formattingEnabled) {
+    try {
+      textbox._forceClearCache = true;
+      if (typeof textbox._clearCache === "function") {
+        textbox._clearCache();
+      }
+    } catch {
+    }
+  }
   if (overflowPolicy === "auto-shrink" && typeof window !== "undefined" && window.__pixldocsDebugAutoShrink === true) {
     console.log("[auto-shrink][final-textbox] " + stringifyDiag({
       id: element.id,
@@ -6391,6 +6951,10 @@ const PageCanvas = react.forwardRef(
     skipFontReadyWait = false,
     onReady
   }, ref) => {
+    setMarkdownThemeColors({
+      primary: projectSettings.primaryColor || "#7c3aed",
+      secondary: projectSettings.secondaryColor || "#ffe066"
+    });
     const isEditorMode = mode === "editor";
     const isPreviewMode = mode === "preview";
     const allowEditing = isEditorMode;
@@ -6486,8 +7050,8 @@ const PageCanvas = react.forwardRef(
     }, [selectedIds]);
     react.useEffect(() => {
       isActiveRef.current = isActive;
-      if (isActive && fabricRef.current) ;
-    }, [isActive, pageId]);
+      if (isEditorMode && isActive && fabricRef.current) ;
+    }, [isActive, isEditorMode, pageId]);
     const getObjId = react.useCallback((obj) => {
       return obj.__docuforgeId;
     }, []);
@@ -6625,11 +7189,18 @@ const PageCanvas = react.forwardRef(
         const targetWidth = Math.max(1, Number(element.width) > 0 ? Number(element.width) : Number(obj.width ?? 200));
         const overflowPolicy = element.overflowPolicy || "grow-and-push";
         const splitByGrapheme = overflowPolicy === "auto-shrink" ? false : element.splitByGrapheme ?? element.wordWrap === "break-word";
+        let reflowText = element.text || "Text";
+        let reflowParsedStyles = null;
+        if (element.formattingEnabled === true) {
+          const parsed = parseTextMarkdown(reflowText);
+          reflowText = parsed.plainText || " ";
+          reflowParsedStyles = parsed.styles;
+        }
         obj.set({
           width: targetWidth,
           minWidth: 1,
           dynamicMinWidth: 0,
-          text: element.text || "Text",
+          text: reflowText,
           fontSize: element.fontSize || 16,
           fontFamily: element.fontFamily || "Open Sans",
           fontWeight: element.fontWeight || 400,
@@ -6638,6 +7209,11 @@ const PageCanvas = react.forwardRef(
           charSpacing: element.charSpacing || 0,
           splitByGrapheme
         });
+        if (element.formattingEnabled === true) {
+          obj.styles = reflowParsedStyles || {};
+        }
+        obj.editable = element.formattingEnabled !== true;
+        obj.__formattingEnabled = element.formattingEnabled === true;
         obj.initDimensions();
         if (Math.abs((obj.width ?? 0) - targetWidth) > 0.01) {
           obj.width = targetWidth;
@@ -6645,10 +7221,26 @@ const PageCanvas = react.forwardRef(
         obj.dynamicMinWidth = 0;
         obj.setCoords();
         obj.dirty = true;
+        try {
+          obj._forceClearCache = true;
+          if (typeof obj._clearCache === "function") obj._clearCache();
+        } catch {
+        }
         didReflow = true;
       };
       canvas2.getObjects().forEach(reflowObject);
-      if (didReflow) canvas2.requestRenderAll();
+      if (didReflow) {
+        canvas2.requestRenderAll();
+        try {
+          requestAnimationFrame(() => {
+            try {
+              canvas2.requestRenderAll();
+            } catch {
+            }
+          });
+        } catch {
+        }
+      }
     }, []);
     react.useEffect(() => {
       if (!canvasElRef.current) return;
@@ -6695,7 +7287,8 @@ const PageCanvas = react.forwardRef(
         absolutePositioned: true
       });
       fabricRef.current = fabricCanvas;
-      registerFabricCanvas(pageId, fabricCanvas);
+      const storeRegistryKey = registerFabricCanvas(pageId, fabricCanvas);
+      fabricCanvas.__storeRegistryKey = storeRegistryKey;
       const initFonts = async () => {
         try {
           await preloadAllFonts();
@@ -6988,7 +7581,10 @@ const PageCanvas = react.forwardRef(
         if (!window.__fabricCanvasRegistry || !(window.__fabricCanvasRegistry instanceof Map)) {
           window.__fabricCanvasRegistry = /* @__PURE__ */ new Map();
         }
-        window.__fabricCanvasRegistry.set(pageId, {
+        const reg = window.__fabricCanvasRegistry;
+        const registryKey = reg.has(pageId) ? `${pageId}#${Math.random().toString(36).slice(2, 10)}` : pageId;
+        fabricCanvas.__registryKey = registryKey;
+        reg.set(registryKey, {
           canvas: fabricCanvas,
           forceUnlockEdits
         });
@@ -7758,9 +8354,6 @@ const PageCanvas = react.forwardRef(
               scaleY: finalScaleY,
               transformMatrix: finalAbsoluteMatrix
             };
-            if (obj instanceof fabric__namespace.Textbox) {
-              elementUpdate.text = obj.text || "";
-            }
             if (sourceElement && sourceElement.opacity !== void 0) {
               elementUpdate.opacity = sourceElement.opacity;
             }
@@ -7839,6 +8432,12 @@ const PageCanvas = react.forwardRef(
         }
         if (target && target instanceof fabric__namespace.Textbox) {
           const elementId = getObjectId(target);
+          if (target.__formattingEnabled === true || target.editable === false) {
+            sonner.toast.info("Inline formatting is on — edit the text in the right panel.", {
+              description: "This protects your **bold**, [c=...] and other formatting tokens."
+            });
+            return;
+          }
           editingTextIdRef.current = elementId || null;
           target.enterEditing();
           target.selectAll();
@@ -7903,7 +8502,19 @@ const PageCanvas = react.forwardRef(
       });
       return () => {
         setReady(false);
-        unregisterFabricCanvas(pageId);
+        unregisterFabricCanvas(fabricCanvas.__storeRegistryKey ?? pageId, fabricCanvas);
+        try {
+          if (typeof window !== "undefined") {
+            const reg = window.__fabricCanvasRegistry;
+            if (reg instanceof Map) {
+              const key = fabricCanvas.__registryKey ?? pageId;
+              const entry = reg.get(key);
+              const entryCanvas = (entry == null ? void 0 : entry.canvas) ?? entry;
+              if (entryCanvas === fabricCanvas) reg.delete(key);
+            }
+          }
+        } catch {
+        }
         if (fabricCanvas.__fontCleanup) {
           fabricCanvas.__fontCleanup();
         }
@@ -9265,6 +9876,12 @@ const PageCanvas = react.forwardRef(
       } else if (obj instanceof fabric__namespace.Textbox) {
         const overflowPolicy = element.overflowPolicy || "grow-and-push";
         let text = element.text || "Text";
+        let parsedStyles = null;
+        if (element.formattingEnabled === true) {
+          const parsed = parseTextMarkdown(text);
+          text = parsed.plainText || " ";
+          parsedStyles = parsed.styles;
+        }
         let fontSize = element.fontSize || 16;
         element.minFontSize || 8;
         const maxLines = element.maxLines || 3;
@@ -9361,6 +9978,11 @@ const PageCanvas = react.forwardRef(
           splitByGrapheme,
           text
         });
+        if (element.formattingEnabled === true) {
+          obj.styles = parsedStyles || {};
+        } else {
+          obj.styles = element.styles || {};
+        }
         obj.initDimensions();
         if (Math.abs((obj.width ?? 0) - textboxWidth) > 0.01) {
           obj.width = textboxWidth;
@@ -10365,6 +10987,7 @@ function PreviewCanvas({
   zoom = 1,
   absoluteZoom = false,
   skipFontReadyWait = false,
+  pageIdOverride,
   className,
   onDynamicFieldClick,
   onReady
@@ -10431,13 +11054,19 @@ function PreviewCanvas({
       backgroundGradient: (_b2 = page == null ? void 0 : page.settings) == null ? void 0 : _b2.backgroundGradient
     };
   }, [(_d = page == null ? void 0 : page.settings) == null ? void 0 : _d.backgroundColor, (_e = page == null ? void 0 : page.settings) == null ? void 0 : _e.backgroundGradient]);
-  const projectSettings = react.useMemo(() => ({
-    showGrid: false,
-    snapToGrid: false,
-    gridSize: 10,
-    snapToGuides: false,
-    snapThreshold: 5
-  }), []);
+  const projectSettings = react.useMemo(() => {
+    var _a2, _b2, _c2;
+    const vars = ((_a2 = config.themeConfig) == null ? void 0 : _a2.variables) || {};
+    return {
+      showGrid: false,
+      snapToGrid: false,
+      gridSize: 10,
+      snapToGuides: false,
+      snapThreshold: 5,
+      primaryColor: (_b2 = vars.primary) == null ? void 0 : _b2.value,
+      secondaryColor: (_c2 = vars.secondary) == null ? void 0 : _c2.value
+    };
+  }, [config.themeConfig]);
   const handleDynamicFieldClick = react.useCallback((elementId) => {
     const fieldInfo = elementToFieldMap.get(elementId);
     if (fieldInfo && onDynamicFieldClick) {
@@ -10507,7 +11136,7 @@ function PreviewCanvas({
               PageCanvas,
               {
                 ref: canvasRef,
-                pageId: page.id || `page-${pageIndex}`,
+                pageId: pageIdOverride || page.id || `page-${pageIndex}`,
                 elements,
                 pageChildren: laidOutPageChildren,
                 pageSettings,
@@ -12398,6 +13027,17 @@ function normalizeFontFamily(fontStack) {
   const first = fontStack.split(",")[0].trim();
   return first.replace(/^['"]|['"]$/g, "");
 }
+function appendStylesheet(url, rejectOnError = true) {
+  return new Promise((resolve, reject) => {
+    const link = document.createElement("link");
+    link.rel = "stylesheet";
+    link.href = url;
+    link.crossOrigin = "anonymous";
+    link.onload = () => resolve();
+    link.onerror = () => rejectOnError ? reject(new Error(`Failed to load stylesheet: ${url}`)) : resolve();
+    document.head.appendChild(link);
+  });
+}
 const loadedFonts = /* @__PURE__ */ new Set();
 const loadingPromises = /* @__PURE__ */ new Map();
 function withTimeout(promise, timeoutMs = 4e3) {
@@ -12423,28 +13063,19 @@ async function loadGoogleFontCSS(rawFontFamily) {
       const fontshareSlug = FONTSHARE_SLUGS[fontFamily];
       if (fontshareSlug) {
         const url2 = `https://api.fontshare.com/v2/css?f[]=${fontshareSlug}@300,400,500,700&display=swap`;
-        const link2 = document.createElement("link");
-        link2.rel = "stylesheet";
-        link2.href = url2;
-        await new Promise((resolve, reject) => {
-          link2.onload = () => resolve();
-          link2.onerror = () => reject(new Error(`Failed to load Fontshare font: ${fontFamily}`));
-          document.head.appendChild(link2);
-        });
+        await appendStylesheet(url2);
+        const italicUrl = `https://api.fontshare.com/v2/css?f[]=${fontshareSlug}@300i,400i,500i,700i&display=swap`;
+        await withTimeout(appendStylesheet(italicUrl, false), 1500);
         loadedFonts.add(fontFamily);
         return;
       }
       const encoded = encodeURIComponent(fontFamily);
       const url = `https://fonts.googleapis.com/css?family=${encoded}:300,400,500,600,700&display=swap`;
-      const link = document.createElement("link");
-      link.rel = "stylesheet";
-      link.href = url;
-      link.crossOrigin = "anonymous";
-      await new Promise((resolve, reject) => {
-        link.onload = () => resolve();
-        link.onerror = () => reject(new Error(`Failed to load font: ${fontFamily}`));
-        document.head.appendChild(link);
-      });
+      await appendStylesheet(url);
+      await withTimeout(Promise.all([300, 400, 500, 600, 700].map((weight) => {
+        const italicUrl = `https://fonts.googleapis.com/css2?family=${encoded}:ital,wght@1,${weight}&display=swap`;
+        return appendStylesheet(italicUrl, false);
+      })), 1800);
       loadedFonts.add(fontFamily);
     } catch (e) {
       console.warn(`[@pixldocs/canvas-renderer] Font load failed: ${fontFamily}`, e);
@@ -12514,6 +13145,23 @@ function collectFontDescriptorsFromConfig(config) {
         if (node.type === "text") {
           for (const w of [300, 400, 500, 600, 700]) {
             add(node.fontFamily, w, node.fontStyle);
+            add(node.fontFamily, w, "italic");
+          }
+        }
+      }
+      if (node.formattingEnabled === true && node.fontFamily) {
+        const parsed = parseTextMarkdown(String(node.text ?? ""));
+        const parsedStyleEntries = Object.values(parsed.styles || {});
+        for (const lineStyle of parsedStyleEntries) {
+          if (lineStyle && typeof lineStyle === "object") {
+            for (const charStyle of Object.values(lineStyle)) {
+              if (!charStyle || typeof charStyle !== "object") continue;
+              add(
+                charStyle.fontFamily || node.fontFamily,
+                charStyle.fontWeight ?? node.fontWeight,
+                charStyle.fontStyle ?? node.fontStyle
+              );
+            }
           }
         }
       }
@@ -13423,11 +14071,20 @@ function PixldocsPreview(props) {
     !canvasSettled && /* @__PURE__ */ jsxRuntime.jsx("div", { style: { position: "absolute", inset: 0, display: "flex", alignItems: "center", justifyContent: "center", minHeight: 200 }, children: /* @__PURE__ */ jsxRuntime.jsx("div", { style: { color: "#888", fontSize: 14 }, children: "Loading preview..." }) })
   ] });
 }
-const PACKAGE_VERSION = "0.5.104";
+const PACKAGE_VERSION = "0.5.105";
 const roundParityValue = (value) => {
   if (typeof value !== "number") return value;
   return Number.isFinite(value) ? Number(value.toFixed(3)) : value;
 };
+function isolatePageForCapture(config, pageIndex) {
+  var _a;
+  const capturePageId = `__pixldocs_capture_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}_${pageIndex}`;
+  const cloned = JSON.parse(JSON.stringify(config));
+  if ((_a = cloned.pages) == null ? void 0 : _a[pageIndex]) {
+    cloned.pages[pageIndex].id = capturePageId;
+  }
+  return { config: cloned, pageId: capturePageId };
+}
 function logJsonLine(tag, payload) {
   try {
     console.log(`${tag} ${JSON.stringify(payload, (_key, value) => roundParityValue(value))}`);
@@ -13465,6 +14122,9 @@ function installUnderlineFix(fab) {
       const hasOwn = !!this[type];
       const hasStyled = typeof this.styleHas === "function" && this.styleHas(type);
       if (!hasOwn && !hasStyled) return;
+      if (!hasOwn && hasStyled) {
+        return original.call(this, ctx, type);
+      }
       const lines = this._textLines;
       const offsets = this.offsets;
       if (!Array.isArray(lines) || !offsets) {
@@ -13476,7 +14136,7 @@ function installUnderlineFix(fab) {
       let topOffset = this._getTopOffset();
       for (let i = 0, len = lines.length; i < len; i++) {
         const heightOfLine = this.getHeightOfLine(i);
-        const lineHas = !!this[type] || typeof this.styleHas === "function" && this.styleHas(type, i);
+        const lineHas = !!this[type];
         if (!lineHas) {
           topOffset += heightOfLine;
           continue;
@@ -14006,9 +14666,11 @@ class PixldocsRenderer {
   }
   async renderPageViaPreviewCanvas(config, pageIndex, pixelRatio, format, quality, options = {}) {
     const { PreviewCanvas: PreviewCanvas2 } = await Promise.resolve().then(() => PreviewCanvas$1);
-    const canvasWidth = config.canvas.width;
-    const canvasHeight = config.canvas.height;
-    const hasAutoShrink = configHasAutoShrinkText(config);
+    const capture = isolatePageForCapture(config, pageIndex);
+    const renderConfig = capture.config;
+    const canvasWidth = renderConfig.canvas.width;
+    const canvasHeight = renderConfig.canvas.height;
+    const hasAutoShrink = configHasAutoShrinkText(renderConfig);
     let firstMountSettled = false;
     let lateFontSettleDetected = false;
     if (typeof document !== "undefined" && document.fonts && hasAutoShrink) {
@@ -14056,12 +14718,12 @@ class PixldocsRenderer {
         root = client.createRoot(container);
         await new Promise((settle) => {
           const onReadyOnce = () => {
-            this.waitForCanvasScene(container, config, pageIndex).then(async () => {
+            this.waitForCanvasScene(container, renderConfig, pageIndex).then(async () => {
               const fabricInstance = this.getFabricCanvasFromContainer(container);
-              const expectedImageCount = this.getExpectedImageCount(config, pageIndex);
+              const expectedImageCount = this.getExpectedImageCount(renderConfig, pageIndex);
               await this.waitForCanvasImages(container, expectedImageCount);
-              await this.waitForStableTextMetrics(container, config);
-              await this.waitForCanvasScene(container, config, pageIndex);
+              await this.waitForStableTextMetrics(container, renderConfig);
+              await this.waitForCanvasScene(container, renderConfig, pageIndex);
               if (!fabricInstance) return settle();
               settle();
             }).catch(() => settle());
@@ -14069,8 +14731,9 @@ class PixldocsRenderer {
           root.render(
             react.createElement(PreviewCanvas2, {
               key: `remount-${mountKey}`,
-              config,
+              config: renderConfig,
               pageIndex,
+              pageIdOverride: capture.pageId,
               zoom: pixelRatio,
               absoluteZoom: true,
               skipFontReadyWait: false,
@@ -14080,13 +14743,13 @@ class PixldocsRenderer {
         });
       };
       const onReady = () => {
-        this.waitForCanvasScene(container, config, pageIndex).then(async () => {
+        this.waitForCanvasScene(container, renderConfig, pageIndex).then(async () => {
           try {
             const fabricInstance = this.getFabricCanvasFromContainer(container);
-            const expectedImageCount = this.getExpectedImageCount(config, pageIndex);
+            const expectedImageCount = this.getExpectedImageCount(renderConfig, pageIndex);
             await this.waitForCanvasImages(container, expectedImageCount);
-            await this.waitForStableTextMetrics(container, config);
-            await this.waitForCanvasScene(container, config, pageIndex);
+            await this.waitForStableTextMetrics(container, renderConfig);
+            await this.waitForCanvasScene(container, renderConfig, pageIndex);
             firstMountSettled = true;
             if (hasAutoShrink && lateFontSettleDetected) {
               console.log("[canvas-renderer][parity] late font-settle detected — remounting for auto-shrink reflow");
@@ -14112,7 +14775,7 @@ class PixldocsRenderer {
             }
             exportCtx.save();
             exportCtx.scale(sourceCanvasAfter.width / canvasWidth, sourceCanvasAfter.height / canvasHeight);
-            this.paintPageBackground(exportCtx, config.pages[pageIndex], canvasWidth, canvasHeight);
+            this.paintPageBackground(exportCtx, renderConfig.pages[pageIndex], canvasWidth, canvasHeight);
             exportCtx.restore();
             exportCtx.drawImage(sourceCanvasAfter, 0, 0);
             const mimeType = format === "jpeg" ? "image/jpeg" : format === "webp" ? "image/webp" : "image/png";
@@ -14128,8 +14791,9 @@ class PixldocsRenderer {
       root = client.createRoot(container);
       root.render(
         react.createElement(PreviewCanvas2, {
-          config,
+          config: renderConfig,
           pageIndex,
+          pageIdOverride: capture.pageId,
           zoom: pixelRatio,
           absoluteZoom: true,
           skipFontReadyWait: false,
@@ -14150,6 +14814,8 @@ class PixldocsRenderer {
   captureSvgViaPreviewCanvas(config, pageIndex, canvasWidth, canvasHeight) {
     return new Promise(async (resolve, reject) => {
       const { PreviewCanvas: PreviewCanvas2 } = await Promise.resolve().then(() => PreviewCanvas$1);
+      const capture = isolatePageForCapture(config, pageIndex);
+      const renderConfig = capture.config;
       const container = document.createElement("div");
       container.style.cssText = `
         position: fixed; left: -99999px; top: -99999px;
@@ -14176,8 +14842,9 @@ class PixldocsRenderer {
         root.render(
           react.createElement(PreviewCanvas2, {
             key: `svg-capture-${mountKey}`,
-            config,
+            config: renderConfig,
             pageIndex,
+            pageIdOverride: capture.pageId,
             zoom: 1,
             absoluteZoom: true,
             skipFontReadyWait: false,
@@ -14186,13 +14853,13 @@ class PixldocsRenderer {
         );
       };
       const onReady = () => {
-        this.waitForCanvasScene(container, config, pageIndex).then(async () => {
+        this.waitForCanvasScene(container, renderConfig, pageIndex).then(async () => {
           var _a, _b;
           try {
-            const expectedImageCount = this.getExpectedImageCount(config, pageIndex);
+            const expectedImageCount = this.getExpectedImageCount(renderConfig, pageIndex);
             await this.waitForCanvasImages(container, expectedImageCount);
-            await this.waitForStableTextMetrics(container, config);
-            await this.waitForCanvasScene(container, config, pageIndex);
+            await this.waitForStableTextMetrics(container, renderConfig);
+            await this.waitForCanvasScene(container, renderConfig, pageIndex);
             const fabricInstance = this.getFabricCanvasFromContainer(container);
             if (!fabricInstance) {
               cleanup();
@@ -14281,7 +14948,7 @@ class PixldocsRenderer {
             );
             if (prevVPT) fabricInstance.viewportTransform = prevVPT;
             fabricInstance.svgViewportTransformation = prevSvgVPT;
-            const page = config.pages[pageIndex];
+            const page = renderConfig.pages[pageIndex];
             const backgroundColor = ((_a = page == null ? void 0 : page.settings) == null ? void 0 : _a.backgroundColor) || "#ffffff";
             const backgroundGradient = (_b = page == null ? void 0 : page.settings) == null ? void 0 : _b.backgroundGradient;
             cleanup();
@@ -14963,8 +15630,9 @@ function getFontPathForWeight(files, weight, isItalic = false) {
   }
   return files.regular;
 }
-function isItalicPath(files, path) {
-  return path === files.italic || path === files.boldItalic || path === files.lightItalic || path === files.mediumItalic || path === files.semiboldItalic;
+function isExactWeightItalicMatch(files, weight, isItalic, path) {
+  const exactKey = isItalic ? weight === 300 ? "lightItalic" : weight === 500 ? "mediumItalic" : weight === 600 ? "semiboldItalic" : weight === 700 ? "boldItalic" : "italic" : weight === 300 ? "light" : weight === 500 ? "medium" : weight === 600 ? "semibold" : weight === 700 ? "bold" : "regular";
+  return files[exactKey] === path;
 }
 function getJsPDFFontName(fontName) {
   return fontName.replace(/\s+/g, "");
@@ -15037,10 +15705,10 @@ async function embedFont(pdf, fontName, weight, fontBaseUrl, isItalic = false) {
   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);
+  if (!isExactWeightItalicMatch(fontFiles, resolvedWeight, isItalic, fontPath)) return false;
+  const jsPdfFontName = getEmbeddedJsPDFFontName(fontName, weight, isItalic);
   const label = FONT_WEIGHT_LABELS[resolvedWeight];
-  const italicSuffix = hasItalicFile ? "Italic" : "";
+  const italicSuffix = isItalic ? "Italic" : "";
   const fileName = `${getJsPDFFontName(fontName)}-${label}${italicSuffix}.ttf`;
   const url = baseUrl + fontPath;
   try {
@@ -15055,6 +15723,7 @@ async function embedFont(pdf, fontName, weight, fontBaseUrl, isItalic = false) {
       }
     }
     registeredFamilies.add(fontName);
+    registeredVariants.add(variantKey(fontName, resolvedWeight, isItalic));
     return true;
   } catch (e) {
     console.warn(`[pdf-fonts] Failed to embed ${fontName} w${weight}:`, e);
@@ -15063,6 +15732,18 @@ async function embedFont(pdf, fontName, weight, fontBaseUrl, isItalic = false) {
 }
 const googleFontNotFound = /* @__PURE__ */ new Set();
 const fontshareNotFound = /* @__PURE__ */ new Set();
+const remoteVariantKey = (family, weight, isItalic) => `${family}|${resolveFontWeight(weight)}|${isItalic ? "i" : "n"}`;
+const registeredVariants = /* @__PURE__ */ new Set();
+const variantKey = (family, weight, italic) => `${family}|${resolveFontWeight(weight)}|${italic ? "i" : "n"}`;
+const resolveBestRegisteredVariant = (family, weight, italic) => {
+  const want = resolveFontWeight(weight);
+  const weights = [300, 400, 500, 600, 700];
+  if (registeredVariants.has(variantKey(family, want, italic))) return { weight: want, italic };
+  const nearest = [...weights].sort((a, b) => Math.abs(a - want) - Math.abs(b - want) || (want >= 500 ? b - a : a - b));
+  for (const w of nearest) if (registeredVariants.has(variantKey(family, w, italic))) return { weight: w, italic };
+  for (const w of nearest) if (registeredVariants.has(variantKey(family, w, !italic))) return { weight: w, italic: !italic };
+  return null;
+};
 function bytesToBase64(bytes) {
   let binary = "";
   for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
@@ -15091,7 +15772,8 @@ async function fetchTtfViaProxy(family, weight, isItalic, source) {
 async function fetchGoogleFontTTF(fontFamily, weight, isItalic = false) {
   const cacheKey = `gf:${fontFamily}:${weight}:${isItalic ? "i" : "n"}`;
   if (ttfCache.has(cacheKey)) return ttfCache.get(cacheKey);
-  if (googleFontNotFound.has(fontFamily)) return null;
+  const notFoundKey = remoteVariantKey(fontFamily, weight, isItalic);
+  if (googleFontNotFound.has(notFoundKey)) return null;
   const proxyBytes = await fetchTtfViaProxy(fontFamily, weight, isItalic, "google");
   if (proxyBytes) {
     const b64 = bytesToBase64(proxyBytes);
@@ -15109,7 +15791,7 @@ async function fetchGoogleFontTTF(fontFamily, weight, isItalic = false) {
       }
     });
     if (!cssRes.ok) {
-      if (cssRes.status === 400 || cssRes.status === 404) googleFontNotFound.add(fontFamily);
+      if (cssRes.status === 400 || cssRes.status === 404) googleFontNotFound.add(notFoundKey);
       return null;
     }
     const css = await cssRes.text();
@@ -15187,6 +15869,7 @@ function registerJsPdfFont(pdf, fontName, resolvedWeight, isItalic, base64) {
       }
     }
     registeredFamilies.add(fontName);
+    registeredVariants.add(variantKey(fontName, resolvedWeight, isItalic));
     return true;
   } catch (err) {
     console.warn(`[pdf-fonts] registerJsPdfFont failed for ${fontName}:`, err);
@@ -15201,16 +15884,8 @@ async function embedFontWithGoogleFallback(pdf, fontName, weight = 400, fontBase
   const resolved = resolveFontWeight(weight);
   const fsB64 = await fetchFontshareTTF(fontName, resolved, isItalic);
   if (fsB64) return registerJsPdfFont(pdf, fontName, resolved, isItalic, fsB64);
-  if (isItalic) {
-    const fsUpright = await fetchFontshareTTF(fontName, resolved, false);
-    if (fsUpright) return registerJsPdfFont(pdf, fontName, resolved, isItalic, fsUpright);
-  }
   const b64 = await fetchGoogleFontTTF(fontName, resolved, isItalic);
   if (b64) return registerJsPdfFont(pdf, fontName, resolved, isItalic, b64);
-  if (isItalic) {
-    const uprightB64 = await fetchGoogleFontTTF(fontName, resolved, false);
-    if (uprightB64) return registerJsPdfFont(pdf, fontName, resolved, isItalic, uprightB64);
-  }
   return false;
 }
 async function embedFontsForConfig(pdf, config, fontBaseUrl) {
@@ -15230,9 +15905,15 @@ async function embedFontsForConfig(pdf, config, fontBaseUrl) {
   };
   const walkElements = (elements) => {
     for (const el of elements) {
+      const addFontVariant = (family, weight, italic) => {
+        fontKeys.add(`${family}${SEP}${weight}${SEP}${italic ? "italic" : "normal"}`);
+      };
       if (el.fontFamily) {
         const w = normalizeWeight(el.fontWeight);
-        fontKeys.add(`${el.fontFamily}${SEP}${w}`);
+        addFontVariant(el.fontFamily, w, /italic|oblique/i.test(String(el.fontStyle ?? "")));
+        addFontVariant(el.fontFamily, 700, false);
+        addFontVariant(el.fontFamily, 400, true);
+        addFontVariant(el.fontFamily, 700, true);
       }
       if (el.styles && typeof el.styles === "object") {
         for (const lineKey of Object.keys(el.styles)) {
@@ -15240,9 +15921,10 @@ async function embedFontsForConfig(pdf, config, fontBaseUrl) {
           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 = normalizeWeight(s.fontWeight);
-                fontKeys.add(`${s.fontFamily}${SEP}${w}`);
+              const styledFamily = (s == null ? void 0 : s.fontFamily) || el.fontFamily;
+              if (styledFamily) {
+                const w = normalizeWeight(s.fontWeight ?? el.fontWeight);
+                addFontVariant(styledFamily, w, /italic|oblique/i.test(String(s.fontStyle ?? el.fontStyle ?? "")));
               }
             }
           }
@@ -15256,19 +15938,21 @@ async function embedFontsForConfig(pdf, config, fontBaseUrl) {
     if (page.children) walkElements(page.children);
     if (page.elements) walkElements(page.elements);
   }
-  fontKeys.add(`${FONT_FALLBACK_SYMBOLS}${SEP}400`);
+  fontKeys.add(`${FONT_FALLBACK_SYMBOLS}${SEP}400${SEP}normal`);
   for (const w of [300, 400, 500, 600, 700]) {
-    fontKeys.add(`${FONT_FALLBACK_DEVANAGARI}${SEP}${w}`);
+    fontKeys.add(`${FONT_FALLBACK_DEVANAGARI}${SEP}${w}${SEP}normal`);
   }
   const embedded = /* @__PURE__ */ new Set();
   const tasks = [];
   for (const key of fontKeys) {
     const sep = key.indexOf(SEP);
+    const secondSep = key.indexOf(SEP, sep + 1);
     const fontName = key.slice(0, sep);
-    const weight = parseInt(key.slice(sep + 1), 10);
+    const weight = parseInt(key.slice(sep + 1, secondSep), 10);
+    const italic = key.slice(secondSep + 1) === "italic";
     if (!isFontAvailable(fontName)) continue;
     tasks.push(
-      embedFont(pdf, fontName, weight, fontBaseUrl).then((ok) => {
+      embedFont(pdf, fontName, weight, fontBaseUrl, italic).then((ok) => {
         if (ok) embedded.add(key);
       })
     );
@@ -15324,7 +16008,7 @@ function splitIntoRuns(text) {
   return runs;
 }
 function rewriteSvgFontsForJsPDF(svgStr) {
-  var _a, _b;
+  var _a, _b, _c;
   const parser = new DOMParser();
   const doc = parser.parseFromString(svgStr, "image/svg+xml");
   const allTextEls = Array.from(doc.querySelectorAll("text, tspan, textPath"));
@@ -15356,6 +16040,13 @@ function rewriteSvgFontsForJsPDF(svgStr) {
     stylePairs.push(`font-style: normal`);
     return stylePairs.join("; ");
   };
+  const applySyntheticItalicTransform = (el) => {
+    const x = Number.parseFloat(resolveInheritedValue(el, "x") || "0") || 0;
+    const y = Number.parseFloat(resolveInheritedValue(el, "y") || "0") || 0;
+    const existing = el.getAttribute("transform") || "";
+    const synth = `translate(${x} ${y}) skewX(-12) translate(${-x} ${-y})`;
+    el.setAttribute("transform", existing ? `${existing} ${synth}` : synth);
+  };
   const getDepth = (el) => {
     let depth = 0;
     let current = el.parentElement;
@@ -15375,20 +16066,40 @@ function rewriteSvgFontsForJsPDF(svgStr) {
     const weightRaw = resolveInheritedValue(el, "font-weight") || "400";
     const styleRaw = resolveInheritedValue(el, "font-style") || "normal";
     const weight = resolveWeightNum(weightRaw);
-    const resolved = resolveFontWeight(weight);
-    const isItalic = /italic|oblique/i.test(styleRaw);
-    const jsPdfName = getEmbeddedJsPDFFontName(clean, resolved, isItalic);
-    sourceMeta.set(el, { clean, resolved, isItalic, jsPdfName, inlineStyle, weight });
+    const requested = resolveFontWeight(weight);
+    const requestedItalic = /italic|oblique/i.test(styleRaw);
+    const best = resolveBestRegisteredVariant(clean, requested, requestedItalic);
+    if (!best) continue;
+    const jsPdfName = getEmbeddedJsPDFFontName(clean, best.weight, best.italic);
+    sourceMeta.set(el, { clean, requested, resolved: best.weight, isItalic: requestedItalic, actualItalic: best.italic, jsPdfName, inlineStyle, weight });
   }
   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, resolved, isItalic, jsPdfName, inlineStyle, weight } = meta;
+    const { clean, requested, resolved, isItalic, actualItalic, jsPdfName, inlineStyle, weight } = meta;
     el.setAttribute("data-source-font-family", clean);
-    el.setAttribute("data-source-font-weight", String(resolved));
+    el.setAttribute("data-source-font-weight", String(requested));
     el.setAttribute("data-source-font-style", isItalic ? "italic" : "normal");
+    if (requested >= 600 && resolved < 600) {
+      const fill = resolveInheritedValue(el, "fill") || readStyleToken(inlineStyle, "fill") || "#000000";
+      el.setAttribute("stroke", fill);
+      el.setAttribute("stroke-width", String(requested === 700 ? 0.7 : 0.5));
+      el.setAttribute("stroke-linejoin", "round");
+    }
+    if (isItalic && !actualItalic) {
+      applySyntheticItalicTransform(el);
+      try {
+        console.log("[Vector PDF][synthetic-italic]", {
+          tag: el.tagName,
+          family: clean,
+          weight: requested,
+          textPreview: (el.textContent || "").slice(0, 40)
+        });
+      } catch {
+      }
+    }
     const directText = Array.from(el.childNodes).filter((n) => n.nodeType === 3).map((n) => n.textContent || "").join("");
     const hasDevanagari = containsDevanagari(directText);
     const hasSymbol = containsSymbol(directText);
@@ -15431,6 +16142,28 @@ function rewriteSvgFontsForJsPDF(svgStr) {
       el.setAttribute("style", buildStyleString(inlineStyle, jsPdfName));
     }
   }
+  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);
+    (_c = parentText.parentNode) == null ? void 0 : _c.insertBefore(wrapper, parentText.nextSibling);
+  }
   return new XMLSerializer().serializeToString(doc.documentElement);
 }
 function extractFontFamiliesFromSvgs(svgs) {
@@ -15461,14 +16194,29 @@ async function embedFontsInPdf(pdf, fontFamilies, fontBaseUrl) {
             if (ok) embedded.add(`${family}${w}`);
           })
         );
+        tasks.push(
+          embedFont(pdf, family, w, fontBaseUrl, true).then((ok) => {
+            if (ok) embedded.add(`${family}${w}i`);
+          })
+        );
       }
     } else {
-      tasks.push(
-        embedFontWithGoogleFallback(pdf, family, 400, fontBaseUrl, false).then((ok) => {
-          if (ok) embedded.add(`${family}400`);
-          else console.warn(`[pdf-fonts] No TTF (local/Google/Fontshare) for "${family}" — will use Helvetica fallback`);
-        })
-      );
+      const variants = [
+        { w: 400, italic: false },
+        { w: 700, italic: false },
+        { w: 400, italic: true },
+        { w: 700, italic: true }
+      ];
+      for (const v of variants) {
+        tasks.push(
+          embedFontWithGoogleFallback(pdf, family, v.w, fontBaseUrl, v.italic).then((ok) => {
+            if (ok) embedded.add(`${family}${v.w}${v.italic ? "i" : ""}`);
+            else if (v.w === 400 && !v.italic) {
+              console.warn(`[pdf-fonts] No TTF (local/Google/Fontshare) for "${family}" — will use Helvetica fallback`);
+            }
+          })
+        );
+      }
     }
   }
   await Promise.all(tasks);
@@ -15489,6 +16237,7 @@ const pdfFonts = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProp
   getEmbeddedJsPDFFontName,
   getFontPathForWeight,
   isFontAvailable,
+  resolveBestRegisteredVariant,
   resolveFontWeight,
   rewriteSvgFontsForJsPDF
 }, Symbol.toStringTag, { value: "Module" }));
@@ -15528,9 +16277,14 @@ function dumpSvgTextDiagnostics(svgStr, pageIndex, tag, stage, maxItems = 30) {
     const sample = texts.slice(0, maxItems).map((t, idx) => {
       var _a, _b;
       const tspans = Array.from(t.querySelectorAll("tspan"));
-      const tspanInfo = tspans.slice(0, 4).map((s) => ({
+      const tspanInfo = tspans.slice(0, 8).map((s) => ({
         x: s.getAttribute("x"),
         y: s.getAttribute("y"),
+        fs: s.getAttribute("font-style"),
+        fw: s.getAttribute("font-weight"),
+        ff: s.getAttribute("font-family"),
+        td: s.getAttribute("text-decoration"),
+        style: (s.getAttribute("style") || "").slice(0, 120),
         text: (s.textContent || "").slice(0, 40)
       }));
       let containerWidth = null;
@@ -16565,13 +17319,15 @@ async function convertTextDecorationsToLines(svg) {
     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;
-      if (!hasUnderline) continue;
+      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";
@@ -16626,23 +17382,26 @@ async function convertTextDecorationsToLines(svg) {
         lineStartX = x - (textAnchor === "middle" ? textWidth / 2 : textAnchor === "end" ? textWidth : 0);
         lineEndX = lineStartX + textWidth;
       }
-      const underlineY = baselineY + 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(lineStartX));
-      line.setAttribute("y1", String(underlineY));
-      line.setAttribute("x2", String(lineEndX));
-      line.setAttribute("y2", String(underlineY));
-      line.setAttribute("stroke", fill.startsWith("url(") ? "#000000" : fill);
-      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);
-      }
+      const makeLine = (yPos) => {
+        const line = doc.createElementNS("http://www.w3.org/2000/svg", "line");
+        line.setAttribute("x1", String(lineStartX));
+        line.setAttribute("y1", String(yPos));
+        line.setAttribute("x2", String(lineEndX));
+        line.setAttribute("y2", String(yPos));
+        line.setAttribute("stroke", fill.startsWith("url(") ? "#000000" : fill);
+        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 (hasUnderline) makeLine(baselineY + fontSize * 0.15);
+      if (hasLinethrough) makeLine(baselineY - fontSize * 0.3);
       stripTextDecoration(tspan);
-      if (textHasUnderline) stripTextDecoration(textEl);
+      if (textHasUnderline || textHasLinethrough) stripTextDecoration(textEl);
     }
   }
   if (tempContainer) {
@@ -16656,7 +17415,7 @@ async function convertSvgTextDecorationsToLinesString(svgStr) {
   if (typeof DOMParser === "undefined" || typeof XMLSerializer === "undefined") {
     return svgStr;
   }
-  if (!/text-decoration/i.test(svgStr) && !/underline/i.test(svgStr)) {
+  if (!/text-decoration/i.test(svgStr) && !/underline/i.test(svgStr) && !/line-through/i.test(svgStr)) {
     return svgStr;
   }
   try {
@@ -16948,7 +17707,7 @@ async function assemblePdfFromSvgs(svgResults, options = {}) {
     const hasGradient = !!((_b = (_a = page.backgroundGradient) == null ? void 0 : _a.stops) == null ? void 0 : _b.length);
     drawPageBackground(pdf, i, page.width, page.height, page.backgroundColor, page.backgroundGradient);
     const shouldStripBg = stripPageBackground ?? hasGradient;
-    const textMode = options.textMode ?? (options.outlineText ? "pixel-perfect" : "selectable");
+    const textMode = options.textMode ?? (options.outlineText === false ? "selectable" : "selectable");
     const shouldOutlineText = textMode === "pixel-perfect" || textMode === "auto";
     const outlineSubMode = textMode === "auto" ? "complex-only" : "all";
     let pageSvg = page.svg;
@@ -16962,7 +17721,7 @@ async function assemblePdfFromSvgs(svgResults, options = {}) {
     }
     if (shouldOutlineText) {
       try {
-        const { convertAllTextToPath } = await Promise.resolve().then(() => require("./svgTextToPath-CWlhIf-q.cjs"));
+        const { convertAllTextToPath } = await Promise.resolve().then(() => require("./svgTextToPath-DTKsddnS.cjs"));
         pageSvg = await convertAllTextToPath(pageSvg, fontBaseUrl, { mode: outlineSubMode });
         try {
           dumpSvgTextDiagnostics(pageSvg, i, PARITY_TAG, "STAGE-1b-after-text-to-path-raw");