@pixldocs/canvas-renderer 0.5.155 → 0.5.157

package/dist/{pdfFonts-BTEVnYX8.cjs → svgTextToPath-7fhL08qs.cjs}

@@ -1,8 +1,47 @@
 "use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+const opentype = require("opentype.js");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const opentype__namespace = /* @__PURE__ */ _interopNamespaceDefault(opentype);
 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 fontCache$1 = /* @__PURE__ */ new Map();
+const fontBytesCache$1 = /* @__PURE__ */ new Map();
 const googleFontUrlCache = /* @__PURE__ */ new Map();
 const googleFontNotFound = /* @__PURE__ */ new Set();
 const proxyNotFound = /* @__PURE__ */ new Set();
@@ -801,7 +840,7 @@ const embedFont = async (pdf, fontName, weight = 400, isItalic = false) => {
   const cacheKey = `${fontName}-${resolvedWeight}${isItalic ? "-italic" : ""}`;
   const jsPdfFontName = getEmbeddedJsPDFFontName(fontName, weight, isItalic);
   try {
-    let base64Font = fontCache.get(cacheKey);
+    let base64Font = fontCache$1.get(cacheKey);
     if (!base64Font) {
       const response = await fetch(fontPath);
       if (!response.ok) throw new Error(`Failed to fetch font: ${response.statusText}`);
@@ -812,7 +851,7 @@ const embedFont = async (pdf, fontName, weight = 400, isItalic = false) => {
       let binary = "";
       for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
       base64Font = btoa(binary);
-      fontCache.set(cacheKey, base64Font);
+      fontCache$1.set(cacheKey, base64Font);
     } else if (!registeredVariantCoverage.has(variantKey(fontName, resolvedWeight, isItalic))) {
       registeredVariantCoverage.set(variantKey(fontName, resolvedWeight, isItalic), extractSupportedCodePointsFromTtf(base64ToBytes(base64Font)));
     }
@@ -838,16 +877,16 @@ const isFontAvailable = (fontName) => {
 };
 async function fetchGoogleFontTTF(fontFamily, weight = 400, isItalic = false) {
   const cacheKey = `gf:${fontFamily}:${weight}:${isItalic ? "i" : "n"}`;
-  if (fontCache.has(cacheKey)) return fontCache.get(cacheKey);
+  if (fontCache$1.has(cacheKey)) return fontCache$1.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.set(cacheKey, proxyBytes);
+    fontBytesCache$1.set(cacheKey, proxyBytes);
     let binary = "";
     for (let i = 0; i < proxyBytes.length; i++) binary += String.fromCharCode(proxyBytes[i]);
     const b64 = btoa(binary);
-    fontCache.set(cacheKey, b64);
+    fontCache$1.set(cacheKey, b64);
     return b64;
   }
   if (resolveFontProxyUrl()) return null;
@@ -878,11 +917,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.set(cacheKey, bytes);
+    fontBytesCache$1.set(cacheKey, bytes);
     let binary = "";
     for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
     const b64 = btoa(binary);
-    fontCache.set(cacheKey, b64);
+    fontCache$1.set(cacheKey, b64);
     return b64;
   } catch (err) {
     console.warn(`[pdfFonts] fetchGoogleFontTTF failed for ${fontFamily} (${weight}):`, err);
@@ -891,9 +930,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.has(cacheKey)) return fontBytesCache.get(cacheKey);
+  if (fontBytesCache$1.has(cacheKey)) return fontBytesCache$1.get(cacheKey);
   await fetchGoogleFontTTF(fontFamily, weight, isItalic);
-  return fontBytesCache.get(cacheKey) || null;
+  return fontBytesCache$1.get(cacheKey) || null;
 }
 const fontshareNotFound = /* @__PURE__ */ new Set();
 function toFontshareSlug(family) {
@@ -901,16 +940,16 @@ function toFontshareSlug(family) {
 }
 async function fetchFontshareTTF(fontFamily, weight = 400, isItalic = false, slug) {
   const cacheKey = `gf:${fontFamily}:${weight}:${isItalic ? "i" : "n"}`;
-  if (fontCache.has(cacheKey)) return fontCache.get(cacheKey);
+  if (fontCache$1.has(cacheKey)) return fontCache$1.get(cacheKey);
   const notFoundKey = remoteVariantKey(fontFamily, weight, isItalic);
   if (fontshareNotFound.has(notFoundKey)) return null;
   const proxyBytes = await fetchTtfViaProxy(fontFamily, weight, isItalic, "fontshare");
   if (proxyBytes && isJsPdfEmbeddableTrueType(proxyBytes)) {
-    fontBytesCache.set(cacheKey, proxyBytes);
+    fontBytesCache$1.set(cacheKey, proxyBytes);
     let binary = "";
     for (let i = 0; i < proxyBytes.length; i++) binary += String.fromCharCode(proxyBytes[i]);
     const b64 = btoa(binary);
-    fontCache.set(cacheKey, b64);
+    fontCache$1.set(cacheKey, b64);
     return b64;
   }
   if (resolveFontProxyUrl()) return null;
@@ -939,11 +978,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.set(cacheKey, bytes);
+    fontBytesCache$1.set(cacheKey, bytes);
     let binary = "";
     for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
     const b64 = btoa(binary);
-    fontCache.set(cacheKey, b64);
+    fontCache$1.set(cacheKey, b64);
     return b64;
   } catch (err) {
     console.warn(`[pdfFonts] fetchFontshareTTF failed for ${fontFamily} (${weight}):`, err);
@@ -952,9 +991,9 @@ 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.has(cacheKey)) return fontBytesCache.get(cacheKey);
+  if (fontBytesCache$1.has(cacheKey)) return fontBytesCache$1.get(cacheKey);
   await fetchFontshareTTF(fontFamily, weight, isItalic);
-  return fontBytesCache.get(cacheKey) || null;
+  return fontBytesCache$1.get(cacheKey) || null;
 }
 const embedFontWithGoogleFallback = async (pdf, fontName, weight = 400, isItalic = false) => {
   if (FONT_FILES[fontName]) {
@@ -1105,27 +1144,753 @@ function resolveDevanagariSibling(latinFont) {
   if (!latinFont) return FONT_FALLBACK_DEVANAGARI;
   return LATIN_TO_DEVANAGARI[latinFont] || FONT_FALLBACK_DEVANAGARI;
 }
+const pdfFonts = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  FONT_FALLBACK_DEVANAGARI,
+  FONT_FALLBACK_MATH,
+  FONT_FALLBACK_SYMBOLS,
+  FONT_FILES,
+  FONT_WEIGHT_LABELS,
+  LATIN_TO_DEVANAGARI,
+  doesVariantSupportChar,
+  embedFont,
+  embedFontWithGoogleFallback,
+  fetchFontshareTTF,
+  fetchGoogleFontTTF,
+  getEmbeddedJsPDFFontName,
+  getEmbeddedVariantsList,
+  getFontshareFontBytes,
+  getGoogleFontBytes,
+  getJsPDFFontName,
+  isFamilyEmbedded,
+  isFontAvailable,
+  isVariantEmbedded,
+  resetPdfFontRegistry,
+  resolveBestRegisteredVariant,
+  resolveDevanagariSibling,
+  resolveFontWeight
+}, Symbol.toStringTag, { value: "Module" }));
+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__namespace.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__namespace.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;
+}
+const DECORATIVE_OUTLINE_FAMILIES = /* @__PURE__ */ new Set([
+  "greatvibes",
+  "great vibes",
+  "cinzel",
+  "cinzeldecorative",
+  "cinzel decorative",
+  "pacifico",
+  "allura",
+  "alexbrush",
+  "alex brush",
+  "abrilfatface",
+  "abril fatface",
+  "cormorant",
+  "cormorantgaramond",
+  "cormorant garamond",
+  "dancingscript",
+  "dancing script",
+  "sacramento",
+  "lobster",
+  "satisfy",
+  "kaushanscript",
+  "kaushan script",
+  "parisienne",
+  "tangerine",
+  "yellowtail",
+  "shadowsintolight",
+  "shadows into light",
+  "amaticsc",
+  "amatic sc",
+  "caveat",
+  "playball",
+  "marckscript",
+  "marck script",
+  "courgette"
+]);
+function isDecorativeFamily(family) {
+  if (!family) return false;
+  const k = family.replace(/['"]/g, "").replace(/\s+/g, " ").trim().toLowerCase();
+  if (DECORATIVE_OUTLINE_FAMILIES.has(k)) return true;
+  return DECORATIVE_OUTLINE_FAMILIES.has(k.replace(/\s+/g, ""));
+}
+function readResolvedFontFamily(textEl) {
+  var _a, _b, _c;
+  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;
+  };
+  let current = textEl;
+  while (current) {
+    const a = (_a = current.getAttribute("font-family")) == null ? void 0 : _a.trim();
+    if (a) return ((_b = a.split(",")[0]) == null ? void 0 : _b.replace(/['"]/g, "").trim()) || null;
+    const s = readStyleToken(current.getAttribute("style") || "", "font-family");
+    if (s) return ((_c = s.split(",")[0]) == null ? void 0 : _c.replace(/['"]/g, "").trim()) || null;
+    current = current.parentElement;
+  }
+  return null;
+}
+async function convertDevanagariTextToPath(svgStr, fontBaseUrl, options = {}) {
+  var _a, _b, _c, _d;
+  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) {
+    if ((_a = textEl.closest) == null ? void 0 : _a.call(textEl, '[data-pd-selectable-layer="1"]')) {
+      skippedCount++;
+      continue;
+    }
+    const fullText = textEl.textContent || "";
+    if (!fullText.trim()) continue;
+    if (mode === "shadow-bound") {
+      const inShadowMarker = !!textEl.closest && !!textEl.closest("g.__pdShadowRaster");
+      let inTaggedTextbox = false;
+      let cur = textEl.parentElement;
+      while (cur) {
+        if (cur.tagName.toLowerCase() === "g" && (cur.hasAttribute("data-pd-shadow-blur") || cur.hasAttribute("data-pd-text-bg"))) {
+          inTaggedTextbox = true;
+          break;
+        }
+        cur = cur.parentElement;
+      }
+      if (!inShadowMarker && !inTaggedTextbox) {
+        skippedCount++;
+        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") {
+      const resolvedFamily = readResolvedFontFamily(textEl);
+      const decorative = isDecorativeFamily(resolvedFamily);
+      if (!needsComplexShaping(fullText) && !hasMixedStyleTspans() && !decorative) {
+        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 = (_c = (_b = getAttrOrStyle(textEl, "font-family")) == null ? void 0 : _b.split(",")[0]) == null ? void 0 : _c.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 baseTextAnchor = 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 elemAnchorRaw = (getAttrOrStyle(elem, "text-anchor") || baseTextAnchor).toLowerCase();
+      const elemTextAnchor = elemAnchorRaw === "middle" ? "middle" : elemAnchorRaw === "end" ? "end" : "start";
+      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 (elemTextAnchor === "middle") x -= totalAdvance / 2;
+        else if (elemTextAnchor === "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) {
+      (_d = textEl.parentNode) == null ? void 0 : _d.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);
+  }
+}
+const svgTextToPath = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  convertAllTextToPath,
+  convertDevanagariTextToPath,
+  preloadDevanagariFont
+}, Symbol.toStringTag, { value: "Module" }));
 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.FONT_WEIGHT_LABELS = FONT_WEIGHT_LABELS;
-exports.LATIN_TO_DEVANAGARI = LATIN_TO_DEVANAGARI;
+exports.convertAllTextToPath = convertAllTextToPath;
 exports.doesVariantSupportChar = doesVariantSupportChar;
-exports.embedFont = embedFont;
 exports.embedFontWithGoogleFallback = embedFontWithGoogleFallback;
-exports.fetchFontshareTTF = fetchFontshareTTF;
-exports.fetchGoogleFontTTF = fetchGoogleFontTTF;
 exports.getEmbeddedJsPDFFontName = getEmbeddedJsPDFFontName;
 exports.getEmbeddedVariantsList = getEmbeddedVariantsList;
-exports.getFontshareFontBytes = getFontshareFontBytes;
-exports.getGoogleFontBytes = getGoogleFontBytes;
-exports.getJsPDFFontName = getJsPDFFontName;
 exports.isFamilyEmbedded = isFamilyEmbedded;
 exports.isFontAvailable = isFontAvailable;
-exports.isVariantEmbedded = isVariantEmbedded;
+exports.pdfFonts = pdfFonts;
 exports.resetPdfFontRegistry = resetPdfFontRegistry;
 exports.resolveBestRegisteredVariant = resolveBestRegisteredVariant;
-exports.resolveDevanagariSibling = resolveDevanagariSibling;
 exports.resolveFontWeight = resolveFontWeight;
-//# sourceMappingURL=pdfFonts-BTEVnYX8.cjs.map
+exports.svgTextToPath = svgTextToPath;
+//# sourceMappingURL=svgTextToPath-7fhL08qs.cjs.map