@pixldocs/canvas-renderer 0.5.110 → 0.5.112

package/dist/index.d.ts

@@ -144,6 +144,9 @@ export declare function extractFontFamiliesFromSvgs(svgs: string[]): Set<string>
 /** Font used for Devanagari / Hindi script */
 export declare const FONT_FALLBACK_DEVANAGARI = "Hind";
 
+/** Font used only when the active font lacks math/operator glyphs. */
+export declare const FONT_FALLBACK_MATH = "Noto Sans Math";
+
 /** Font used for symbols (● ◆ ★ etc.) */
 export declare const FONT_FALLBACK_SYMBOLS = "Noto Sans";
 

package/dist/index.js

@@ -15052,6 +15052,7 @@ function resolveFontWeight(weight) {
 }
 const FONT_FALLBACK_SYMBOLS = "Noto Sans";
 const FONT_FALLBACK_DEVANAGARI = "Hind";
+const FONT_FALLBACK_MATH = "Noto Sans Math";
 const FONT_FILES = {
   "Playfair Display": {
     regular: "PlayfairDisplay-Regular.ttf",
@@ -15523,6 +15524,9 @@ const FONT_FILES = {
     medium: "Hind-Medium.ttf",
     semibold: "Hind-SemiBold.ttf"
   },
+  "Noto Sans Math": {
+    regular: "NotoSansMath-Regular.ttf"
+  },
   "Cinzel": { regular: "Cinzel-Regular.ttf", bold: "Cinzel-Bold.ttf" },
   "Cormorant Garamond": {
     regular: "CormorantGaramond-Regular.ttf",
@@ -15625,6 +15629,54 @@ function isJsPdfEmbeddableTrueType(bytes) {
   }
   return false;
 }
+function base64ToBytes(b64) {
+  const binary = atob(b64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+function extractSupportedCodePointsFromTtf(bytes) {
+  const out = /* @__PURE__ */ new Set();
+  if (bytes.length < 12) return out;
+  const u16 = (o) => bytes[o] << 8 | bytes[o + 1];
+  const i16 = (o) => {
+    const v = u16(o);
+    return v & 32768 ? v - 65536 : v;
+  };
+  const u32 = (o) => (bytes[o] << 24 | bytes[o + 1] << 16 | bytes[o + 2] << 8 | bytes[o + 3]) >>> 0;
+  let cmap = 0;
+  for (let i = 0, n = u16(4); i < n; i++) {
+    const off = 12 + i * 16;
+    if (String.fromCharCode(bytes[off], bytes[off + 1], bytes[off + 2], bytes[off + 3]) === "cmap") {
+      cmap = u32(off + 8);
+      break;
+    }
+  }
+  if (!cmap) return out;
+  const candidates = [];
+  for (let i = 0, n = u16(cmap + 2); i < n; i++) {
+    const enc = cmap + 4 + i * 8;
+    const platform = u16(enc), encoding = u16(enc + 2), off = cmap + u32(enc + 4), format = u16(off);
+    const score = (format === 12 ? 40 : format === 4 ? 30 : 0) + (platform === 3 && encoding === 10 ? 2 : platform === 0 ? 1 : 0);
+    if (score) candidates.push({ format, off, score });
+  }
+  candidates.sort((a, b) => b.score - a.score);
+  const best = candidates[0];
+  if (!best) return out;
+  if (best.format === 12) {
+    for (let i = 0, n = u32(best.off + 12); i < n; i++) {
+      const off = best.off + 16 + i * 12, start = u32(off), end = u32(off + 4);
+      for (let cp = start; cp <= end && cp <= 1114111; cp++) out.add(cp);
+    }
+  } else if (best.format === 4) {
+    const segCount = u16(best.off + 6) / 2, endCodes = best.off + 14, startCodes = endCodes + segCount * 2 + 2, deltas = startCodes + segCount * 2, ranges = deltas + segCount * 2;
+    for (let i = 0; i < segCount; i++) for (let cp = u16(startCodes + i * 2), end = u16(endCodes + i * 2); cp <= end && cp !== 65535; cp++) {
+      const ro = u16(ranges + i * 2);
+      if (ro === 0 ? (cp + i16(deltas + i * 2) & 65535) !== 0 : u16(ranges + i * 2 + ro + (cp - u16(startCodes + i * 2)) * 2) !== 0) out.add(cp);
+    }
+  }
+  return out;
+}
 async function embedFont(pdf, fontName, weight, fontBaseUrl, isItalic = false) {
   const fontFiles = FONT_FILES[fontName];
   if (!fontFiles) return false;
@@ -15641,6 +15693,7 @@ async function embedFont(pdf, fontName, weight, fontBaseUrl, isItalic = false) {
   try {
     const b64 = await fetchTTFAsBase64(url);
     if (!b64) return false;
+    registeredVariantCoverage.set(variantKey(fontName, resolvedWeight, isItalic), extractSupportedCodePointsFromTtf(base64ToBytes(b64)));
     pdf.addFileToVFS(fileName, b64);
     pdf.addFont(fileName, jsPdfFontName, "normal");
     if (fontName !== jsPdfFontName) {
@@ -15661,6 +15714,7 @@ const googleFontNotFound = /* @__PURE__ */ new Set();
 const fontshareNotFound = /* @__PURE__ */ new Set();
 const remoteVariantKey = (family, weight, isItalic) => `${family}|${resolveFontWeight(weight)}|${isItalic ? "i" : "n"}`;
 const registeredVariants = /* @__PURE__ */ new Set();
+const registeredVariantCoverage = /* @__PURE__ */ new Map();
 const variantKey = (family, weight, italic) => `${family}|${resolveFontWeight(weight)}|${italic ? "i" : "n"}`;
 const resolveBestRegisteredVariant = (family, weight, italic) => {
   const want = resolveFontWeight(weight);
@@ -15671,6 +15725,12 @@ const resolveBestRegisteredVariant = (family, weight, italic) => {
   for (const w of nearest) if (registeredVariants.has(variantKey(family, w, !italic))) return { weight: w, italic: !italic };
   return null;
 };
+const doesVariantSupportChar = (family, weight, italic, char) => {
+  var _a;
+  const cp = char.codePointAt(0);
+  if (cp == null) return false;
+  return ((_a = registeredVariantCoverage.get(variantKey(family, weight, italic))) == null ? void 0 : _a.has(cp)) === true;
+};
 function bytesToBase64(bytes) {
   let binary = "";
   for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
@@ -15787,6 +15847,7 @@ function registerJsPdfFont(pdf, fontName, resolvedWeight, isItalic, base64) {
   const jsPdfFontName = getEmbeddedJsPDFFontName(fontName, resolvedWeight, isItalic);
   const fileName = `${getJsPDFFontName(fontName)}-${label}${italicSuffix}.ttf`;
   try {
+    registeredVariantCoverage.set(variantKey(fontName, resolvedWeight, isItalic), extractSupportedCodePointsFromTtf(base64ToBytes(base64)));
     pdf.addFileToVFS(fileName, base64);
     pdf.addFont(fileName, jsPdfFontName, "normal");
     if (fontName !== jsPdfFontName) {
@@ -15883,6 +15944,7 @@ async function embedFontsForConfig(pdf, config, fontBaseUrl) {
     if (page.elements) walkElements(page.elements);
   }
   fontKeys.add(`${FONT_FALLBACK_SYMBOLS}${SEP}400${SEP}normal`);
+  fontKeys.add(`${FONT_FALLBACK_MATH}${SEP}400${SEP}normal`);
   for (const w of [300, 400, 500, 600, 700]) {
     fontKeys.add(`${FONT_FALLBACK_DEVANAGARI}${SEP}${w}${SEP}normal`);
   }
@@ -15916,10 +15978,10 @@ function containsDevanagari(text) {
   }
   return false;
 }
-function containsSymbol(text) {
+function containsSymbol(text, mainSupportsChar) {
   if (!text) return false;
   for (const char of text) {
-    if (classifyChar(char) === "symbol") return true;
+    if (classifyChar(char, mainSupportsChar) !== "main") return true;
   }
   return false;
 }
@@ -15933,19 +15995,25 @@ function isCommonLatinPunctuation(char) {
   if (c === 8467 || c === 8482) return true;
   return false;
 }
-function classifyChar(char) {
+function isMathOperator(char) {
+  const c = char.codePointAt(0) ?? 0;
+  return c >= 8592 && c <= 8959 || c >= 8960 && c <= 9215 || c >= 10176 && c <= 11007 || c >= 11008 && c <= 11097;
+}
+function classifyChar(char, mainSupportsChar) {
   if (isBasicLatinOrLatin1(char)) return "main";
   if (isCommonLatinPunctuation(char)) return "main";
+  if (!isDevanagari(char) && (mainSupportsChar == null ? void 0 : mainSupportsChar(char))) return "main";
   if (isDevanagari(char)) return "devanagari";
+  if (isMathOperator(char)) return "math";
   return "symbol";
 }
-function splitIntoRuns(text) {
+function splitIntoRuns(text, mainSupportsChar) {
   if (!text) return [];
   const runs = [];
   let currentType = null;
   let currentText = "";
   for (const char of text) {
-    const type = classifyChar(char);
+    const type = classifyChar(char, mainSupportsChar);
     if (type !== currentType && currentText) {
       runs.push({ text: currentText, runType: currentType });
       currentText = "";
@@ -16053,15 +16121,17 @@ function rewriteSvgFontsForJsPDF(svgStr) {
     }
     const directText = Array.from(el.childNodes).filter((n) => n.nodeType === 3).map((n) => n.textContent || "").join("");
     const hasDevanagari = containsDevanagari(directText);
-    const hasSymbol = containsSymbol(directText);
+    const mainSupportsChar = (char) => doesVariantSupportChar(clean, resolved, actualItalic, char);
+    const hasSymbol = containsSymbol(directText, mainSupportsChar);
     if ((hasDevanagari || hasSymbol) && directText.length > 0) {
       const devanagariWeight = resolveFontWeight(weight);
       const devanagariJsPdfName = getEmbeddedJsPDFFontName(FONT_FALLBACK_DEVANAGARI, devanagariWeight);
       const symbolJsPdfName = isFontAvailable(FONT_FALLBACK_SYMBOLS) ? getEmbeddedJsPDFFontName(FONT_FALLBACK_SYMBOLS, 400) : jsPdfName;
+      const mathJsPdfName = isFontAvailable(FONT_FALLBACK_MATH) ? getEmbeddedJsPDFFontName(FONT_FALLBACK_MATH, 400) : symbolJsPdfName;
       const childNodes = Array.from(el.childNodes);
       for (const node of childNodes) {
         if (node.nodeType !== 3 || !node.textContent) continue;
-        const runs = splitIntoRuns(node.textContent);
+        const runs = splitIntoRuns(node.textContent, mainSupportsChar);
         if (runs.length <= 1 && ((_b = runs[0]) == null ? void 0 : _b.runType) === "main") continue;
         const fragment = doc.createDocumentFragment();
         for (const run of runs) {
@@ -16071,6 +16141,8 @@ function rewriteSvgFontsForJsPDF(svgStr) {
             runFont = devanagariJsPdfName;
           } else if (run.runType === "symbol") {
             runFont = symbolJsPdfName;
+          } else if (run.runType === "math") {
+            runFont = mathJsPdfName;
           } else {
             runFont = jsPdfName;
           }
@@ -16177,6 +16249,7 @@ async function embedFontsInPdf(pdf, fontFamilies, fontBaseUrl) {
 const pdfFonts = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   FONT_FALLBACK_DEVANAGARI,
+  FONT_FALLBACK_MATH,
   FONT_FALLBACK_SYMBOLS,
   FONT_FILES,
   FONT_WEIGHT_LABELS,
@@ -17653,7 +17726,7 @@ async function assemblePdfFromSvgs(svgResults, options = {}) {
     const hasGradient = !!((_b = (_a = page.backgroundGradient) == null ? void 0 : _a.stops) == null ? void 0 : _b.length);
     drawPageBackground(pdf, i, page.width, page.height, page.backgroundColor, page.backgroundGradient);
     const shouldStripBg = stripPageBackground ?? hasGradient;
-    const textMode = options.textMode ?? (options.outlineText === false ? "selectable" : "pixel-perfect");
+    const textMode = options.textMode ?? (options.outlineText === true ? "pixel-perfect" : "selectable");
     const shouldOutlineText = textMode === "pixel-perfect" || textMode === "auto";
     const outlineSubMode = textMode === "auto" ? "complex-only" : "all";
     let pageSvg = page.svg;
@@ -17823,6 +17896,7 @@ function setAutoShrinkDebug(enabled) {
 }
 export {
   FONT_FALLBACK_DEVANAGARI,
+  FONT_FALLBACK_MATH,
   FONT_FALLBACK_SYMBOLS,
   FONT_FILES,
   PACKAGE_VERSION,