@pixldocs/canvas-renderer 0.5.65 → 0.5.66

package/dist/svgTextToPath-BTHnqJpM.cjs

@@ -0,0 +1,1105 @@
+"use strict";
+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
+));
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const opentype = require("opentype.js");
+const fontCache$1 = /* @__PURE__ */ new Map();
+const fontBytesCache$1 = /* @__PURE__ */ new Map();
+const googleFontUrlCache = /* @__PURE__ */ new Map();
+const googleFontNotFound = /* @__PURE__ */ new Set();
+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_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"
+  }
+};
+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 (googleFontNotFound.has(fontFamily)) return null;
+  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(fontFamily);
+      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);
+    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$1.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$1.has(cacheKey)) return fontBytesCache$1.get(cacheKey);
+  await fetchGoogleFontTTF(fontFamily, weight, isItalic);
+  return fontBytesCache$1.get(cacheKey) || null;
+}
+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;
+}
+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 isIgnorableForCoverage(char) {
+  return /\s/.test(char) || /[\u0964\u0965\u200c\u200d]/u.test(char);
+}
+function fontSupportsText(font, text) {
+  if (!font) return false;
+  for (const char of text) {
+    if (!isDevanagari(char) || isIgnorableForCoverage(char)) 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 getFontPath(fontFiles, weight) {
+  const resolved = resolveFontWeight(weight);
+  const keyMap = {
+    300: ["light", "regular"],
+    400: ["regular"],
+    500: ["medium", "regular"],
+    600: ["semibold", "bold"],
+    700: ["bold", "semibold", "regular"]
+  };
+  for (const key of keyMap[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) {
+  const cacheKey = `${fontFamily}__${weight}`;
+  if (fontCache.has(cacheKey)) return fontCache.get(cacheKey);
+  const fontFiles = FONT_FILES[fontFamily];
+  if (fontFiles) {
+    const fileName = getFontPath(fontFiles, weight);
+    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);
+    const bytes = await getGoogleFontBytes(fontFamily, resolvedWeight, false);
+    if (!bytes) {
+      console.warn(`[text-to-path] Google Fonts has no TTF for ${fontFamily} (${weight})`);
+      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) {
+  const cacheKey = `${fontFamily}__${weight}`;
+  if (!fontBytesCache.has(cacheKey)) {
+    await loadFont(fontFamily, weight, fontBaseUrl);
+  }
+  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 splitByScript(text) {
+  if (!text) return [];
+  const runs = [];
+  let buf = "";
+  let bufIsDeva = isDevanagari(text[0]);
+  for (const ch of text) {
+    const chDeva = isDevanagari(ch);
+    const isNeutral = /\s/.test(ch);
+    if (chDeva === bufIsDeva || isNeutral) {
+      buf += ch;
+    } else {
+      if (buf) runs.push({ text: buf, isDevanagari: bufIsDeva });
+      buf = ch;
+      bufIsDeva = chDeva;
+    }
+  }
+  if (buf) runs.push({ text: buf, isDevanagari: bufIsDeva });
+  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 };
+}
+async function convertDevanagariTextToPath(svgStr, fontBaseUrl) {
+  var _a, _b, _c;
+  const baseUrl = fontBaseUrl ?? (typeof window !== "undefined" ? window.location.origin + "/fonts/" : "/fonts/");
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(svgStr, "image/svg+xml");
+  const textEls = doc.querySelectorAll("text");
+  let convertedCount = 0;
+  let skippedCount = 0;
+  for (const textEl of textEls) {
+    const fullText = textEl.textContent || "";
+    if (!fullText.trim()) continue;
+    const readStyleToken = (style, prop) => {
+      var _a2;
+      const m = style.match(new RegExp(`${prop}\\s*:\\s*([^;]+)`, "i"));
+      return ((_a2 = m == null ? void 0 : m[1]) == null ? void 0 : _a2.trim()) || null;
+    };
+    const getAttrOrStyle = (el, attr) => {
+      var _a2;
+      let current = el;
+      while (current) {
+        const attrVal = (_a2 = current.getAttribute(attr)) == null ? void 0 : _a2.trim();
+        if (attrVal) return attrVal;
+        const styleVal = readStyleToken(current.getAttribute("style") || "", attr);
+        if (styleVal) return styleVal;
+        current = current.parentElement;
+      }
+      return null;
+    };
+    const fontFamily = (_b = (_a = getAttrOrStyle(textEl, "font-family")) == null ? void 0 : _a.split(",")[0]) == null ? void 0 : _b.replace(/['"]/g, "").trim();
+    const fontSizeStr = getAttrOrStyle(textEl, "font-size") || "16";
+    const fontSize = parseFloat(fontSizeStr);
+    const fontWeightStr = getAttrOrStyle(textEl, "font-weight") || "400";
+    const fontWeight = Number.parseInt(fontWeightStr, 10) || 400;
+    const fillColor = getAttrOrStyle(textEl, "fill") || "#000000";
+    const fillOpacity = getAttrOrStyle(textEl, "fill-opacity") || "1";
+    if (!fontFamily) {
+      skippedCount++;
+      continue;
+    }
+    const primaryFont = await loadFont(fontFamily, fontWeight, baseUrl);
+    const primaryBytes = await getFontBytes(fontFamily, fontWeight, baseUrl);
+    const hasDeva = containsDevanagari(fullText);
+    const 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 || !fontSupportsText(font, runText)) 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;
+    };
+    if (!primaryFont && !hasDeva) {
+      console.warn(`[text-to-path] No font available for "${fontFamily}", leaving as <text>`);
+      skippedCount++;
+      continue;
+    }
+    const textAnchorRaw = (getAttrOrStyle(textEl, "text-anchor") || "start").toLowerCase();
+    const textAnchor = textAnchorRaw === "middle" ? "middle" : textAnchorRaw === "end" ? "end" : "start";
+    const tspans = textEl.querySelectorAll("tspan");
+    const elementsToProcess = tspans.length > 0 ? Array.from(tspans) : [textEl];
+    const group = doc.createElementNS("http://www.w3.org/2000/svg", "g");
+    const textTransform = textEl.getAttribute("transform");
+    if (textTransform) group.setAttribute("transform", textTransform);
+    const baseX = parseFloat(textEl.getAttribute("x") || "0");
+    const baseY = parseFloat(textEl.getAttribute("y") || "0");
+    for (const elem of elementsToProcess) {
+      const text = elem.textContent || "";
+      if (!text.trim()) continue;
+      const elemX = parseFloat(elem.getAttribute("x") || String(baseX));
+      const elemY = parseFloat(elem.getAttribute("y") || String(baseY));
+      const elemTransform = elem !== textEl ? parseTranslate(elem.getAttribute("transform")) : { tx: 0, ty: 0 };
+      let x = elemX + elemTransform.tx;
+      const y = elemY + elemTransform.ty;
+      const elemFill = getAttrOrStyle(elem, "fill") || fillColor;
+      const elemFillOpacity = getAttrOrStyle(elem, "fill-opacity") || fillOpacity;
+      const elemFontSizeStr = getAttrOrStyle(elem, "font-size") || String(fontSize);
+      const elemFontSize = parseFloat(elemFontSizeStr);
+      const runs = splitByScript(text);
+      let totalAdvance = 0;
+      let canMeasureAll = true;
+      for (const r of runs) {
+        if (r.isDevanagari) {
+          const resolved = await resolveDevaFontForRun(r.text, elemFontSize);
+          if (resolved) totalAdvance += measureRunWidth(resolved.font, r.text, elemFontSize);
+          else canMeasureAll = false;
+        } else {
+          if (primaryFont) totalAdvance += measureRunWidth(primaryFont, r.text, elemFontSize);
+          else canMeasureAll = false;
+        }
+      }
+      if (canMeasureAll) {
+        if (textAnchor === "middle") x -= totalAdvance / 2;
+        else if (textAnchor === "end") x -= totalAdvance;
+      }
+      let cursor = x;
+      let elemConverted = false;
+      for (const r of runs) {
+        const resolvedDeva = r.isDevanagari ? await resolveDevaFontForRun(r.text, elemFontSize) : null;
+        const useDeva = !!resolvedDeva;
+        const fontForRun = (resolvedDeva == null ? void 0 : resolvedDeva.font) ?? primaryFont;
+        const bytesForRun = (resolvedDeva == null ? void 0 : resolvedDeva.bytes) ?? primaryBytes;
+        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 (elemFillOpacity !== "1") {
+            pathEl.setAttribute("fill-opacity", elemFillOpacity);
+          }
+          group.appendChild(pathEl);
+          elemConverted = true;
+        }
+        if (result) cursor += result.advance;
+      }
+      if (elemConverted) {
+        convertedCount++;
+      } else {
+        if (elem === textEl) {
+          const clone = elem.cloneNode(true);
+          if (textTransform) clone.removeAttribute("transform");
+          group.appendChild(clone);
+        } else {
+          const newText = doc.createElementNS("http://www.w3.org/2000/svg", "text");
+          newText.setAttribute("x", String(elemX));
+          newText.setAttribute("y", String(elemY));
+          if (elem.getAttribute("style")) newText.setAttribute("style", elem.getAttribute("style"));
+          if (elem.getAttribute("font-family")) newText.setAttribute("font-family", elem.getAttribute("font-family"));
+          if (elem.getAttribute("font-size")) newText.setAttribute("font-size", elem.getAttribute("font-size"));
+          if (elem.getAttribute("font-weight")) newText.setAttribute("font-weight", elem.getAttribute("font-weight"));
+          newText.textContent = text;
+          group.appendChild(newText);
+        }
+      }
+    }
+    if (group.childNodes.length > 0) {
+      (_c = textEl.parentNode) == null ? void 0 : _c.replaceChild(group, textEl);
+    }
+  }
+  console.log(
+    `[text-to-path] Universal outline complete: converted=${convertedCount} skipped=${skippedCount}`
+  );
+  return new XMLSerializer().serializeToString(doc.documentElement);
+}
+const convertAllTextToPath = convertDevanagariTextToPath;
+async function preloadDevanagariFont(fontBaseUrl) {
+  const baseUrl = fontBaseUrl ?? (typeof window !== "undefined" ? window.location.origin + "/fonts/" : "/fonts/");
+  for (const weight of [300, 400, 500, 600, 700]) {
+    await loadFont(FONT_FALLBACK_DEVANAGARI, weight, baseUrl);
+  }
+}
+exports.convertAllTextToPath = convertAllTextToPath;
+exports.convertDevanagariTextToPath = convertDevanagariTextToPath;
+exports.preloadDevanagariFont = preloadDevanagariFont;
+//# sourceMappingURL=svgTextToPath-BTHnqJpM.cjs.map