@pixldocs/canvas-renderer 0.5.117 → 0.5.119

package/dist/{svgTextToPath-CQ2Tp03U.js → pdfFonts-CHHpRsRK.cjs}

@@ -1,15 +1,68 @@
-import * as opentype from "opentype.js";
-const __vite_import_meta_env__ = {};
-const fontCache$1 = /* @__PURE__ */ new Map();
-const fontBytesCache$1 = /* @__PURE__ */ new Map();
+"use strict";
+const __vite_import_meta_env__ = { "BASE_URL": "/", "DEV": false, "MODE": "production", "PROD": true, "SSR": false };
+const fontCache = /* @__PURE__ */ new Map();
+const fontBytesCache = /* @__PURE__ */ new Map();
 const googleFontUrlCache = /* @__PURE__ */ new Map();
 const googleFontNotFound = /* @__PURE__ */ new Set();
+const registeredFamilies = /* @__PURE__ */ new Set();
+const registeredVariantCoverage = /* @__PURE__ */ new Map();
+const isFamilyEmbedded = (family) => registeredFamilies.has(family);
+const registeredVariants = /* @__PURE__ */ new Set();
+const variantKey = (family, weight, italic) => `${family}|${weight}|${italic ? "i" : "n"}`;
 const remoteVariantKey = (family, weight, italic) => `${family}|${resolveFontWeight(weight)}|${italic ? "i" : "n"}`;
