@pixldocs/canvas-renderer 0.5.156 → 0.5.158

package/dist/{svgTextToPath-V1vC0SQt.js → pdfFonts-b3_bv7F0.js}

@@ -1,7 +1,6 @@
-import * as opentype from "opentype.js";
 const __vite_import_meta_env__ = { "BASE_URL": "/", "DEV": false, "MODE": "production", "PROD": true, "SSR": false };
-const fontCache$1 = /* @__PURE__ */ new Map();
-const fontBytesCache$1 = /* @__PURE__ */ new Map();
+const fontCache = /* @__PURE__ */ new Map();
+const fontBytesCache = /* @__PURE__ */ new Map();
 const googleFontUrlCache = /* @__PURE__ */ new Map();
 const googleFontNotFound = /* @__PURE__ */ new Set();
 const proxyNotFound = /* @__PURE__ */ new Set();
@@ -800,7 +799,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$1.get(cacheKey);
+    let base64Font = fontCache.get(cacheKey);
     if (!base64Font) {
       const response = await fetch(fontPath);
       if (!response.ok) throw new Error(`Failed to fetch font: ${response.statusText}`);
@@ -811,7 +810,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$1.set(cacheKey, base64Font);
+      fontCache.set(cacheKey, base64Font);
     } else if (!registeredVariantCoverage.has(variantKey(fontName, resolvedWeight, isItalic))) {
       registeredVariantCoverage.set(variantKey(fontName, resolvedWeight, isItalic), extractSupportedCodePointsFromTtf(base64ToBytes(base64Font)));
     }
@@ -837,16 +836,16 @@ const isFontAvailable = (fontName) => {
 };
 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;
   }
   if (resolveFontProxyUrl()) return null;
@@ -877,11 +876,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);
@@ -890,9 +889,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) {
@@ -900,16 +899,16 @@ 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);
   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$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;
   }
   if (resolveFontProxyUrl()) return null;
@@ -938,11 +937,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);
@@ -951,9 +950,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$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]) {
@@ -1104,8 +1103,7 @@ 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,
+export {
   FONT_FALLBACK_DEVANAGARI,
   FONT_FALLBACK_MATH,
   FONT_FALLBACK_SYMBOLS,
@@ -1129,730 +1127,5 @@ const pdfFonts = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProp
   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.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;
-}
-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" }));
-export {
-  FONT_FALLBACK_SYMBOLS as F,
-  FONT_FALLBACK_MATH as a,
-  FONT_FALLBACK_DEVANAGARI as b,
-  isFamilyEmbedded as c,
-  resolveBestRegisteredVariant as d,
-  embedFontWithGoogleFallback as e,
-  getEmbeddedJsPDFFontName as f,
-  getEmbeddedVariantsList as g,
-  convertAllTextToPath as h,
-  isFontAvailable as i,
-  resolveFontWeight as j,
-  doesVariantSupportChar as k,
-  pdfFonts as p,
-  resetPdfFontRegistry as r,
-  svgTextToPath as s
 };
-//# sourceMappingURL=svgTextToPath-V1vC0SQt.js.map
+//# sourceMappingURL=pdfFonts-b3_bv7F0.js.map