@pixldocs/canvas-renderer 0.5.117 → 0.5.119

package/dist/pdfFonts-CB5z77qO.js

@@ -0,0 +1,1014 @@
+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 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) {
+  const proxyUrl = resolveFontProxyUrl();
+  if (!proxyUrl) return null;
+  try {
+    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();
+    return new Uint8Array(buf);
+  } catch {
+    return null;
+  }
+}
+const FONT_WEIGHT_LABELS = {
+  300: "Light",
+  400: "Regular",
+  500: "Medium",
+  600: "SemiBold",
+  700: "Bold"
+};
+function resolveFontWeight(weight) {
+  if (weight <= 350) return 300;
+  if (weight <= 450) return 400;
+  if (weight <= 550) return 500;
+  if (weight <= 650) return 600;
+  return 700;
+}
+const FONT_FALLBACK_SYMBOLS = "Noto Sans";
+const FONT_FALLBACK_MATH = "Noto Sans Math";
+const FONT_FALLBACK_DEVANAGARI = "Hind";
+const FONT_FILES = {
+  "Playfair Display": {
+    regular: "/fonts/PlayfairDisplay-Regular.ttf",
+    bold: "/fonts/PlayfairDisplay-Bold.ttf",
+    italic: "/fonts/PlayfairDisplay-Italic.ttf",
+    boldItalic: "/fonts/PlayfairDisplay-BoldItalic.ttf"
+  },
+  "Merriweather": {
+    regular: "/fonts/Merriweather-Regular.ttf",
+    bold: "/fonts/Merriweather-Bold.ttf",
+    light: "/fonts/Merriweather-Light.ttf",
+    italic: "/fonts/Merriweather-Italic.ttf",
+    boldItalic: "/fonts/Merriweather-BoldItalic.ttf",
+    lightItalic: "/fonts/Merriweather-LightItalic.ttf"
+  },
+  "Lora": {
+    regular: "/fonts/Lora-Regular.ttf",
+    bold: "/fonts/Lora-Bold.ttf",
+    italic: "/fonts/Lora-Italic.ttf",
+    boldItalic: "/fonts/Lora-BoldItalic.ttf"
+  },
+  "Montserrat": {
+    regular: "/fonts/Montserrat-Regular.ttf",
+    bold: "/fonts/Montserrat-Bold.ttf",
+    light: "/fonts/Montserrat-Light.ttf",
+    medium: "/fonts/Montserrat-Medium.ttf",
+    semibold: "/fonts/Montserrat-SemiBold.ttf",
+    italic: "/fonts/Montserrat-Italic.ttf",
+    boldItalic: "/fonts/Montserrat-BoldItalic.ttf",
+    lightItalic: "/fonts/Montserrat-LightItalic.ttf",
+    mediumItalic: "/fonts/Montserrat-MediumItalic.ttf",
+    semiboldItalic: "/fonts/Montserrat-SemiBoldItalic.ttf"
+  },
+  "Open Sans": {
+    regular: "/fonts/OpenSans-Regular.ttf",
+    bold: "/fonts/OpenSans-Bold.ttf",
+    light: "/fonts/OpenSans-Light.ttf",
+    semibold: "/fonts/OpenSans-SemiBold.ttf",
+    italic: "/fonts/OpenSans-Italic.ttf",
+    boldItalic: "/fonts/OpenSans-BoldItalic.ttf",
+    lightItalic: "/fonts/OpenSans-LightItalic.ttf",
+    semiboldItalic: "/fonts/OpenSans-SemiBoldItalic.ttf"
+  },
+  "Roboto": {
+    regular: "/fonts/Roboto-Regular.ttf",
+    bold: "/fonts/Roboto-Bold.ttf",
+    light: "/fonts/Roboto-Light.ttf",
+    medium: "/fonts/Roboto-Medium.ttf",
+    italic: "/fonts/Roboto-Italic.ttf",
+    boldItalic: "/fonts/Roboto-BoldItalic.ttf",
+    lightItalic: "/fonts/Roboto-LightItalic.ttf",
+    mediumItalic: "/fonts/Roboto-MediumItalic.ttf"
+  },
+  "Lato": {
+    regular: "/fonts/Lato-Regular.ttf",
+    bold: "/fonts/Lato-Bold.ttf",
+    light: "/fonts/Lato-Light.ttf",
+    italic: "/fonts/Lato-Italic.ttf",
+    boldItalic: "/fonts/Lato-BoldItalic.ttf",
+    lightItalic: "/fonts/Lato-LightItalic.ttf"
+  },
+  "Raleway": {
+    regular: "/fonts/Raleway-Regular.ttf",
+    bold: "/fonts/Raleway-Bold.ttf",
+    light: "/fonts/Raleway-Light.ttf",
+    medium: "/fonts/Raleway-Medium.ttf",
+    semibold: "/fonts/Raleway-SemiBold.ttf",
+    italic: "/fonts/Raleway-Italic.ttf",
+    boldItalic: "/fonts/Raleway-BoldItalic.ttf",
+    lightItalic: "/fonts/Raleway-LightItalic.ttf"
+  },
+  "Poppins": {
+    regular: "/fonts/Poppins-Regular.ttf",
+    bold: "/fonts/Poppins-Bold.ttf",
+    light: "/fonts/Poppins-Light.ttf",
+    medium: "/fonts/Poppins-Medium.ttf",
+    semibold: "/fonts/Poppins-SemiBold.ttf",
+    italic: "/fonts/Poppins-Italic.ttf",
+    boldItalic: "/fonts/Poppins-BoldItalic.ttf",
+    lightItalic: "/fonts/Poppins-LightItalic.ttf",
+    mediumItalic: "/fonts/Poppins-MediumItalic.ttf",
+    semiboldItalic: "/fonts/Poppins-SemiBoldItalic.ttf"
+  },
+  "Inter": {
+    regular: "/fonts/Inter-Regular.ttf",
+    bold: "/fonts/Inter-Bold.ttf",
+    italic: "/fonts/Inter-Italic.ttf",
+    boldItalic: "/fonts/Inter-BoldItalic.ttf"
+  },
+  "Nunito": {
+    regular: "/fonts/Nunito-Regular.ttf",
+    bold: "/fonts/Nunito-Bold.ttf",
+    light: "/fonts/Nunito-Light.ttf",
+    medium: "/fonts/Nunito-Medium.ttf",
+    semibold: "/fonts/Nunito-SemiBold.ttf",
+    italic: "/fonts/Nunito-Italic.ttf",
+    boldItalic: "/fonts/Nunito-BoldItalic.ttf"
+  },
+  "Source Sans Pro": {
+    regular: "/fonts/SourceSansPro-Regular.ttf",
+    bold: "/fonts/SourceSansPro-Bold.ttf",
+    light: "/fonts/SourceSansPro-Light.ttf",
+    italic: "/fonts/SourceSansPro-Italic.ttf",
+    boldItalic: "/fonts/SourceSansPro-BoldItalic.ttf"
+  },
+  "Work Sans": {
+    regular: "/fonts/WorkSans-Regular.ttf",
+    bold: "/fonts/WorkSans-Bold.ttf",
+    italic: "/fonts/WorkSans-Italic.ttf",
+    boldItalic: "/fonts/WorkSans-BoldItalic.ttf"
+  },
+  "Oswald": { regular: "/fonts/Oswald-Regular.ttf", bold: "/fonts/Oswald-Bold.ttf" },
+  "Bebas Neue": { regular: "/fonts/BebasNeue-Regular.ttf" },
+  "Abril Fatface": { regular: "/fonts/AbrilFatface-Regular.ttf" },
+  "Dancing Script": { regular: "/fonts/DancingScript-Regular.ttf", bold: "/fonts/DancingScript-Bold.ttf" },
+  "Pacifico": { regular: "/fonts/Pacifico-Regular.ttf" },
+  "Great Vibes": { regular: "/fonts/GreatVibes-Regular.ttf" },
+  // ── Previously variable-only fonts — now with static per-weight TTFs for PDF export ──
+  "DM Sans": {
+    regular: "/fonts/DMSans-Regular.ttf",
+    bold: "/fonts/DMSans-Bold.ttf",
+    light: "/fonts/DMSans-Light.ttf",
+    medium: "/fonts/DMSans-Medium.ttf",
+    semibold: "/fonts/DMSans-SemiBold.ttf",
+    italic: "/fonts/DMSans-RegularItalic.ttf",
+    boldItalic: "/fonts/DMSans-BoldItalic.ttf",
+    lightItalic: "/fonts/DMSans-LightItalic.ttf",
+    mediumItalic: "/fonts/DMSans-MediumItalic.ttf",
+    semiboldItalic: "/fonts/DMSans-SemiBoldItalic.ttf"
+  },
+  "Outfit": {
+    regular: "/fonts/Outfit-Regular.ttf",
+    bold: "/fonts/Outfit-Bold.ttf",
+    light: "/fonts/Outfit-Light.ttf",
+    medium: "/fonts/Outfit-Medium.ttf",
+    semibold: "/fonts/Outfit-SemiBold.ttf"
+  },
+  "Figtree": {
+    regular: "/fonts/Figtree-Regular.ttf",
+    bold: "/fonts/Figtree-Bold.ttf",
+    light: "/fonts/Figtree-Light.ttf",
+    medium: "/fonts/Figtree-Medium.ttf",
+    semibold: "/fonts/Figtree-SemiBold.ttf",
+    italic: "/fonts/Figtree-RegularItalic.ttf",
+    boldItalic: "/fonts/Figtree-BoldItalic.ttf",
+    lightItalic: "/fonts/Figtree-LightItalic.ttf",
+    mediumItalic: "/fonts/Figtree-MediumItalic.ttf",
+    semiboldItalic: "/fonts/Figtree-SemiBoldItalic.ttf"
+  },
+  "Manrope": {
+    regular: "/fonts/Manrope-Regular.ttf",
+    bold: "/fonts/Manrope-Bold.ttf",
+    light: "/fonts/Manrope-Light.ttf",
+    medium: "/fonts/Manrope-Medium.ttf",
+    semibold: "/fonts/Manrope-SemiBold.ttf"
+  },
+  "Space Grotesk": {
+    regular: "/fonts/SpaceGrotesk-Regular.ttf",
+    bold: "/fonts/SpaceGrotesk-Bold.ttf",
+    light: "/fonts/SpaceGrotesk-Light.ttf",
+    medium: "/fonts/SpaceGrotesk-Medium.ttf",
+    semibold: "/fonts/SpaceGrotesk-SemiBold.ttf"
+  },
+  "League Spartan": {
+    regular: "/fonts/LeagueSpartan-Regular.ttf",
+    bold: "/fonts/LeagueSpartan-Bold.ttf",
+    light: "/fonts/LeagueSpartan-Light.ttf",
+    medium: "/fonts/LeagueSpartan-Medium.ttf",
+    semibold: "/fonts/LeagueSpartan-SemiBold.ttf"
+  },
+  "EB Garamond": {
+    regular: "/fonts/EBGaramond-Regular.ttf",
+    bold: "/fonts/EBGaramond-Bold.ttf",
+    medium: "/fonts/EBGaramond-Medium.ttf",
+    semibold: "/fonts/EBGaramond-SemiBold.ttf",
+    italic: "/fonts/EBGaramond-RegularItalic.ttf",
+    boldItalic: "/fonts/EBGaramond-BoldItalic.ttf",
+    mediumItalic: "/fonts/EBGaramond-MediumItalic.ttf",
+    semiboldItalic: "/fonts/EBGaramond-SemiBoldItalic.ttf"
+  },
+  "Libre Baskerville": {
+    regular: "/fonts/LibreBaskerville-Regular.ttf",
+    bold: "/fonts/LibreBaskerville-Bold.ttf",
+    italic: "/fonts/LibreBaskerville-RegularItalic.ttf",
+    boldItalic: "/fonts/LibreBaskerville-BoldItalic.ttf"
+  },
+  "Crimson Text": {
+    regular: "/fonts/CrimsonText-Regular.ttf",
+    bold: "/fonts/CrimsonText-Bold.ttf",
+    italic: "/fonts/CrimsonText-Italic.ttf",
+    boldItalic: "/fonts/CrimsonText-BoldItalic.ttf"
+  },
+  "DM Serif Display": {
+    regular: "/fonts/DMSerifDisplay-Regular.ttf",
+    italic: "/fonts/DMSerifDisplay-Italic.ttf"
+  },
+  "Libre Franklin": {
+    regular: "/fonts/LibreFranklin-Regular.ttf",
+    bold: "/fonts/LibreFranklin-Bold.ttf",
+    light: "/fonts/LibreFranklin-Light.ttf",
+    medium: "/fonts/LibreFranklin-Medium.ttf",
+    semibold: "/fonts/LibreFranklin-SemiBold.ttf",
+    italic: "/fonts/LibreFranklin-RegularItalic.ttf",
+    boldItalic: "/fonts/LibreFranklin-BoldItalic.ttf",
+    lightItalic: "/fonts/LibreFranklin-LightItalic.ttf",
+    mediumItalic: "/fonts/LibreFranklin-MediumItalic.ttf",
+    semiboldItalic: "/fonts/LibreFranklin-SemiBoldItalic.ttf"
+  },
+  "Mulish": {
+    regular: "/fonts/Mulish-Regular.ttf",
+    bold: "/fonts/Mulish-Bold.ttf",
+    light: "/fonts/Mulish-Light.ttf",
+    medium: "/fonts/Mulish-Medium.ttf",
+    semibold: "/fonts/Mulish-SemiBold.ttf",
+    italic: "/fonts/Mulish-RegularItalic.ttf",
+    boldItalic: "/fonts/Mulish-BoldItalic.ttf",
+    lightItalic: "/fonts/Mulish-LightItalic.ttf",
+    mediumItalic: "/fonts/Mulish-MediumItalic.ttf",
+    semiboldItalic: "/fonts/Mulish-SemiBoldItalic.ttf"
+  },
+  "Quicksand": {
+    regular: "/fonts/Quicksand-Regular.ttf",
+    bold: "/fonts/Quicksand-Bold.ttf",
+    light: "/fonts/Quicksand-Light.ttf",
+    medium: "/fonts/Quicksand-Medium.ttf",
+    semibold: "/fonts/Quicksand-SemiBold.ttf"
+  },
+  "Rubik": {
+    regular: "/fonts/Rubik-Regular.ttf",
+    bold: "/fonts/Rubik-Bold.ttf",
+    light: "/fonts/Rubik-Light.ttf",
+    medium: "/fonts/Rubik-Medium.ttf",
+    semibold: "/fonts/Rubik-SemiBold.ttf",
+    italic: "/fonts/Rubik-RegularItalic.ttf",
+    boldItalic: "/fonts/Rubik-BoldItalic.ttf",
+    lightItalic: "/fonts/Rubik-LightItalic.ttf",
+    mediumItalic: "/fonts/Rubik-MediumItalic.ttf",
+    semiboldItalic: "/fonts/Rubik-SemiBoldItalic.ttf"
+  },
+  "Karla": {
+    regular: "/fonts/Karla-Regular.ttf",
+    bold: "/fonts/Karla-Bold.ttf",
+    light: "/fonts/Karla-Light.ttf",
+    medium: "/fonts/Karla-Medium.ttf",
+    semibold: "/fonts/Karla-SemiBold.ttf",
+    italic: "/fonts/Karla-RegularItalic.ttf",
+    boldItalic: "/fonts/Karla-BoldItalic.ttf",
+    lightItalic: "/fonts/Karla-LightItalic.ttf",
+    mediumItalic: "/fonts/Karla-MediumItalic.ttf",
+    semiboldItalic: "/fonts/Karla-SemiBoldItalic.ttf"
+  },
+  "Plus Jakarta Sans": {
+    regular: "/fonts/PlusJakartaSans-Regular.ttf",
+    bold: "/fonts/PlusJakartaSans-Bold.ttf",
+    light: "/fonts/PlusJakartaSans-Light.ttf",
+    medium: "/fonts/PlusJakartaSans-Medium.ttf",
+    semibold: "/fonts/PlusJakartaSans-SemiBold.ttf",
+    italic: "/fonts/PlusJakartaSans-RegularItalic.ttf",
+    boldItalic: "/fonts/PlusJakartaSans-BoldItalic.ttf",
+    lightItalic: "/fonts/PlusJakartaSans-LightItalic.ttf",
+    mediumItalic: "/fonts/PlusJakartaSans-MediumItalic.ttf",
+    semiboldItalic: "/fonts/PlusJakartaSans-SemiBoldItalic.ttf"
+  },
+  "Sora": {
+    regular: "/fonts/Sora-Regular.ttf",
+    bold: "/fonts/Sora-Bold.ttf",
+    light: "/fonts/Sora-Light.ttf",
+    medium: "/fonts/Sora-Medium.ttf",
+    semibold: "/fonts/Sora-SemiBold.ttf"
+  },
+  "Urbanist": {
+    regular: "/fonts/Urbanist-Regular.ttf",
+    bold: "/fonts/Urbanist-Bold.ttf",
+    light: "/fonts/Urbanist-Light.ttf",
+    medium: "/fonts/Urbanist-Medium.ttf",
+    semibold: "/fonts/Urbanist-SemiBold.ttf",
+    italic: "/fonts/Urbanist-RegularItalic.ttf",
+    boldItalic: "/fonts/Urbanist-BoldItalic.ttf",
+    lightItalic: "/fonts/Urbanist-LightItalic.ttf",
+    mediumItalic: "/fonts/Urbanist-MediumItalic.ttf",
+    semiboldItalic: "/fonts/Urbanist-SemiBoldItalic.ttf"
+  },
+  "Lexend": {
+    regular: "/fonts/Lexend-Regular.ttf",
+    bold: "/fonts/Lexend-Bold.ttf",
+    light: "/fonts/Lexend-Light.ttf",
+    medium: "/fonts/Lexend-Medium.ttf",
+    semibold: "/fonts/Lexend-SemiBold.ttf"
+  },
+  "Albert Sans": {
+    regular: "/fonts/AlbertSans-Regular.ttf",
+    bold: "/fonts/AlbertSans-Bold.ttf",
+    light: "/fonts/AlbertSans-Light.ttf",
+    medium: "/fonts/AlbertSans-Medium.ttf",
+    semibold: "/fonts/AlbertSans-SemiBold.ttf",
+    italic: "/fonts/AlbertSans-RegularItalic.ttf",
+    boldItalic: "/fonts/AlbertSans-BoldItalic.ttf",
+    lightItalic: "/fonts/AlbertSans-LightItalic.ttf",
+    mediumItalic: "/fonts/AlbertSans-MediumItalic.ttf",
+    semiboldItalic: "/fonts/AlbertSans-SemiBoldItalic.ttf"
+  },
+  "Noto Sans": {
+    regular: "/fonts/NotoSans-Regular.ttf",
+    bold: "/fonts/NotoSans-Bold.ttf",
+    light: "/fonts/NotoSans-Light.ttf",
+    medium: "/fonts/NotoSans-Medium.ttf",
+    semibold: "/fonts/NotoSans-SemiBold.ttf",
+    italic: "/fonts/NotoSans-RegularItalic.ttf",
+    boldItalic: "/fonts/NotoSans-BoldItalic.ttf",
+    lightItalic: "/fonts/NotoSans-LightItalic.ttf",
+    mediumItalic: "/fonts/NotoSans-MediumItalic.ttf",
+    semiboldItalic: "/fonts/NotoSans-SemiBoldItalic.ttf"
+  },
+  "Cabin": {
+    regular: "/fonts/Cabin-Regular.ttf",
+    bold: "/fonts/Cabin-Bold.ttf",
+    medium: "/fonts/Cabin-Medium.ttf",
+    semibold: "/fonts/Cabin-SemiBold.ttf",
+    italic: "/fonts/Cabin-RegularItalic.ttf",
+    boldItalic: "/fonts/Cabin-BoldItalic.ttf",
+    mediumItalic: "/fonts/Cabin-MediumItalic.ttf",
+    semiboldItalic: "/fonts/Cabin-SemiBoldItalic.ttf"
+  },
+  "Barlow": {
+    regular: "/fonts/Barlow-Regular.ttf",
+    bold: "/fonts/Barlow-Bold.ttf",
+    light: "/fonts/Barlow-Light.ttf",
+    medium: "/fonts/Barlow-Medium.ttf",
+    semibold: "/fonts/Barlow-SemiBold.ttf",
+    italic: "/fonts/Barlow-Italic.ttf",
+    boldItalic: "/fonts/Barlow-BoldItalic.ttf"
+  },
+  "Josefin Sans": {
+    regular: "/fonts/JosefinSans-Regular.ttf",
+    bold: "/fonts/JosefinSans-Bold.ttf",
+    light: "/fonts/JosefinSans-Light.ttf",
+    medium: "/fonts/JosefinSans-Medium.ttf",
+    semibold: "/fonts/JosefinSans-SemiBold.ttf",
+    italic: "/fonts/JosefinSans-RegularItalic.ttf",
+    boldItalic: "/fonts/JosefinSans-BoldItalic.ttf",
+    lightItalic: "/fonts/JosefinSans-LightItalic.ttf",
+    mediumItalic: "/fonts/JosefinSans-MediumItalic.ttf",
+    semiboldItalic: "/fonts/JosefinSans-SemiBoldItalic.ttf"
+  },
+  "Archivo": {
+    regular: "/fonts/Archivo-Regular.ttf",
+    bold: "/fonts/Archivo-Bold.ttf",
+    light: "/fonts/Archivo-Light.ttf",
+    medium: "/fonts/Archivo-Medium.ttf",
+    semibold: "/fonts/Archivo-SemiBold.ttf",
+    italic: "/fonts/Archivo-RegularItalic.ttf",
+    boldItalic: "/fonts/Archivo-BoldItalic.ttf",
+    lightItalic: "/fonts/Archivo-LightItalic.ttf",
+    mediumItalic: "/fonts/Archivo-MediumItalic.ttf",
+    semiboldItalic: "/fonts/Archivo-SemiBoldItalic.ttf"
+  },
+  "Overpass": {
+    regular: "/fonts/Overpass-Regular.ttf",
+    bold: "/fonts/Overpass-Bold.ttf",
+    light: "/fonts/Overpass-Light.ttf",
+    medium: "/fonts/Overpass-Medium.ttf",
+    semibold: "/fonts/Overpass-SemiBold.ttf",
+    italic: "/fonts/Overpass-RegularItalic.ttf",
+    boldItalic: "/fonts/Overpass-BoldItalic.ttf",
+    lightItalic: "/fonts/Overpass-LightItalic.ttf",
+    mediumItalic: "/fonts/Overpass-MediumItalic.ttf",
+    semiboldItalic: "/fonts/Overpass-SemiBoldItalic.ttf"
+  },
+  "Exo 2": {
+    regular: "/fonts/Exo2-Regular.ttf",
+    bold: "/fonts/Exo2-Bold.ttf",
+    light: "/fonts/Exo2-Light.ttf",
+    medium: "/fonts/Exo2-Medium.ttf",
+    semibold: "/fonts/Exo2-SemiBold.ttf",
+    italic: "/fonts/Exo2-RegularItalic.ttf",
+    boldItalic: "/fonts/Exo2-BoldItalic.ttf",
+    lightItalic: "/fonts/Exo2-LightItalic.ttf",
+    mediumItalic: "/fonts/Exo2-MediumItalic.ttf",
+    semiboldItalic: "/fonts/Exo2-SemiBoldItalic.ttf"
+  },
+  "Roboto Mono": {
+    regular: "/fonts/RobotoMono-Regular.ttf",
+    bold: "/fonts/RobotoMono-Bold.ttf",
+    light: "/fonts/RobotoMono-Light.ttf",
+    medium: "/fonts/RobotoMono-Medium.ttf",
+    semibold: "/fonts/RobotoMono-SemiBold.ttf",
+    italic: "/fonts/RobotoMono-RegularItalic.ttf",
+    boldItalic: "/fonts/RobotoMono-BoldItalic.ttf",
+    lightItalic: "/fonts/RobotoMono-LightItalic.ttf",
+    mediumItalic: "/fonts/RobotoMono-MediumItalic.ttf",
+    semiboldItalic: "/fonts/RobotoMono-SemiBoldItalic.ttf"
+  },
+  "Fira Code": {
+    regular: "/fonts/FiraCode-Regular.ttf",
+    bold: "/fonts/FiraCode-Bold.ttf",
+    light: "/fonts/FiraCode-Light.ttf",
+    medium: "/fonts/FiraCode-Medium.ttf",
+    semibold: "/fonts/FiraCode-SemiBold.ttf"
+  },
+  "JetBrains Mono": {
+    regular: "/fonts/JetBrainsMono-Regular.ttf",
+    bold: "/fonts/JetBrainsMono-Bold.ttf",
+    light: "/fonts/JetBrainsMono-Light.ttf",
+    medium: "/fonts/JetBrainsMono-Medium.ttf",
+    semibold: "/fonts/JetBrainsMono-SemiBold.ttf",
+    italic: "/fonts/JetBrainsMono-RegularItalic.ttf",
+    boldItalic: "/fonts/JetBrainsMono-BoldItalic.ttf",
+    lightItalic: "/fonts/JetBrainsMono-LightItalic.ttf",
+    mediumItalic: "/fonts/JetBrainsMono-MediumItalic.ttf",
+    semiboldItalic: "/fonts/JetBrainsMono-SemiBoldItalic.ttf"
+  },
+  "Source Code Pro": {
+    regular: "/fonts/SourceCodePro-Regular.ttf",
+    bold: "/fonts/SourceCodePro-Bold.ttf",
+    light: "/fonts/SourceCodePro-Light.ttf",
+    medium: "/fonts/SourceCodePro-Medium.ttf",
+    semibold: "/fonts/SourceCodePro-SemiBold.ttf",
+    italic: "/fonts/SourceCodePro-RegularItalic.ttf",
+    boldItalic: "/fonts/SourceCodePro-BoldItalic.ttf",
+    lightItalic: "/fonts/SourceCodePro-LightItalic.ttf",
+    mediumItalic: "/fonts/SourceCodePro-MediumItalic.ttf",
+    semiboldItalic: "/fonts/SourceCodePro-SemiBoldItalic.ttf"
+  },
+  "IBM Plex Mono": {
+    regular: "/fonts/IBMPlexMono-Regular.ttf",
+    bold: "/fonts/IBMPlexMono-Bold.ttf"
+  },
+  "Space Mono": {
+    regular: "/fonts/SpaceMono-Regular.ttf",
+    bold: "/fonts/SpaceMono-Bold.ttf",
+    italic: "/fonts/SpaceMono-Italic.ttf",
+    boldItalic: "/fonts/SpaceMono-BoldItalic.ttf"
+  },
+  "Sacramento": { regular: "/fonts/Sacramento-Regular.ttf" },
+  "Alex Brush": { regular: "/fonts/AlexBrush-Regular.ttf" },
+  "Allura": { regular: "/fonts/Allura-Regular.ttf" },
+  "Caveat": {
+    regular: "/fonts/Caveat-Regular.ttf",
+    bold: "/fonts/Caveat-Bold.ttf",
+    medium: "/fonts/Caveat-Medium.ttf",
+    semibold: "/fonts/Caveat-SemiBold.ttf"
+  },
+  "Lobster": { regular: "/fonts/Lobster-Regular.ttf" },
+  "Comfortaa": {
+    regular: "/fonts/Comfortaa-Regular.ttf",
+    bold: "/fonts/Comfortaa-Bold.ttf",
+    light: "/fonts/Comfortaa-Light.ttf",
+    medium: "/fonts/Comfortaa-Medium.ttf",
+    semibold: "/fonts/Comfortaa-SemiBold.ttf"
+  },
+  "Anton": { regular: "/fonts/Anton-Regular.ttf" },
+  "Teko": {
+    regular: "/fonts/Teko-Regular.ttf",
+    bold: "/fonts/Teko-Bold.ttf",
+    light: "/fonts/Teko-Light.ttf",
+    medium: "/fonts/Teko-Medium.ttf",
+    semibold: "/fonts/Teko-SemiBold.ttf"
+  },
+  // ── Indic Script Fallback Fonts ──
+  "Noto Sans Devanagari": {
+    regular: "/fonts/NotoSansDevanagari-Regular.ttf",
+    bold: "/fonts/NotoSansDevanagari-Bold.ttf",
+    light: "/fonts/NotoSansDevanagari-Light.ttf",
+    medium: "/fonts/NotoSansDevanagari-Medium.ttf",
+    semibold: "/fonts/NotoSansDevanagari-SemiBold.ttf"
+  },
+  "Hind": {
+    regular: "/fonts/Hind-Regular.ttf",
+    bold: "/fonts/Hind-Bold.ttf",
+    light: "/fonts/Hind-Light.ttf",
+    medium: "/fonts/Hind-Medium.ttf",
+    semibold: "/fonts/Hind-SemiBold.ttf"
+  },
+  // ── Math / Operator Symbol Fallback ──
+  // Carries glyphs that NotoSans-Regular's Latin subset is missing
+  // (≠ ≤ ≥ ≈ ∞ → ← × ÷ ∑ √ ∈ ∀ ∃ etc.). Used as a tertiary fallback
+  // ONLY for chars classified as 'math' that the main font + Noto Sans
+  // both lack.
+  "Noto Sans Math": {
+    regular: "/fonts/NotoSansMath-Regular.ttf"
+  }
+};
+function isJsPdfEmbeddableTrueType(bytes) {
+  if (bytes.length < 12) return false;
+  const signature = String.fromCharCode(bytes[0], bytes[1], bytes[2], bytes[3]);
+  if (signature !== "\0
\0\0" && signature !== "true") return false;
+  const u16 = (offset) => bytes[offset] << 8 | bytes[offset + 1];
+  const u32 = (offset) => (bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]) >>> 0;
+  const tableCount = u16(4);
+  for (let i = 0; i < tableCount; i++) {
+    const recordOffset = 12 + i * 16;
+    if (recordOffset + 16 > bytes.length) return false;
+    const tag = String.fromCharCode(bytes[recordOffset], bytes[recordOffset + 1], bytes[recordOffset + 2], bytes[recordOffset + 3]);
+    if (tag !== "cmap") continue;
+    const cmapOffset = u32(recordOffset + 8);
+    const cmapLength = u32(recordOffset + 12);
+    if (cmapOffset + Math.min(cmapLength, 4) > bytes.length) return false;
+    const subtables = u16(cmapOffset + 2);
+    for (let j = 0; j < subtables; j++) {
+      const encOffset = cmapOffset + 4 + j * 8;
+      if (encOffset + 8 > bytes.length) return false;
+      const platform = u16(encOffset);
+      const encoding = u16(encOffset + 2);
+      if (platform === 0 || platform === 3 && (encoding === 1 || encoding === 10)) return true;
+    }
+    return false;
+  }
+  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.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.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);
+    return b64;
+  }
+  try {
+    const ital = isItalic ? "1" : "0";
+    const cssUrl = `https://fonts.googleapis.com/css2?family=${encodeURIComponent(
+      fontFamily
+    )}:ital,wght@${ital},${weight}&display=swap`;
+    const cssRes = await fetch(cssUrl, {
+      headers: {
+        "User-Agent": "Mozilla/5.0 (Linux; U; Android 2.2; en-us) AppleWebKit/533.1 (KHTML, like Gecko)"
+      }
+    });
+    if (!cssRes.ok) {
+      if (cssRes.status === 400 || cssRes.status === 404) googleFontNotFound.add(notFoundKey);
+      return null;
+    }
+    const css = await cssRes.text();
+    const urlMatch = css.match(/url\(([^)]+)\)\s+format\(['"]?truetype['"]?\)/i) || css.match(/url\(([^)]+)\)/);
+    if (!urlMatch) return null;
+    const ttfUrl = urlMatch[1].replace(/['"]/g, "");
+    googleFontUrlCache.set(cacheKey, ttfUrl);
+    const ttfRes = await fetch(ttfUrl);
+    if (!ttfRes.ok) return null;
+    const buf = await ttfRes.arrayBuffer();
+    const bytes = new Uint8Array(buf);
+    if (!isJsPdfEmbeddableTrueType(bytes)) {
+      console.warn(`[pdfFonts] Google Fonts returned a non-TTF font for ${fontFamily} (${weight}); skipping jsPDF embed`);
+      return null;
+    }
+    fontBytesCache.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);
+    return b64;
+  } catch (err) {
+    console.warn(`[pdfFonts] fetchGoogleFontTTF failed for ${fontFamily} (${weight}):`, err);
+    return null;
+  }
+}
+async function getGoogleFontBytes(fontFamily, weight = 400, isItalic = false) {
+  const cacheKey = `gf:${fontFamily}:${weight}:${isItalic ? "i" : "n"}`;
+  if (fontBytesCache.has(cacheKey)) return fontBytesCache.get(cacheKey);
+  await fetchGoogleFontTTF(fontFamily, weight, isItalic);
+  return fontBytesCache.get(cacheKey) || null;
+}
+const fontshareNotFound = /* @__PURE__ */ new Set();
+function toFontshareSlug(family) {
+  return family.trim().toLowerCase().replace(/\s+/g, "-");
+}
+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 (fontshareNotFound.has(fontFamily)) return null;
+  const proxyBytes = await fetchTtfViaProxy(fontFamily, weight, isItalic, "fontshare");
+  if (proxyBytes && isJsPdfEmbeddableTrueType(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.set(cacheKey, b64);
+    return b64;
+  }
+  const finalSlug = toFontshareSlug(fontFamily);
+  try {
+    const styleSuffix = isItalic ? "i" : "";
+    const cssUrl = `https://api.fontshare.com/v2/css?f[]=${finalSlug}@${weight}${styleSuffix}&display=swap`;
+    const cssRes = await fetch(cssUrl);
+    if (!cssRes.ok) {
+      if (cssRes.status === 400 || cssRes.status === 404) fontshareNotFound.add(fontFamily);
+      return null;
+    }
+    const css = await cssRes.text();
+    const ttMatch = css.match(/url\(([^)]+)\)\s+format\(['"]?truetype['"]?\)/i);
+    if (!ttMatch) {
+      fontshareNotFound.add(fontFamily);
+      return null;
+    }
+    let ttfUrl = ttMatch[1].replace(/['"]/g, "").trim();
+    if (ttfUrl.startsWith("//")) ttfUrl = `https:${ttfUrl}`;
+    const ttfRes = await fetch(ttfUrl);
+    if (!ttfRes.ok) return null;
+    const buf = await ttfRes.arrayBuffer();
+    const bytes = new Uint8Array(buf);
+    if (!isJsPdfEmbeddableTrueType(bytes)) {
+      console.warn(`[pdfFonts] Fontshare returned a non-TTF font for ${fontFamily} (${weight}); skipping jsPDF embed`);
+      return null;
+    }
+    fontBytesCache.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);
+    return b64;
+  } catch (err) {
+    console.warn(`[pdfFonts] fetchFontshareTTF failed for ${fontFamily} (${weight}):`, err);
+    return null;
+  }
+}
+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);
+  await fetchFontshareTTF(fontFamily, weight, isItalic);
+  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
+  "Poppins": "Poppins",
+  "Noto Sans": "Noto Sans Devanagari",
+  "Noto Serif": "Noto Serif Devanagari",
+  "Hind": "Hind",
+  "Mukta": "Mukta",
+  // Curated visual matches (Google's own recommendations)
+  "Montserrat": "Mukta",
+  "Open Sans": "Mukta",
+  "Lato": "Mukta",
+  "Roboto": "Mukta",
+  "Inter": "Mukta",
+  "Nunito": "Mukta",
+  "Source Sans Pro": "Mukta",
+  "Work Sans": "Mukta",
+  "DM Sans": "Mukta",
+  "Outfit": "Mukta",
+  "Figtree": "Mukta",
+  "Manrope": "Mukta",
+  "Plus Jakarta Sans": "Mukta",
+  "Sora": "Mukta",
+  "Urbanist": "Mukta",
+  "Lexend": "Mukta",
+  "Albert Sans": "Mukta",
+  "Cabin": "Mukta",
+  "Karla": "Mukta",
+  "Mulish": "Mukta",
+  "Rubik": "Mukta",
+  "Quicksand": "Mukta",
+  "Libre Franklin": "Mukta",
+  "Barlow": "Mukta",
+  "Archivo": "Mukta",
+  "Overpass": "Mukta",
+  "Josefin Sans": "Mukta",
+  "Exo 2": "Mukta",
+  "Space Grotesk": "Mukta",
+  // Display / heavy
+  "Oswald": "Teko",
+  "Bebas Neue": "Teko",
+  "Anton": "Teko",
+  "Teko": "Teko",
+  "League Spartan": "Teko",
+  // Serifs → Tiro Devanagari Hindi (a refined Devanagari serif)
+  "Playfair Display": "Tiro Devanagari Hindi",
+  "Merriweather": "Tiro Devanagari Hindi",
+  "Lora": "Tiro Devanagari Hindi",
+  "EB Garamond": "Tiro Devanagari Hindi",
+  "Libre Baskerville": "Tiro Devanagari Hindi",
+  "Crimson Text": "Tiro Devanagari Hindi",
+  "DM Serif Display": "Tiro Devanagari Sanskrit",
+  "Abril Fatface": "Tiro Devanagari Sanskrit",
+  // Handwriting → Kalam (the only serious Devanagari handwriting family on GF)
+  "Dancing Script": "Kalam",
+  "Pacifico": "Kalam",
+  "Great Vibes": "Kalam",
+  "Sacramento": "Kalam",
+  "Alex Brush": "Kalam",
+  "Allura": "Kalam",
+  "Caveat": "Kalam",
+  "Lobster": "Kalam",
+  "Comfortaa": "Mukta",
+  // Monospace → there's no proper Devanagari mono; fall back to Mukta
+  "Roboto Mono": "Mukta",
+  "Fira Code": "Mukta",
+  "JetBrains Mono": "Mukta",
+  "Source Code Pro": "Mukta",
+  "IBM Plex Mono": "Mukta",
+  "Space Mono": "Mukta"
+};
+function resolveDevanagariSibling(latinFont) {
+  if (!latinFont) return FONT_FALLBACK_DEVANAGARI;
+  return LATIN_TO_DEVANAGARI[latinFont] || FONT_FALLBACK_DEVANAGARI;
+}
+export {
+  FONT_FALLBACK_SYMBOLS as F,
+  FONT_FALLBACK_MATH as a,
+  FONT_FALLBACK_DEVANAGARI as b,
+  isFamilyEmbedded as c,
+  resolveFontWeight as d,
+  embedFontWithGoogleFallback as e,
+  doesVariantSupportChar as f,
+  getEmbeddedJsPDFFontName as g,
+  getGoogleFontBytes as h,
+  isFontAvailable as i,
+  getFontshareFontBytes as j,
+  FONT_FILES as k,
+  resolveDevanagariSibling as l,
+  resolveBestRegisteredVariant as r
+};
+//# sourceMappingURL=pdfFonts-CB5z77qO.js.map