-const FONT_PROXY_URL = `${(__vite_import_meta_env__ == null ? void 0 : __vite_import_meta_env__.VITE_SUPABASE_URL) ?? ""}/functions/v1/font-proxy`;
+const doesVariantSupportChar = (family, weight, italic, char) => {
+  var _a;
+  const cp = char.codePointAt(0);
+  if (cp == null) return false;
+  return ((_a = registeredVariantCoverage.get(variantKey(family, resolveFontWeight(weight), italic))) == null ? void 0 : _a.has(cp)) === true;
+};
+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 sortedByDistance = [...weights].sort((a, b) => {
+    const da = Math.abs(a - want);
+    const db = Math.abs(b - want);
+    if (da !== db) return da - db;
+    return want >= 500 ? b - a : a - b;
+  });
+  for (const w of sortedByDistance) {
+    if (registeredVariants.has(variantKey(family, w, italic))) {
+      return { weight: w, italic };
+    }
+  }
+  for (const w of sortedByDistance) {
+    if (registeredVariants.has(variantKey(family, w, !italic))) {
+      return { weight: w, italic: !italic };
+    }
+  }
+  return null;
+};
+function resolveFontProxyUrl() {
+  const fromEnv = (() => {
+    try {
+      return (__vite_import_meta_env__ == null ? void 0 : __vite_import_meta_env__.VITE_SUPABASE_URL) ?? "";
+    } catch {
+      return "";
+    }
+  })();
+  const fromWindow = (() => {
+    try {
+      return typeof window !== "undefined" && window.__PIXLDOCS_SUPABASE_URL || "";
+    } catch {
+      return "";
+    }
+  })();
+  const base = fromEnv || fromWindow || "";
+  return base ? `${base}/functions/v1/font-proxy` : "";
+}
 async function fetchTtfViaProxy(family, weight, isItalic, source) {
-  if (!FONT_PROXY_URL || FONT_PROXY_URL.startsWith("/functions")) return null;
+  const proxyUrl = resolveFontProxyUrl();
+  if (!proxyUrl) return null;
   try {
-    const url = `${FONT_PROXY_URL}?family=${encodeURIComponent(family)}&weight=${weight}&italic=${isItalic ? 1 : 0}&source=${source}`;
+    const url = `${proxyUrl}?family=${encodeURIComponent(family)}&weight=${weight}&italic=${isItalic ? 1 : 0}&source=${source}`;
     const res = await fetch(url);
     if (!res.ok) return null;
     const buf = await res.arrayBuffer();
@@ -18,6 +71,13 @@ async function fetchTtfViaProxy(family, weight, isItalic, source) {
     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;
@@ -537,18 +597,180 @@ function isJsPdfEmbeddableTrueType(bytes) {
   }
   return false;
 }
+function extractSupportedCodePointsFromTtf(bytes) {
+  const supported = /* @__PURE__ */ new Set();
+  if (bytes.length < 12) return supported;
+  const u16 = (offset) => bytes[offset] << 8 | bytes[offset + 1];
+  const i16 = (offset) => {
+    const value = u16(offset);
+    return value & 32768 ? value - 65536 : value;
+  };
+  const u32 = (offset) => (bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]) >>> 0;
+  const tableCount = u16(4);
+  let cmapOffset = 0;
+  for (let i = 0; i < tableCount; i++) {
+    const recordOffset = 12 + i * 16;
+    if (recordOffset + 16 > bytes.length) return supported;
+    if (String.fromCharCode(bytes[recordOffset], bytes[recordOffset + 1], bytes[recordOffset + 2], bytes[recordOffset + 3]) === "cmap") {
+      cmapOffset = u32(recordOffset + 8);
+      break;
+    }
+  }
+  if (!cmapOffset || cmapOffset + 4 > bytes.length) return supported;
+  const subtables = u16(cmapOffset + 2);
+  const candidates = [];
+  for (let j = 0; j < subtables; j++) {
+    const encOffset = cmapOffset + 4 + j * 8;
+    if (encOffset + 8 > bytes.length) continue;
+    const platform = u16(encOffset);
+    const encoding = u16(encOffset + 2);
+    const subOffset = cmapOffset + u32(encOffset + 4);
+    if (subOffset + 2 > bytes.length) continue;
+    const format = u16(subOffset);
+    const score = format === 12 ? 40 : format === 4 ? 30 : 0;
+    if (score) candidates.push({ format, offset: subOffset, score: score + (platform === 3 && encoding === 10 ? 2 : platform === 0 ? 1 : 0) });
+  }
+  candidates.sort((a, b) => b.score - a.score);
+  const best = candidates[0];
+  if (!best) return supported;
+  if (best.format === 12 && best.offset + 16 <= bytes.length) {
+    const nGroups = u32(best.offset + 12);
+    for (let i = 0; i < nGroups; i++) {
+      const off = best.offset + 16 + i * 12;
+      if (off + 12 > bytes.length) break;
+      const start = u32(off);
+      const end = u32(off + 4);
+      for (let cp = start; cp <= end && cp <= 1114111; cp++) supported.add(cp);
+    }
+  } else if (best.format === 4 && best.offset + 14 <= bytes.length) {
+    const segCount = u16(best.offset + 6) / 2;
+    const endCodes = best.offset + 14;
+    const startCodes = endCodes + segCount * 2 + 2;
+    const idDeltas = startCodes + segCount * 2;
+    const idRangeOffsets = idDeltas + segCount * 2;
+    for (let i = 0; i < segCount; i++) {
+      const start = u16(startCodes + i * 2);
+      const end = u16(endCodes + i * 2);
+      const delta = i16(idDeltas + i * 2);
+      const rangeOffset = u16(idRangeOffsets + i * 2);
+      for (let cp = start; cp <= end && cp !== 65535; cp++) {
+        if (rangeOffset === 0) {
+          if ((cp + delta & 65535) !== 0) supported.add(cp);
+        } else {
+          const glyphOffset = idRangeOffsets + i * 2 + rangeOffset + (cp - start) * 2;
+          if (glyphOffset + 2 <= bytes.length && u16(glyphOffset) !== 0) supported.add(cp);
+        }
+      }
+    }
+  }
+  return supported;
+}
+function base64ToBytes(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+const getJsPDFFontName = (fontName) => {
+  return fontName.replace(/\s+/g, "");
+};
+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(fontFiles, resolvedWeight, isItalic = false) {
+  const keys = isItalic ? WEIGHT_TO_ITALIC_KEYS[resolvedWeight] : WEIGHT_TO_KEYS[resolvedWeight];
+  if (!keys) return fontFiles.regular;
+  for (const k of keys) {
+    const path = fontFiles[k];
+    if (path) return path;
+  }
+  return fontFiles.regular;
+}
+function isExactWeightItalicMatch(fontFiles, resolvedWeight, isItalic, resolvedPath) {
+  const exactKey = isItalic ? resolvedWeight === 300 ? "lightItalic" : resolvedWeight === 500 ? "mediumItalic" : resolvedWeight === 600 ? "semiboldItalic" : resolvedWeight === 700 ? "boldItalic" : "italic" : resolvedWeight === 300 ? "light" : resolvedWeight === 500 ? "medium" : resolvedWeight === 600 ? "semibold" : resolvedWeight === 700 ? "bold" : "regular";
+  return fontFiles[exactKey] === resolvedPath;
+}
+const getEmbeddedJsPDFFontName = (fontName, weight, isItalic = false) => {
+  const resolved = resolveFontWeight(weight);
+  const label = FONT_WEIGHT_LABELS[resolved];
+  const italicSuffix = isItalic ? "Italic" : "";
+  return `${getJsPDFFontName(fontName)}-${label}${italicSuffix}`;
+};
+const embedFont = async (pdf, fontName, weight = 400, isItalic = false) => {
+  const fontFiles = FONT_FILES[fontName];
+  if (!fontFiles) {
+    console.warn(`Font ${fontName} not found in local fonts`);
+    return false;
+  }
+  const resolvedWeight = resolveFontWeight(weight);
+  const fontPath = getFontPathForWeight(fontFiles, resolvedWeight, isItalic);
+  if (!fontPath) return false;
+  if (!isExactWeightItalicMatch(fontFiles, resolvedWeight, isItalic, fontPath)) {
+    return false;
+  }
+  const label = FONT_WEIGHT_LABELS[resolvedWeight];
+  const italicSuffix = isItalic ? "Italic" : "";
+  const cacheKey = `${fontName}-${resolvedWeight}${isItalic ? "-italic" : ""}`;
+  const jsPdfFontName = getEmbeddedJsPDFFontName(fontName, weight, isItalic);
+  try {
+    let base64Font = fontCache.get(cacheKey);
+    if (!base64Font) {
+      const response = await fetch(fontPath);
+      if (!response.ok) throw new Error(`Failed to fetch font: ${response.statusText}`);
+      const arrayBuffer = await response.arrayBuffer();
+      const bytes = new Uint8Array(arrayBuffer);
+      if (!isJsPdfEmbeddableTrueType(bytes)) throw new Error(`Font is not a jsPDF-compatible TrueType file: ${fontPath}`);
+      registeredVariantCoverage.set(variantKey(fontName, resolvedWeight, isItalic), extractSupportedCodePointsFromTtf(bytes));
+      let binary = "";
+      for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
+      base64Font = btoa(binary);
+      fontCache.set(cacheKey, base64Font);
+    } else if (!registeredVariantCoverage.has(variantKey(fontName, resolvedWeight, isItalic))) {
+      registeredVariantCoverage.set(variantKey(fontName, resolvedWeight, isItalic), extractSupportedCodePointsFromTtf(base64ToBytes(base64Font)));
+    }
+    const fileName = `${getJsPDFFontName(fontName)}-${label}${italicSuffix}.ttf`;
+    pdf.addFileToVFS(fileName, base64Font);
+    pdf.addFont(fileName, jsPdfFontName, "normal");
+    if (fontName !== jsPdfFontName) {
+      try {
+        pdf.addFont(fileName, fontName, "normal");
+      } catch {
+      }
+    }
+    registeredFamilies.add(fontName);
+    registeredVariants.add(variantKey(fontName, resolvedWeight, isItalic));
+    return true;
+  } catch (error) {
+    console.error(`Failed to embed font ${fontName} (weight ${weight}, italic=${isItalic}):`, error);
+    return false;
+  }
+};
+const isFontAvailable = (fontName) => {
+  return fontName in FONT_FILES;
+};
 async function fetchGoogleFontTTF(fontFamily, weight = 400, isItalic = false) {
   const cacheKey = `gf:${fontFamily}:${weight}:${isItalic ? "i" : "n"}`;
-  if (fontCache$1.has(cacheKey)) return fontCache$1.get(cacheKey);
+  if (fontCache.has(cacheKey)) return fontCache.get(cacheKey);
   const notFoundKey = remoteVariantKey(fontFamily, weight, isItalic);
   if (googleFontNotFound.has(notFoundKey)) return null;
   const proxyBytes = await fetchTtfViaProxy(fontFamily, weight, isItalic, "google");
   if (proxyBytes && isJsPdfEmbeddableTrueType(proxyBytes)) {
-    fontBytesCache$1.set(cacheKey, proxyBytes);
+    fontBytesCache.set(cacheKey, proxyBytes);
     let binary = "";
     for (let i = 0; i < proxyBytes.length; i++) binary += String.fromCharCode(proxyBytes[i]);
     const b64 = btoa(binary);
-    fontCache$1.set(cacheKey, b64);
+    fontCache.set(cacheKey, b64);
     return b64;
   }
   try {
@@ -578,11 +800,11 @@ async function fetchGoogleFontTTF(fontFamily, weight = 400, isItalic = false) {
       console.warn(`[pdfFonts] Google Fonts returned a non-TTF font for ${fontFamily} (${weight}); skipping jsPDF embed`);
       return null;
     }
-    fontBytesCache$1.set(cacheKey, bytes);
+    fontBytesCache.set(cacheKey, bytes);
     let binary = "";
     for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
     const b64 = btoa(binary);
-    fontCache$1.set(cacheKey, b64);
+    fontCache.set(cacheKey, b64);
     return b64;
   } catch (err) {
     console.warn(`[pdfFonts] fetchGoogleFontTTF failed for ${fontFamily} (${weight}):`, err);
@@ -591,9 +813,9 @@ async function fetchGoogleFontTTF(fontFamily, weight = 400, isItalic = false) {
 }
 async function getGoogleFontBytes(fontFamily, weight = 400, isItalic = false) {
   const cacheKey = `gf:${fontFamily}:${weight}:${isItalic ? "i" : "n"}`;
-  if (fontBytesCache$1.has(cacheKey)) return fontBytesCache$1.get(cacheKey);
+  if (fontBytesCache.has(cacheKey)) return fontBytesCache.get(cacheKey);
   await fetchGoogleFontTTF(fontFamily, weight, isItalic);
-  return fontBytesCache$1.get(cacheKey) || null;
+  return fontBytesCache.get(cacheKey) || null;
 }
 const fontshareNotFound = /* @__PURE__ */ new Set();
 function toFontshareSlug(family) {
@@ -601,15 +823,15 @@ function toFontshareSlug(family) {
 }
 async function fetchFontshareTTF(fontFamily, weight = 400, isItalic = false, slug) {
   const cacheKey = `gf:${fontFamily}:${weight}:${isItalic ? "i" : "n"}`;
-  if (fontCache$1.has(cacheKey)) return fontCache$1.get(cacheKey);
+  if (fontCache.has(cacheKey)) return fontCache.get(cacheKey);
   if (fontshareNotFound.has(fontFamily)) return null;
   const proxyBytes = await fetchTtfViaProxy(fontFamily, weight, isItalic, "fontshare");
   if (proxyBytes && isJsPdfEmbeddableTrueType(proxyBytes)) {
-    fontBytesCache$1.set(cacheKey, proxyBytes);
+    fontBytesCache.set(cacheKey, proxyBytes);
     let binary = "";
     for (let i = 0; i < proxyBytes.length; i++) binary += String.fromCharCode(proxyBytes[i]);
     const b64 = btoa(binary);
-    fontCache$1.set(cacheKey, b64);
+    fontCache.set(cacheKey, b64);
     return b64;
   }
   const finalSlug = toFontshareSlug(fontFamily);
@@ -637,11 +859,11 @@ async function fetchFontshareTTF(fontFamily, weight = 400, isItalic = false, slu
       console.warn(`[pdfFonts] Fontshare returned a non-TTF font for ${fontFamily} (${weight}); skipping jsPDF embed`);
       return null;
     }
-    fontBytesCache$1.set(cacheKey, bytes);
+    fontBytesCache.set(cacheKey, bytes);
     let binary = "";
     for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
     const b64 = btoa(binary);
-    fontCache$1.set(cacheKey, b64);
+    fontCache.set(cacheKey, b64);
     return b64;
   } catch (err) {
     console.warn(`[pdfFonts] fetchFontshareTTF failed for ${fontFamily} (${weight}):`, err);
@@ -650,9 +872,55 @@ async function fetchFontshareTTF(fontFamily, weight = 400, isItalic = false, slu
 }
 async function getFontshareFontBytes(fontFamily, weight = 400, isItalic = false, slug) {
   const cacheKey = `gf:${fontFamily}:${weight}:${isItalic ? "i" : "n"}`;
-  if (fontBytesCache$1.has(cacheKey)) return fontBytesCache$1.get(cacheKey);
+  if (fontBytesCache.has(cacheKey)) return fontBytesCache.get(cacheKey);
   await fetchFontshareTTF(fontFamily, weight, isItalic);
-  return fontBytesCache$1.get(cacheKey) || null;
+  return fontBytesCache.get(cacheKey) || null;
+}
+const embedFontWithGoogleFallback = async (pdf, fontName, weight = 400, isItalic = false) => {
+  if (FONT_FILES[fontName]) {
+    const ok = await embedFont(pdf, fontName, weight, isItalic);
+    if (ok) return true;
+  }
+  const resolvedFs = resolveFontWeight(weight);
+  const fsB64 = await fetchFontshareTTF(fontName, resolvedFs, isItalic);
+  if (fsB64) {
+    return registerJsPdfFont(pdf, fontName, resolvedFs, isItalic, fsB64);
+  }
+  const resolved = resolveFontWeight(weight);
+  const b64 = await fetchGoogleFontTTF(fontName, resolved, isItalic);
+  if (!b64) {
+    return false;
+  }
+  return registerJsPdfFont(pdf, fontName, resolved, isItalic, b64);
+};
+function registerJsPdfFont(pdf, fontName, resolvedWeight, isItalic, base64) {
+  const label = FONT_WEIGHT_LABELS[resolvedWeight];
+  const italicSuffix = isItalic ? "Italic" : "";
+  const jsPdfFontName = getEmbeddedJsPDFFontName(fontName, resolvedWeight, isItalic);
+  const fileName = `${getJsPDFFontName(fontName)}-${label}${italicSuffix}.ttf`;
+  try {
+    try {
+      const binary = atob(base64);
+      const bytes = new Uint8Array(binary.length);
+      for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+      registeredVariantCoverage.set(variantKey(fontName, resolvedWeight, isItalic), extractSupportedCodePointsFromTtf(bytes));
+    } catch {
+    }
+    pdf.addFileToVFS(fileName, base64);
+    pdf.addFont(fileName, jsPdfFontName, "normal");
+    if (fontName !== jsPdfFontName) {
+      try {
+        pdf.addFont(fileName, fontName, "normal");
+      } catch {
+      }
+    }
+    registeredFamilies.add(fontName);
+    registeredVariants.add(variantKey(fontName, resolvedWeight, isItalic));
+    return true;
+  } catch (err) {
+    console.warn(`[pdfFonts] registerJsPdfFont failed for ${fontName}:`, err);
+    return false;
+  }
 }
 const LATIN_TO_DEVANAGARI = {
   // Direct Devanagari subsets — same family carries both scripts
@@ -728,627 +996,18 @@ function resolveDevanagariSibling(latinFont) {
   if (!latinFont) return FONT_FALLBACK_DEVANAGARI;
   return LATIN_TO_DEVANAGARI[latinFont] || FONT_FALLBACK_DEVANAGARI;
 }
-const HB_WASM_URL = "/wasm/hb.wasm";
-let hbInstancePromise = null;
-async function getHB() {
-  if (hbInstancePromise) return hbInstancePromise;
-  hbInstancePromise = (async () => {
-    const [{ default: createHarfBuzz }, { default: hbjs }] = await Promise.all([
-      import("harfbuzzjs/hb.js"),
-      import("harfbuzzjs/hbjs.js")
-    ]);
-    const moduleInstance = await createHarfBuzz({
-      locateFile: (path) => {
-        if (path.endsWith(".wasm")) return HB_WASM_URL;
-        return path;
-      }
-    });
-    return hbjs(moduleInstance);
-  })();
-  return hbInstancePromise;
-}
-const hbFontCache = /* @__PURE__ */ new Map();
-async function getHBFont(cacheKey, fontDataLoader) {
-  const cached = hbFontCache.get(cacheKey);
-  if (cached) return { font: cached.font, upem: cached.upem };
-  const hb = await getHB();
-  const fontData = await fontDataLoader();
-  const blob = hb.createBlob(fontData);
-  const face = hb.createFace(blob, 0);
-  const font = hb.createFont(face);
-  const upem = (face.getUpem ? face.getUpem() : face.upem ?? 1e3) || 1e3;
-  font.setScale(upem, upem);
-  blob.destroy();
-  hbFontCache.set(cacheKey, { face, font, upem });
-  return { font, upem };
-}
-async function shapeRunToSvgPath(fontData, cacheKey, text, x, y, fontSize, opts) {
-  const hb = await getHB();
-  const loader = typeof fontData === "function" ? fontData : async () => fontData;
-  const { font, upem } = await getHBFont(cacheKey, loader);
-  const buffer = hb.createBuffer();
-  buffer.addText(text);
-  if (opts == null ? void 0 : opts.direction) buffer.setDirection(opts.direction);
-  if (opts == null ? void 0 : opts.script) buffer.setScript(opts.script);
-  if (opts == null ? void 0 : opts.language) buffer.setLanguage(opts.language);
-  buffer.guessSegmentProperties();
-  hb.shape(font, buffer);
-  const glyphs = buffer.json();
-  const scale = fontSize / upem;
-  let penX = 0;
-  let penY = 0;
-  const pieces = [];
-  for (const g of glyphs) {
-    const rawPath = font.glyphToPath(g.g);
-    if (rawPath) {
-      const ox = (penX + g.dx) * scale + x;
-      const oy = (penY + g.dy) * -scale + y;
-      pieces.push(transformPathData(rawPath, scale, -scale, ox, oy));
-    }
-    penX += g.ax;
-    penY += g.ay;
-  }
-  buffer.destroy();
-  return {
-    pathData: pieces.join(""),
-    width: penX * scale
-  };
-}
-function transformPathData(d, sx, sy, tx, ty) {
-  let out = "";
-  let i = 0;
-  const n = d.length;
-  while (i < n) {
-    const c = d[i];
-    if (c === "M" || c === "L" || c === "C" || c === "Q") {
-      out += c;
-      i++;
-      let pairsBuf = "";
-      while (i < n && d[i] !== "M" && d[i] !== "L" && d[i] !== "C" && d[i] !== "Q" && d[i] !== "Z") {
-        pairsBuf += d[i];
-        i++;
-      }
-      const nums = pairsBuf.trim().split(/[ ,]+/).filter(Boolean).map(Number);
-      for (let k = 0; k < nums.length; k += 2) {
-        const px = nums[k] * sx + tx;
-        const py = nums[k + 1] * sy + ty;
-        if (k > 0) out += " ";
-        out += `${round(px)},${round(py)}`;
-      }
-    } else if (c === "Z") {
-      out += "Z";
-      i++;
-    } else {
-      i++;
-    }
-  }
-  return out;
-}
-function round(n) {
-  return (Math.round(n * 100) / 100).toString();
-}
-const fontCache = /* @__PURE__ */ new Map();
-const fontBytesCache = /* @__PURE__ */ new Map();
-function isDevanagari(char) {
-  const c = char.codePointAt(0) ?? 0;
-  return c >= 2304 && c <= 2431 || c >= 43232 && c <= 43263 || c >= 7376 && c <= 7423;
-}
-function containsDevanagari(text) {
-  if (!text) return false;
-  for (const char of text) {
-    if (isDevanagari(char)) return true;
-  }
-  return false;
-}
-function isBasicLatinOrLatinExtended(char) {
-  const c = char.codePointAt(0) ?? 0;
-  return c <= 591;
-}
-function isMathOperatorChar(char) {
-  const c = char.codePointAt(0) ?? 0;
-  if (c >= 8592 && c <= 8703) return true;
-  if (c >= 8704 && c <= 8959) return true;
-  if (c >= 8960 && c <= 9215) return true;
-  if (c >= 10176 && c <= 10223) return true;
-  if (c >= 10624 && c <= 10751) return true;
-  if (c >= 10752 && c <= 11007) return true;
-  if (c >= 11008 && c <= 11097) return true;
-  return false;
-}
-function classifyCharForFontRun(char) {
-  if (isBasicLatinOrLatinExtended(char)) return "main";
-  if (isDevanagari(char)) return "devanagari";
-  if (isMathOperatorChar(char)) return "math";
-  return "symbol";
-}
-function isIgnorableForCoverage(char) {
-  return /\s/.test(char) || /[\u0964\u0965\u200c\u200d]/u.test(char);
-}
-function fontSupportsRun(font, text, runType) {
-  if (!font) return false;
-  for (const char of text) {
-    if (isIgnorableForCoverage(char)) continue;
-    if (runType === "devanagari" && !isDevanagari(char)) continue;
-    if (runType === "symbol" && classifyCharForFontRun(char) !== "symbol") continue;
-    if (runType === "math" && classifyCharForFontRun(char) !== "math") continue;
-    const glyph = font.charToGlyph(char);
-    if (!glyph || glyph.index === 0) return false;
-  }
-  return true;
-}
-const browserMeasureCanvas = typeof document !== "undefined" ? document.createElement("canvas") : null;
-function measureBrowserWidth(fontFamily, weight, fontSize, text) {
-  const ctx = browserMeasureCanvas == null ? void 0 : browserMeasureCanvas.getContext("2d");
-  if (!ctx) return null;
-  ctx.font = `normal normal ${weight} ${fontSize}px "${fontFamily}"`;
-  return ctx.measureText(text).width;
-}
-function uniqueFamilies(families) {
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (const family of families) {
-    const clean = family == null ? void 0 : family.trim();
-    if (!clean || seen.has(clean)) continue;
-    seen.add(clean);
-    out.push(clean);
-  }
-  return out;
-}
-function fontLooksItalic(font) {
-  var _a, _b, _c, _d;
-  if (!font) return false;
-  const names = font.names;
-  const candidates = [
-    (_a = names.fontSubfamily) == null ? void 0 : _a.en,
-    (_b = names.typographicSubfamily) == null ? void 0 : _b.en,
-    (_c = names.fullName) == null ? void 0 : _c.en,
-    (_d = names.postScriptName) == null ? void 0 : _d.en
-  ].filter(Boolean).join(" ");
-  return /italic|oblique/i.test(candidates);
-}
-function syntheticItalicTransform(anchorX, baselineY) {
-  return `translate(${anchorX} ${baselineY}) skewX(-12) translate(${-anchorX} ${-baselineY})`;
-}
-function getFontPath(fontFiles, weight, isItalic = false) {
-  const resolved = resolveFontWeight(weight);
-  const uprightMap = {
-    300: ["light", "regular"],
-    400: ["regular"],
-    500: ["medium", "regular"],
-    600: ["semibold", "bold"],
-    700: ["bold", "semibold", "regular"]
-  };
-  const italicMap = {
-    300: ["lightItalic", "italic", "light", "regular"],
-    400: ["italic", "regular"],
-    500: ["mediumItalic", "italic", "medium", "regular"],
-    600: ["semiboldItalic", "boldItalic", "italic", "semibold", "bold", "regular"],
-    700: ["boldItalic", "semiboldItalic", "italic", "bold", "semibold", "regular"]
-  };
-  const map = isItalic ? italicMap : uprightMap;
-  for (const key of map[resolved] || ["regular"]) {
-    if (fontFiles[key]) return fontFiles[key];
-  }
-  return fontFiles.regular || null;
-}
-function resolveFontUrl(fileName, fontBaseUrl) {
-  if (/^https?:\/\//i.test(fileName) || fileName.startsWith("data:")) return fileName;
-  if (fileName.startsWith("/")) {
-    return typeof window !== "undefined" ? new URL(fileName, window.location.origin).toString() : fileName;
-  }
-  const baseUrl = fontBaseUrl.endsWith("/") ? fontBaseUrl : fontBaseUrl + "/";
-  return new URL(fileName, baseUrl).toString();
-}
-async function loadFont(fontFamily, weight, fontBaseUrl, isItalic = false) {
-  const cacheKey = `${fontFamily}__${weight}__${isItalic ? "i" : "n"}`;
-  if (fontCache.has(cacheKey)) return fontCache.get(cacheKey);
-  const fontFiles = FONT_FILES[fontFamily];
-  if (fontFiles) {
-    const fileName = getFontPath(fontFiles, weight, isItalic);
-    if (!fileName) return null;
-    const url = resolveFontUrl(fileName, fontBaseUrl);
-    try {
-      const response = await fetch(url);
-      if (!response.ok) {
-        console.warn(`[text-to-path] Failed to fetch font ${url}: ${response.status}`);
-        return null;
-      }
-      const buffer = await response.arrayBuffer();
-      const bytes = new Uint8Array(buffer);
-      fontBytesCache.set(cacheKey, bytes);
-      const font = opentype.parse(buffer);
-      fontCache.set(cacheKey, font);
-      return font;
-    } catch (err) {
-      console.warn(`[text-to-path] Failed to load local font ${fontFamily}:`, err);
-      return null;
-    }
-  }
-  try {
-    const resolvedWeight = resolveFontWeight(weight);
-    let bytes = await getGoogleFontBytes(fontFamily, resolvedWeight, isItalic);
-    if (!bytes) {
-      bytes = await getFontshareFontBytes(fontFamily, resolvedWeight, isItalic);
-    }
-    if (!bytes && isItalic) {
-      bytes = await getGoogleFontBytes(fontFamily, resolvedWeight, false);
-      if (!bytes) bytes = await getFontshareFontBytes(fontFamily, resolvedWeight, false);
-    }
-    if (!bytes) {
-      console.warn(`[text-to-path] No TTF available for ${fontFamily} (${weight}) on Google Fonts or Fontshare`);
-      return null;
-    }
-    fontBytesCache.set(cacheKey, bytes);
-    const ab = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
-    const font = opentype.parse(ab);
-    fontCache.set(cacheKey, font);
-    return font;
-  } catch (err) {
-    console.warn(`[text-to-path] Failed to load Google font ${fontFamily}:`, err);
-    return null;
-  }
-}
-async function getFontBytes(fontFamily, weight, fontBaseUrl, isItalic = false) {
-  const cacheKey = `${fontFamily}__${weight}__${isItalic ? "i" : "n"}`;
-  if (!fontBytesCache.has(cacheKey)) {
-    await loadFont(fontFamily, weight, fontBaseUrl, isItalic);
-  }
-  const bytes = fontBytesCache.get(cacheKey);
-  return bytes ? { bytes, cacheKey } : null;
-}
-function measureRunWidth(font, text, fontSize) {
-  try {
-    return font.getAdvanceWidth(text, fontSize, { kerning: true });
-  } catch {
-    try {
-      return font.getAdvanceWidth(text, fontSize);
-    } catch {
-      return text.length * fontSize * 0.5;
-    }
-  }
-}
-function splitByFontRun(text) {
-  if (!text) return [];
-  const runs = [];
-  let buf = "";
-  let bufType = classifyCharForFontRun(text[0]);
-  for (const ch of text) {
-    const chType = classifyCharForFontRun(ch);
-    const isNeutral = /\s/.test(ch);
-    if (chType === bufType || isNeutral) {
-      buf += ch;
-    } else {
-      if (buf) runs.push({ text: buf, runType: bufType });
-      buf = ch;
-      bufType = chType;
-    }
-  }
-  if (buf) runs.push({ text: buf, runType: bufType });
-  return runs;
-}
-async function shapeRunToPath(run, isDeva, primaryFont, primaryBytes, devaFont, devaBytes, x, y, fontSize) {
-  if (isDeva && devaBytes && devaFont) {
-    try {
-      const shaped = await shapeRunToSvgPath(
-        devaBytes.bytes,
-        devaBytes.cacheKey,
-        run,
-        x,
-        y,
-        fontSize,
-        { script: "deva", language: "hin", direction: "ltr" }
-      );
-      if (shaped.pathData) {
-        const advance = measureRunWidth(devaFont, run, fontSize);
-        return { pathData: shaped.pathData, advance };
-      }
-    } catch (err) {
-      console.warn(`[text-to-path] HarfBuzz failed for "${run}":`, err);
-    }
-    try {
-      const path = devaFont.getPath(run, x, y, fontSize);
-      const d = path.toPathData(2);
-      if (d && d !== "M0 0") return { pathData: d, advance: measureRunWidth(devaFont, run, fontSize) };
-    } catch {
-    }
-    return null;
-  }
-  try {
-    const path = primaryFont.getPath(run, x, y, fontSize, { kerning: true });
-    const d = path.toPathData(2);
-    if (d && d !== "M0 0") return { pathData: d, advance: measureRunWidth(primaryFont, run, fontSize) };
-    return { pathData: "", advance: measureRunWidth(primaryFont, run, fontSize) };
-  } catch (err) {
-    console.warn(`[text-to-path] opentype getPath failed for "${run}":`, err);
-    return null;
-  }
-}
-function parseTranslate(transform) {
-  if (!transform) return { tx: 0, ty: 0 };
-  const m = transform.match(/translate\(\s*([-\d.]+)[ \s,]+([-\d.]+)\s*\)/);
-  if (m) return { tx: parseFloat(m[1]), ty: parseFloat(m[2]) };
-  const mm = transform.match(/matrix\(\s*([-\d.]+)[ \s,]+([-\d.]+)[ \s,]+([-\d.]+)[ \s,]+([-\d.]+)[ \s,]+([-\d.]+)[ \s,]+([-\d.]+)\s*\)/);
-  if (mm) return { tx: parseFloat(mm[5]), ty: parseFloat(mm[6]) };
-  return { tx: 0, ty: 0 };
-}
-function needsComplexShaping(text) {
-  if (!text) return false;
-  for (const ch of text) {
-    const c = ch.codePointAt(0) ?? 0;
-    if (c >= 2304 && c <= 2431 || c >= 43232 && c <= 43263 || c >= 7376 && c <= 7423) return true;
-    if (c >= 2432 && c <= 3583) return true;
-    if (c >= 3584 && c <= 4095) return true;
-    if (c >= 4096 && c <= 4255) return true;
-    if (c >= 6016 && c <= 6143) return true;
-    if (c >= 1424 && c <= 1791) return true;
-    if (c >= 1792 && c <= 1871) return true;
-    if (c >= 12288 && c <= 40959) return true;
-    if (c >= 44032 && c <= 55215) return true;
-    if (c >= 126976) return true;
-    if (c >= 8592 && c <= 8703) return true;
-    if (c >= 8704 && c <= 8959) return true;
-    if (c >= 8960 && c <= 9215) return true;
-    if (c >= 10176 && c <= 10223) return true;
-    if (c >= 10624 && c <= 10751) return true;
-    if (c >= 10752 && c <= 11007) return true;
-    if (c >= 11008 && c <= 11097) return true;
-  }
-  return false;
-}
-async function convertDevanagariTextToPath(svgStr, fontBaseUrl, options = {}) {
-  var _a, _b, _c;
-  const baseUrl = fontBaseUrl ?? (typeof window !== "undefined" ? window.location.origin + "/fonts/" : "/fonts/");
-  const mode = options.mode ?? "all";
-  const parser = new DOMParser();
-  const doc = parser.parseFromString(svgStr, "image/svg+xml");
-  const textEls = doc.querySelectorAll("text");
-  let convertedCount = 0;
-  let skippedCount = 0;
-  for (const textEl of textEls) {
-    const fullText = textEl.textContent || "";
-    if (!fullText.trim()) continue;
-    const hasMixedStyleTspans = () => {
-      const tspansAll = textEl.querySelectorAll("tspan");
-      const readProp = (el, prop) => {
-        const attr = (el.getAttribute(prop) || "").trim();
-        if (attr) return attr;
-        const style = el.getAttribute("style") || "";
-        const m = style.match(new RegExp(`(?:^|;)\\s*${prop}\\s*:\\s*([^;]+)`, "i"));
-        return m ? m[1].trim() : "";
-      };
-      const baseWeight = readProp(textEl, "font-weight");
-      const baseStyle = readProp(textEl, "font-style");
-      const baseFill = readProp(textEl, "fill");
-      const baseDeco = readProp(textEl, "text-decoration");
-      for (const ts of tspansAll) {
-        const tw = readProp(ts, "font-weight");
-        const tst = readProp(ts, "font-style");
-        const tFill = readProp(ts, "fill");
-        const tDeco = readProp(ts, "text-decoration");
-        const tBg = (ts.getAttribute("style") || "").match(/background|text-background/i);
-        if (tw && tw !== baseWeight || tst && tst !== baseStyle || tFill && tFill !== baseFill || tDeco && tDeco !== baseDeco || tBg) {
-          return true;
-        }
-      }
-      return false;
-    };
-    if (mode === "complex-only" && !needsComplexShaping(fullText) && !hasMixedStyleTspans()) {
-      skippedCount++;
-      continue;
-    }
-    if (mode === "mixed-style-only" && !hasMixedStyleTspans()) {
-      skippedCount++;
-      continue;
-    }
-    const readStyleToken = (style, prop) => {
-      var _a2;
-      const m = style.match(new RegExp(`${prop}\\s*:\\s*([^;]+)`, "i"));
-      return ((_a2 = m == null ? void 0 : m[1]) == null ? void 0 : _a2.trim()) || null;
-    };
-    const getAttrOrStyle = (el, 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") || "", attr);
-        if (styleVal) return styleVal;
-        current = current.parentElement;
-      }
-      return null;
-    };
-    const fontFamily = (_b = (_a = getAttrOrStyle(textEl, "font-family")) == null ? void 0 : _a.split(",")[0]) == null ? void 0 : _b.replace(/['"]/g, "").trim();
-    const fontSizeStr = getAttrOrStyle(textEl, "font-size") || "16";
-    const fontSize = parseFloat(fontSizeStr);
-    const fontWeightStr = getAttrOrStyle(textEl, "font-weight") || "400";
-    const fontWeight = Number.parseInt(fontWeightStr, 10) || 400;
-    const fillColor = getAttrOrStyle(textEl, "fill") || "#000000";
-    const fillOpacity = getAttrOrStyle(textEl, "fill-opacity") || "1";
-    if (!fontFamily) {
-      skippedCount++;
-      continue;
-    }
-    const primaryFont = await loadFont(fontFamily, fontWeight, baseUrl);
-    const primaryBytes = await getFontBytes(fontFamily, fontWeight, baseUrl);
-    const hasDeva = containsDevanagari(fullText);
-    const hasSymbol = [...fullText].some((char) => classifyCharForFontRun(char) === "symbol");
-    const hasMath = [...fullText].some((char) => classifyCharForFontRun(char) === "math");
-    const devaCandidateFamilies = hasDeva ? uniqueFamilies([fontFamily, FONT_FALLBACK_DEVANAGARI, resolveDevanagariSibling(fontFamily)]) : [];
-    const devaRunFontCache = /* @__PURE__ */ new Map();
-    const resolveDevaFontForRun = (runText, runFontSize) => {
-      const cacheKey = `${runText}__${runFontSize}`;
-      const cached = devaRunFontCache.get(cacheKey);
-      if (cached) return cached;
-      const promise = (async () => {
-        const browserWidth = measureBrowserWidth(fontFamily, fontWeight, runFontSize, runText);
-        let best = null;
-        for (const family of devaCandidateFamilies) {
-          const font = family === fontFamily ? primaryFont : await loadFont(family, fontWeight, baseUrl);
-          const bytes = family === fontFamily ? primaryBytes : await getFontBytes(family, fontWeight, baseUrl);
-          if (!font || !bytes || !fontSupportsRun(font, runText, "devanagari")) continue;
-          const width = measureRunWidth(font, runText, runFontSize);
-          const diff = browserWidth == null ? 0 : Math.abs(width - browserWidth);
-          if (!best || diff < best.diff) best = { family, font, bytes, diff };
-          if (browserWidth != null && diff <= 0.25) break;
-        }
-        if (best) {
-          console.log("[text-to-path] Devanagari font resolved", {
-            requestedFamily: fontFamily,
-            resolvedFamily: best.family,
-            browserWidth,
-            diff: Math.round(best.diff * 100) / 100
-          });
-        }
-        return best;
-      })();
-      devaRunFontCache.set(cacheKey, promise);
-      return promise;
-    };
-    const symbolRunFontPromise = hasSymbol ? (async () => {
-      const symbolFont = await loadFont(FONT_FALLBACK_SYMBOLS, 400, baseUrl);
-      const symbolBytes = await getFontBytes(FONT_FALLBACK_SYMBOLS, 400, baseUrl);
-      return symbolFont && symbolBytes ? { family: FONT_FALLBACK_SYMBOLS, font: symbolFont, bytes: symbolBytes } : null;
-    })() : null;
-    const mathRunFontPromise = hasMath ? (async () => {
-      const mathFont = await loadFont(FONT_FALLBACK_MATH, 400, baseUrl);
-      const mathBytes = await getFontBytes(FONT_FALLBACK_MATH, 400, baseUrl);
-      return mathFont && mathBytes ? { family: FONT_FALLBACK_MATH, font: mathFont, bytes: mathBytes } : null;
-    })() : null;
-    if (!primaryFont && !hasDeva && !hasSymbol && !hasMath) {
-      console.warn(`[text-to-path] No font available for "${fontFamily}", leaving as <text>`);
-      skippedCount++;
-      continue;
-    }
-    const textAnchorRaw = (getAttrOrStyle(textEl, "text-anchor") || "start").toLowerCase();
-    const textAnchor = textAnchorRaw === "middle" ? "middle" : textAnchorRaw === "end" ? "end" : "start";
-    const tspans = textEl.querySelectorAll("tspan");
-    const elementsToProcess = tspans.length > 0 ? Array.from(tspans) : [textEl];
-    const group = doc.createElementNS("http://www.w3.org/2000/svg", "g");
-    const textTransform = textEl.getAttribute("transform");
-    if (textTransform) group.setAttribute("transform", textTransform);
-    const baseX = parseFloat(textEl.getAttribute("x") || "0");
-    const baseY = parseFloat(textEl.getAttribute("y") || "0");
-    for (const elem of elementsToProcess) {
-      const text = elem.textContent || "";
-      if (!text.trim()) continue;
-      const elemX = parseFloat(elem.getAttribute("x") || String(baseX));
-      const elemY = parseFloat(elem.getAttribute("y") || String(baseY));
-      const elemTransform = elem !== textEl ? parseTranslate(elem.getAttribute("transform")) : { tx: 0, ty: 0 };
-      let x = elemX + elemTransform.tx;
-      const y = elemY + elemTransform.ty;
-      const elemFill = getAttrOrStyle(elem, "fill") || fillColor;
-      const elemFillOpacity = getAttrOrStyle(elem, "fill-opacity") || fillOpacity;
-      const elemFontSizeStr = getAttrOrStyle(elem, "font-size") || String(fontSize);
-      const elemFontSize = parseFloat(elemFontSizeStr);
-      const elemWeightStr = getAttrOrStyle(elem, "font-weight") || String(fontWeight);
-      const elemWeight = Number.parseInt(elemWeightStr, 10) || (/bold/i.test(elemWeightStr) ? 700 : fontWeight);
-      const elemStyleRaw = (getAttrOrStyle(elem, "font-style") || "normal").toLowerCase();
-      const elemItalic = /italic|oblique/i.test(elemStyleRaw);
-      const sameAsPrimary = elemWeight === fontWeight && !elemItalic;
-      const elemFont = sameAsPrimary ? primaryFont : await loadFont(fontFamily, elemWeight, baseUrl, elemItalic);
-      const elemBytes = sameAsPrimary ? primaryBytes : await getFontBytes(fontFamily, elemWeight, baseUrl, elemItalic);
-      const fontForElem = elemFont || primaryFont;
-      const bytesForElem = elemBytes || primaryBytes;
-      const runs = splitByFontRun(text);
-      let totalAdvance = 0;
-      let canMeasureAll = true;
-      for (const r of runs) {
-        if (r.runType === "devanagari") {
-          const resolved = await resolveDevaFontForRun(r.text, elemFontSize);
-          if (resolved) totalAdvance += measureRunWidth(resolved.font, r.text, elemFontSize);
-          else canMeasureAll = false;
-        } else if (r.runType === "symbol") {
-          const resolved = await symbolRunFontPromise;
-          if (resolved && fontSupportsRun(resolved.font, r.text, "symbol")) totalAdvance += measureRunWidth(resolved.font, r.text, elemFontSize);
-          else canMeasureAll = false;
-        } else if (r.runType === "math") {
-          const resolved = await mathRunFontPromise;
-          if (resolved && fontSupportsRun(resolved.font, r.text, "math")) totalAdvance += measureRunWidth(resolved.font, r.text, elemFontSize);
-          else canMeasureAll = false;
-        } else {
-          if (fontForElem) totalAdvance += measureRunWidth(fontForElem, r.text, elemFontSize);
-          else canMeasureAll = false;
-        }
-      }
-      if (canMeasureAll) {
-        if (textAnchor === "middle") x -= totalAdvance / 2;
-        else if (textAnchor === "end") x -= totalAdvance;
-      }
-      let cursor = x;
-      let elemConverted = false;
-      for (const r of runs) {
-        const resolvedDeva = r.runType === "devanagari" ? await resolveDevaFontForRun(r.text, elemFontSize) : null;
-        const resolvedSymbol = r.runType === "symbol" ? await symbolRunFontPromise : null;
-        const resolvedMath = r.runType === "math" ? await mathRunFontPromise : null;
-        const useDeva = !!resolvedDeva;
-        const fontForRun = (resolvedDeva == null ? void 0 : resolvedDeva.font) ?? (resolvedSymbol == null ? void 0 : resolvedSymbol.font) ?? (resolvedMath == null ? void 0 : resolvedMath.font) ?? fontForElem;
-        const bytesForRun = (resolvedDeva == null ? void 0 : resolvedDeva.bytes) ?? (resolvedSymbol == null ? void 0 : resolvedSymbol.bytes) ?? (resolvedMath == null ? void 0 : resolvedMath.bytes) ?? bytesForElem;
-        if (!fontForRun) continue;
-        const result = await shapeRunToPath(
-          r.text,
-          !!useDeva,
-          fontForRun,
-          bytesForRun,
-          (resolvedDeva == null ? void 0 : resolvedDeva.font) ?? null,
-          (resolvedDeva == null ? void 0 : resolvedDeva.bytes) ?? null,
-          cursor,
-          y,
-          elemFontSize
-        );
-        if (result && result.pathData) {
-          const pathEl = doc.createElementNS("http://www.w3.org/2000/svg", "path");
-          pathEl.setAttribute("d", result.pathData);
-          pathEl.setAttribute("fill", elemFill);
-          if (elemItalic && !fontLooksItalic(fontForRun)) {
-            pathEl.setAttribute("transform", syntheticItalicTransform(cursor, y));
-          }
-          if (elemFillOpacity !== "1") {
-            pathEl.setAttribute("fill-opacity", elemFillOpacity);
-          }
-          group.appendChild(pathEl);
-          elemConverted = true;
-        }
-        if (result) cursor += result.advance;
-      }
-      if (elemConverted) {
-        convertedCount++;
-      } else {
-        if (elem === textEl) {
-          const clone = elem.cloneNode(true);
-          if (textTransform) clone.removeAttribute("transform");
-          group.appendChild(clone);
-        } else {
-          const newText = doc.createElementNS("http://www.w3.org/2000/svg", "text");
-          newText.setAttribute("x", String(elemX));
-          newText.setAttribute("y", String(elemY));
-          if (elem.getAttribute("style")) newText.setAttribute("style", elem.getAttribute("style"));
-          if (elem.getAttribute("font-family")) newText.setAttribute("font-family", elem.getAttribute("font-family"));
-          if (elem.getAttribute("font-size")) newText.setAttribute("font-size", elem.getAttribute("font-size"));
-          if (elem.getAttribute("font-weight")) newText.setAttribute("font-weight", elem.getAttribute("font-weight"));
-          newText.textContent = text;
-          group.appendChild(newText);
-        }
-      }
-    }
-    if (group.childNodes.length > 0) {
-      (_c = textEl.parentNode) == null ? void 0 : _c.replaceChild(group, textEl);
-    }
-  }
-  console.log(
-    `[text-to-path] Universal outline complete: converted=${convertedCount} skipped=${skippedCount}`
-  );
-  return new XMLSerializer().serializeToString(doc.documentElement);
-}
-const convertAllTextToPath = convertDevanagariTextToPath;
-async function preloadDevanagariFont(fontBaseUrl) {
-  const baseUrl = fontBaseUrl ?? (typeof window !== "undefined" ? window.location.origin + "/fonts/" : "/fonts/");
-  for (const weight of [300, 400, 500, 600, 700]) {
-    await loadFont(FONT_FALLBACK_DEVANAGARI, weight, baseUrl);
-  }
-}
-export {
-  convertAllTextToPath,
-  convertDevanagariTextToPath,
-  preloadDevanagariFont
-};
-//# sourceMappingURL=svgTextToPath-CQ2Tp03U.js.map
+exports.FONT_FALLBACK_DEVANAGARI = FONT_FALLBACK_DEVANAGARI;
+exports.FONT_FALLBACK_MATH = FONT_FALLBACK_MATH;
+exports.FONT_FALLBACK_SYMBOLS = FONT_FALLBACK_SYMBOLS;
+exports.FONT_FILES = FONT_FILES;
+exports.doesVariantSupportChar = doesVariantSupportChar;
+exports.embedFontWithGoogleFallback = embedFontWithGoogleFallback;
+exports.getEmbeddedJsPDFFontName = getEmbeddedJsPDFFontName;
+exports.getFontshareFontBytes = getFontshareFontBytes;
+exports.getGoogleFontBytes = getGoogleFontBytes;
+exports.isFamilyEmbedded = isFamilyEmbedded;
+exports.isFontAvailable = isFontAvailable;
+exports.resolveBestRegisteredVariant = resolveBestRegisteredVariant;
+exports.resolveDevanagariSibling = resolveDevanagariSibling;
+exports.resolveFontWeight = resolveFontWeight;
+//# sourceMappingURL=pdfFonts-CHHpRsRK.cjs.map