pdfnative 1.2.0 → 1.3.0

package/dist/index.cjs

@@ -121,8 +121,8 @@ function aesECB(data, key) {
   aesEncryptBlock(block, expandedKey, nr);
   return block;
 }
-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;
@@ -179,8 +179,8 @@ function md5(input) {
   rv.setUint32(12, d0, true);
   return result;
 }
-function rotr32(x, n) {
-  return (x >>> n | x << 32 - n) >>> 0;
+function rotr32(x, n2) {
+  return (x >>> n2 | x << 32 - n2) >>> 0;
 }
 function sha256(input) {
   const len = input.length;
@@ -212,8 +212,8 @@ function sha256(input) {
     let a = h0, b = h1, c = h2, d = h3, e = h4, f = h5, g = h6, h = h7;
     for (let j = 0; j < 64; j++) {
       const S1 = rotr32(e, 6) ^ rotr32(e, 11) ^ rotr32(e, 25);
-      const ch = e & f ^ ~e & g;
-      const temp1 = h + S1 + ch + SHA256_K[j] + W[j] >>> 0;
+      const ch2 = e & f ^ ~e & g;
+      const temp1 = h + S1 + ch2 + SHA256_K[j] + W[j] >>> 0;
       const S0 = rotr32(a, 2) ^ rotr32(a, 13) ^ rotr32(a, 22);
       const maj = a & b ^ a & c ^ b & c;
       const temp2 = S0 + maj >>> 0;
@@ -275,16 +275,17 @@ function computePermissions(perms) {
 function fillRandom(buf) {
   if (typeof globalThis.crypto !== "undefined" && typeof globalThis.crypto.getRandomValues === "function") {
     globalThis.crypto.getRandomValues(buf);
-  } else {
-    for (let i = 0; i < buf.length; i++) buf[i] = Math.floor(Math.random() * 256);
+    return buf;
   }
-  return buf;
+  throw new Error(
+    "pdfnative: PDF encryption requires a cryptographically secure random source (Web Crypto `crypto.getRandomValues`), which is unavailable in this environment. Refusing to generate predictable IVs/document IDs. On older runtimes, install a Web Crypto polyfill (e.g. `react-native-get-random-values`) before encrypting."
+  );
 }
 function generateDocId() {
   return fillRandom(new Uint8Array(16));
 }
-function randomBytes(n) {
-  return fillRandom(new Uint8Array(n));
+function randomBytes(n2) {
+  return fillRandom(new Uint8Array(n2));
 }
 function computeKeyR4(userPwd, oValue, pValue, docId) {
   const buf = new Uint8Array(userPwd.length + oValue.length + 4 + docId.length);
@@ -1051,18 +1052,18 @@ function add64(ah, al, bh, bl) {
   const hi = ah + bh + (lo < al ? 1 : 0) >>> 0;
   return [hi, lo];
 }
-function rotr64(h, l, n) {
-  if (n < 32) {
-    return [(h >>> n | l << 32 - n) >>> 0, (l >>> n | h << 32 - n) >>> 0];
+function rotr64(h, l, n2) {
+  if (n2 < 32) {
+    return [(h >>> n2 | l << 32 - n2) >>> 0, (l >>> n2 | h << 32 - n2) >>> 0];
   }
-  const m = n - 32;
+  const m = n2 - 32;
   return [(l >>> m | h << 32 - m) >>> 0, (h >>> m | l << 32 - m) >>> 0];
 }
-function shr64(h, l, n) {
-  if (n < 32) {
-    return [h >>> n >>> 0, (l >>> n | h << 32 - n) >>> 0];
+function shr64(h, l, n2) {
+  if (n2 < 32) {
+    return [h >>> n2 >>> 0, (l >>> n2 | h << 32 - n2) >>> 0];
   }
-  return [0, h >>> n - 32 >>> 0];
+  return [0, h >>> n2 - 32 >>> 0];
 }
 function sha512Core(input, iv, outputLen) {
   const len = input.length;
@@ -1108,7 +1109,7 @@ function sha512Core(input, iv, outputLen) {
     }
     let ah = h0h, al = h0l;
     let bh = h1h, bl = h1l;
-    let ch = h2h, cl = h2l;
+    let ch2 = h2h, cl = h2l;
     let dh = h3h, dl = h3l;
     let eh = h4h, el = h4l;
     let fh = h5h, fl = h5l;
@@ -1131,7 +1132,7 @@ function sha512Core(input, iv, outputLen) {
       const [a39h, a39l] = rotr64(ah, al, 39);
       const S0h = (a28h ^ a34h ^ a39h) >>> 0;
       const S0l = (a28l ^ a34l ^ a39l) >>> 0;
-      const majH = (ah & bh ^ ah & ch ^ bh & ch) >>> 0;
+      const majH = (ah & bh ^ ah & ch2 ^ bh & ch2) >>> 0;
       const majL = (al & bl ^ al & cl ^ bl & cl) >>> 0;
       const [t2h, t2l] = add64(S0h, S0l, majH, majL);
       hh = gh;
@@ -1141,9 +1142,9 @@ function sha512Core(input, iv, outputLen) {
       fh = eh;
       fl = el;
       [eh, el] = add64(dh, dl, t1h, t1l);
-      dh = ch;
+      dh = ch2;
       dl = cl;
-      ch = bh;
+      ch2 = bh;
       cl = bl;
       bh = ah;
       bl = al;
@@ -1151,7 +1152,7 @@ function sha512Core(input, iv, outputLen) {
     }
     [h0h, h0l] = add64(h0h, h0l, ah, al);
     [h1h, h1l] = add64(h1h, h1l, bh, bl);
-    [h2h, h2l] = add64(h2h, h2l, ch, cl);
+    [h2h, h2l] = add64(h2h, h2l, ch2, cl);
     [h3h, h3l] = add64(h3h, h3l, dh, dl);
     [h4h, h4l] = add64(h4h, h4l, eh, el);
     [h5h, h5l] = add64(h5h, h5l, fh, fl);
@@ -1766,8 +1767,8 @@ function bigIntToBytes(value, length) {
   }
   return result;
 }
-function keyByteLen(n) {
-  const hex = n.toString(16);
+function keyByteLen(n2) {
+  const hex = n2.toString(16);
   return Math.ceil(hex.length / 2);
 }
 function rsaSign(message, privateKey) {
@@ -2291,6 +2292,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
@@ -2321,6 +2349,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;
 }
@@ -2345,6 +2376,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;
 }
@@ -2355,6 +2404,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;
@@ -2389,6 +2441,42 @@ 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 containsEthiopic(str) {
+  for (let i = 0; i < str.length; i++) {
+    if (isEthiopicCodepoint(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;
@@ -2398,7 +2486,7 @@ function containsDevanagari(str) {
 
 // src/shaping/script-detect.ts
 function needsUnicodeFont(lang) {
-  return ["th", "ja", "zh", "ko", "el", "hi", "tr", "vi", "pl", "ar", "he", "ru", "ka", "hy", "emoji"].includes(lang);
+  return ["th", "ja", "zh", "ko", "el", "hi", "te", "tr", "vi", "pl", "ar", "he", "ru", "ka", "hy", "am", "si", "bo", "km", "my", "emoji"].includes(lang);
 }
 function detectFallbackLangs(texts, primaryLang) {
   const needed = /* @__PURE__ */ new Set();
@@ -2415,6 +2503,30 @@ function detectFallbackLangs(texts, primaryLang) {
         needed.add("hi");
         continue;
       }
+      if (cp >= 3072 && cp <= 3199) {
+        needed.add("te");
+        continue;
+      }
+      if (isSinhalaCodepoint(cp)) {
+        needed.add("si");
+        continue;
+      }
+      if (isTibetanCodepoint(cp)) {
+        needed.add("bo");
+        continue;
+      }
+      if (isKhmerCodepoint(cp)) {
+        needed.add("km");
+        continue;
+      }
+      if (isMyanmarCodepoint(cp)) {
+        needed.add("my");
+        continue;
+      }
+      if (isEthiopicCodepoint(cp)) {
+        needed.add("am");
+        continue;
+      }
       if (cp >= 3584 && cp <= 3711) {
         needed.add("th");
         continue;
@@ -2487,6 +2599,12 @@ function detectFallbackLangs(texts, primaryLang) {
 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";
@@ -2520,6 +2638,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) {
@@ -2824,18 +2946,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);
@@ -2846,8 +2976,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);
@@ -2910,6 +3127,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; ) {
@@ -2998,6 +3217,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;
@@ -3079,6 +3299,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";
@@ -3170,56 +3441,238 @@ function tryLigature(gids, ligatures) {
   return null;
 }
 
-// src/shaping/bengali-shaper.ts
-var HALANT = 2509;
-var NUKTA = 2492;
-var RA = 2480;
-function bengaliCharType(cp) {
-  if (cp === HALANT) return 7;
-  if (cp === NUKTA) return 8;
-  if (cp >= 2433 && cp <= 2435) return 6;
-  if (cp >= 2437 && cp <= 2452) return 1;
-  if (cp >= 2453 && cp <= 2489) return 0;
-  if (cp === 2495) return 4;
-  if (cp === 2503) return 4;
-  if (cp === 2504) return 4;
-  if (cp === 2497 || cp === 2498 || cp === 2499 || cp === 2500) return 3;
-  if (cp === 2494) return 5;
-  if (cp === 2496) return 5;
-  if (cp === 2507) return 4;
-  if (cp === 2508) return 4;
-  if (cp >= 2494 && cp <= 2508) return 2;
-  if (cp === 2519) return 5;
-  if (cp >= 2534 && cp <= 2543) return 9;
-  if (cp === 2527) return 0;
-  if (cp === 2493) return 1;
-  if (cp === 2510) return 0;
-  return -1;
+// 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 isConsonant(cp) {
-  return bengaliCharType(cp) === 0;
+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 buildBengaliClusters(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;
-  }
+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";
+}
+function classifyClusters(codePoints) {
+  const out = [];
   let i = 0;
+  while (i < codePoints.length) {
+    const cluster = nextCluster(codePoints, i);
+    out.push(cluster.cluster);
+    i = cluster.next;
+  }
+  return out;
+}
+var DEVA_RA = 2352;
+var BENG_RA = 2480;
+function nextCluster(cps, start) {
+  const prebase = [];
+  const above = [];
+  const below = [];
+  const post = [];
+  const tail = [];
+  let i = start;
+  let eyelash = false;
+  const cp0 = cps[i];
+  const cat0 = classifyUseCategory(cp0);
+  const isRa = cp0 === DEVA_RA || cp0 === BENG_RA;
+  if (isRa && i + 1 < cps.length && classifyUseCategory(cps[i + 1]) === "H" && i + 2 < cps.length) {
+    const cat2 = classifyUseCategory(cps[i + 2]);
+    if (cat2 === "B") {
+      prebase.push({ cp: cp0, category: "R" });
+      i += 2;
+    } else if (cat2 === "ZWJ") {
+      prebase.push({ cp: cp0, category: "R" });
+      eyelash = true;
+      i += 3;
+    }
+  }
+  while (i < cps.length && classifyUseCategory(cps[i]) === "Mpre") {
+    prebase.push({ cp: cps[i], category: "Mpre" });
+    i++;
+  }
+  let base = null;
+  if (i < cps.length) {
+    const cat = classifyUseCategory(cps[i]);
+    if (cat === "B" || cat === "V") {
+      base = { cp: cps[i], category: cat };
+      i++;
+    }
+  }
   while (i < cps.length) {
     const cp = cps[i];
-    const type = bengaliCharType(cp);
-    if (type < 0 || cp < BENGALI_START || cp > BENGALI_END) {
-      clusters.push({ codepoints: [cp], baseIndex: 0, hasReph: false, preBaseMatras: [] });
+    const cat = classifyUseCategory(cp);
+    if (cat === "B" || cat === "V") break;
+    if (cat === "H") {
+      tail.push({ cp, category: "H" });
       i++;
-      continue;
-    }
-    const syllable = [];
-    let baseIdx = 0;
-    let hasReph = false;
-    const preMatras = [];
+      if (i < cps.length) {
+        const nextCat = classifyUseCategory(cps[i]);
+        if (nextCat === "B") {
+          tail.push({ cp: cps[i], category: "B" });
+          i++;
+        }
+      }
+      continue;
+    }
+    if (cat === "Mabv") {
+      above.push({ cp, category: "Mabv" });
+      i++;
+      continue;
+    }
+    if (cat === "Mblw") {
+      below.push({ cp, category: "Mblw" });
+      i++;
+      continue;
+    }
+    if (cat === "Mpst") {
+      post.push({ cp, category: "Mpst" });
+      i++;
+      continue;
+    }
+    if (cat === "Mpre") {
+      prebase.push({ cp, category: "Mpre" });
+      i++;
+      continue;
+    }
+    if (cat === "M") {
+      post.push({ cp, category: "M" });
+      i++;
+      continue;
+    }
+    if (cat === "ZWJ" || cat === "ZWNJ") {
+      tail.push({ cp, category: cat });
+      i++;
+      continue;
+    }
+    if (cat === "N" || cat === "O") {
+      if (!base) {
+        base = { cp, category: cat === "N" ? "N" : "O" };
+        i++;
+        continue;
+      }
+      break;
+    }
+    break;
+  }
+  if (i === start) {
+    base = { cp: cps[i], category: cat0 };
+    i++;
+  }
+  return {
+    cluster: eyelash ? { prebase, base, above, below, post, tail, eyelash: true } : { prebase, base, above, below, post, tail },
+    next: i
+  };
+}
+
+// src/shaping/bengali-shaper.ts
+var HALANT = 2509;
+var NUKTA = 2492;
+var RA = 2480;
+function bengaliCharType(cp) {
+  if (cp === HALANT) return 7;
+  if (cp === NUKTA) return 8;
+  if (cp >= 2433 && cp <= 2435) return 6;
+  if (cp >= 2437 && cp <= 2452) return 1;
+  if (cp >= 2453 && cp <= 2489) return 0;
+  if (cp === 2495) return 4;
+  if (cp === 2503) return 4;
+  if (cp === 2504) return 4;
+  if (cp === 2497 || cp === 2498 || cp === 2499 || cp === 2500) return 3;
+  if (cp === 2494) return 5;
+  if (cp === 2496) return 5;
+  if (cp === 2507) return 4;
+  if (cp === 2508) return 4;
+  if (cp >= 2494 && cp <= 2508) return 2;
+  if (cp === 2519) return 5;
+  if (cp >= 2534 && cp <= 2543) return 9;
+  if (cp === 2527) return 0;
+  if (cp === 2493) return 1;
+  if (cp === 2510) return 0;
+  return -1;
+}
+function isConsonant(cp) {
+  return bengaliCharType(cp) === 0;
+}
+function buildBengaliClusters(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 = 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++;
+      continue;
+    }
+    const syllable = [];
+    let baseIdx = 0;
+    let hasReph = false;
+    const preMatras = [];
     if (isConsonant(cp) && cp === RA && i + 2 < cps.length && cps[i + 1] === HALANT && isConsonant(cps[i + 2])) {
       hasReph = true;
       syllable.push(cp, cps[i + 1]);
@@ -3238,13 +3691,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;
           }
         }
@@ -3481,6 +3945,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++;
@@ -3497,13 +3965,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;
           }
         }
@@ -3683,8 +4162,1016 @@ function shapeTamilText(str, fontData) {
         emitGlyph(resolveGid(cp), false);
       }
     }
-    for (const postCp of splitPostComponents) {
-      emitGlyph(resolveGid(postCp), 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++) {
+      if (myanmarCharType(codepoints[ci]) === 0) {
+        baseGid = resolveGid(codepoints[ci]);
+        break;
+      }
+    }
+    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;
+      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 = myanmarCharType(codepoints[origCi]);
+          if (ct === 7 || ct === 8) 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 = 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 = markStart; ci < codepoints.length; ci++) {
+      const cp = codepoints[ci];
+      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;
@@ -3736,7 +5223,7 @@ function devanagariCharType(cp) {
   if (cp === 2384) return 1;
   return -1;
 }
-function isConsonant3(cp) {
+function isConsonant7(cp) {
   return devanagariCharType(cp) === 0;
 }
 function buildDevanagariClusters(str) {
@@ -3751,6 +5238,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++;
@@ -3759,7 +5250,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;
@@ -3777,13 +5268,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;
           }
         }
@@ -4141,6 +5643,448 @@ function shapeArabicText(str, fontData) {
   return glyphs;
 }
 
+// src/fonts/font-loader.ts
+var _fontRegistry = /* @__PURE__ */ new Map();
+var _fontDataCache = /* @__PURE__ */ new Map();
+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;
+}
+function registerFont(lang, loader) {
+  _fontRegistry.set(lang, loader);
+}
+function registerFonts(fonts) {
+  for (const [lang, loader] of Object.entries(fonts)) {
+    _fontRegistry.set(lang, loader);
+  }
+}
+async function loadFontData(lang) {
+  const cached = _fontDataCache.get(lang);
+  if (cached) return cached;
+  const loader = _fontRegistry.get(lang);
+  if (!loader) return null;
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const mod2 = await loader();
+      const fontData = "default" in mod2 ? mod2.default : mod2;
+      _fontDataCache.set(lang, fontData);
+      return fontData;
+    } catch {
+      if (attempt === 0) {
+        await new Promise((r) => setTimeout(r, 500));
+      }
+    }
+  }
+  return null;
+}
+function hasFontLoader(lang) {
+  return _fontRegistry.has(lang);
+}
+function getRegisteredLangs() {
+  return [..._fontRegistry.keys()];
+}
+function clearFontCache() {
+  _fontDataCache.clear();
+}
+function resetFontRegistry() {
+  _fontRegistry.clear();
+  _fontDataCache.clear();
+}
+
+// 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;
@@ -4245,13 +6189,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"
@@ -4264,6 +6209,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,
@@ -4273,8 +6219,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)) {
@@ -4341,6 +6289,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;
@@ -4398,6 +6396,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;
@@ -4414,6 +6467,7 @@ function createEncodingContext(fontEntries, pdfA = false) {
     },
     ps(str) {
       if (!str) return "<>";
+      str = _norm(str);
       str = stripBidiControls(str);
       if (!str) return "<>";
       const { cmap } = primary.fontData;
@@ -4442,7 +6496,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;
@@ -4454,7 +6508,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) {
@@ -4523,77 +6577,17 @@ function buildSubsetWidthArray(widths, usedGids) {
   if (sorted.length === 0) return null;
   const parts = [];
   let i = 0;
-  while (i < sorted.length) {
-    const start = sorted[i];
-    const run = [widths[start]];
-    while (i + 1 < sorted.length && sorted[i + 1] === sorted[i] + 1) {
-      i++;
-      run.push(widths[sorted[i]]);
-    }
-    parts.push(`${start} [${run.join(" ")}]`);
-    i++;
-  }
-  return parts.join(" ");
-}
-
-// src/fonts/font-loader.ts
-var _fontRegistry = /* @__PURE__ */ new Map();
-var _fontDataCache = /* @__PURE__ */ new Map();
-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;
-}
-function registerFont(lang, loader) {
-  _fontRegistry.set(lang, loader);
-}
-function registerFonts(fonts) {
-  for (const [lang, loader] of Object.entries(fonts)) {
-    _fontRegistry.set(lang, loader);
-  }
-}
-async function loadFontData(lang) {
-  const cached = _fontDataCache.get(lang);
-  if (cached) return cached;
-  const loader = _fontRegistry.get(lang);
-  if (!loader) return null;
-  for (let attempt = 0; attempt < 2; attempt++) {
-    try {
-      const mod2 = await loader();
-      const fontData = "default" in mod2 ? mod2.default : mod2;
-      _fontDataCache.set(lang, fontData);
-      return fontData;
-    } catch {
-      if (attempt === 0) {
-        await new Promise((r) => setTimeout(r, 500));
-      }
+  while (i < sorted.length) {
+    const start = sorted[i];
+    const run = [widths[start]];
+    while (i + 1 < sorted.length && sorted[i + 1] === sorted[i] + 1) {
+      i++;
+      run.push(widths[sorted[i]]);
     }
+    parts.push(`${start} [${run.join(" ")}]`);
+    i++;
   }
-  return null;
-}
-function hasFontLoader(lang) {
-  return _fontRegistry.has(lang);
-}
-function getRegisteredLangs() {
-  return [..._fontRegistry.keys()];
-}
-function clearFontCache() {
-  _fontDataCache.clear();
-}
-function resetFontRegistry() {
-  _fontRegistry.clear();
-  _fontDataCache.clear();
+  return parts.join(" ");
 }
 
 // src/fonts/font-subsetter.ts
@@ -4909,7 +6903,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());
@@ -5191,26 +7185,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");
 }
@@ -5290,6 +7303,7 @@ var PG_W = 595.28;
 var PG_H = 841.89;
 var DEFAULT_MARGINS = { t: 45, r: 36, b: 35, l: 36 };
 var DEFAULT_CW = PG_W - DEFAULT_MARGINS.l - DEFAULT_MARGINS.r;
+var DEFAULT_MAX_BLOCKS = 1e5;
 var ROW_H = 12;
 var TH_H = 15;
 var INFO_LN = 13;
@@ -5327,12 +7341,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 fixed2 = 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;
@@ -5346,7 +7360,7 @@ function computeColumnPositions(columns, marginLeft, contentWidth) {
     }
     if (clamped) {
       cwi[i] = w;
-      fixed[i] = true;
+      fixed2[i] = true;
       totalFixed += w;
     } else {
       freeWeight += col.f;
@@ -5354,13 +7368,13 @@ function computeColumnPositions(columns, marginLeft, contentWidth) {
   }
   const remaining = contentWidth - totalFixed;
   if (freeWeight > 0) {
-    for (let i = 0; i < n; i++) {
-      if (!fixed[i]) cwi[i] = columns[i].f / freeWeight * remaining;
+    for (let i = 0; i < n2; i++) {
+      if (!fixed2[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];
   }
@@ -5401,8 +7415,8 @@ function isValidPdfRgb(str) {
   if (!PDF_RGB_RE.test(str)) return false;
   const parts = str.split(" ");
   return parts.length === 3 && parts.every((p) => {
-    const n = Number(p);
-    return n >= 0 && n <= 1;
+    const n2 = Number(p);
+    return n2 >= 0 && n2 <= 1;
   });
 }
 function normalizeColors(colors) {
@@ -5421,8 +7435,8 @@ function normalizeColors(colors) {
     footer: parseColor(colors.footer)
   };
 }
-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);
 }
@@ -5464,8 +7478,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.`
       );
@@ -5926,7 +7940,7 @@ function _buildTextWatermarkOps(wm, pgW, pgH, enc, gsName) {
   const textWidth = enc.tw(wm.text, sz);
   const offsetX = -textWidth / 2;
   const offsetY = -sz * capRatio / 2;
-  const tx = cx + offsetX * cos - offsetY * sin;
+  const tx2 = cx + offsetX * cos - offsetY * sin;
   const ty = cy + offsetX * sin + offsetY * cos;
   const escapedText = enc.ps(wm.text);
   const ops = [
@@ -5935,7 +7949,7 @@ function _buildTextWatermarkOps(wm, pgW, pgH, enc, gsName) {
     "BT",
     `${color} rg`,
     `${enc.f2} ${fmtNum(sz)} Tf`,
-    `${fmtNum(cos)} ${fmtNum(sin)} ${fmtNum(-sin)} ${fmtNum(cos)} ${fmtNum(tx)} ${fmtNum(ty)} Tm`,
+    `${fmtNum(cos)} ${fmtNum(sin)} ${fmtNum(-sin)} ${fmtNum(cos)} ${fmtNum(tx2)} ${fmtNum(ty)} Tm`,
     `${escapedText} Tj`,
     "ET",
     "Q"
@@ -6090,6 +8104,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");
   }
@@ -6115,7 +8132,7 @@ function buildPDF(params, layoutOptions) {
   const fontEntries = params.fontEntries || (fontData ? [{ fontData, fontRef: "/F3", lang: "unknown" }] : []);
   const pdfaConfig = resolvePdfAConfig(layoutOptions?.tagged);
   const tagged = pdfaConfig.enabled;
-  const enc = createEncodingContext(fontEntries, tagged);
+  const enc = createEncodingContext(fontEntries, tagged, layoutOptions?.normalize ?? false);
   const footerTpl = layoutOptions?.footerTemplate ?? {
     left: footerText || void 0,
     right: "{page}/{pages}"
@@ -6123,7 +8140,7 @@ function buildPDF(params, layoutOptions) {
   const headerTpl = layoutOptions?.headerTemplate;
   const headerH = headerTpl ? HEADER_H : 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;
@@ -6157,6 +8174,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;
@@ -6313,8 +8333,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];
@@ -6386,8 +8406,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} >>`);
     const wmObjStartLatin = 5;
     let wmGsResLatin = "";
     let wmImgResLatin = "";
@@ -6419,13 +8439,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;
   let afArrayStr = "";
@@ -6469,7 +8494,7 @@ function buildPDF(params, layoutOptions) {
           emitObj(objNum, content);
         }
       }
-      afArrayStr = efResult.filespecObjNums.map((n) => `${n} 0 R`).join(" ");
+      afArrayStr = efResult.filespecObjNums.map((n2) => `${n2} 0 R`).join(" ");
       embeddedFilesNamesDict = efResult.namesDict;
       totalObjs += efResult.totalObjects;
     }
@@ -6500,7 +8525,7 @@ endobj
   }
   const writer = { emit, emitObj, emitStreamObj, offset: getOffset, adjustOffset, objOffsets, parts };
   writeXrefTrailer(writer, totalObjs, infoObjNum, encState, `${infoTitle}|${pdfDate}`);
-  return parts.join("");
+  return parts;
 }
 function buildPDFBytes(params, layoutOptions) {
   return toBytes(buildPDF(params, layoutOptions));
@@ -6522,8 +8547,8 @@ var CHECK_COLOR = "0 0 0";
 function pdfStr(s) {
   return s.replace(/\\/g, "\\\\").replace(/\(/g, "\\(").replace(/\)/g, "\\)");
 }
-function fmtNum2(n) {
-  return Math.round(n * 100) / 100 === Math.round(n) ? String(Math.round(n)) : (Math.round(n * 100) / 100).toString();
+function fmtNum2(n2) {
+  return Math.round(n2 * 100) / 100 === Math.round(n2) ? String(Math.round(n2)) : (Math.round(n2 * 100) / 100).toString();
 }
 function defaultFieldHeight(fieldType) {
   switch (fieldType) {
@@ -6819,7 +8844,7 @@ function buildFormWidget(field, apObjNum, radioCtx) {
   return { widgetDict, appearanceStream: apStream, apYesStream, apOffStream };
 }
 function buildAcroFormDict(fieldObjNums, fontObjNum) {
-  const refs = fieldObjNums.map((n) => `${n} 0 R`).join(" ");
+  const refs = fieldObjNums.map((n2) => `${n2} 0 R`).join(" ");
   const fontEntry = fontObjNum !== void 0 ? `/Helv ${fontObjNum} 0 R` : "/Helv << /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding >>";
   return `/AcroForm << /Fields [${refs}] /DR << /Font << ${fontEntry} >> >> /NeedAppearances false >>`;
 }
@@ -6831,7 +8856,7 @@ function buildRadioGroupParent(name, selectedValue, childObjNums, readOnly, requ
   let ff = FF_RADIO | FF_NO_TOGGLE_TO_OFF;
   if (readOnly) ff |= FF_READONLY;
   if (required) ff |= FF_REQUIRED;
-  const kids = childObjNums.map((n) => `${n} 0 R`).join(" ");
+  const kids = childObjNums.map((n2) => `${n2} 0 R`).join(" ");
   const v = selectedValue ? `/${selectedValue}` : "/Off";
   return `<< /FT /Btn /Ff ${ff} /T (${pdfStr(name)}) /V ${v} /Kids [${kids}] >>`;
 }
@@ -7376,14 +9401,14 @@ function generateQR(data, ecLevel = "M") {
 }
 function renderQR(data, x, y, size, ecLevel = "M") {
   const modules = generateQR(data, ecLevel);
-  const n = modules.length;
-  const moduleSize = size / n;
+  const n2 = modules.length;
+  const moduleSize = size / n2;
   const ops = ["q", "0 0 0 rg"];
-  for (let row = 0; row < n; row++) {
-    for (let col = 0; col < n; col++) {
+  for (let row = 0; row < n2; row++) {
+    for (let col = 0; col < n2; col++) {
       if (modules[row][col]) {
         const mx = x + col * moduleSize;
-        const my = y + (n - 1 - row) * moduleSize;
+        const my = y + (n2 - 1 - row) * moduleSize;
         ops.push(`${fmtNum(mx)} ${fmtNum(my)} ${fmtNum(moduleSize)} ${fmtNum(moduleSize)} re f`);
       }
     }
@@ -8003,14 +10028,14 @@ function generateDataMatrix(data) {
 }
 function renderDataMatrix(data, x, y, size) {
   const modules = generateDataMatrix(data);
-  const n = modules.length;
-  const moduleSize = size / n;
+  const n2 = modules.length;
+  const moduleSize = size / n2;
   const ops = ["q", "0 0 0 rg"];
-  for (let row = 0; row < n; row++) {
+  for (let row = 0; row < n2; row++) {
     for (let col = 0; col < modules[row].length; col++) {
       if (modules[row][col]) {
         const mx = x + col * moduleSize;
-        const my = y + (n - 1 - row) * moduleSize;
+        const my = y + (n2 - 1 - row) * moduleSize;
         ops.push(`${fmtNum(mx)} ${fmtNum(my)} ${fmtNum(moduleSize)} ${fmtNum(moduleSize)} re f`);
       }
     }
@@ -8328,18 +10353,18 @@ function tokenize(d) {
   const len = d.length;
   let i = 0;
   while (i < len) {
-    const ch = d.charCodeAt(i);
-    if (ch === 32 || ch === 44 || ch === 9 || ch === 10 || ch === 13) {
+    const ch2 = d.charCodeAt(i);
+    if (ch2 === 32 || ch2 === 44 || ch2 === 9 || ch2 === 10 || ch2 === 13) {
       i++;
       continue;
     }
-    if (ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122) {
+    if (ch2 >= 65 && ch2 <= 90 || ch2 >= 97 && ch2 <= 122) {
       tokens.push(d[i]);
       i++;
       continue;
     }
     const start = i;
-    if (ch === 43 || ch === 45) i++;
+    if (ch2 === 43 || ch2 === 45) i++;
     let hasDot = false;
     while (i < len) {
       const c = d.charCodeAt(i);
@@ -8671,7 +10696,7 @@ function parseSvgMarkup(svg) {
   let viewBox;
   if (vbMatch) {
     const p = vbMatch[1].trim().split(/[\s,]+/).map(Number);
-    if (p.length === 4 && p.every((n) => !isNaN(n))) {
+    if (p.length === 4 && p.every((n2) => !isNaN(n2))) {
       viewBox = [p[0], p[1], p[2], p[3]];
     }
   }
@@ -8726,7 +10751,7 @@ function parseSvgMarkup(svg) {
   }
   return { elements, viewBox };
 }
-var fn = (n) => n.toFixed(2);
+var fn = (n2) => n2.toFixed(2);
 function resolveColor(color, fallback) {
   if (color === "none") return null;
   if (color !== void 0) return parseColor(color);
@@ -8798,10 +10823,10 @@ var CELL_PAD_LEFT = 3;
 var CELL_PAD_RIGHT = 3;
 var CELL_PAD_TOTAL = CELL_PAD_LEFT + CELL_PAD_RIGHT;
 function computeAutoFitColumns(columns, headers, rows, enc, thSize, tdSize) {
-  const n = columns.length;
-  if (n === 0) return [];
-  const desired = new Array(n).fill(0);
-  for (let i = 0; i < n; i++) {
+  const n2 = columns.length;
+  if (n2 === 0) return [];
+  const desired = new Array(n2).fill(0);
+  for (let i = 0; i < n2; i++) {
     let max = 0;
     const hdr = headers[i];
     if (hdr) {
@@ -8817,10 +10842,10 @@ function computeAutoFitColumns(columns, headers, rows, enc, thSize, tdSize) {
     desired[i] = max + CELL_PAD_TOTAL;
   }
   let total = 0;
-  for (let i = 0; i < n; i++) total += desired[i];
+  for (let i = 0; i < n2; i++) total += desired[i];
   if (total <= 0) return columns.slice();
-  const out = new Array(n);
-  for (let i = 0; i < n; i++) {
+  const out = new Array(n2);
+  for (let i = 0; i < n2; i++) {
     out[i] = { ...columns[i], f: desired[i] / total };
   }
   return out;
@@ -8861,20 +10886,20 @@ function isCJKBreakable(cp) {
 function tokenizeForWrap(text) {
   const segments = [];
   let buf = "";
-  for (const ch of text) {
-    const cp = ch.codePointAt(0) ?? 0;
+  for (const ch2 of text) {
+    const cp = ch2.codePointAt(0) ?? 0;
     if (isCJKBreakable(cp)) {
       if (buf) {
         segments.push(buf);
         buf = "";
       }
-      segments.push(ch);
+      segments.push(ch2);
     } else if (cp === 32 || cp === 9) {
-      buf += ch;
+      buf += ch2;
       segments.push(buf);
       buf = "";
     } else {
-      buf += ch;
+      buf += ch2;
     }
   }
   if (buf) segments.push(buf);
@@ -8883,14 +10908,14 @@ function tokenizeForWrap(text) {
 function hardBreakSegment(seg, maxWidth, fontSize, enc) {
   const pieces = [];
   let buf = "";
-  for (const ch of seg) {
-    const candidate = buf + ch;
+  for (const ch2 of seg) {
+    const candidate = buf + ch2;
     const w = measureText(candidate, fontSize, enc);
     if (w <= maxWidth || buf === "") {
       buf = candidate;
     } else {
       pieces.push(buf);
-      buf = ch;
+      buf = ch2;
     }
   }
   if (buf) pieces.push(buf);
@@ -9132,7 +11157,7 @@ function renderTable(block, y, enc, mgL, mgR, pgW, cw, tagCtx, documentChildren,
   const clipCell = (op, i, top, h) => clip ? `q ${fmtNum(cx[i])} ${fmtNum(top - h)} ${fmtNum(cwi[i])} ${fmtNum(h)} re W n
 ${op}
 Q` : op;
-  function emitCell(lines, colIdx, rowTop, rowH, font, sz, targetMcid, isHeader) {
+  function emitCell(lines, colIdx, rowTop, rowH, font, sz, mcRefsOut, isHeader) {
     const col = columns[colIdx];
     const out = [];
     const lineH = sz * TABLE_LINE_HEIGHT;
@@ -9141,13 +11166,15 @@ Q` : op;
       const t = lines.length === 1 && wrapMode === "never" ? truncate(lines[li], isHeader && col.mxH !== void 0 ? col.mxH : col.mx) : lines[li];
       const baselineY = lines.length === 1 ? rowTop - rowH + padBottom : rowTop - pad - sz + sz * 0.2 - li * lineH;
       let op;
-      if (targetMcid !== null) {
+      if (mcRefsOut !== null && tagCtx?.tagged) {
+        const mcid = tagCtx.mcidAlloc.next(tagCtx.pageObjNum);
+        mcRefsOut.push({ mcid, pageObjNum: tagCtx.pageObjNum });
         if (col.a === "r") {
-          op = txtRTagged(t, cx[colIdx] + cwi[colIdx] - pad, baselineY, font, sz, enc, targetMcid, isHeader);
+          op = txtRTagged(t, cx[colIdx] + cwi[colIdx] - pad, baselineY, font, sz, enc, mcid, isHeader);
         } else if (col.a === "c") {
-          op = txtCTagged(t, cx[colIdx], baselineY, font, sz, cwi[colIdx], enc, targetMcid, isHeader);
+          op = txtCTagged(t, cx[colIdx], baselineY, font, sz, cwi[colIdx], enc, mcid, isHeader);
         } else {
-          op = txtTagged(t, cx[colIdx] + pad, baselineY, font, sz, enc, targetMcid);
+          op = txtTagged(t, cx[colIdx] + pad, baselineY, font, sz, enc, mcid);
         }
       } else {
         if (col.a === "r") {
@@ -9166,22 +11193,20 @@ Q` : op;
     ops.push(`${colors.text} rg`);
     const lineH = CAPTION_FONT_SIZE * TABLE_LINE_HEIGHT;
     let cy = y - CAPTION_FONT_SIZE;
-    let captionMcid = null;
-    if (tagCtx?.tagged) {
-      captionMcid = tagCtx.mcidAlloc.next(tagCtx.pageObjNum);
-      tableStructAccum.push({
-        type: "Caption",
-        children: [{ mcid: captionMcid, pageObjNum: tagCtx.pageObjNum }]
-      });
-    }
+    const captionRefs = tagCtx?.tagged ? [] : null;
     for (const line of plan.captionLines) {
-      if (captionMcid !== null) {
-        ops.push(txtCTagged(line, mgL, cy, enc.f2, CAPTION_FONT_SIZE, cw, enc, captionMcid, true));
+      if (captionRefs !== null && tagCtx?.tagged) {
+        const mcid = tagCtx.mcidAlloc.next(tagCtx.pageObjNum);
+        captionRefs.push({ mcid, pageObjNum: tagCtx.pageObjNum });
+        ops.push(txtCTagged(line, mgL, cy, enc.f2, CAPTION_FONT_SIZE, cw, enc, mcid, true));
       } else {
         ops.push(txtC(line, mgL, cy, enc.f2, CAPTION_FONT_SIZE, cw, enc, true));
       }
       cy -= lineH;
     }
+    if (captionRefs && captionRefs.length > 0) {
+      tableStructAccum.push({ type: "Caption", children: captionRefs });
+    }
     y -= plan.captionHeight;
   }
   if (drawHeader) {
@@ -9192,12 +11217,11 @@ Q` : op;
     ops.push(`${colors.text} rg`);
     const thChildren = [];
     for (let i = 0; i < block.headers.length && i < columns.length; i++) {
-      let mcid = null;
-      if (tagCtx?.tagged) {
-        mcid = tagCtx.mcidAlloc.next(tagCtx.pageObjNum);
-        thChildren.push({ type: "TH", children: [{ mcid, pageObjNum: tagCtx.pageObjNum }] });
+      const cellRefs = tagCtx?.tagged ? [] : null;
+      ops.push(...emitCell(headerLines[i] ?? [""], i, y, headerHeight, enc.f2, fs.th, cellRefs, true));
+      if (cellRefs && cellRefs.length > 0) {
+        thChildren.push({ type: "TH", children: cellRefs });
       }
-      ops.push(...emitCell(headerLines[i] ?? [""], i, y, headerHeight, enc.f2, fs.th, mcid, true));
     }
     if (tagCtx?.tagged && thChildren.length > 0) {
       tableStructAccum.push({ type: "TR", children: thChildren });
@@ -9220,12 +11244,11 @@ Q` : op;
       const color = isAmount ? row.type === "credit" ? colors.credit : colors.debit : colors.text;
       const font = isAmount ? enc.f2 : enc.f1;
       ops.push(`${color} rg`);
-      let mcid = null;
-      if (tagCtx?.tagged) {
-        mcid = tagCtx.mcidAlloc.next(tagCtx.pageObjNum);
-        tdChildren.push({ type: "TD", children: [{ mcid, pageObjNum: tagCtx.pageObjNum }] });
+      const cellRefs = tagCtx?.tagged ? [] : null;
+      ops.push(...emitCell(cells[i] ?? [""], i, y, rowH, font, fs.td, cellRefs, false));
+      if (cellRefs && cellRefs.length > 0) {
+        tdChildren.push({ type: "TD", children: cellRefs });
       }
-      ops.push(...emitCell(cells[i] ?? [""], i, y, rowH, font, fs.td, mcid, false));
     }
     if (tagCtx?.tagged && tdChildren.length > 0) {
       tableStructAccum.push({ type: "TR", children: tdChildren });
@@ -9638,16 +11661,20 @@ function estimateBlockHeight(block, enc, cw, headings) {
 
 // src/core/pdf-document.ts
 function buildDocumentPDF(params, layoutOptions) {
+  return assembleDocumentParts(params, layoutOptions).join("");
+}
+function assembleDocumentParts(params, layoutOptions) {
   if (!params || typeof params !== "object") {
     throw new Error("buildDocumentPDF: params is required and must be an object");
   }
   if (!Array.isArray(params.blocks)) {
     throw new Error("buildDocumentPDF: params.blocks must be an array");
   }
-  if (params.blocks.length > 1e4) {
-    throw new Error(`buildDocumentPDF: block count (${params.blocks.length}) exceeds safe limit (10,000)`);
-  }
   const layout = layoutOptions ?? params.layout;
+  const maxBlocks = layout?.maxBlocks ?? DEFAULT_MAX_BLOCKS;
+  if (params.blocks.length > maxBlocks) {
+    throw new Error(`buildDocumentPDF: block count (${params.blocks.length}) exceeds safe limit (${maxBlocks}). Raise it via layout.maxBlocks if this is intentional.`);
+  }
   const pgW = layout?.pageWidth ?? PG_W;
   const pgH = layout?.pageHeight ?? PG_H;
   const mg = layout?.margins ?? { ...DEFAULT_MARGINS };
@@ -9655,7 +11682,7 @@ function buildDocumentPDF(params, layoutOptions) {
   const fontEntries = params.fontEntries ? [...params.fontEntries] : [];
   const pdfaConfig = resolvePdfAConfig(layout?.tagged);
   const tagged = pdfaConfig.enabled;
-  const enc = createEncodingContext(fontEntries, tagged);
+  const enc = createEncodingContext(fontEntries, tagged, layout?.normalize ?? false);
   const encryptionOpts = layout?.encryption;
   if (tagged && encryptionOpts) {
     throw new Error("PDF/A and encryption are mutually exclusive (ISO 19005-1 \xA76.3.2)");
@@ -9678,7 +11705,7 @@ function buildDocumentPDF(params, layoutOptions) {
   const headerTpl = layout?.headerTemplate;
   const headerH = headerTpl ? HEADER_H : 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 docTitle = params.title ?? "";
   const availableH = pgH - mg.t - mg.b - FT_H - headerH;
@@ -10040,6 +12067,15 @@ function buildDocumentPDF(params, layoutOptions) {
   const numRadioGroups = radioGroups.size;
   const totalFormObjs = totalFieldObjs + numRadioGroups;
   const formFontObjs = totalFormFields > 0 ? 1 : 0;
+  const preBaseObjCount = enc.isUnicode && fontEntries.length > 0 ? 4 + fontEntries.length * 5 + imageCount + wmExtraObjs + totalPages * 2 + totalAnnots + totalFormObjs + formFontObjs : 4 + imageCount + wmExtraObjs + totalPages * 2 + totalAnnots + totalFormObjs + formFontObjs;
+  const latinToUniObjNum = tagged ? 0 : preBaseObjCount + 2;
+  const baseFontToUniRef = latinToUniObjNum ? ` /ToUnicode ${latinToUniObjNum} 0 R` : "";
+  const colorEmojiForms = enc.colorEmoji?.forms ?? [];
+  const colorEmojiStart = colorEmojiForms.length > 0 ? (latinToUniObjNum || preBaseObjCount + 1) + 1 : 0;
+  let colorEmojiXObjRefs = "";
+  for (let k = 0; k < colorEmojiForms.length; k++) {
+    colorEmojiXObjRefs += ` /${colorEmojiForms[k].name} ${colorEmojiStart + k} 0 R`;
+  }
   const { emit, emitObj, emitStreamObj, offset: getOffset, adjustOffset, objOffsets, parts } = createPdfWriter(compress, encState);
   emit(`%PDF-${pdfaConfig.pdfVersion}
 `);
@@ -10070,9 +12106,10 @@ function buildDocumentPDF(params, layoutOptions) {
       wmImgRef = `/ImW1 ${wmObjStart + wmObjIdx} 0 R`;
     }
   }
-  if (imgXObjRes || wmImgRef) {
+  if (imgXObjRes || wmImgRef || colorEmojiXObjRefs) {
     if (!imgXObjRes) imgXObjRes = " /XObject <<";
     if (wmImgRef) imgXObjRes += ` ${wmImgRef}`;
+    imgXObjRes += colorEmojiXObjRefs;
     imgXObjRes += " >>";
   }
   if (enc.isUnicode && fontEntries.length > 0) {
@@ -10090,8 +12127,8 @@ function buildDocumentPDF(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];
@@ -10245,8 +12282,8 @@ function buildDocumentPDF(params, layoutOptions) {
       kids.push(`${5 + imageCount + wmExtraObjs + 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} >>`);
     for (let i = 0; i < imageCount; i++) {
       const img = resolvedImages[i];
       emitObj(imageObjStart + i, buildImageXObject(img.parsed));
@@ -10364,7 +12401,7 @@ function buildDocumentPDF(params, layoutOptions) {
   }
   const baseObjCount = enc.isUnicode ? 4 + fontEntries.length * 5 + imageCount + wmExtraObjs + totalPages * 2 + totalAnnots + totalFormObjs + formFontObjs : 4 + imageCount + wmExtraObjs + totalPages * 2 + totalAnnots + totalFormObjs + formFontObjs;
   const infoObjNum = baseObjCount + 1;
-  const { pdfDate, xmpDate: isoDate } = buildPdfMetadata();
+  const { pdfDate, xmpDate: isoDate } = buildPdfMetadata(layout?.creationDate);
   const infoTitle = params.title ?? "";
   const metaParts = [`/Title ${encodePdfTextString(infoTitle)}`, "/Producer (pdfnative)", `/CreationDate (${pdfDate})`];
   if (params.metadata?.author) {
@@ -10378,6 +12415,24 @@ function buildDocumentPDF(params, layoutOptions) {
   }
   emitObj(infoObjNum, `<< ${metaParts.join(" ")} >>`);
   let totalObjs = infoObjNum;
+  if (latinToUniObjNum) {
+    const cmap = buildWinAnsiToUnicodeCMap();
+    emitStreamObj(latinToUniObjNum, `<< /Length ${cmap.length}`, cmap);
+    totalObjs = latinToUniObjNum;
+  }
+  if (colorEmojiForms.length > 0) {
+    for (let k = 0; k < colorEmojiForms.length; k++) {
+      const f = colorEmojiForms[k];
+      const objNum = colorEmojiStart + k;
+      const res = f.resources ? ` /Resources << ${f.resources} >>` : "";
+      emitStreamObj(
+        objNum,
+        `<< /Type /XObject /Subtype /Form /BBox [${f.bbox.join(" ")}]${res} /Length ${f.content.length}`,
+        f.content
+      );
+    }
+    totalObjs = colorEmojiStart + colorEmojiForms.length - 1;
+  }
   let xmpObjNum = 0;
   let outputIntentObjNum = 0;
   let afArrayStr = "";
@@ -10421,7 +12476,7 @@ function buildDocumentPDF(params, layoutOptions) {
           emitObj(objNum, content);
         }
       }
-      afArrayStr = efResult.filespecObjNums.map((n) => `${n} 0 R`).join(" ");
+      afArrayStr = efResult.filespecObjNums.map((n2) => `${n2} 0 R`).join(" ");
       embeddedFilesNamesDict = efResult.namesDict;
       totalObjs += efResult.totalObjects;
     }
@@ -10499,7 +12554,7 @@ endobj
   }
   const writer = { emit, emitObj, emitStreamObj, offset: getOffset, adjustOffset, objOffsets, parts };
   writeXrefTrailer(writer, totalObjs, infoObjNum, encState, `${infoTitle}|${pdfDate}`);
-  return parts.join("");
+  return parts;
 }
 function buildDocumentPDFBytes(params, layoutOptions) {
   return toBytes(buildDocumentPDF(params, layoutOptions));
@@ -10690,8 +12745,8 @@ function formatPdfDate(d) {
   const sec = String(d.getUTCSeconds()).padStart(2, "0");
   return `${y}${m}${day}${h}${min}${sec}Z`;
 }
-function padNum(n) {
-  return String(n).padStart(10, "0");
+function padNum(n2) {
+  return String(n2).padStart(10, "0");
 }
 function uint8ToLatin1(bytes) {
   let s = "";
@@ -11292,15 +13347,15 @@ function buildHuffmanTable(lengths, maxSymbol) {
   }
   return { counts, symbols };
 }
-function readBits(br, n) {
-  while (br.bitCnt < n) {
+function readBits(br, n2) {
+  while (br.bitCnt < n2) {
     if (br.pos >= br.buf.length) throw new Error("inflate: unexpected end of data");
     br.bitBuf |= br.buf[br.pos++] << br.bitCnt;
     br.bitCnt += 8;
   }
-  const val = br.bitBuf & (1 << n) - 1;
-  br.bitBuf >>>= n;
-  br.bitCnt -= n;
+  const val = br.bitBuf & (1 << n2) - 1;
+  br.bitBuf >>>= n2;
+  br.bitCnt -= n2;
   return val;
 }
 function decodeSymbol(br, table) {
@@ -11609,8 +13664,8 @@ function getTrailerRef(trailer, key) {
 
 // src/parser/pdf-decode-filters.ts
 var MAX_DECODE_OUTPUT = 256 * 1024 * 1024;
-function checkOutputSize(n, filter) {
-  if (n > MAX_DECODE_OUTPUT) {
+function checkOutputSize(n2, filter) {
+  if (n2 > MAX_DECODE_OUTPUT) {
     throw new Error(
       `${filter} output exceeds ${MAX_DECODE_OUTPUT} bytes (possible zip-bomb)`
     );
@@ -11740,17 +13795,17 @@ function decodeRunLength(data) {
   const out = [];
   let p = 0;
   while (p < data.length) {
-    const n = data[p++];
-    if (n === 128) break;
-    if (n < 128) {
-      const len = n + 1;
+    const n2 = data[p++];
+    if (n2 === 128) break;
+    if (n2 < 128) {
+      const len = n2 + 1;
       if (p + len > data.length) throw new Error("RunLengthDecode: truncated literal");
       for (let i = 0; i < len; i++) out.push(data[p + i]);
       p += len;
     } else {
       if (p >= data.length) throw new Error("RunLengthDecode: truncated repeat");
       const v = data[p++];
-      const len = 257 - n;
+      const len = 257 - n2;
       for (let i = 0; i < len; i++) out.push(v);
     }
     checkOutputSize(out.length, "RunLengthDecode");
@@ -11915,11 +13970,11 @@ function resolveCompressedObject(buf, xref, _cache, streamObjNum, indexInStream,
   if (filter === "FlateDecode") {
     data = inflateSync(data);
   }
-  const n = dictGetNum(streamObj.dict, "N") ?? 0;
+  const n2 = dictGetNum(streamObj.dict, "N") ?? 0;
   const first = dictGetNum(streamObj.dict, "First") ?? 0;
   const headerTok = createTokenizer(data, 0);
   const objectOffsets = [];
-  for (let i = 0; i < n; i++) {
+  for (let i = 0; i < n2; i++) {
     const numTok = headerTok.next();
     const offTok = headerTok.next();
     if (!numTok || !offTok) break;
@@ -12429,6 +14484,38 @@ async function* buildPDFStream(params, layoutOptions, streamOptions) {
   const binary = buildPDF(params, layoutOptions);
   yield* chunkBinaryString(binary, chunkSize);
 }
+function* streamPartsChunked(parts, chunkSize) {
+  let buf = new Uint8Array(chunkSize);
+  let filled = 0;
+  for (let p = 0; p < parts.length; p++) {
+    const part = parts[p];
+    parts[p] = "";
+    const len = part.length;
+    for (let i = 0; i < len; i++) {
+      buf[filled++] = part.charCodeAt(i) & 255;
+      if (filled === chunkSize) {
+        yield buf;
+        buf = new Uint8Array(chunkSize);
+        filled = 0;
+      }
+    }
+  }
+  if (filled > 0) {
+    yield buf.subarray(0, filled);
+  }
+}
+async function* buildDocumentPDFStreamTrue(params, layoutOptions, streamOptions) {
+  validateDocumentStreamable(params, layoutOptions);
+  const chunkSize = resolveChunkSize(streamOptions?.chunkSize);
+  const parts = assembleDocumentParts(params, layoutOptions);
+  yield* streamPartsChunked(parts, chunkSize);
+}
+async function* buildPDFStreamTrue(params, layoutOptions, streamOptions) {
+  validateTableStreamable(params, layoutOptions);
+  const chunkSize = resolveChunkSize(streamOptions?.chunkSize);
+  const parts = assembleTableParts(params, layoutOptions);
+  yield* streamPartsChunked(parts, chunkSize);
+}
 function concatChunks(chunks) {
   let totalLen = 0;
   for (let i = 0; i < chunks.length; i++) totalLen += chunks[i].length;
@@ -12662,177 +14749,374 @@ async function initCrypto() {
   initEcdsaAsn12(asn1);
 }
 
-// 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";
-}
-function classifyClusters(codePoints) {
-  const out = [];
-  let i = 0;
-  while (i < codePoints.length) {
-    const cluster = nextCluster(codePoints, i);
-    out.push(cluster.cluster);
-    i = cluster.next;
-  }
-  return out;
+// src/fonts/colr-parser.ts
+var IDENTITY = [1, 0, 0, 1, 0, 0];
+function compose(outer, inner) {
+  const [a1, b1, c1, d1, e1, f1] = outer;
+  const [a2, b2, c2, d2, e2, f2] = inner;
+  return [
+    a1 * a2 + c1 * b2,
+    b1 * a2 + d1 * b2,
+    a1 * c2 + c1 * d2,
+    b1 * c2 + d1 * d2,
+    a1 * e2 + c1 * f2 + e1,
+    b1 * e2 + d1 * f2 + f1
+  ];
 }
-var DEVA_RA = 2352;
-var BENG_RA = 2480;
-function nextCluster(cps, start) {
-  const prebase = [];
-  const above = [];
-  const below = [];
-  const post = [];
-  const tail = [];
-  let i = start;
-  const cp0 = cps[i];
-  const cat0 = classifyUseCategory(cp0);
-  const isRa = cp0 === DEVA_RA || cp0 === BENG_RA;
-  if (isRa && i + 1 < cps.length && classifyUseCategory(cps[i + 1]) === "H" && i + 2 < cps.length) {
-    const cat2 = classifyUseCategory(cps[i + 2]);
-    if (cat2 === "B") {
-      prebase.push({ cp: cp0, category: "R" });
-      i += 2;
+var UnsupportedPaint = class extends Error {
+};
+function tableDirectory(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 getUint24(view, pos) {
+  return view.getUint8(pos) << 16 | view.getUint8(pos + 1) << 8 | view.getUint8(pos + 2);
+}
+function f2dot14(view, pos) {
+  return view.getInt16(pos) / 16384;
+}
+function fixed(view, pos) {
+  return view.getInt32(pos) / 65536;
+}
+function parseCpal(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const tables = tableDirectory(view);
+  const cpal = tables["CPAL"];
+  if (!cpal) return null;
+  const base = cpal.offset;
+  const numPaletteEntries = view.getUint16(base + 2);
+  const colorRecordsArrayOffset = view.getUint32(base + 8);
+  const firstIndex = view.getUint16(base + 12);
+  const recBase = base + colorRecordsArrayOffset + firstIndex * 4;
+  const colors = [];
+  for (let i = 0; i < numPaletteEntries; i++) {
+    const p = recBase + i * 4;
+    const b = view.getUint8(p);
+    const g = view.getUint8(p + 1);
+    const r = view.getUint8(p + 2);
+    const a = view.getUint8(p + 3);
+    colors.push([r, g, b, a]);
+  }
+  return colors;
+}
+function resolveColor2(ctx, paletteIndex, alpha) {
+  const base = paletteIndex === 65535 ? [0, 0, 0, 255] : ctx.palette[paletteIndex] ?? [0, 0, 0, 255];
+  const a = Math.round(base[3] * Math.max(0, Math.min(1, alpha)));
+  return [base[0], base[1], base[2], a];
+}
+var EXTEND = ["pad", "repeat", "reflect"];
+function readColorLine(ctx, offset) {
+  const { view } = ctx;
+  const extend = EXTEND[view.getUint8(offset)] ?? "pad";
+  const numStops = view.getUint16(offset + 1);
+  const stops = [];
+  let p = offset + 3;
+  for (let i = 0; i < numStops; i++) {
+    const stopOffset = f2dot14(view, p);
+    const paletteIndex = view.getUint16(p + 2);
+    const alpha = f2dot14(view, p + 4);
+    stops.push({ offset: stopOffset, color: resolveColor2(ctx, paletteIndex, alpha) });
+    p += 6;
+  }
+  return { stops, extend };
+}
+function apply(m, x, y) {
+  return [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];
+}
+function avgScale(m) {
+  const sx = Math.hypot(m[0], m[1]);
+  const sy = Math.hypot(m[2], m[3]);
+  return (sx + sy) / 2 || 1;
+}
+function resolveFill(ctx, offset, m) {
+  const { view } = ctx;
+  const format = view.getUint8(offset);
+  switch (format) {
+    case 2: {
+      const paletteIndex = view.getUint16(offset + 1);
+      const alpha = f2dot14(view, offset + 3);
+      return { kind: "solid", color: resolveColor2(ctx, paletteIndex, alpha) };
+    }
+    case 4: {
+      const colorLineOffset = getUint24(view, offset + 1);
+      const x0 = view.getInt16(offset + 4), y0 = view.getInt16(offset + 6);
+      const x1 = view.getInt16(offset + 8), y1 = view.getInt16(offset + 10);
+      const { stops, extend } = readColorLine(ctx, offset + colorLineOffset);
+      return { kind: "linear", p0: apply(m, x0, y0), p1: apply(m, x1, y1), stops, extend };
+    }
+    case 6: {
+      const colorLineOffset = getUint24(view, offset + 1);
+      const x0 = view.getInt16(offset + 4), y0 = view.getInt16(offset + 6);
+      const r0 = view.getUint16(offset + 8);
+      const x1 = view.getInt16(offset + 10), y1 = view.getInt16(offset + 12);
+      const r1 = view.getUint16(offset + 14);
+      const { stops, extend } = readColorLine(ctx, offset + colorLineOffset);
+      const s = avgScale(m);
+      return { kind: "radial", c0: apply(m, x0, y0), r0: r0 * s, c1: apply(m, x1, y1), r1: r1 * s, stops, extend };
+    }
+    case 12: {
+      const subOffset = getUint24(view, offset + 1);
+      const transformOffset = getUint24(view, offset + 4);
+      const t = readAffine(view, offset + transformOffset);
+      return resolveFill(ctx, offset + subOffset, compose(m, t));
+    }
+    case 14: {
+      const subOffset = getUint24(view, offset + 1);
+      const dx = view.getInt16(offset + 4), dy = view.getInt16(offset + 6);
+      return resolveFill(ctx, offset + subOffset, compose(m, [1, 0, 0, 1, dx, dy]));
+    }
+    case 16: {
+      const subOffset = getUint24(view, offset + 1);
+      const sx = f2dot14(view, offset + 4), sy = f2dot14(view, offset + 6);
+      return resolveFill(ctx, offset + subOffset, compose(m, [sx, 0, 0, sy, 0, 0]));
     }
+    default:
+      throw new UnsupportedPaint(`fill paint format ${format}`);
+  }
+}
+function readAffine(view, pos) {
+  const xx = fixed(view, pos);
+  const yx = fixed(view, pos + 4);
+  const xy = fixed(view, pos + 8);
+  const yy = fixed(view, pos + 12);
+  const dx = fixed(view, pos + 16);
+  const dy = fixed(view, pos + 20);
+  return [xx, yx, xy, yy, dx, dy];
+}
+function collectLayers(ctx, offset, m, out, depth) {
+  if (depth > 16) throw new UnsupportedPaint("paint recursion too deep");
+  const { view } = ctx;
+  const format = view.getUint8(offset);
+  switch (format) {
+    case 1: {
+      const numLayers = view.getUint8(offset + 1);
+      const firstLayerIndex = view.getUint32(offset + 2);
+      if (!ctx.layerListBase) throw new UnsupportedPaint("PaintColrLayers without LayerList");
+      for (let i = 0; i < numLayers; i++) {
+        const idx = firstLayerIndex + i;
+        const paintOffset = view.getUint32(ctx.layerListBase + 4 + idx * 4);
+        collectLayers(ctx, ctx.layerListBase + paintOffset, m, out, depth + 1);
+      }
+      return;
+    }
+    case 10: {
+      const subOffset = getUint24(view, offset + 1);
+      const glyphId = view.getUint16(offset + 4);
+      const paint = resolveFill(ctx, offset + subOffset, IDENTITY);
+      out.push(m === IDENTITY ? { glyphId, paint } : { glyphId, paint, transform: m });
+      return;
+    }
+    case 11: {
+      const glyphId = view.getUint16(offset + 1);
+      const paintOffset = baseGlyphPaintOffset(ctx, glyphId);
+      if (paintOffset === null) throw new UnsupportedPaint("PaintColrGlyph missing base");
+      collectLayers(ctx, paintOffset, m, out, depth + 1);
+      return;
+    }
+    case 12: {
+      const subOffset = getUint24(view, offset + 1);
+      const transformOffset = getUint24(view, offset + 4);
+      const t = readAffine(view, offset + transformOffset);
+      collectLayers(ctx, offset + subOffset, compose(m, t), out, depth + 1);
+      return;
+    }
+    case 14: {
+      const subOffset = getUint24(view, offset + 1);
+      const dx = view.getInt16(offset + 4), dy = view.getInt16(offset + 6);
+      collectLayers(ctx, offset + subOffset, compose(m, [1, 0, 0, 1, dx, dy]), out, depth + 1);
+      return;
+    }
+    case 16: {
+      const subOffset = getUint24(view, offset + 1);
+      const sx = f2dot14(view, offset + 4), sy = f2dot14(view, offset + 6);
+      collectLayers(ctx, offset + subOffset, compose(m, [sx, 0, 0, sy, 0, 0]), out, depth + 1);
+      return;
+    }
+    default:
+      throw new UnsupportedPaint(`structural paint format ${format}`);
   }
-  while (i < cps.length && classifyUseCategory(cps[i]) === "Mpre") {
-    prebase.push({ cp: cps[i], category: "Mpre" });
-    i++;
-  }
-  let base = null;
-  if (i < cps.length) {
-    const cat = classifyUseCategory(cps[i]);
-    if (cat === "B" || cat === "V") {
-      base = { cp: cps[i], category: cat };
-      i++;
+}
+function baseGlyphPaintOffset(ctx, glyphId) {
+  const { view, colrBase } = ctx;
+  const baseGlyphListOffset = view.getUint32(colrBase + 14);
+  if (!baseGlyphListOffset) return null;
+  const listBase = colrBase + baseGlyphListOffset;
+  const numRecords = view.getUint32(listBase);
+  for (let i = 0; i < numRecords; i++) {
+    const rec = listBase + 4 + i * 6;
+    const gid = view.getUint16(rec);
+    if (gid === glyphId) {
+      return listBase + view.getUint32(rec + 2);
     }
   }
-  while (i < cps.length) {
-    const cp = cps[i];
-    const cat = classifyUseCategory(cp);
-    if (cat === "B" || cat === "V") break;
-    if (cat === "H") {
-      tail.push({ cp, category: "H" });
-      i++;
-      if (i < cps.length) {
-        const nextCat = classifyUseCategory(cps[i]);
-        if (nextCat === "B") {
-          tail.push({ cp: cps[i], category: "B" });
-          i++;
+  return null;
+}
+function parseColrCpal(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const tables = tableDirectory(view);
+  const colr = tables["COLR"];
+  if (!colr) return null;
+  const palette = parseCpal(bytes) ?? [];
+  const colrBase = colr.offset;
+  const version = view.getUint16(colrBase);
+  const result = {};
+  const numBaseGlyphRecords = view.getUint16(colrBase + 2);
+  const baseGlyphRecordsOffset = view.getUint32(colrBase + 4);
+  const layerRecordsOffset = view.getUint32(colrBase + 8);
+  if (numBaseGlyphRecords && baseGlyphRecordsOffset && layerRecordsOffset) {
+    const recBase = colrBase + baseGlyphRecordsOffset;
+    const layerBase = colrBase + layerRecordsOffset;
+    for (let i = 0; i < numBaseGlyphRecords; i++) {
+      const rec = recBase + i * 6;
+      const gid = view.getUint16(rec);
+      const firstLayer = view.getUint16(rec + 2);
+      const numLayers = view.getUint16(rec + 4);
+      const layers = [];
+      for (let j = 0; j < numLayers; j++) {
+        const lr = layerBase + (firstLayer + j) * 4;
+        const layerGid = view.getUint16(lr);
+        const paletteIndex = view.getUint16(lr + 2);
+        const color = paletteIndex === 65535 ? [0, 0, 0, 255] : palette[paletteIndex] ?? [0, 0, 0, 255];
+        layers.push({ glyphId: layerGid, paint: { kind: "solid", color } });
+      }
+      if (layers.length) result[gid] = { layers };
+    }
+  }
+  if (version >= 1) {
+    const layerListOffset = view.getUint32(colrBase + 18);
+    const ctx = {
+      view,
+      palette,
+      colrBase,
+      layerListBase: layerListOffset ? colrBase + layerListOffset : 0
+    };
+    const baseGlyphListOffset = view.getUint32(colrBase + 14);
+    if (baseGlyphListOffset) {
+      const listBase = colrBase + baseGlyphListOffset;
+      const numRecords = view.getUint32(listBase);
+      for (let i = 0; i < numRecords; i++) {
+        const rec = listBase + 4 + i * 6;
+        const gid = view.getUint16(rec);
+        const paintOffset = listBase + view.getUint32(rec + 2);
+        try {
+          const layers = [];
+          collectLayers(ctx, paintOffset, IDENTITY, layers, 0);
+          if (layers.length) result[gid] = { layers };
+        } catch (e) {
+          if (!(e instanceof UnsupportedPaint)) throw e;
         }
       }
-      continue;
-    }
-    if (cat === "Mabv") {
-      above.push({ cp, category: "Mabv" });
-      i++;
-      continue;
     }
-    if (cat === "Mblw") {
-      below.push({ cp, category: "Mblw" });
-      i++;
-      continue;
+  }
+  return Object.keys(result).length ? result : null;
+}
+
+// src/parser/pdf-ua-validator.ts
+function pageContentText(reader, page) {
+  const contents = page.get("Contents");
+  if (contents === void 0) return "";
+  const resolved = reader.resolveValue(contents);
+  const streams = [];
+  if (isStream(resolved)) {
+    streams.push(resolved);
+  } else if (isArray(resolved)) {
+    for (const item of resolved) {
+      const s = reader.resolveValue(item);
+      if (isStream(s)) streams.push(s);
+    }
+  }
+  let text = "";
+  for (const s of streams) {
+    try {
+      const data = reader.decodeStream(s);
+      text += new TextDecoder("latin1").decode(data);
+    } catch {
     }
-    if (cat === "Mpst") {
-      post.push({ cp, category: "Mpst" });
-      i++;
-      continue;
+  }
+  return text;
+}
+function validatePdfUA(bytes) {
+  const errors = [];
+  const warnings = [];
+  let reader;
+  try {
+    reader = openPdf(bytes);
+  } catch (err) {
+    return { valid: false, errors: [`Unparseable PDF: ${err.message}`], warnings: [] };
+  }
+  let catalog;
+  try {
+    catalog = reader.getCatalog();
+  } catch (err) {
+    return { valid: false, errors: [`No document catalog: ${err.message}`], warnings: [] };
+  }
+  const markInfo = reader.resolveValue(catalog.get("MarkInfo") ?? null);
+  if (!isDict(markInfo)) {
+    errors.push("Catalog is missing /MarkInfo (ISO 14289-1 \xA77.1).");
+  } else if (markInfo.get("Marked") !== true) {
+    errors.push("Catalog /MarkInfo /Marked must be true (ISO 14289-1 \xA77.1).");
+  }
+  const structRootRef = dictGetRef(catalog, "StructTreeRoot");
+  const structRoot = structRootRef ? reader.resolveValue(structRootRef) : reader.resolveValue(catalog.get("StructTreeRoot") ?? null);
+  if (!isDict(structRoot)) {
+    errors.push("Catalog is missing /StructTreeRoot (ISO 14289-1 \xA77.1).");
+  } else {
+    const parentTree = structRoot.get("ParentTree");
+    if (parentTree === void 0) {
+      errors.push("/StructTreeRoot is missing /ParentTree (ISO 32000-1 \xA714.7.4.4).");
     }
-    if (cat === "Mpre") {
-      prebase.push({ cp, category: "Mpre" });
-      i++;
-      continue;
+    if (dictGetName(structRoot, "Type") !== "StructTreeRoot") {
+      warnings.push("/StructTreeRoot should declare /Type /StructTreeRoot.");
     }
-    if (cat === "M") {
-      post.push({ cp, category: "M" });
-      i++;
-      continue;
+  }
+  if (catalog.get("Metadata") === void 0) {
+    errors.push("Catalog is missing /Metadata (XMP) (ISO 14289-1 \xA77.2).");
+  }
+  const lang = catalog.get("Lang");
+  if (lang === void 0) {
+    warnings.push("Catalog has no /Lang \u2014 a default natural language is recommended (ISO 14289-1 \xA77.2).");
+  }
+  let pages = [];
+  try {
+    pages = reader.getPages();
+  } catch (err) {
+    errors.push(`Unable to enumerate pages: ${err.message}`);
+  }
+  for (let p = 0; p < pages.length; p++) {
+    const page = pages[p];
+    const content = pageContentText(reader, page);
+    if (!content) continue;
+    const seen = /* @__PURE__ */ new Set();
+    const re = /\/MCID\s+(\d+)/g;
+    let m;
+    let count = 0;
+    while ((m = re.exec(content)) !== null) {
+      count++;
+      const mcid = Number(m[1]);
+      if (seen.has(mcid)) {
+        errors.push(`Page ${p + 1}: duplicate /MCID ${mcid} in content stream (ISO 32000-1 \xA714.7.4.3).`);
+      }
+      seen.add(mcid);
     }
-    if (cat === "ZWJ" || cat === "ZWNJ") {
-      tail.push({ cp, category: cat });
-      i++;
-      continue;
+    if (count === 0 && /\b(Tj|TJ)\b/.test(content)) {
+      warnings.push(`Page ${p + 1}: text content is not wrapped in marked-content (no /MCID found).`);
     }
-    if (cat === "N" || cat === "O") {
-      if (!base) {
-        base = { cp, category: cat === "N" ? "N" : "O" };
-        i++;
-        continue;
-      }
-      break;
+    if (count > 0 && page.get("StructParents") === void 0) {
+      warnings.push(`Page ${p + 1}: marked content present but page has no /StructParents key.`);
     }
-    break;
-  }
-  if (i === start) {
-    base = { cp: cps[i], category: cat0 };
-    i++;
   }
-  return {
-    cluster: { prebase, base, above, below, post, tail },
-    next: i
-  };
+  return { valid: errors.length === 0, errors, warnings };
 }
 
 // src/worker/worker-api.ts
@@ -12901,6 +15185,7 @@ exports.DEFAULT_COLUMNS = DEFAULT_COLUMNS;
 exports.DEFAULT_CW = DEFAULT_CW;
 exports.DEFAULT_FONT_SIZES = DEFAULT_FONT_SIZES;
 exports.DEFAULT_MARGINS = DEFAULT_MARGINS;
+exports.DEFAULT_MAX_BLOCKS = DEFAULT_MAX_BLOCKS;
 exports.DEFAULT_MAX_INFLATE_OUTPUT = DEFAULT_MAX_INFLATE_OUTPUT;
 exports.FT_H = FT_H;
 exports.HEADER_H = HEADER_H;
@@ -12926,6 +15211,7 @@ exports.buildDocumentPDF = buildDocumentPDF;
 exports.buildDocumentPDFBytes = buildDocumentPDFBytes;
 exports.buildDocumentPDFStream = buildDocumentPDFStream;
 exports.buildDocumentPDFStreamPageByPage = buildDocumentPDFStreamPageByPage;
+exports.buildDocumentPDFStreamTrue = buildDocumentPDFStreamTrue;
 exports.buildEmbeddedFiles = buildEmbeddedFiles;
 exports.buildFormWidget = buildFormWidget;
 exports.buildImageOperators = buildImageOperators;
@@ -12936,6 +15222,7 @@ exports.buildPDF = buildPDF;
 exports.buildPDFBytes = buildPDFBytes;
 exports.buildPDFStream = buildPDFStream;
 exports.buildPDFStreamPageByPage = buildPDFStreamPageByPage;
+exports.buildPDFStreamTrue = buildPDFStreamTrue;
 exports.buildRadioGroupParent = buildRadioGroupParent;
 exports.buildSMaskXObject = buildSMaskXObject;
 exports.buildSigDict = buildSigDict;
@@ -12949,10 +15236,17 @@ exports.concatChunks = concatChunks;
 exports.containsArabic = containsArabic;
 exports.containsBengali = containsBengali;
 exports.containsDevanagari = containsDevanagari;
+exports.containsEthiopic = containsEthiopic;
 exports.containsHebrew = containsHebrew;
+exports.containsKhmer = containsKhmer;
+exports.containsMyanmar = containsMyanmar;
 exports.containsRTL = containsRTL;
+exports.containsSinhala = containsSinhala;
 exports.containsTamil = containsTamil;
+exports.containsTelugu = containsTelugu;
 exports.containsThai = containsThai;
+exports.containsTibetan = containsTibetan;
+exports.contoursToPath = contoursToPath;
 exports.createEncodingContext = createEncodingContext;
 exports.createModifier = createModifier;
 exports.createPDF = createPDF;
@@ -12989,6 +15283,7 @@ exports.encodePDF417 = encodePDF417;
 exports.encodePdfTextString = encodePdfTextString;
 exports.estimateCmsSize = estimateCmsSize;
 exports.estimateContentsSize = estimateContentsSize;
+exports.extractGlyphContours = extractGlyphContours;
 exports.findStartxref = findStartxref;
 exports.generateDataMatrix = generateDataMatrix;
 exports.generatePDFInWorker = generatePDFInWorker;
@@ -13012,13 +15307,19 @@ exports.isBengaliCodepoint = isBengaliCodepoint;
 exports.isCyrillicCodepoint = isCyrillicCodepoint;
 exports.isDevanagariCodepoint = isDevanagariCodepoint;
 exports.isDict = isDict;
+exports.isEthiopicCodepoint = isEthiopicCodepoint;
 exports.isGeorgianCodepoint = isGeorgianCodepoint;
+exports.isKhmerCodepoint = isKhmerCodepoint;
 exports.isLinkAnnotation = isLinkAnnotation;
+exports.isMyanmarCodepoint = isMyanmarCodepoint;
 exports.isName = isName;
 exports.isRef = isRef;
 exports.isSelfSigned = isSelfSigned;
+exports.isSinhalaCodepoint = isSinhalaCodepoint;
 exports.isStream = isStream;
 exports.isTamilCodepoint = isTamilCodepoint;
+exports.isTeluguCodepoint = isTeluguCodepoint;
+exports.isTibetanCodepoint = isTibetanCodepoint;
 exports.isValidPdfRgb = isValidPdfRgb;
 exports.loadFontData = loadFontData;
 exports.nameValue = nameValue;
@@ -13028,6 +15329,9 @@ exports.normalizeColors = normalizeColors;
 exports.openPdf = openPdf;
 exports.parseCertificate = parseCertificate;
 exports.parseColor = parseColor;
+exports.parseColrCpal = parseColrCpal;
+exports.parseCpal = parseCpal;
+exports.parseGlyfFont = parseGlyfFont;
 exports.parseImage = parseImage;
 exports.parseIndirectObject = parseIndirectObject;
 exports.parseJPEG = parseJPEG;
@@ -13042,6 +15346,7 @@ exports.registerFont = registerFont;
 exports.registerFonts = registerFonts;
 exports.renderBarcode = renderBarcode;
 exports.renderCode128 = renderCode128;
+exports.renderColorGlyph = renderColorGlyph;
 exports.renderDataMatrix = renderDataMatrix;
 exports.renderEAN13 = renderEAN13;
 exports.renderPDF417 = renderPDF417;
@@ -13064,8 +15369,13 @@ exports.sha512 = sha512;
 exports.shapeArabicText = shapeArabicText;
 exports.shapeBengaliText = shapeBengaliText;
 exports.shapeDevanagariText = shapeDevanagariText;
+exports.shapeKhmerText = shapeKhmerText;
+exports.shapeMyanmarText = shapeMyanmarText;
+exports.shapeSinhalaText = shapeSinhalaText;
 exports.shapeTamilText = shapeTamilText;
+exports.shapeTeluguText = shapeTeluguText;
 exports.shapeThaiText = shapeThaiText;
+exports.shapeTibetanText = shapeTibetanText;
 exports.signPdfBytes = signPdfBytes;
 exports.slugify = slugify;
 exports.splitTextByFont = splitTextByFont;
@@ -13077,6 +15387,7 @@ exports.truncate = truncate;
 exports.truncateToWidth = truncateToWidth;
 exports.validateAttachments = validateAttachments;
 exports.validateDocumentStreamable = validateDocumentStreamable;
+exports.validatePdfUA = validatePdfUA;
 exports.validateTableStreamable = validateTableStreamable;
 exports.validateURL = validateURL;
 exports.validateWatermark = validateWatermark;