pdfnative 1.2.0 → 1.3.0

package/dist/worker/index.cjs

@@ -200,6 +200,33 @@ var BENGALI_START = 2432;
 var BENGALI_END = 2559;
 var TAMIL_START = 2944;
 var TAMIL_END = 3071;
+var TELUGU_START = 3072;
+var TELUGU_END = 3199;
+var ETHIOPIC_START = 4608;
+var ETHIOPIC_END = 4991;
+var ETHIOPIC_SUPPLEMENT_START = 4992;
+var ETHIOPIC_SUPPLEMENT_END = 5023;
+var ETHIOPIC_EXTENDED_START = 11648;
+var ETHIOPIC_EXTENDED_END = 11743;
+var ETHIOPIC_EXTENDED_A_START = 43776;
+var ETHIOPIC_EXTENDED_A_END = 43823;
+var SINHALA_START = 3456;
+var SINHALA_END = 3583;
+var SINHALA_VIRAMA = 3530;
+var TIBETAN_START = 3840;
+var TIBETAN_END = 4095;
+var KHMER_START = 6016;
+var KHMER_END = 6143;
+var KHMER_SYMBOLS_START = 6624;
+var KHMER_SYMBOLS_END = 6655;
+var KHMER_COENG = 6098;
+var MYANMAR_START = 4096;
+var MYANMAR_END = 4255;
+var MYANMAR_EXTENDED_A_START = 43616;
+var MYANMAR_EXTENDED_A_END = 43647;
+var MYANMAR_EXTENDED_B_START = 43488;
+var MYANMAR_EXTENDED_B_END = 43519;
+var MYANMAR_VIRAMA = 4153;
 var EMOJI_RANGES = [
   [127744, 128511],
   // Miscellaneous Symbols and Pictographs
@@ -230,6 +257,9 @@ var EMOJI_RANGES = [
 ];
 var FITZPATRICK_START = 127995;
 var FITZPATRICK_END = 127999;
+var ZWJ = 8205;
+var VS15 = 65038;
+var VS16 = 65039;
 function isArabicCodepoint(cp) {
   return cp >= ARABIC_START && cp <= ARABIC_END || cp >= ARABIC_SUPPLEMENT_START && cp <= ARABIC_SUPPLEMENT_END || cp >= ARABIC_EXTENDED_A_START && cp <= ARABIC_EXTENDED_A_END || cp >= ARABIC_PRES_A_START && cp <= ARABIC_PRES_A_END || cp >= ARABIC_PRES_B_START && cp <= ARABIC_PRES_B_END;
 }
@@ -242,6 +272,24 @@ function isBengaliCodepoint(cp) {
 function isTamilCodepoint(cp) {
   return cp >= TAMIL_START && cp <= TAMIL_END;
 }
+function isTeluguCodepoint(cp) {
+  return cp >= TELUGU_START && cp <= TELUGU_END;
+}
+function isEthiopicCodepoint(cp) {
+  return cp >= ETHIOPIC_START && cp <= ETHIOPIC_END || cp >= ETHIOPIC_SUPPLEMENT_START && cp <= ETHIOPIC_SUPPLEMENT_END || cp >= ETHIOPIC_EXTENDED_START && cp <= ETHIOPIC_EXTENDED_END || cp >= ETHIOPIC_EXTENDED_A_START && cp <= ETHIOPIC_EXTENDED_A_END;
+}
+function isSinhalaCodepoint(cp) {
+  return cp >= SINHALA_START && cp <= SINHALA_END;
+}
+function isTibetanCodepoint(cp) {
+  return cp >= TIBETAN_START && cp <= TIBETAN_END;
+}
+function isKhmerCodepoint(cp) {
+  return cp >= KHMER_START && cp <= KHMER_END || cp >= KHMER_SYMBOLS_START && cp <= KHMER_SYMBOLS_END;
+}
+function isMyanmarCodepoint(cp) {
+  return cp >= MYANMAR_START && cp <= MYANMAR_END || cp >= MYANMAR_EXTENDED_A_START && cp <= MYANMAR_EXTENDED_A_END || cp >= MYANMAR_EXTENDED_B_START && cp <= MYANMAR_EXTENDED_B_END;
+}
 function isDevanagariCodepoint(cp) {
   return cp >= DEVANAGARI_START && cp <= DEVANAGARI_END || cp >= DEVANAGARI_EXT_START && cp <= DEVANAGARI_EXT_END;
 }
@@ -252,6 +300,9 @@ function isEmojiCodepoint(cp) {
   }
   return false;
 }
+function isZeroWidthFormat(cp) {
+  return cp === ZWJ || cp === 8204 || cp === VS15 || cp === VS16 || cp >= FITZPATRICK_START && cp <= FITZPATRICK_END;
+}
 function containsArabic(text) {
   for (let i = 0; i < text.length; ) {
     const cp = text.codePointAt(i) ?? 0;
@@ -278,6 +329,36 @@ function containsTamil(str) {
   }
   return false;
 }
+function containsTelugu(str) {
+  for (let i = 0; i < str.length; i++) {
+    if (isTeluguCodepoint(str.charCodeAt(i))) return true;
+  }
+  return false;
+}
+function containsSinhala(str) {
+  for (let i = 0; i < str.length; i++) {
+    if (isSinhalaCodepoint(str.charCodeAt(i))) return true;
+  }
+  return false;
+}
+function containsTibetan(str) {
+  for (let i = 0; i < str.length; i++) {
+    if (isTibetanCodepoint(str.charCodeAt(i))) return true;
+  }
+  return false;
+}
+function containsKhmer(str) {
+  for (let i = 0; i < str.length; i++) {
+    if (isKhmerCodepoint(str.charCodeAt(i))) return true;
+  }
+  return false;
+}
+function containsMyanmar(str) {
+  for (let i = 0; i < str.length; i++) {
+    if (isMyanmarCodepoint(str.charCodeAt(i))) return true;
+  }
+  return false;
+}
 function containsDevanagari(str) {
   for (let i = 0; i < str.length; i++) {
     if (isDevanagariCodepoint(str.charCodeAt(i))) return true;
@@ -289,6 +370,12 @@ function containsDevanagari(str) {
 function detectCharLang(cp) {
   if (cp >= 880 && cp <= 1023 || cp >= 7936 && cp <= 8191) return "el";
   if (cp >= 2304 && cp <= 2431 || cp >= 43232 && cp <= 43263) return "hi";
+  if (cp >= 3072 && cp <= 3199) return "te";
+  if (isSinhalaCodepoint(cp)) return "si";
+  if (isTibetanCodepoint(cp)) return "bo";
+  if (isKhmerCodepoint(cp)) return "km";
+  if (isMyanmarCodepoint(cp)) return "my";
+  if (isEthiopicCodepoint(cp)) return "am";
   if (cp >= 3584 && cp <= 3711) return "th";
   if (cp >= 12352 && cp <= 12543) return "ja";
   if (cp >= 44032 && cp <= 55215 || cp >= 4352 && cp <= 4607 || cp >= 12592 && cp <= 12687) return "ko";
@@ -322,6 +409,10 @@ function splitTextByFont(str, fontEntries) {
       i += charLen;
       continue;
     }
+    if (isZeroWidthFormat(normCp) && !fontEntries.some((fe) => fe.fontData.cmap[normCp])) {
+      i += charLen;
+      continue;
+    }
     let newEntry = null;
     const charLang = detectCharLang(normCp);
     if (charLang) {
@@ -626,18 +717,26 @@ function normalizeBidiEmbeddings(text) {
   for (let i = 0; i < text.length; ) {
     const cp = text.codePointAt(i) ?? 0;
     const cpLen = cp > 65535 ? 2 : 1;
-    if (cp === LRE || cp === RLO || cp === LRO || cp === RLE) {
+    if (cp === LRE || cp === RLE) {
       if (stack.length >= MAX_DEPTH) {
         i += cpLen;
         continue;
       }
-      stack.push(1);
-      out.push(cp === LRE || cp === LRO ? LRI : RLI);
+      stack.push("E");
+      out.push(cp === LRE ? LRI : RLI);
       i += cpLen;
-    } else if (cp === PDF_CP) {
-      if (stack.pop()) {
-        out.push(PDI);
+    } else if (cp === LRO || cp === RLO) {
+      if (stack.length >= MAX_DEPTH) {
+        i += cpLen;
+        continue;
       }
+      stack.push("O");
+      out.push(cp);
+      i += cpLen;
+    } else if (cp === PDF_CP) {
+      const frame = stack.pop();
+      if (frame === "E") out.push(PDI);
+      else if (frame === "O") out.push(PDF_CP);
       i += cpLen;
     } else {
       out.push(cp);
@@ -648,8 +747,95 @@ function normalizeBidiEmbeddings(text) {
   for (let i = 0; i < out.length; i++) result += String.fromCodePoint(out[i]);
   return result;
 }
+function matchingPdfIndex(codePoints, openCp) {
+  let depth = 1;
+  for (let j = openCp + 1; j < codePoints.length; j++) {
+    const cj = codePoints[j];
+    if (cj === 8234 || cj === 8235 || cj === 8237 || cj === 8238) depth++;
+    else if (cj === 8236) {
+      depth--;
+      if (depth === 0) return j;
+    }
+  }
+  return -1;
+}
+function matchingPdiIndex(codePoints, openCp) {
+  let depth = 1;
+  for (let j = openCp + 1; j < codePoints.length; j++) {
+    const cj = codePoints[j];
+    if (cj === 8294 || cj === 8295 || cj === 8296) depth++;
+    else if (cj === 8297) {
+      depth--;
+      if (depth === 0) return j;
+    }
+  }
+  return -1;
+}
+function tryResolveOverrides(text, forcedLevel) {
+  const LRE = 8234, RLE = 8235, LRO = 8237, RLO = 8238;
+  if (text.indexOf("\u202D") === -1 && text.indexOf("\u202E") === -1) return null;
+  const codePoints = [];
+  const cpToStr = [];
+  for (let i2 = 0; i2 < text.length; ) {
+    cpToStr.push(i2);
+    const cp = text.codePointAt(i2) ?? 0;
+    codePoints.push(cp);
+    i2 += cp > 65535 ? 2 : 1;
+  }
+  cpToStr.push(text.length);
+  const len = codePoints.length;
+  const spans = [];
+  let i = 0;
+  while (i < len) {
+    const cp = codePoints[i];
+    if (cp === LRO || cp === RLO) {
+      const close = matchingPdfIndex(codePoints, i);
+      if (close === -1) {
+        i++;
+        continue;
+      }
+      spans.push({ open: i, close, rtl: cp === RLO });
+      i = close + 1;
+    } else if (cp === LRE || cp === RLE) {
+      const close = matchingPdfIndex(codePoints, i);
+      i = close === -1 ? i + 1 : close + 1;
+    } else if (cp === 8294 || cp === 8295 || cp === 8296) {
+      const close = matchingPdiIndex(codePoints, i);
+      i = close === -1 ? i + 1 : close + 1;
+    } else {
+      i++;
+    }
+  }
+  if (spans.length === 0) return null;
+  const out = [];
+  const emitGap = (cpStart, cpEnd) => {
+    if (cpStart >= cpEnd) return;
+    const segText = text.substring(cpToStr[cpStart], cpToStr[cpEnd]);
+    const baseStrIdx = cpToStr[cpStart];
+    const segRuns = forcedLevel === void 0 ? resolveBidiRuns(segText) : resolveBidiRunsForced(segText, forcedLevel);
+    for (const r of segRuns) {
+      out.push({ text: r.text, level: r.level, start: r.start + baseStrIdx });
+    }
+  };
+  let cursor = 0;
+  for (const span of spans) {
+    emitGap(cursor, span.open);
+    const innerRaw = text.substring(cpToStr[span.open + 1], cpToStr[span.close]);
+    const inner = stripBidiControls(innerRaw);
+    if (inner) {
+      const level = span.rtl ? 1 : 0;
+      const runText = span.rtl ? reverseString(inner) : inner;
+      out.push({ text: runText, level, start: cpToStr[span.open + 1] });
+    }
+    cursor = span.close + 1;
+  }
+  emitGap(cursor, len);
+  return out;
+}
 function resolveBidiRuns(text) {
   if (!text) return [];
+  const overrideRuns = tryResolveOverrides(text);
+  if (overrideRuns) return overrideRuns;
   const normalized = normalizeBidiEmbeddings(text);
   if (normalized !== text) {
     return resolveBidiRuns(normalized);
@@ -712,6 +898,8 @@ function resolveBidiRuns(text) {
 }
 function resolveBidiRunsForced(text, forcedLevel) {
   if (!text) return [];
+  const overrideRuns = tryResolveOverrides(text, forcedLevel);
+  if (overrideRuns) return overrideRuns;
   const codePoints = [];
   const cpToStr = [];
   for (let i = 0; i < text.length; ) {
@@ -800,6 +988,7 @@ function resolveBidiCore(text, codePoints, cpToStr, forcedLevel) {
 function containsRTL(text) {
   for (let i = 0; i < text.length; ) {
     const cp = text.codePointAt(i) ?? 0;
+    if (cp === 8237 || cp === 8238) return true;
     const t = classifyBidiType(cp);
     if (t === "R" || t === "AL") return true;
     i += cp > 65535 ? 2 : 1;
@@ -881,6 +1070,57 @@ function pdfString(str) {
   const s = toWinAnsi(stripBidiControls(str));
   return "(" + s.replace(/\\/g, "\\\\").replace(/\(/g, "\\(").replace(/\)/g, "\\)") + ")";
 }
+var WINANSI_HIGH_TO_UNICODE = {
+  128: 8364,
+  130: 8218,
+  131: 402,
+  132: 8222,
+  133: 8230,
+  134: 8224,
+  135: 8225,
+  136: 710,
+  137: 8240,
+  138: 352,
+  139: 8249,
+  140: 338,
+  142: 381,
+  145: 8216,
+  146: 8217,
+  147: 8220,
+  148: 8221,
+  149: 8226,
+  150: 8211,
+  151: 8212,
+  152: 732,
+  153: 8482,
+  154: 353,
+  155: 8250,
+  156: 339,
+  158: 382,
+  159: 376
+};
+function buildWinAnsiToUnicodeCMap() {
+  const entries = [];
+  const hex2 = (n2) => n2.toString(16).toUpperCase().padStart(2, "0");
+  const hex4 = (n2) => n2.toString(16).toUpperCase().padStart(4, "0");
+  for (let b = 32; b <= 255; b++) {
+    if (b >= 127 && b <= 159) {
+      const u = WINANSI_HIGH_TO_UNICODE[b];
+      if (u === void 0) continue;
+      entries.push(`<${hex2(b)}> <${hex4(u)}>`);
+    } else {
+      entries.push(`<${hex2(b)}> <${hex4(b)}>`);
+    }
+  }
+  const blocks = [];
+  for (let i = 0; i < entries.length; i += 100) {
+    const chunk = entries.slice(i, i + 100);
+    blocks.push(`${chunk.length} beginbfchar
+${chunk.join("\n")}
+endbfchar`);
+  }
+  return "/CIDInit /ProcSet findresource begin\n12 dict begin\nbegincmap\n/CIDSystemInfo << /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def\n/CMapName /Adobe-Identity-UCS def\n/CMapType 2 def\n1 begincodespacerange\n<20> <FF>\nendcodespacerange\n" + blocks.join("\n") + "\nendcmap\nCMapName currentdict /CMap defineresource pop\nend\nend";
+}
 function truncate(str, max) {
   if (!str || str.length <= max) return str || "";
   if (max <= 1) return "\u2026";
@@ -956,6 +1196,73 @@ function tryLigature(gids, ligatures) {
   return null;
 }
 
+// src/shaping/use-lite.ts
+function devanagariCategory(cp) {
+  if (cp === 2305 || cp === 2306) return "Mabv";
+  if (cp === 2307) return "Mpst";
+  if (cp >= 2308 && cp <= 2324) return "V";
+  if (cp >= 2325 && cp <= 2361) return "B";
+  if (cp === 2362) return "Mabv";
+  if (cp === 2363) return "Mpst";
+  if (cp === 2364) return "Mblw";
+  if (cp === 2365) return "O";
+  if (cp === 2366) return "Mpst";
+  if (cp >= 2367 && cp <= 2368) return cp === 2367 ? "Mpre" : "Mpst";
+  if (cp >= 2369 && cp <= 2376) return "Mblw";
+  if (cp >= 2377 && cp <= 2380) return "Mpst";
+  if (cp === 2381) return "H";
+  if (cp >= 2382 && cp <= 2383) return "Mpre";
+  if (cp === 2384) return "O";
+  if (cp >= 2385 && cp <= 2391) return "Mabv";
+  if (cp >= 2392 && cp <= 2401) return "B";
+  if (cp >= 2402 && cp <= 2403) return "Mblw";
+  if (cp >= 2406 && cp <= 2415) return "N";
+  return "O";
+}
+function bengaliCategory(cp) {
+  if (cp === 2433) return "Mabv";
+  if (cp === 2434) return "Mpst";
+  if (cp === 2435) return "Mpst";
+  if (cp >= 2437 && cp <= 2452) return "V";
+  if (cp >= 2453 && cp <= 2489) return "B";
+  if (cp === 2492) return "Mblw";
+  if (cp === 2493) return "O";
+  if (cp === 2494) return "Mpst";
+  if (cp >= 2495 && cp <= 2496) return cp === 2495 ? "Mpre" : "Mpst";
+  if (cp >= 2497 && cp <= 2500) return "Mblw";
+  if (cp >= 2503 && cp <= 2504) return "Mpre";
+  if (cp >= 2507 && cp <= 2508) return "Mpre";
+  if (cp === 2509) return "H";
+  if (cp === 2510) return "B";
+  if (cp === 2519) return "Mpst";
+  if (cp >= 2524 && cp <= 2527) return "B";
+  if (cp >= 2528 && cp <= 2531) return "O";
+  if (cp >= 2534 && cp <= 2543) return "N";
+  return "O";
+}
+function tamilCategory(cp) {
+  if (cp === 2946) return "Mabv";
+  if (cp >= 2949 && cp <= 2964) return "V";
+  if (cp >= 2965 && cp <= 3001) return "B";
+  if (cp === 3006) return "Mpst";
+  if (cp === 3007) return "Mpst";
+  if (cp >= 3008 && cp <= 3010) return "Mpst";
+  if (cp >= 3014 && cp <= 3016) return "Mpre";
+  if (cp >= 3018 && cp <= 3020) return "Mpre";
+  if (cp === 3021) return "H";
+  if (cp === 3031) return "Mpst";
+  if (cp >= 3046 && cp <= 3055) return "N";
+  return "O";
+}
+function classifyUseCategory(cp) {
+  if (cp === 8204) return "ZWNJ";
+  if (cp === 8205) return "ZWJ";
+  if (cp >= 2304 && cp <= 2431) return devanagariCategory(cp);
+  if (cp >= 2432 && cp <= 2559) return bengaliCategory(cp);
+  if (cp >= 2944 && cp <= 3071) return tamilCategory(cp);
+  return "O";
+}
+
 // src/shaping/bengali-shaper.ts
 var HALANT = 2509;
 var NUKTA = 2492;
@@ -997,6 +1304,10 @@ function buildBengaliClusters(str) {
   while (i < cps.length) {
     const cp = cps[i];
     const type = bengaliCharType(cp);
+    if (classifyUseCategory(cp) === "ZWJ" || classifyUseCategory(cp) === "ZWNJ") {
+      i++;
+      continue;
+    }
     if (type < 0 || cp < BENGALI_START || cp > BENGALI_END) {
       clusters.push({ codepoints: [cp], baseIndex: 0, hasReph: false, preBaseMatras: [] });
       i++;
@@ -1024,13 +1335,24 @@ function buildBengaliClusters(str) {
           i++;
         }
         if (i < cps.length && cps[i] === HALANT) {
-          if (i + 1 < cps.length && isConsonant(cps[i + 1])) {
+          let j = i + 1;
+          let zwnj = false;
+          if (j < cps.length) {
+            const jc = classifyUseCategory(cps[j]);
+            if (jc === "ZWJ") {
+              j++;
+            } else if (jc === "ZWNJ") {
+              j++;
+              zwnj = true;
+            }
+          }
+          if (!zwnj && j < cps.length && isConsonant(cps[j])) {
             syllable.push(cps[i]);
-            i++;
+            i = j;
             continue;
           } else {
             syllable.push(cps[i]);
-            i++;
+            i = j;
             break;
           }
         }
@@ -1267,6 +1589,10 @@ function buildTamilClusters(str) {
   while (i < cps.length) {
     const cp = cps[i];
     const type = tamilCharType(cp);
+    if (classifyUseCategory(cp) === "ZWJ" || classifyUseCategory(cp) === "ZWNJ") {
+      i++;
+      continue;
+    }
     if (type < 0 || cp < TAMIL_START || cp > TAMIL_END) {
       clusters.push({ codepoints: [cp], baseIndex: 0, preBaseMatras: [] });
       i++;
@@ -1283,13 +1609,24 @@ function buildTamilClusters(str) {
         syllable.push(cc);
         i++;
         if (i < cps.length && cps[i] === PULLI) {
-          if (i + 1 < cps.length && isConsonant2(cps[i + 1])) {
+          let j = i + 1;
+          let zwnj = false;
+          if (j < cps.length) {
+            const jc = classifyUseCategory(cps[j]);
+            if (jc === "ZWJ") {
+              j++;
+            } else if (jc === "ZWNJ") {
+              j++;
+              zwnj = true;
+            }
+          }
+          if (!zwnj && j < cps.length && isConsonant2(cps[j])) {
             syllable.push(cps[i]);
-            i++;
+            i = j;
             continue;
           } else {
             syllable.push(cps[i]);
-            i++;
+            i = j;
             break;
           }
         }
@@ -1401,76 +1738,1084 @@ function shapeTamilText(str, fontData) {
         }
       }
     }
-    const clusterGids = [];
-    const clusterEndIdx = [];
-    let matraStart = codepoints.length;
+    const clusterGids = [];
+    const clusterEndIdx = [];
+    let matraStart = codepoints.length;
+    for (let ci = 0; ci < codepoints.length; ci++) {
+      const ct = tamilCharType(codepoints[ci]);
+      if (ct === 0 || ct === 7) {
+        clusterGids.push(resolveGid(codepoints[ci]));
+        clusterEndIdx.push(ci);
+      } else if (ct >= 2) {
+        matraStart = ci;
+        break;
+      } else if (ct < 0) {
+        emitGlyph(resolveGid(codepoints[ci]), false);
+      } else if (ct === 1) {
+        emitGlyph(resolveGid(codepoints[ci]), false);
+      }
+    }
+    let ligConsumed = 0;
+    const ligResult = tryLig(clusterGids);
+    if (ligResult) {
+      emitGlyph(ligResult.resultGid, false);
+      baseGid = ligResult.resultGid;
+      ligConsumed = ligResult.consumed;
+      let gi = ligConsumed;
+      while (gi < clusterGids.length) {
+        const subSeq = clusterGids.slice(gi);
+        const subLig = tryLig(subSeq);
+        if (subLig) {
+          emitGlyph(subLig.resultGid, false);
+          gi += subLig.consumed;
+        } else {
+          const origCi = clusterEndIdx[gi];
+          const ct = tamilCharType(codepoints[origCi]);
+          if (ct === 7) {
+            emitGlyph(clusterGids[gi], true, baseGid);
+          } else {
+            emitGlyph(clusterGids[gi], false);
+          }
+          gi++;
+        }
+      }
+    } else {
+      for (let ci = 0; ci < matraStart; ci++) {
+        const cp = codepoints[ci];
+        const ct = tamilCharType(cp);
+        if (ct === 0) {
+          emitGlyph(resolveGid(cp), false);
+        } else if (ct === 7) {
+          emitGlyph(resolveGid(cp), true, baseGid);
+        }
+      }
+    }
+    for (let ci = matraStart; ci < codepoints.length; ci++) {
+      const cp = codepoints[ci];
+      const ct = tamilCharType(cp);
+      if (ct === 4) continue;
+      if (ct === 2 || ct === 3) {
+        emitGlyph(resolveGid(cp), true, baseGid);
+      } else if (ct === 5) {
+        emitGlyph(resolveGid(cp), false);
+      } else if (ct === 6) {
+        emitGlyph(resolveGid(cp), true, baseGid);
+      } else if (ct === 9) {
+        emitGlyph(resolveGid(cp), false);
+      } else {
+        emitGlyph(resolveGid(cp), false);
+      }
+    }
+    for (const postCp of splitPostComponents) {
+      emitGlyph(resolveGid(postCp), false);
+    }
+  }
+  return shaped;
+}
+
+// src/shaping/telugu-shaper.ts
+var VIRAMA = 3149;
+function teluguCharType(cp) {
+  if (cp === VIRAMA) return 7;
+  if (cp >= 3072 && cp <= 3076) return 6;
+  if (cp >= 3077 && cp <= 3092) return 1;
+  if (cp === 3133) return 1;
+  if (cp >= 3093 && cp <= 3129) return 0;
+  if (cp >= 3160 && cp <= 3162) return 0;
+  if (cp === 3134) return 5;
+  if (cp === 3135) return 2;
+  if (cp === 3136) return 2;
+  if (cp === 3137) return 5;
+  if (cp === 3138) return 5;
+  if (cp === 3139) return 2;
+  if (cp === 3140) return 2;
+  if (cp === 3142) return 2;
+  if (cp === 3143) return 2;
+  if (cp === 3144) return 2;
+  if (cp === 3146) return 5;
+  if (cp === 3147) return 5;
+  if (cp === 3148) return 5;
+  if (cp === 3170 || cp === 3171) return 3;
+  if (cp === 3157 || cp === 3158) return 6;
+  if (cp === 3168 || cp === 3169) return 1;
+  if (cp >= 3174 && cp <= 3183) return 9;
+  if (cp >= 3192 && cp <= 3199) return 9;
+  return -1;
+}
+function isConsonant3(cp) {
+  return teluguCharType(cp) === 0;
+}
+function buildTeluguClusters(str) {
+  const clusters = [];
+  const cps = [];
+  for (let i2 = 0; i2 < str.length; ) {
+    const cp = str.codePointAt(i2) ?? 0;
+    cps.push(cp);
+    i2 += cp > 65535 ? 2 : 1;
+  }
+  let i = 0;
+  while (i < cps.length) {
+    const cp = cps[i];
+    const type = teluguCharType(cp);
+    if (classifyUseCategory(cp) === "ZWJ" || classifyUseCategory(cp) === "ZWNJ") {
+      i++;
+      continue;
+    }
+    if (type < 0 || cp < TELUGU_START || cp > TELUGU_END) {
+      clusters.push({ codepoints: [cp], baseIndex: 0 });
+      i++;
+      continue;
+    }
+    const syllable = [];
+    let lastConsonantIdx = -1;
+    while (i < cps.length) {
+      const cc = cps[i];
+      const ct = teluguCharType(cc);
+      if (ct === 0) {
+        lastConsonantIdx = syllable.length;
+        syllable.push(cc);
+        i++;
+        if (i < cps.length && cps[i] === VIRAMA) {
+          let j = i + 1;
+          let zwnj = false;
+          if (j < cps.length) {
+            const jc = classifyUseCategory(cps[j]);
+            if (jc === "ZWJ") {
+              j++;
+            } else if (jc === "ZWNJ") {
+              j++;
+              zwnj = true;
+            }
+          }
+          if (!zwnj && j < cps.length && isConsonant3(cps[j])) {
+            syllable.push(cps[i]);
+            i = j;
+            continue;
+          } else {
+            syllable.push(cps[i]);
+            i = j;
+            break;
+          }
+        }
+        break;
+      } else {
+        break;
+      }
+    }
+    const baseIdx = lastConsonantIdx >= 0 ? lastConsonantIdx : 0;
+    while (i < cps.length) {
+      const ct = teluguCharType(cps[i]);
+      if (ct >= 2 && ct <= 5) {
+        syllable.push(cps[i]);
+        i++;
+      } else {
+        break;
+      }
+    }
+    while (i < cps.length && teluguCharType(cps[i]) === 6) {
+      syllable.push(cps[i]);
+      i++;
+    }
+    if (syllable.length === 0) {
+      syllable.push(cps[i] ?? 32);
+      i++;
+    }
+    clusters.push({ codepoints: syllable, baseIndex: baseIdx });
+  }
+  return clusters;
+}
+function shapeTeluguText(str, fontData) {
+  const { cmap, ligatures, markAnchors, widths, defaultWidth } = fontData;
+  const shaped = [];
+  function resolveGid(cp) {
+    const normCp = cp === 8239 || cp === 160 ? 32 : cp;
+    return cmap[normCp] || 0;
+  }
+  function tryLig(gids) {
+    return tryLigature(gids, ligatures);
+  }
+  function getAdv(gid) {
+    return widths[gid] !== void 0 ? widths[gid] : defaultWidth;
+  }
+  function getBaseAnchor2(baseGid, markClass) {
+    const base = markAnchors && markAnchors.bases && markAnchors.bases[baseGid];
+    if (!base) return null;
+    return base[markClass] ?? null;
+  }
+  function getMarkAnchor2(markGid) {
+    const mark = markAnchors && markAnchors.marks && markAnchors.marks[markGid];
+    if (!mark) return null;
+    return { classIdx: mark[0], x: mark[1], y: mark[2] };
+  }
+  function emitGlyph(gid, isZero, baseGid) {
+    if (isZero && baseGid !== void 0) {
+      const markAnchor = getMarkAnchor2(gid);
+      if (markAnchor) {
+        const baseAnchorPt = getBaseAnchor2(baseGid, markAnchor.classIdx);
+        if (baseAnchorPt) {
+          const baseAdv = getAdv(baseGid);
+          shaped.push({
+            gid,
+            dx: baseAnchorPt[0] - markAnchor.x - baseAdv,
+            dy: baseAnchorPt[1] - markAnchor.y,
+            isZeroAdvance: true
+          });
+          return;
+        }
+      }
+      shaped.push({ gid, dx: 0, dy: 0, isZeroAdvance: true });
+    } else {
+      shaped.push({ gid, dx: 0, dy: 0, isZeroAdvance: false });
+    }
+  }
+  const clusters = buildTeluguClusters(str);
+  for (const cluster of clusters) {
+    const { codepoints } = cluster;
+    let baseGid = 0;
+    for (let ci = 0; ci < codepoints.length; ci++) {
+      const ct = teluguCharType(codepoints[ci]);
+      if (ct === 0) {
+        baseGid = resolveGid(codepoints[ci]);
+      } else if (ct >= 2) {
+        break;
+      }
+    }
+    const clusterGids = [];
+    const clusterEndIdx = [];
+    let matraStart = codepoints.length;
+    for (let ci = 0; ci < codepoints.length; ci++) {
+      const ct = teluguCharType(codepoints[ci]);
+      if (ct === 0 || ct === 7) {
+        clusterGids.push(resolveGid(codepoints[ci]));
+        clusterEndIdx.push(ci);
+      } else if (ct >= 2) {
+        matraStart = ci;
+        break;
+      } else if (ct < 0 || ct === 1 || ct === 9) {
+        emitGlyph(resolveGid(codepoints[ci]), false);
+      }
+    }
+    const ligResult = tryLig(clusterGids);
+    if (ligResult) {
+      emitGlyph(ligResult.resultGid, false);
+      baseGid = ligResult.resultGid;
+      let gi = ligResult.consumed;
+      while (gi < clusterGids.length) {
+        const subSeq = clusterGids.slice(gi);
+        const subLig = tryLig(subSeq);
+        if (subLig) {
+          emitGlyph(subLig.resultGid, false);
+          gi += subLig.consumed;
+        } else {
+          const origCi = clusterEndIdx[gi];
+          const ct = teluguCharType(codepoints[origCi]);
+          if (ct === 7) {
+            emitGlyph(clusterGids[gi], true, baseGid);
+          } else {
+            emitGlyph(clusterGids[gi], false);
+          }
+          gi++;
+        }
+      }
+    } else {
+      for (let ci = 0; ci < matraStart; ci++) {
+        const cp = codepoints[ci];
+        const ct = teluguCharType(cp);
+        if (ct === 0) {
+          emitGlyph(resolveGid(cp), false);
+        } else if (ct === 7) {
+          emitGlyph(resolveGid(cp), true, baseGid);
+        }
+      }
+    }
+    for (let ci = matraStart; ci < codepoints.length; ci++) {
+      const cp = codepoints[ci];
+      const ct = teluguCharType(cp);
+      if (ct === 2 || ct === 3) {
+        emitGlyph(resolveGid(cp), true, baseGid);
+      } else if (ct === 5) {
+        emitGlyph(resolveGid(cp), false);
+      } else if (ct === 6) {
+        emitGlyph(resolveGid(cp), true, baseGid);
+      } else if (ct === 9) {
+        emitGlyph(resolveGid(cp), false);
+      } else {
+        emitGlyph(resolveGid(cp), false);
+      }
+    }
+  }
+  return shaped;
+}
+
+// src/shaping/sinhala-shaper.ts
+var VIRAMA2 = SINHALA_VIRAMA;
+var TWO_PART_VOWELS = {
+  3546: [3545, 3530],
+  // ේ  (ee)
+  3548: [3545, 3535],
+  // ො  (o)
+  3549: [3545, 3535, 3530],
+  // ෝ  (oo)
+  3550: [3545, 3551]
+  // ෞ  (au)
+};
+function sinhalaCharType(cp) {
+  if (cp === VIRAMA2) return 7;
+  if (cp >= 3458 && cp <= 3460) return 6;
+  if (cp >= 3461 && cp <= 3478) return 1;
+  if (cp >= 3482 && cp <= 3526) return 0;
+  if (cp === 3535) return 5;
+  if (cp === 3536 || cp === 3537) return 5;
+  if (cp === 3538 || cp === 3539) return 2;
+  if (cp === 3540 || cp === 3542) return 3;
+  if (cp === 3544) return 5;
+  if (cp === 3545 || cp === 3547) return 4;
+  if (cp === 3551) return 5;
+  if (cp === 3570 || cp === 3571) return 5;
+  if (cp >= 3558 && cp <= 3567) return 9;
+  return -1;
+}
+function isConsonant4(cp) {
+  return sinhalaCharType(cp) === 0;
+}
+function buildSinhalaClusters(str) {
+  const clusters = [];
+  const cps = [];
+  for (let i2 = 0; i2 < str.length; ) {
+    const cp = str.codePointAt(i2) ?? 0;
+    const decomp = TWO_PART_VOWELS[cp];
+    if (decomp) {
+      for (const d of decomp) cps.push(d);
+    } else {
+      cps.push(cp);
+    }
+    i2 += cp > 65535 ? 2 : 1;
+  }
+  let i = 0;
+  while (i < cps.length) {
+    const cp = cps[i];
+    const type = sinhalaCharType(cp);
+    if (classifyUseCategory(cp) === "ZWNJ") {
+      i++;
+      continue;
+    }
+    if (type < 0 || cp < SINHALA_START || cp > SINHALA_END) {
+      clusters.push({ codepoints: [cp], baseIndex: 0 });
+      i++;
+      continue;
+    }
+    const syllable = [];
+    let lastConsonantIdx = -1;
+    while (i < cps.length) {
+      const cc = cps[i];
+      const ct = sinhalaCharType(cc);
+      if (ct === 0) {
+        lastConsonantIdx = syllable.length;
+        syllable.push(cc);
+        i++;
+        if (i < cps.length && cps[i] === VIRAMA2) {
+          let j = i + 1;
+          let zwnj = false;
+          let zwj = false;
+          if (j < cps.length) {
+            const jc = classifyUseCategory(cps[j]);
+            if (jc === "ZWJ") {
+              j++;
+              zwj = true;
+            } else if (jc === "ZWNJ") {
+              j++;
+              zwnj = true;
+            }
+          }
+          if (!zwnj && j < cps.length && isConsonant4(cps[j])) {
+            syllable.push(cps[i]);
+            if (zwj) syllable.push(8205);
+            i = j;
+            continue;
+          } else {
+            syllable.push(cps[i]);
+            i = j;
+            break;
+          }
+        }
+        break;
+      } else {
+        break;
+      }
+    }
+    const baseIdx = lastConsonantIdx >= 0 ? lastConsonantIdx : 0;
+    while (i < cps.length) {
+      const ct = sinhalaCharType(cps[i]);
+      if (ct >= 2 && ct <= 5) {
+        syllable.push(cps[i]);
+        i++;
+      } else {
+        break;
+      }
+    }
+    while (i < cps.length && sinhalaCharType(cps[i]) === 6) {
+      syllable.push(cps[i]);
+      i++;
+    }
+    if (syllable.length === 0) {
+      syllable.push(cps[i] ?? 32);
+      i++;
+    }
+    clusters.push({ codepoints: syllable, baseIndex: baseIdx });
+  }
+  return clusters;
+}
+function shapeSinhalaText(str, fontData) {
+  const { cmap, ligatures, markAnchors, widths, defaultWidth } = fontData;
+  const shaped = [];
+  function resolveGid(cp) {
+    const normCp = cp === 8239 || cp === 160 ? 32 : cp;
+    return cmap[normCp] || 0;
+  }
+  function tryLig(gids) {
+    return tryLigature(gids, ligatures);
+  }
+  function getAdv(gid) {
+    return widths[gid] !== void 0 ? widths[gid] : defaultWidth;
+  }
+  function getBaseAnchor2(baseGid, markClass) {
+    const base = markAnchors && markAnchors.bases && markAnchors.bases[baseGid];
+    if (!base) return null;
+    return base[markClass] ?? null;
+  }
+  function getMarkAnchor2(markGid) {
+    const mark = markAnchors && markAnchors.marks && markAnchors.marks[markGid];
+    if (!mark) return null;
+    return { classIdx: mark[0], x: mark[1], y: mark[2] };
+  }
+  function emitGlyph(gid, isZero, baseGid) {
+    if (isZero && baseGid !== void 0) {
+      const markAnchor = getMarkAnchor2(gid);
+      if (markAnchor) {
+        const baseAnchorPt = getBaseAnchor2(baseGid, markAnchor.classIdx);
+        if (baseAnchorPt) {
+          const baseAdv = getAdv(baseGid);
+          shaped.push({
+            gid,
+            dx: baseAnchorPt[0] - markAnchor.x - baseAdv,
+            dy: baseAnchorPt[1] - markAnchor.y,
+            isZeroAdvance: true
+          });
+          return;
+        }
+      }
+      shaped.push({ gid, dx: 0, dy: 0, isZeroAdvance: true });
+    } else {
+      shaped.push({ gid, dx: 0, dy: 0, isZeroAdvance: false });
+    }
+  }
+  const clusters = buildSinhalaClusters(str);
+  for (const cluster of clusters) {
+    const { codepoints } = cluster;
+    let baseGid = 0;
+    for (let ci = 0; ci < codepoints.length; ci++) {
+      const ct = sinhalaCharType(codepoints[ci]);
+      if (ct === 0) {
+        baseGid = resolveGid(codepoints[ci]);
+      } else if (ct >= 2 && ct !== 7) {
+        break;
+      }
+    }
+    for (let ci = 0; ci < codepoints.length; ci++) {
+      if (sinhalaCharType(codepoints[ci]) === 4) {
+        emitGlyph(resolveGid(codepoints[ci]), false);
+      }
+    }
+    const clusterGids = [];
+    const clusterEndIdx = [];
+    let matraStart = codepoints.length;
+    for (let ci = 0; ci < codepoints.length; ci++) {
+      const cp = codepoints[ci];
+      const ct = sinhalaCharType(cp);
+      if (ct === 0 || ct === 7 || cp === 8205) {
+        clusterGids.push(resolveGid(cp));
+        clusterEndIdx.push(ci);
+      } else if (ct >= 2 && ct <= 6) {
+        matraStart = ci;
+        break;
+      } else if (ct < 0 || ct === 1 || ct === 9) {
+        emitGlyph(resolveGid(cp), false);
+      }
+    }
+    const ligResult = tryLig(clusterGids);
+    if (ligResult) {
+      emitGlyph(ligResult.resultGid, false);
+      baseGid = ligResult.resultGid;
+      let gi = ligResult.consumed;
+      while (gi < clusterGids.length) {
+        const subSeq = clusterGids.slice(gi);
+        const subLig = tryLig(subSeq);
+        if (subLig) {
+          emitGlyph(subLig.resultGid, false);
+          gi += subLig.consumed;
+        } else {
+          const origCi = clusterEndIdx[gi];
+          const ct = sinhalaCharType(codepoints[origCi]);
+          if (ct === 7) emitGlyph(clusterGids[gi], true, baseGid);
+          else emitGlyph(clusterGids[gi], false);
+          gi++;
+        }
+      }
+    } else {
+      for (let ci = 0; ci < matraStart; ci++) {
+        const cp = codepoints[ci];
+        const ct = sinhalaCharType(cp);
+        if (ct === 0) emitGlyph(resolveGid(cp), false);
+        else if (ct === 7) emitGlyph(resolveGid(cp), true, baseGid);
+        else ;
+      }
+    }
+    for (let ci = matraStart; ci < codepoints.length; ci++) {
+      const cp = codepoints[ci];
+      const ct = sinhalaCharType(cp);
+      if (ct === 2 || ct === 3 || ct === 6) emitGlyph(resolveGid(cp), true, baseGid);
+      else if (ct === 5) emitGlyph(resolveGid(cp), false);
+      else if (ct === 4) ; else emitGlyph(resolveGid(cp), false);
+    }
+  }
+  return shaped;
+}
+
+// src/shaping/tibetan-shaper.ts
+function tibetanCharType(cp) {
+  if (cp >= 3984 && cp <= 4028) return 8;
+  if (cp === 3972) return 6;
+  if (cp >= 3904 && cp <= 3948) return 0;
+  if (cp === 3954 || cp === 3962 || cp === 3963 || cp === 3964 || cp === 3965 || cp === 3968 || cp === 3969 || cp === 3971 || cp === 3970 || cp === 3966) return 2;
+  if (cp === 3953 || cp === 3956 || cp === 3955 || cp === 3957 || cp === 3864 || cp === 3865 || cp === 3893 || cp === 3895 || cp === 3897) return 3;
+  if (cp === 3967) return 5;
+  if (cp === 3840 || cp >= 3976 && cp <= 3980) return 1;
+  if (cp >= 3872 && cp <= 3891) return 9;
+  if (cp >= 3841 && cp <= 3863) return 9;
+  if (cp >= 3898 && cp <= 3903) return 9;
+  if (cp >= 4030 && cp <= 4047) return 9;
+  if (cp === 3892 || cp === 3894 || cp === 3896) return 9;
+  if (cp === 3973) return 9;
+  return -1;
+}
+function buildTibetanStacks(str) {
+  const stacks = [];
+  const cps = [];
+  for (let i2 = 0; i2 < str.length; ) {
+    const cp = str.codePointAt(i2) ?? 0;
+    cps.push(cp);
+    i2 += cp > 65535 ? 2 : 1;
+  }
+  let i = 0;
+  while (i < cps.length) {
+    const cp = cps[i];
+    const type = tibetanCharType(cp);
+    if (type < 0 || cp < TIBETAN_START || cp > TIBETAN_END) {
+      stacks.push({ codepoints: [cp] });
+      i++;
+      continue;
+    }
+    if (type !== 0 && type !== 1) {
+      stacks.push({ codepoints: [cp] });
+      i++;
+      continue;
+    }
+    const stack = [cp];
+    i++;
+    while (i < cps.length && tibetanCharType(cps[i]) === 8) {
+      stack.push(cps[i]);
+      i++;
+    }
+    while (i < cps.length) {
+      const ct = tibetanCharType(cps[i]);
+      if (ct === 2 || ct === 3 || ct === 5 || ct === 6) {
+        stack.push(cps[i]);
+        i++;
+      } else {
+        break;
+      }
+    }
+    stacks.push({ codepoints: stack });
+  }
+  return stacks;
+}
+function shapeTibetanText(str, fontData) {
+  const { cmap, ligatures, markAnchors, widths, defaultWidth } = fontData;
+  const shaped = [];
+  function resolveGid(cp) {
+    const normCp = cp === 8239 || cp === 160 ? 32 : cp;
+    return cmap[normCp] || 0;
+  }
+  function tryLig(gids) {
+    return tryLigature(gids, ligatures);
+  }
+  function getAdv(gid) {
+    return widths[gid] !== void 0 ? widths[gid] : defaultWidth;
+  }
+  function getBaseAnchor2(baseGid, markClass) {
+    const base = markAnchors && markAnchors.bases && markAnchors.bases[baseGid];
+    if (!base) return null;
+    return base[markClass] ?? null;
+  }
+  function getMarkAnchor2(markGid) {
+    const mark = markAnchors && markAnchors.marks && markAnchors.marks[markGid];
+    if (!mark) return null;
+    return { classIdx: mark[0], x: mark[1], y: mark[2] };
+  }
+  function emitGlyph(gid, isZero, baseGid) {
+    if (isZero && baseGid !== void 0) {
+      const markAnchor = getMarkAnchor2(gid);
+      if (markAnchor) {
+        const baseAnchorPt = getBaseAnchor2(baseGid, markAnchor.classIdx);
+        if (baseAnchorPt) {
+          const baseAdv = getAdv(baseGid);
+          shaped.push({
+            gid,
+            dx: baseAnchorPt[0] - markAnchor.x - baseAdv,
+            dy: baseAnchorPt[1] - markAnchor.y,
+            isZeroAdvance: true
+          });
+          return;
+        }
+      }
+      shaped.push({ gid, dx: 0, dy: 0, isZeroAdvance: true });
+    } else {
+      shaped.push({ gid, dx: 0, dy: 0, isZeroAdvance: false });
+    }
+  }
+  const stacks = buildTibetanStacks(str);
+  for (const stack of stacks) {
+    const { codepoints } = stack;
+    const stackGids = [];
+    const stackEndIdx = [];
+    let markStart = codepoints.length;
+    for (let ci = 0; ci < codepoints.length; ci++) {
+      const ct = tibetanCharType(codepoints[ci]);
+      if (ct === 0 || ct === 8 || ct === 1 || ct === 6) {
+        stackGids.push(resolveGid(codepoints[ci]));
+        stackEndIdx.push(ci);
+      } else if (ct === 2 || ct === 3 || ct === 5) {
+        markStart = ci;
+        break;
+      } else if (ct < 0 || ct === 9) {
+        emitGlyph(resolveGid(codepoints[ci]), false);
+      }
+    }
+    let baseGid = stackGids.length > 0 ? stackGids[0] : 0;
+    const ligResult = tryLig(stackGids);
+    if (ligResult) {
+      emitGlyph(ligResult.resultGid, false);
+      baseGid = ligResult.resultGid;
+      let gi = ligResult.consumed;
+      while (gi < stackGids.length) {
+        const subSeq = stackGids.slice(gi);
+        const subLig = tryLig(subSeq);
+        if (subLig) {
+          emitGlyph(subLig.resultGid, false);
+          gi += subLig.consumed;
+        } else {
+          const origCi = stackEndIdx[gi];
+          const ct = tibetanCharType(codepoints[origCi]);
+          if (ct === 8 || ct === 6) emitGlyph(stackGids[gi], true, baseGid);
+          else emitGlyph(stackGids[gi], false);
+          gi++;
+        }
+      }
+    } else {
+      for (let gi = 0; gi < stackGids.length; gi++) {
+        const origCi = stackEndIdx[gi];
+        const ct = tibetanCharType(codepoints[origCi]);
+        if (gi === 0) emitGlyph(stackGids[gi], false);
+        else if (ct === 8 || ct === 6) emitGlyph(stackGids[gi], true, baseGid);
+        else emitGlyph(stackGids[gi], false);
+      }
+    }
+    for (let ci = markStart; ci < codepoints.length; ci++) {
+      const cp = codepoints[ci];
+      const ct = tibetanCharType(cp);
+      if (ct === 2 || ct === 3) emitGlyph(resolveGid(cp), true, baseGid);
+      else if (ct === 5) emitGlyph(resolveGid(cp), false);
+      else emitGlyph(resolveGid(cp), false);
+    }
+  }
+  return shaped;
+}
+
+// src/shaping/khmer-shaper.ts
+var COENG = KHMER_COENG;
+var TWO_PART_VOWELS2 = {
+  6078: [6081, 6070],
+  // ើ
+  6079: [6081, 6072],
+  // ឿ  (approx: e + y-like)
+  6080: [6081, 6073],
+  // ៀ  (approx)
+  6084: [6081, 6070],
+  // ោ  (e + aa)
+  6085: [6081, 6070]
+  // ៅ  (e + aa-like)
+};
+function khmerCharType(cp) {
+  if (cp === COENG) return 7;
+  if (cp >= 6016 && cp <= 6050) return 0;
+  if (cp >= 6051 && cp <= 6069) return 1;
+  if (cp === 6081 || cp === 6082 || cp === 6083) return 4;
+  if (cp === 6071 || cp === 6072 || cp === 6073 || cp === 6074 || cp === 6075 || cp === 6077) return 2;
+  if (cp === 6076) return 3;
+  if (cp === 6070 || cp === 6084 || cp === 6085) return 5;
+  if (cp >= 6086 && cp <= 6097) return 6;
+  if (cp === 6091 || cp === 6093 || cp === 6094 || cp === 6095 || cp === 6096) return 6;
+  if (cp === 6109) return 6;
+  if (cp >= 6112 && cp <= 6121) return 9;
+  if (cp >= 6100 && cp <= 6108) return 9;
+  if (cp >= 6128 && cp <= 6137) return 9;
+  return -1;
+}
+function isConsonant5(cp) {
+  return khmerCharType(cp) === 0;
+}
+function buildKhmerClusters(str) {
+  const clusters = [];
+  const cps = [];
+  for (let i2 = 0; i2 < str.length; ) {
+    const cp = str.codePointAt(i2) ?? 0;
+    const decomp = TWO_PART_VOWELS2[cp];
+    if (decomp) {
+      for (const d of decomp) cps.push(d);
+    } else cps.push(cp);
+    i2 += cp > 65535 ? 2 : 1;
+  }
+  let i = 0;
+  while (i < cps.length) {
+    const cp = cps[i];
+    const type = khmerCharType(cp);
+    if (type < 0 || cp < KHMER_START || cp > KHMER_END) {
+      clusters.push({ codepoints: [cp] });
+      i++;
+      continue;
+    }
+    if (type !== 0 && type !== 1) {
+      clusters.push({ codepoints: [cp] });
+      i++;
+      continue;
+    }
+    const cluster = [cp];
+    i++;
+    while (i < cps.length && cps[i] === COENG) {
+      if (i + 1 < cps.length && isConsonant5(cps[i + 1])) {
+        cluster.push(cps[i]);
+        cluster.push(cps[i + 1]);
+        i += 2;
+      } else {
+        cluster.push(cps[i]);
+        i++;
+        break;
+      }
+    }
+    while (i < cps.length) {
+      const ct = khmerCharType(cps[i]);
+      if (ct >= 2 && ct <= 6) {
+        cluster.push(cps[i]);
+        i++;
+      } else break;
+    }
+    clusters.push({ codepoints: cluster });
+  }
+  return clusters;
+}
+function shapeKhmerText(str, fontData) {
+  const { cmap, ligatures, markAnchors, widths, defaultWidth } = fontData;
+  const shaped = [];
+  function resolveGid(cp) {
+    const normCp = cp === 8239 || cp === 160 ? 32 : cp;
+    return cmap[normCp] || 0;
+  }
+  function tryLig(gids) {
+    return tryLigature(gids, ligatures);
+  }
+  function getAdv(gid) {
+    return widths[gid] !== void 0 ? widths[gid] : defaultWidth;
+  }
+  function getBaseAnchor2(baseGid, markClass) {
+    const base = markAnchors && markAnchors.bases && markAnchors.bases[baseGid];
+    if (!base) return null;
+    return base[markClass] ?? null;
+  }
+  function getMarkAnchor2(markGid) {
+    const mark = markAnchors && markAnchors.marks && markAnchors.marks[markGid];
+    if (!mark) return null;
+    return { classIdx: mark[0], x: mark[1], y: mark[2] };
+  }
+  function emitGlyph(gid, isZero, baseGid) {
+    if (isZero && baseGid !== void 0) {
+      const markAnchor = getMarkAnchor2(gid);
+      if (markAnchor) {
+        const baseAnchorPt = getBaseAnchor2(baseGid, markAnchor.classIdx);
+        if (baseAnchorPt) {
+          const baseAdv = getAdv(baseGid);
+          shaped.push({
+            gid,
+            dx: baseAnchorPt[0] - markAnchor.x - baseAdv,
+            dy: baseAnchorPt[1] - markAnchor.y,
+            isZeroAdvance: true
+          });
+          return;
+        }
+      }
+      shaped.push({ gid, dx: 0, dy: 0, isZeroAdvance: true });
+    } else {
+      shaped.push({ gid, dx: 0, dy: 0, isZeroAdvance: false });
+    }
+  }
+  const clusters = buildKhmerClusters(str);
+  for (const cluster of clusters) {
+    const { codepoints } = cluster;
+    let baseGid = 0;
+    for (let ci = 0; ci < codepoints.length; ci++) {
+      const ct = khmerCharType(codepoints[ci]);
+      if (ct === 0 || ct === 1) {
+        baseGid = resolveGid(codepoints[ci]);
+        break;
+      }
+    }
+    for (let ci = 0; ci < codepoints.length; ci++) {
+      if (khmerCharType(codepoints[ci]) === 4) emitGlyph(resolveGid(codepoints[ci]), false);
+    }
+    const stackGids = [];
+    const stackEndIdx = [];
+    let markStart = codepoints.length;
+    for (let ci = 0; ci < codepoints.length; ci++) {
+      const cp = codepoints[ci];
+      const ct = khmerCharType(cp);
+      if (ct === 0 || ct === 1 || ct === 7) {
+        stackGids.push(resolveGid(cp));
+        stackEndIdx.push(ci);
+      } else if (ct >= 2 && ct <= 6) {
+        markStart = ci;
+        break;
+      } else {
+        emitGlyph(resolveGid(cp), false);
+      }
+    }
+    const ligResult = tryLig(stackGids);
+    if (ligResult) {
+      emitGlyph(ligResult.resultGid, false);
+      baseGid = ligResult.resultGid;
+      let gi = ligResult.consumed;
+      while (gi < stackGids.length) {
+        const subLig = tryLig(stackGids.slice(gi));
+        if (subLig) {
+          emitGlyph(subLig.resultGid, false);
+          gi += subLig.consumed;
+        } else {
+          const origCi = stackEndIdx[gi];
+          const ct = khmerCharType(codepoints[origCi]);
+          if (ct === 7) emitGlyph(stackGids[gi], true, baseGid);
+          else emitGlyph(stackGids[gi], false);
+          gi++;
+        }
+      }
+    } else {
+      for (let gi = 0; gi < stackGids.length; gi++) {
+        const origCi = stackEndIdx[gi];
+        const ct = khmerCharType(codepoints[origCi]);
+        if (gi === 0) emitGlyph(stackGids[gi], false);
+        else if (ct === 7) emitGlyph(stackGids[gi], true, baseGid);
+        else emitGlyph(stackGids[gi], true, baseGid);
+      }
+    }
+    for (let ci = markStart; ci < codepoints.length; ci++) {
+      const cp = codepoints[ci];
+      const ct = khmerCharType(cp);
+      if (ct === 2 || ct === 3 || ct === 6) emitGlyph(resolveGid(cp), true, baseGid);
+      else if (ct === 5) emitGlyph(resolveGid(cp), false);
+      else if (ct === 4) ; else emitGlyph(resolveGid(cp), false);
+    }
+  }
+  return shaped;
+}
+
+// src/shaping/myanmar-shaper.ts
+var VIRAMA3 = MYANMAR_VIRAMA;
+var MEDIAL_RA = 4156;
+function myanmarCharType(cp) {
+  if (cp === VIRAMA3) return 7;
+  if (cp === MEDIAL_RA) return 4;
+  if (cp === 4155 || cp === 4157 || cp === 4158) return 8;
+  if (cp >= 4096 && cp <= 4138) return 0;
+  if (cp === 4159) return 0;
+  if (cp >= 4176 && cp <= 4181) return 0;
+  if (cp === 4141 || cp === 4142 || cp === 4146 || cp === 4150 || cp === 4147 || cp === 4148 || cp === 4149) return 2;
+  if (cp === 4143 || cp === 4144 || cp === 4151) return 3;
+  if (cp === 4139 || cp === 4140) return 5;
+  if (cp === 4145) return 4;
+  if (cp === 4154) return 6;
+  if (cp === 4152) return 5;
+  if (cp >= 4160 && cp <= 4169) return 9;
+  if (cp >= 4240 && cp <= 4249) return 9;
+  if (cp === 4170 || cp === 4171) return 9;
+  if (cp >= 4172 && cp <= 4175) return 9;
+  return -1;
+}
+function isConsonant6(cp) {
+  return myanmarCharType(cp) === 0;
+}
+function buildMyanmarClusters(str) {
+  const clusters = [];
+  const cps = [];
+  for (let i2 = 0; i2 < str.length; ) {
+    const cp = str.codePointAt(i2) ?? 0;
+    cps.push(cp);
+    i2 += cp > 65535 ? 2 : 1;
+  }
+  let i = 0;
+  while (i < cps.length) {
+    const cp = cps[i];
+    const type = myanmarCharType(cp);
+    if (type < 0 || cp < MYANMAR_START || cp > MYANMAR_END) {
+      clusters.push({ codepoints: [cp] });
+      i++;
+      continue;
+    }
+    if (type !== 0) {
+      clusters.push({ codepoints: [cp] });
+      i++;
+      continue;
+    }
+    const cluster = [cp];
+    i++;
+    while (i < cps.length && cps[i] === VIRAMA3) {
+      if (i + 1 < cps.length && isConsonant6(cps[i + 1])) {
+        cluster.push(cps[i]);
+        cluster.push(cps[i + 1]);
+        i += 2;
+      } else {
+        cluster.push(cps[i]);
+        i++;
+        break;
+      }
+    }
+    while (i < cps.length && myanmarCharType(cps[i]) === 8) {
+      cluster.push(cps[i]);
+      i++;
+    }
+    while (i < cps.length) {
+      const ct = myanmarCharType(cps[i]);
+      if (ct >= 2 && ct <= 6) {
+        cluster.push(cps[i]);
+        i++;
+      } else break;
+    }
+    clusters.push({ codepoints: cluster });
+  }
+  return clusters;
+}
+function shapeMyanmarText(str, fontData) {
+  const { cmap, ligatures, markAnchors, widths, defaultWidth } = fontData;
+  const shaped = [];
+  function resolveGid(cp) {
+    const normCp = cp === 8239 || cp === 160 ? 32 : cp;
+    return cmap[normCp] || 0;
+  }
+  function tryLig(gids) {
+    return tryLigature(gids, ligatures);
+  }
+  function getAdv(gid) {
+    return widths[gid] !== void 0 ? widths[gid] : defaultWidth;
+  }
+  function getBaseAnchor2(baseGid, markClass) {
+    const base = markAnchors && markAnchors.bases && markAnchors.bases[baseGid];
+    if (!base) return null;
+    return base[markClass] ?? null;
+  }
+  function getMarkAnchor2(markGid) {
+    const mark = markAnchors && markAnchors.marks && markAnchors.marks[markGid];
+    if (!mark) return null;
+    return { classIdx: mark[0], x: mark[1], y: mark[2] };
+  }
+  function emitGlyph(gid, isZero, baseGid) {
+    if (isZero && baseGid !== void 0) {
+      const markAnchor = getMarkAnchor2(gid);
+      if (markAnchor) {
+        const baseAnchorPt = getBaseAnchor2(baseGid, markAnchor.classIdx);
+        if (baseAnchorPt) {
+          const baseAdv = getAdv(baseGid);
+          shaped.push({
+            gid,
+            dx: baseAnchorPt[0] - markAnchor.x - baseAdv,
+            dy: baseAnchorPt[1] - markAnchor.y,
+            isZeroAdvance: true
+          });
+          return;
+        }
+      }
+      shaped.push({ gid, dx: 0, dy: 0, isZeroAdvance: true });
+    } else {
+      shaped.push({ gid, dx: 0, dy: 0, isZeroAdvance: false });
+    }
+  }
+  const clusters = buildMyanmarClusters(str);
+  for (const cluster of clusters) {
+    const { codepoints } = cluster;
+    let baseGid = 0;
     for (let ci = 0; ci < codepoints.length; ci++) {
-      const ct = tamilCharType(codepoints[ci]);
-      if (ct === 0 || ct === 7) {
-        clusterGids.push(resolveGid(codepoints[ci]));
-        clusterEndIdx.push(ci);
-      } else if (ct >= 2) {
-        matraStart = ci;
+      if (myanmarCharType(codepoints[ci]) === 0) {
+        baseGid = resolveGid(codepoints[ci]);
         break;
-      } else if (ct < 0) {
-        emitGlyph(resolveGid(codepoints[ci]), false);
-      } else if (ct === 1) {
-        emitGlyph(resolveGid(codepoints[ci]), false);
       }
     }
-    let ligConsumed = 0;
-    const ligResult = tryLig(clusterGids);
+    for (let ci = 0; ci < codepoints.length; ci++) {
+      if (myanmarCharType(codepoints[ci]) === 4) emitGlyph(resolveGid(codepoints[ci]), false);
+    }
+    const stackGids = [];
+    const stackEndIdx = [];
+    let markStart = codepoints.length;
+    for (let ci = 0; ci < codepoints.length; ci++) {
+      const cp = codepoints[ci];
+      const ct = myanmarCharType(cp);
+      if (ct === 0 || ct === 7 || ct === 8) {
+        stackGids.push(resolveGid(cp));
+        stackEndIdx.push(ci);
+      } else if (ct === 2 || ct === 3 || ct === 5 || ct === 6) {
+        markStart = ci;
+        break;
+      } else if (ct === 4) ; else {
+        emitGlyph(resolveGid(cp), false);
+      }
+    }
+    const ligResult = tryLig(stackGids);
     if (ligResult) {
       emitGlyph(ligResult.resultGid, false);
       baseGid = ligResult.resultGid;
-      ligConsumed = ligResult.consumed;
-      let gi = ligConsumed;
-      while (gi < clusterGids.length) {
-        const subSeq = clusterGids.slice(gi);
-        const subLig = tryLig(subSeq);
+      let gi = ligResult.consumed;
+      while (gi < stackGids.length) {
+        const subLig = tryLig(stackGids.slice(gi));
         if (subLig) {
           emitGlyph(subLig.resultGid, false);
           gi += subLig.consumed;
         } else {
-          const origCi = clusterEndIdx[gi];
-          const ct = tamilCharType(codepoints[origCi]);
-          if (ct === 7) {
-            emitGlyph(clusterGids[gi], true, baseGid);
-          } else {
-            emitGlyph(clusterGids[gi], false);
-          }
+          const origCi = stackEndIdx[gi];
+          const ct = myanmarCharType(codepoints[origCi]);
+          if (ct === 7 || ct === 8) emitGlyph(stackGids[gi], true, baseGid);
+          else emitGlyph(stackGids[gi], false);
           gi++;
         }
       }
     } else {
-      for (let ci = 0; ci < matraStart; ci++) {
-        const cp = codepoints[ci];
-        const ct = tamilCharType(cp);
-        if (ct === 0) {
-          emitGlyph(resolveGid(cp), false);
-        } else if (ct === 7) {
-          emitGlyph(resolveGid(cp), true, baseGid);
-        }
+      for (let gi = 0; gi < stackGids.length; gi++) {
+        const origCi = stackEndIdx[gi];
+        const ct = myanmarCharType(codepoints[origCi]);
+        if (gi === 0) emitGlyph(stackGids[gi], false);
+        else if (ct === 7 || ct === 8) emitGlyph(stackGids[gi], true, baseGid);
+        else emitGlyph(stackGids[gi], false);
       }
     }
-    for (let ci = matraStart; ci < codepoints.length; ci++) {
+    for (let ci = markStart; ci < codepoints.length; ci++) {
       const cp = codepoints[ci];
-      const ct = tamilCharType(cp);
-      if (ct === 4) continue;
-      if (ct === 2 || ct === 3) {
-        emitGlyph(resolveGid(cp), true, baseGid);
-      } else if (ct === 5) {
-        emitGlyph(resolveGid(cp), false);
-      } else if (ct === 6) {
-        emitGlyph(resolveGid(cp), true, baseGid);
-      } else if (ct === 9) {
-        emitGlyph(resolveGid(cp), false);
-      } else {
-        emitGlyph(resolveGid(cp), false);
-      }
-    }
-    for (const postCp of splitPostComponents) {
-      emitGlyph(resolveGid(postCp), false);
+      const ct = myanmarCharType(cp);
+      if (ct === 2 || ct === 3 || ct === 6) emitGlyph(resolveGid(cp), true, baseGid);
+      else if (ct === 5) emitGlyph(resolveGid(cp), false);
+      else if (ct === 4) ; else emitGlyph(resolveGid(cp), false);
     }
   }
   return shaped;
@@ -1522,7 +2867,7 @@ function devanagariCharType(cp) {
   if (cp === 2384) return 1;
   return -1;
 }
-function isConsonant3(cp) {
+function isConsonant7(cp) {
   return devanagariCharType(cp) === 0;
 }
 function buildDevanagariClusters(str) {
@@ -1537,6 +2882,10 @@ function buildDevanagariClusters(str) {
   while (i < cps.length) {
     const cp = cps[i];
     const type = devanagariCharType(cp);
+    if (classifyUseCategory(cp) === "ZWJ" || classifyUseCategory(cp) === "ZWNJ") {
+      i++;
+      continue;
+    }
     if (type < 0 || cp < DEVANAGARI_START || cp > DEVANAGARI_END) {
       clusters.push({ codepoints: [cp], baseIndex: 0, hasReph: false, preBaseMatras: [] });
       i++;
@@ -1545,7 +2894,7 @@ function buildDevanagariClusters(str) {
     const syllable = [];
     let hasReph = false;
     const preMatras = [];
-    if (isConsonant3(cp) && cp === RA2 && i + 2 < cps.length && cps[i + 1] === HALANT2 && isConsonant3(cps[i + 2])) {
+    if (isConsonant7(cp) && cp === RA2 && i + 2 < cps.length && cps[i + 1] === HALANT2 && isConsonant7(cps[i + 2])) {
       hasReph = true;
       syllable.push(cp, cps[i + 1]);
       i += 2;
@@ -1563,13 +2912,24 @@ function buildDevanagariClusters(str) {
           i++;
         }
         if (i < cps.length && cps[i] === HALANT2) {
-          if (i + 1 < cps.length && isConsonant3(cps[i + 1])) {
+          let j = i + 1;
+          let zwnj = false;
+          if (j < cps.length) {
+            const jc = classifyUseCategory(cps[j]);
+            if (jc === "ZWJ") {
+              j++;
+            } else if (jc === "ZWNJ") {
+              j++;
+              zwnj = true;
+            }
+          }
+          if (!zwnj && j < cps.length && isConsonant7(cps[j])) {
             syllable.push(cps[i]);
-            i++;
+            i = j;
             continue;
           } else {
             syllable.push(cps[i]);
-            i++;
+            i = j;
             break;
           }
         }
@@ -1927,6 +3287,406 @@ function shapeArabicText(str, fontData) {
   return glyphs;
 }
 
+// src/fonts/font-loader.ts
+var _fontBinaryCache = /* @__PURE__ */ new WeakMap();
+function getDecodedFontBytes(fontData) {
+  const cached = _fontBinaryCache.get(fontData);
+  if (cached) return cached;
+  let bytes;
+  if (typeof atob === "function") {
+    const binaryStr = atob(fontData.ttfBase64);
+    bytes = new Uint8Array(binaryStr.length);
+    for (let i = 0; i < binaryStr.length; i++) bytes[i] = binaryStr.charCodeAt(i);
+  } else {
+    const buf = globalThis["Buffer"];
+    bytes = buf.from(fontData.ttfBase64, "base64");
+  }
+  _fontBinaryCache.set(fontData, bytes);
+  return bytes;
+}
+
+// src/fonts/glyf-outline.ts
+function readTableDirectory(view) {
+  const numTables = view.getUint16(4);
+  const tables = {};
+  for (let i = 0; i < numTables; i++) {
+    const rec = 12 + i * 16;
+    const tag = String.fromCharCode(
+      view.getUint8(rec),
+      view.getUint8(rec + 1),
+      view.getUint8(rec + 2),
+      view.getUint8(rec + 3)
+    );
+    tables[tag] = { offset: view.getUint32(rec + 8), length: view.getUint32(rec + 12) };
+  }
+  return tables;
+}
+function parseGlyfFont(bytes) {
+  if (bytes.length < 12) return null;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const tables = readTableDirectory(view);
+  const head = tables["head"];
+  const maxp = tables["maxp"];
+  const loca = tables["loca"];
+  const glyf = tables["glyf"];
+  if (!head || !maxp || !loca || !glyf) return null;
+  const unitsPerEm = view.getUint16(head.offset + 18) || 1e3;
+  const locaFormat = view.getInt16(head.offset + 50);
+  const numGlyphs = view.getUint16(maxp.offset + 4);
+  const locaOffsets = new Array(numGlyphs + 1);
+  for (let i = 0; i <= numGlyphs; i++) {
+    locaOffsets[i] = locaFormat === 0 ? view.getUint16(loca.offset + i * 2) * 2 : view.getUint32(loca.offset + i * 4);
+  }
+  return { view, glyfOffset: glyf.offset, locaOffsets, unitsPerEm };
+}
+function transformPoint(p, a, b, c, d, e, f) {
+  return {
+    x: a * p.x + c * p.y + e,
+    y: b * p.x + d * p.y + f,
+    onCurve: p.onCurve
+  };
+}
+function readF2Dot14(view, pos) {
+  return view.getInt16(pos) / 16384;
+}
+function extractGlyphContours(font, gid, depth = 0) {
+  if (depth > 8) return [];
+  const { view, glyfOffset, locaOffsets } = font;
+  if (gid < 0 || gid + 1 >= locaOffsets.length) return [];
+  const start = locaOffsets[gid];
+  const end = locaOffsets[gid + 1];
+  if (end <= start) return [];
+  const base = glyfOffset + start;
+  const numberOfContours = view.getInt16(base);
+  if (numberOfContours < 0) {
+    return extractCompositeContours(font, base, depth);
+  }
+  return extractSimpleContours(view, base, numberOfContours);
+}
+function extractSimpleContours(view, base, numberOfContours) {
+  let pos = base + 10;
+  const endPts = new Array(numberOfContours);
+  for (let i = 0; i < numberOfContours; i++) {
+    endPts[i] = view.getUint16(pos);
+    pos += 2;
+  }
+  const numPoints = numberOfContours > 0 ? endPts[numberOfContours - 1] + 1 : 0;
+  const instrLen = view.getUint16(pos);
+  pos += 2 + instrLen;
+  const flags = new Array(numPoints);
+  for (let i = 0; i < numPoints; ) {
+    const flag = view.getUint8(pos++);
+    flags[i++] = flag;
+    if (flag & 8) {
+      let repeat = view.getUint8(pos++);
+      while (repeat-- > 0 && i < numPoints) flags[i++] = flag;
+    }
+  }
+  const xs = new Array(numPoints);
+  let x = 0;
+  for (let i = 0; i < numPoints; i++) {
+    const flag = flags[i];
+    if (flag & 2) {
+      const dx = view.getUint8(pos++);
+      x += flag & 16 ? dx : -dx;
+    } else if (!(flag & 16)) {
+      x += view.getInt16(pos);
+      pos += 2;
+    }
+    xs[i] = x;
+  }
+  const ys = new Array(numPoints);
+  let y = 0;
+  for (let i = 0; i < numPoints; i++) {
+    const flag = flags[i];
+    if (flag & 4) {
+      const dy = view.getUint8(pos++);
+      y += flag & 32 ? dy : -dy;
+    } else if (!(flag & 32)) {
+      y += view.getInt16(pos);
+      pos += 2;
+    }
+    ys[i] = y;
+  }
+  const contours = [];
+  let startPt = 0;
+  for (let c = 0; c < numberOfContours; c++) {
+    const endPt = endPts[c];
+    const contour = [];
+    for (let i = startPt; i <= endPt; i++) {
+      contour.push({ x: xs[i], y: ys[i], onCurve: (flags[i] & 1) !== 0 });
+    }
+    if (contour.length > 0) contours.push(contour);
+    startPt = endPt + 1;
+  }
+  return contours;
+}
+function extractCompositeContours(font, base, depth) {
+  const { view } = font;
+  let pos = base + 10;
+  const out = [];
+  while (true) {
+    const flags = view.getUint16(pos);
+    pos += 2;
+    const componentGid = view.getUint16(pos);
+    pos += 2;
+    let arg1;
+    let arg2;
+    if (flags & 1) {
+      arg1 = view.getInt16(pos);
+      pos += 2;
+      arg2 = view.getInt16(pos);
+      pos += 2;
+    } else {
+      arg1 = view.getInt8(pos);
+      pos += 1;
+      arg2 = view.getInt8(pos);
+      pos += 1;
+    }
+    let a = 1, b = 0, c = 0, d = 1;
+    if (flags & 8) {
+      a = d = readF2Dot14(view, pos);
+      pos += 2;
+    } else if (flags & 64) {
+      a = readF2Dot14(view, pos);
+      pos += 2;
+      d = readF2Dot14(view, pos);
+      pos += 2;
+    } else if (flags & 128) {
+      a = readF2Dot14(view, pos);
+      pos += 2;
+      b = readF2Dot14(view, pos);
+      pos += 2;
+      c = readF2Dot14(view, pos);
+      pos += 2;
+      d = readF2Dot14(view, pos);
+      pos += 2;
+    }
+    const e = flags & 2 ? arg1 : 0;
+    const f = flags & 2 ? arg2 : 0;
+    const sub = extractGlyphContours(font, componentGid, depth + 1);
+    for (const contour of sub) {
+      out.push(contour.map((p) => transformPoint(p, a, b, c, d, e, f)));
+    }
+    if (!(flags & 32)) break;
+  }
+  return out;
+}
+
+// src/core/pdf-color-glyph.ts
+var ID = [1, 0, 0, 1, 0, 0];
+function n(v) {
+  if (!Number.isFinite(v)) return "0";
+  if (Number.isInteger(v)) return String(v);
+  let s = v.toFixed(3);
+  s = s.replace(/0+$/, "").replace(/\.$/, "");
+  return s === "-0" ? "0" : s;
+}
+function tx(m, x, y) {
+  return [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];
+}
+function ch(v) {
+  return n(Math.max(0, Math.min(1, v / 255)));
+}
+function contoursToPath(contours, m = ID) {
+  const ops = [];
+  for (const contour of contours) {
+    if (contour.length === 0) continue;
+    const pts = contour.slice();
+    let startIdx = pts.findIndex((p) => p.onCurve);
+    let start;
+    if (startIdx < 0) {
+      const a = pts[0], b = pts[pts.length - 1];
+      start = [(a.x + b.x) / 2, (a.y + b.y) / 2];
+      startIdx = 0;
+    } else {
+      start = [pts[startIdx].x, pts[startIdx].y];
+    }
+    const [sx, sy] = tx(m, start[0], start[1]);
+    ops.push(`${n(sx)} ${n(sy)} m`);
+    const len = pts.length;
+    let curX = start[0], curY = start[1];
+    let i = 1;
+    while (i <= len) {
+      const p = pts[(startIdx + i) % len];
+      if (p.onCurve) {
+        const [px, py] = tx(m, p.x, p.y);
+        ops.push(`${n(px)} ${n(py)} l`);
+        curX = p.x;
+        curY = p.y;
+        i++;
+      } else {
+        const next = pts[(startIdx + i + 1) % len];
+        let endX, endY;
+        let consumed;
+        if (next.onCurve) {
+          endX = next.x;
+          endY = next.y;
+          consumed = 2;
+        } else {
+          endX = (p.x + next.x) / 2;
+          endY = (p.y + next.y) / 2;
+          consumed = 1;
+        }
+        const c1x = curX + 2 / 3 * (p.x - curX);
+        const c1y = curY + 2 / 3 * (p.y - curY);
+        const c2x = endX + 2 / 3 * (p.x - endX);
+        const c2y = endY + 2 / 3 * (p.y - endY);
+        const [a1, b1] = tx(m, c1x, c1y);
+        const [a2, b2] = tx(m, c2x, c2y);
+        const [ex, ey] = tx(m, endX, endY);
+        ops.push(`${n(a1)} ${n(b1)} ${n(a2)} ${n(b2)} ${n(ex)} ${n(ey)} c`);
+        curX = endX;
+        curY = endY;
+        i += consumed;
+      }
+    }
+    ops.push("h");
+  }
+  return ops.join("\n");
+}
+function buildGradientFunction(stops) {
+  const sorted = stops.slice().sort((a, b) => a.offset - b.offset);
+  if (sorted.length === 0) return "<< /FunctionType 2 /Domain [0 1] /C0 [0 0 0] /C1 [0 0 0] /N 1 >>";
+  if (sorted.length === 1) {
+    const c = sorted[0].color;
+    return `<< /FunctionType 2 /Domain [0 1] /C0 [${ch(c[0])} ${ch(c[1])} ${ch(c[2])}] /C1 [${ch(c[0])} ${ch(c[1])} ${ch(c[2])}] /N 1 >>`;
+  }
+  if (sorted.length === 2) {
+    const a = sorted[0].color, b = sorted[1].color;
+    return `<< /FunctionType 2 /Domain [0 1] /C0 [${ch(a[0])} ${ch(a[1])} ${ch(a[2])}] /C1 [${ch(b[0])} ${ch(b[1])} ${ch(b[2])}] /N 1 >>`;
+  }
+  const subFns = [];
+  const bounds = [];
+  const encode = [];
+  for (let i = 0; i < sorted.length - 1; i++) {
+    const a = sorted[i].color, b = sorted[i + 1].color;
+    subFns.push(`<< /FunctionType 2 /Domain [0 1] /C0 [${ch(a[0])} ${ch(a[1])} ${ch(a[2])}] /C1 [${ch(b[0])} ${ch(b[1])} ${ch(b[2])}] /N 1 >>`);
+    encode.push("0 1");
+    if (i > 0) bounds.push(n(Math.max(0, Math.min(1, sorted[i].offset))));
+  }
+  return `<< /FunctionType 3 /Domain [0 1] /Functions [${subFns.join(" ")}] /Bounds [${bounds.join(" ")}] /Encode [${encode.join(" ")}] >>`;
+}
+function extendFlags(extend) {
+  return extend === "pad" ? "[true true]" : "[true true]";
+}
+function linearShadingDict(p, m) {
+  const [x0, y0] = tx(m, p.p0[0], p.p0[1]);
+  const [x1, y1] = tx(m, p.p1[0], p.p1[1]);
+  return `<< /ShadingType 2 /ColorSpace /DeviceRGB /Coords [${n(x0)} ${n(y0)} ${n(x1)} ${n(y1)}] /Function ${buildGradientFunction(p.stops)} /Extend ${extendFlags(p.extend)} >>`;
+}
+function radialShadingDict(p, m) {
+  const [x0, y0] = tx(m, p.c0[0], p.c0[1]);
+  const [x1, y1] = tx(m, p.c1[0], p.c1[1]);
+  const sx = Math.hypot(m[0], m[1]);
+  const sy = Math.hypot(m[2], m[3]);
+  const s = (sx + sy) / 2 || 1;
+  return `<< /ShadingType 3 /ColorSpace /DeviceRGB /Coords [${n(x0)} ${n(y0)} ${n(p.r0 * s)} ${n(x1)} ${n(y1)} ${n(p.r1 * s)}] /Function ${buildGradientFunction(p.stops)} /Extend ${extendFlags(p.extend)} >>`;
+}
+function renderColorGlyph(glyph, outlines, unitsPerEm) {
+  const body = [];
+  const shadings = [];
+  const extGStates = [];
+  const alphaMap = /* @__PURE__ */ new Map();
+  let shadingIdx = 0;
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const layer of glyph.layers) {
+    const m = layer.transform ?? ID;
+    const contours = outlines(layer.glyphId);
+    if (contours.length === 0) continue;
+    const path = contoursToPath(contours, m);
+    for (const contour of contours) {
+      for (const pt of contour) {
+        const [px, py] = tx(m, pt.x, pt.y);
+        if (px < minX) minX = px;
+        if (py < minY) minY = py;
+        if (px > maxX) maxX = px;
+        if (py > maxY) maxY = py;
+      }
+    }
+    if (layer.paint.kind === "solid") {
+      const c = layer.paint.color;
+      const alpha = c[3] / 255;
+      body.push("q");
+      if (alpha < 0.999) {
+        let gs = alphaMap.get(c[3]);
+        if (!gs) {
+          gs = `GsA${alphaMap.size}`;
+          alphaMap.set(c[3], gs);
+          extGStates.push({ name: gs, dict: `<< /ca ${n(alpha)} /CA ${n(alpha)} >>` });
+        }
+        body.push(`/${gs} gs`);
+      }
+      body.push(`${ch(c[0])} ${ch(c[1])} ${ch(c[2])} rg`);
+      body.push(path);
+      body.push("f");
+      body.push("Q");
+    } else {
+      const name = `Sh${shadingIdx++}`;
+      const dict = layer.paint.kind === "linear" ? linearShadingDict(layer.paint, m) : radialShadingDict(layer.paint, m);
+      shadings.push({ name, dict });
+      body.push("q");
+      body.push(path);
+      body.push("W n");
+      body.push(`/${name} sh`);
+      body.push("Q");
+    }
+  }
+  const bbox = Number.isFinite(minX) ? [Math.floor(minX) - 1, Math.floor(minY) - 1, Math.ceil(maxX) + 1, Math.ceil(maxY) + 1] : [0, 0, unitsPerEm, unitsPerEm];
+  return {
+    content: body.join("\n"),
+    bbox,
+    shadings,
+    extGStates
+  };
+}
+
+// src/core/color-emoji.ts
+function createColorEmojiCollector() {
+  const forms = [];
+  const nameByGlyph = /* @__PURE__ */ new WeakMap();
+  const glyfByFont = /* @__PURE__ */ new WeakMap();
+  function glyfFor(fontData) {
+    let g = glyfByFont.get(fontData);
+    if (g === void 0) {
+      g = parseGlyfFont(getDecodedFontBytes(fontData));
+      glyfByFont.set(fontData, g);
+    }
+    return g;
+  }
+  function useGlyph(fontData, gid) {
+    const colorGlyph = fontData.colorGlyphs?.[gid];
+    if (!colorGlyph) return null;
+    let perFont = nameByGlyph.get(fontData);
+    if (!perFont) {
+      perFont = /* @__PURE__ */ new Map();
+      nameByGlyph.set(fontData, perFont);
+    }
+    const cached = perFont.get(gid);
+    if (cached) return cached;
+    const glyf = glyfFor(fontData);
+    if (!glyf) return null;
+    const rendered = renderColorGlyph(
+      colorGlyph,
+      (baseGid) => extractGlyphContours(glyf, baseGid),
+      fontData.metrics.unitsPerEm
+    );
+    if (rendered.content.trim() === "") return null;
+    const name = `CEm${forms.length}`;
+    const resParts = [];
+    if (rendered.shadings.length > 0) {
+      resParts.push(`/Shading << ${rendered.shadings.map((s) => `/${s.name} ${s.dict}`).join(" ")} >>`);
+    }
+    if (rendered.extGStates.length > 0) {
+      resParts.push(`/ExtGState << ${rendered.extGStates.map((g) => `/${g.name} ${g.dict}`).join(" ")} >>`);
+    }
+    forms.push({ name, content: rendered.content, resources: resParts.join(" "), bbox: rendered.bbox });
+    perFont.set(gid, name);
+    return name;
+  }
+  return { useGlyph, forms };
+}
+
 // src/core/encoding-context.ts
 function isWinAnsi(cp) {
   if (cp >= 32 && cp <= 126 || cp >= 160 && cp <= 255) return true;
@@ -2031,13 +3791,14 @@ function buildTextRunsWithFallback(text, fontRef, fd, sz, trackGid, pdfA = false
   if (mode === "hel") flushHel();
   return result;
 }
-function createEncodingContext(fontEntries, pdfA = false) {
+function createEncodingContext(fontEntries, pdfA = false, normalize = false) {
+  const _norm = normalize ? (s) => s.normalize(normalize) : (s) => s;
   if (!fontEntries || fontEntries.length === 0) {
     return {
       isUnicode: false,
       fontEntries: [],
-      ps: pdfString,
-      tw: helveticaWidth,
+      ps: normalize ? (s) => pdfString(_norm(s)) : pdfString,
+      tw: normalize ? (s, sz) => helveticaWidth(_norm(s), sz) : helveticaWidth,
       textRuns: () => [],
       f1: "/F1",
       f2: "/F2"
@@ -2050,6 +3811,7 @@ function createEncodingContext(fontEntries, pdfA = false) {
     const s = _usedGids.get(fontRef);
     if (s) s.add(gid);
   }
+  const _colorEmoji = fontEntries.some((fe) => fe.fontData.colorGlyphs) ? createColorEmojiCollector() : void 0;
   return {
     isUnicode: true,
     fontEntries,
@@ -2059,8 +3821,10 @@ function createEncodingContext(fontEntries, pdfA = false) {
     getUsedGids() {
       return _usedGids;
     },
+    colorEmoji: _colorEmoji,
     textRuns(str, sz) {
       if (!str) return [];
+      str = _norm(str);
       str = stripBidiControls(str);
       if (!str) return [];
       if (containsRTL(str)) {
@@ -2127,6 +3891,56 @@ function createEncodingContext(fontEntries, pdfA = false) {
                   }
                 }
                 result.push({ text: fRun.text, fontRef, fontData: fd, shaped, hexStr: null, widthPt: designW * sz / upm });
+              } else if (containsTelugu(fRun.text)) {
+                const shaped = shapeTeluguText(fRun.text, fd);
+                let designW = 0;
+                for (const g of shaped) {
+                  _trackGid(fontRef, g.gid);
+                  if (!g.isZeroAdvance) {
+                    designW += fd.widths[g.gid] !== void 0 ? fd.widths[g.gid] : fd.defaultWidth;
+                  }
+                }
+                result.push({ text: fRun.text, fontRef, fontData: fd, shaped, hexStr: null, widthPt: designW * sz / upm });
+              } else if (containsSinhala(fRun.text)) {
+                const shaped = shapeSinhalaText(fRun.text, fd);
+                let designW = 0;
+                for (const g of shaped) {
+                  _trackGid(fontRef, g.gid);
+                  if (!g.isZeroAdvance) {
+                    designW += fd.widths[g.gid] !== void 0 ? fd.widths[g.gid] : fd.defaultWidth;
+                  }
+                }
+                result.push({ text: fRun.text, fontRef, fontData: fd, shaped, hexStr: null, widthPt: designW * sz / upm });
+              } else if (containsTibetan(fRun.text)) {
+                const shaped = shapeTibetanText(fRun.text, fd);
+                let designW = 0;
+                for (const g of shaped) {
+                  _trackGid(fontRef, g.gid);
+                  if (!g.isZeroAdvance) {
+                    designW += fd.widths[g.gid] !== void 0 ? fd.widths[g.gid] : fd.defaultWidth;
+                  }
+                }
+                result.push({ text: fRun.text, fontRef, fontData: fd, shaped, hexStr: null, widthPt: designW * sz / upm });
+              } else if (containsKhmer(fRun.text)) {
+                const shaped = shapeKhmerText(fRun.text, fd);
+                let designW = 0;
+                for (const g of shaped) {
+                  _trackGid(fontRef, g.gid);
+                  if (!g.isZeroAdvance) {
+                    designW += fd.widths[g.gid] !== void 0 ? fd.widths[g.gid] : fd.defaultWidth;
+                  }
+                }
+                result.push({ text: fRun.text, fontRef, fontData: fd, shaped, hexStr: null, widthPt: designW * sz / upm });
+              } else if (containsMyanmar(fRun.text)) {
+                const shaped = shapeMyanmarText(fRun.text, fd);
+                let designW = 0;
+                for (const g of shaped) {
+                  _trackGid(fontRef, g.gid);
+                  if (!g.isZeroAdvance) {
+                    designW += fd.widths[g.gid] !== void 0 ? fd.widths[g.gid] : fd.defaultWidth;
+                  }
+                }
+                result.push({ text: fRun.text, fontRef, fontData: fd, shaped, hexStr: null, widthPt: designW * sz / upm });
               } else if (containsDevanagari(fRun.text)) {
                 const shaped = shapeDevanagariText(fRun.text, fd);
                 let designW = 0;
@@ -2184,6 +3998,61 @@ function createEncodingContext(fontEntries, pdfA = false) {
           }
           return [{ text: run.text, fontRef, fontData: fd, shaped, hexStr: null, widthPt: designW * sz / upm }];
         }
+        if (containsTelugu(run.text)) {
+          const shaped = shapeTeluguText(run.text, fd);
+          let designW = 0;
+          for (const g of shaped) {
+            _trackGid(fontRef, g.gid);
+            if (!g.isZeroAdvance) {
+              designW += fd.widths[g.gid] !== void 0 ? fd.widths[g.gid] : fd.defaultWidth;
+            }
+          }
+          return [{ text: run.text, fontRef, fontData: fd, shaped, hexStr: null, widthPt: designW * sz / upm }];
+        }
+        if (containsSinhala(run.text)) {
+          const shaped = shapeSinhalaText(run.text, fd);
+          let designW = 0;
+          for (const g of shaped) {
+            _trackGid(fontRef, g.gid);
+            if (!g.isZeroAdvance) {
+              designW += fd.widths[g.gid] !== void 0 ? fd.widths[g.gid] : fd.defaultWidth;
+            }
+          }
+          return [{ text: run.text, fontRef, fontData: fd, shaped, hexStr: null, widthPt: designW * sz / upm }];
+        }
+        if (containsTibetan(run.text)) {
+          const shaped = shapeTibetanText(run.text, fd);
+          let designW = 0;
+          for (const g of shaped) {
+            _trackGid(fontRef, g.gid);
+            if (!g.isZeroAdvance) {
+              designW += fd.widths[g.gid] !== void 0 ? fd.widths[g.gid] : fd.defaultWidth;
+            }
+          }
+          return [{ text: run.text, fontRef, fontData: fd, shaped, hexStr: null, widthPt: designW * sz / upm }];
+        }
+        if (containsKhmer(run.text)) {
+          const shaped = shapeKhmerText(run.text, fd);
+          let designW = 0;
+          for (const g of shaped) {
+            _trackGid(fontRef, g.gid);
+            if (!g.isZeroAdvance) {
+              designW += fd.widths[g.gid] !== void 0 ? fd.widths[g.gid] : fd.defaultWidth;
+            }
+          }
+          return [{ text: run.text, fontRef, fontData: fd, shaped, hexStr: null, widthPt: designW * sz / upm }];
+        }
+        if (containsMyanmar(run.text)) {
+          const shaped = shapeMyanmarText(run.text, fd);
+          let designW = 0;
+          for (const g of shaped) {
+            _trackGid(fontRef, g.gid);
+            if (!g.isZeroAdvance) {
+              designW += fd.widths[g.gid] !== void 0 ? fd.widths[g.gid] : fd.defaultWidth;
+            }
+          }
+          return [{ text: run.text, fontRef, fontData: fd, shaped, hexStr: null, widthPt: designW * sz / upm }];
+        }
         if (containsDevanagari(run.text)) {
           const shaped = shapeDevanagariText(run.text, fd);
           let designW = 0;
@@ -2200,6 +4069,7 @@ function createEncodingContext(fontEntries, pdfA = false) {
     },
     ps(str) {
       if (!str) return "<>";
+      str = _norm(str);
       str = stripBidiControls(str);
       if (!str) return "<>";
       const { cmap } = primary.fontData;
@@ -2228,7 +4098,7 @@ function createEncodingContext(fontEntries, pdfA = false) {
         }
         return `<${hex2.toUpperCase()}>`;
       }
-      if (!containsThai(str) && !containsBengali(str) && !containsTamil(str) && !containsDevanagari(str)) {
+      if (!containsThai(str) && !containsBengali(str) && !containsTamil(str) && !containsTelugu(str) && !containsSinhala(str) && !containsTibetan(str) && !containsKhmer(str) && !containsMyanmar(str) && !containsDevanagari(str)) {
         let hex2 = "";
         for (let i = 0; i < str.length; i++) {
           const rawCp = str.codePointAt(i) ?? 0;
@@ -2240,7 +4110,7 @@ function createEncodingContext(fontEntries, pdfA = false) {
         }
         return `<${hex2.toUpperCase()}>`;
       }
-      const shapeFn = containsThai(str) ? shapeThaiText : containsBengali(str) ? shapeBengaliText : containsTamil(str) ? shapeTamilText : shapeDevanagariText;
+      const shapeFn = containsThai(str) ? shapeThaiText : containsBengali(str) ? shapeBengaliText : containsTamil(str) ? shapeTamilText : containsTelugu(str) ? shapeTeluguText : containsSinhala(str) ? shapeSinhalaText : containsTibetan(str) ? shapeTibetanText : containsKhmer(str) ? shapeKhmerText : containsMyanmar(str) ? shapeMyanmarText : shapeDevanagariText;
       const shaped = shapeFn(str, primary.fontData);
       let hex = "";
       for (const g of shaped) {
@@ -2322,24 +4192,6 @@ function buildSubsetWidthArray(widths, usedGids) {
   return parts.join(" ");
 }
 
-// src/fonts/font-loader.ts
-var _fontBinaryCache = /* @__PURE__ */ new WeakMap();
-function getDecodedFontBytes(fontData) {
-  const cached = _fontBinaryCache.get(fontData);
-  if (cached) return cached;
-  let bytes;
-  if (typeof atob === "function") {
-    const binaryStr = atob(fontData.ttfBase64);
-    bytes = new Uint8Array(binaryStr.length);
-    for (let i = 0; i < binaryStr.length; i++) bytes[i] = binaryStr.charCodeAt(i);
-  } else {
-    const buf = globalThis["Buffer"];
-    bytes = buf.from(fontData.ttfBase64, "base64");
-  }
-  _fontBinaryCache.set(fontData, bytes);
-  return bytes;
-}
-
 // src/fonts/font-subsetter.ts
 function subsetTTF(ttfInput, usedGids) {
   try {
@@ -2653,7 +4505,7 @@ function buildStructureTree(root, startObjNum, pageObjToStructParents) {
   };
 }
 function buildPdfMetadata(now = /* @__PURE__ */ new Date()) {
-  const pad2 = (n) => String(n).padStart(2, "0");
+  const pad2 = (n2) => String(n2).padStart(2, "0");
   const yyyy = now.getFullYear();
   const mm = pad2(now.getMonth() + 1);
   const dd = pad2(now.getDate());
@@ -2861,26 +4713,45 @@ function txtShaped(shaped, x, y, font, sz, fontData) {
   }
   return parts.join("\n");
 }
+var fmtScale = (v) => v.toFixed(5).replace(/0+$/, "").replace(/\.$/, "") || "0";
+function emitColorEmojiRun(parts, run, penX, y, sz, enc) {
+  const fd = run.fontData;
+  const upm = fd.metrics.unitsPerEm;
+  const scale = sz / upm;
+  const s = fmtScale(scale);
+  const hex = (run.hexStr ?? "").replace(/[<>]/g, "");
+  for (let i = 0; i + 4 <= hex.length; i += 4) {
+    const tag = hex.substr(i, 4);
+    const gid = parseInt(tag, 16);
+    const adv = (fd.widths[gid] !== void 0 ? fd.widths[gid] : fd.defaultWidth) * scale;
+    const name = enc.colorEmoji?.useGlyph(fd, gid) ?? null;
+    if (name) {
+      parts.push(`q ${s} 0 0 ${s} ${fmtNum(penX)} ${fmtNum(y)} cm /${name} Do Q`);
+    } else {
+      parts.push(`BT ${run.fontRef} ${sz} Tf ${fmtNum(penX)} ${fmtNum(y)} Td <${tag}> Tj ET`);
+    }
+    penX += adv;
+  }
+  return penX;
+}
 function txt(str, x, y, font, sz, enc) {
   if (!enc.isUnicode) {
     return `BT ${font} ${sz} Tf ${fmtNum(x)} ${fmtNum(y)} Td ${enc.ps(str)} Tj ET`;
   }
   const runs = enc.textRuns(str, sz);
   if (runs.length === 0) return "";
-  if (runs.length === 1) {
-    const run = runs[0];
-    if (run.shaped) return txtShaped(run.shaped, x, y, run.fontRef, sz, run.fontData);
-    return `BT ${run.fontRef} ${sz} Tf ${fmtNum(x)} ${fmtNum(y)} Td ${run.hexStr} Tj ET`;
-  }
   const parts = [];
   let penX = x;
   for (const run of runs) {
-    if (run.shaped) {
+    if (enc.colorEmoji && run.fontData.colorGlyphs && run.hexStr) {
+      penX = emitColorEmojiRun(parts, run, penX, y, sz, enc);
+    } else if (run.shaped) {
       parts.push(txtShaped(run.shaped, penX, y, run.fontRef, sz, run.fontData));
+      penX += run.widthPt;
     } else {
       parts.push(`BT ${run.fontRef} ${sz} Tf ${fmtNum(penX)} ${fmtNum(y)} Td ${run.hexStr} Tj ET`);
+      penX += run.widthPt;
     }
-    penX += run.widthPt;
   }
   return parts.join("\n");
 }
@@ -2973,12 +4844,12 @@ var DEFAULT_COLUMNS = [
   { f: 0.18, a: "c", mx: 20, mxH: 20 }
 ];
 function computeColumnPositions(columns, marginLeft, contentWidth) {
-  const n = columns.length;
-  const cwi = new Array(n).fill(0);
-  const fixed = new Array(n).fill(false);
+  const n2 = columns.length;
+  const cwi = new Array(n2).fill(0);
+  const fixed = new Array(n2).fill(false);
   let totalFixed = 0;
   let freeWeight = 0;
-  for (let i = 0; i < n; i++) {
+  for (let i = 0; i < n2; i++) {
     const col = columns[i];
     let w = col.f * contentWidth;
     let clamped = false;
@@ -3000,13 +4871,13 @@ function computeColumnPositions(columns, marginLeft, contentWidth) {
   }
   const remaining = contentWidth - totalFixed;
   if (freeWeight > 0) {
-    for (let i = 0; i < n; i++) {
+    for (let i = 0; i < n2; i++) {
       if (!fixed[i]) cwi[i] = columns[i].f / freeWeight * remaining;
     }
   }
-  const cx = new Array(n);
+  const cx = new Array(n2);
   let x = marginLeft;
-  for (let i = 0; i < n; i++) {
+  for (let i = 0; i < n2; i++) {
     cx[i] = x;
     x += cwi[i];
   }
@@ -3032,8 +4903,8 @@ function parseColor(input) {
     `Invalid color format: ${JSON.stringify(input)}. Expected "#RRGGBB", "#RGB", [r, g, b] (0\u2013255), or "R G B" (0.0\u20131.0).`
   );
 }
-function fmtChannel(n) {
-  const clamped = Math.max(0, Math.min(1, n));
+function fmtChannel(n2) {
+  const clamped = Math.max(0, Math.min(1, n2));
   const rounded = Math.round(clamped * 1e3) / 1e3;
   return String(rounded);
 }
@@ -3075,8 +4946,8 @@ function parseTupleColor(tuple) {
 function parsePdfRgbString(str) {
   const parts = str.split(" ");
   for (const p of parts) {
-    const n = Number(p);
-    if (n < 0 || n > 1) {
+    const n2 = Number(p);
+    if (n2 < 0 || n2 > 1) {
       throw new Error(
         `Invalid PDF RGB value: ${p} in ${JSON.stringify(str)}. Each value must be 0.0\u20131.0.`
       );
@@ -3216,8 +5087,8 @@ var MD5_K = new Uint32Array([
   718787259,
   3951481745
 ]);
-function rotl32(x, n) {
-  return (x << n | x >>> 32 - n) >>> 0;
+function rotl32(x, n2) {
+  return (x << n2 | x >>> 32 - n2) >>> 0;
 }
 function md5(input) {
   const len = input.length;
@@ -3455,6 +5326,9 @@ function _buildPageTemplate(template, page, pages, title, date, y, enc, mgL, mgR
   return { ops, structEls };
 }
 function buildPDF(params, layoutOptions) {
+  return assembleTableParts(params, layoutOptions).join("");
+}
+function assembleTableParts(params, layoutOptions) {
   if (!params || typeof params !== "object") {
     throw new Error("buildPDF: params is required and must be an object");
   }
@@ -3480,14 +5354,14 @@ function buildPDF(params, layoutOptions) {
   const fontEntries = params.fontEntries || (fontData ? [{ fontData, fontRef: "/F3", lang: "unknown" }] : []);
   const pdfaConfig = resolvePdfAConfig();
   const tagged = pdfaConfig.enabled;
-  const enc = createEncodingContext(fontEntries, tagged);
+  const enc = createEncodingContext(fontEntries, tagged, false);
   const footerTpl = {
     left: footerText || void 0,
     right: "{page}/{pages}"
   };
   const headerH = 0;
   const dateNow = /* @__PURE__ */ new Date();
-  const pad2d = (n) => String(n).padStart(2, "0");
+  const pad2d = (n2) => String(n2).padStart(2, "0");
   const dateStr = `${dateNow.getFullYear()}-${pad2d(dateNow.getMonth() + 1)}-${pad2d(dateNow.getDate())}`;
   const infoCount = infoItems.length;
   const page1Header = TITLE_LN + 16 + infoCount * INFO_LN + 8 + BAL_H + 10;
@@ -3509,6 +5383,9 @@ function buildPDF(params, layoutOptions) {
   const pageStreams = [];
   let rowIdx = 0;
   const prePageObjStart = enc.isUnicode && fontEntries.length > 0 ? 5 + fontEntries.length * 5 + wmExtraObjs : 5 + wmExtraObjs;
+  const preBaseObjCount = enc.isUnicode && fontEntries.length > 0 ? 4 + fontEntries.length * 5 + wmExtraObjs + totalPages * 2 : 4 + wmExtraObjs + totalPages * 2;
+  const latinToUniObjNum = tagged ? 0 : preBaseObjCount + 2;
+  const baseFontToUniRef = latinToUniObjNum ? ` /ToUnicode ${latinToUniObjNum} 0 R` : "";
   const pageObjToStructParents = /* @__PURE__ */ new Map();
   for (let p = 0; p < totalPages; p++) {
     const pageObjNum = prePageObjStart + p * 2;
@@ -3638,8 +5515,8 @@ function buildPDF(params, layoutOptions) {
       emitObj(3, refDict);
       emitObj(4, refDict);
     } else {
-      emitObj(3, "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding >>");
-      emitObj(4, "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica-Bold /Encoding /WinAnsiEncoding >>");
+      emitObj(3, `<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding${baseFontToUniRef} >>`);
+      emitObj(4, `<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica-Bold /Encoding /WinAnsiEncoding${baseFontToUniRef} >>`);
     }
     for (let fi = 0; fi < fontEntries.length; fi++) {
       const fe = fontEntries[fi];
@@ -3697,8 +5574,8 @@ function buildPDF(params, layoutOptions) {
       kids.push(`${pageObjStart + p * 2} 0 R`);
     }
     emitObj(2, `<< /Type /Pages /Kids [${kids.join(" ")}] /Count ${totalPages} >>`);
-    emitObj(3, "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding >>");
-    emitObj(4, "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica-Bold /Encoding /WinAnsiEncoding >>");
+    emitObj(3, `<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding${baseFontToUniRef} >>`);
+    emitObj(4, `<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica-Bold /Encoding /WinAnsiEncoding${baseFontToUniRef} >>`);
     let wmGsResLatin = "";
     let wmImgResLatin = "";
     for (let p = 0; p < totalPages; p++) {
@@ -3715,13 +5592,18 @@ function buildPDF(params, layoutOptions) {
   }
   const baseObjCount = enc.isUnicode ? 4 + fontEntries.length * 5 + wmExtraObjs + totalPages * 2 : 4 + wmExtraObjs + totalPages * 2;
   const infoObjNum = baseObjCount + 1;
-  const { pdfDate, xmpDate: isoDate } = buildPdfMetadata();
+  const { pdfDate, xmpDate: isoDate } = buildPdfMetadata(layoutOptions?.creationDate);
   const infoTitle = params.docTitle || title || "";
   emitObj(
     infoObjNum,
     `<< /Title ${encodePdfTextString(infoTitle)} /Producer (pdfnative) /CreationDate (${pdfDate}) >>`
   );
   let totalObjs = infoObjNum;
+  if (latinToUniObjNum) {
+    const cmap = buildWinAnsiToUnicodeCMap();
+    emitStreamObj(latinToUniObjNum, `<< /Length ${cmap.length}`, cmap);
+    totalObjs = latinToUniObjNum;
+  }
   let xmpObjNum = 0;
   let outputIntentObjNum = 0;
   if (tagged) {
@@ -3777,7 +5659,7 @@ endobj
   }
   const writer = { emit, emitObj, emitStreamObj, offset: getOffset, adjustOffset, objOffsets, parts };
   writeXrefTrailer(writer, totalObjs, infoObjNum, encState, `${infoTitle}|${pdfDate}`);
-  return parts.join("");
+  return parts;
 }
 
 // src/worker/pdf-worker.ts