pdfnative 1.1.0 → 1.3.0

package/dist/worker/index.js

@@ -198,6 +198,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
@@ -228,6 +255,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;
 }
@@ -240,6 +270,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;
 }
@@ -250,6 +298,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;
@@ -276,6 +327,36 @@ function containsTamil(str) {
   }
   return false;
 }
+function containsTelugu(str) {
+  for (let i = 0; i < str.length; i++) {
+    if (isTeluguCodepoint(str.charCodeAt(i))) return true;
+  }
+  return false;
+}
+function containsSinhala(str) {
+  for (let i = 0; i < str.length; i++) {
+    if (isSinhalaCodepoint(str.charCodeAt(i))) return true;
+  }
+  return false;
+}
+function containsTibetan(str) {
+  for (let i = 0; i < str.length; i++) {
+    if (isTibetanCodepoint(str.charCodeAt(i))) return true;
+  }
+  return false;
+}
+function containsKhmer(str) {
+  for (let i = 0; i < str.length; i++) {
+    if (isKhmerCodepoint(str.charCodeAt(i))) return true;
+  }
+  return false;
+}
+function containsMyanmar(str) {
+  for (let i = 0; i < str.length; i++) {
+    if (isMyanmarCodepoint(str.charCodeAt(i))) return true;
+  }
+  return false;
+}
 function containsDevanagari(str) {
   for (let i = 0; i < str.length; i++) {
     if (isDevanagariCodepoint(str.charCodeAt(i))) return true;
@@ -287,6 +368,12 @@ function containsDevanagari(str) {
 function detectCharLang(cp) {
   if (cp >= 880 && cp <= 1023 || cp >= 7936 && cp <= 8191) return "el";
   if (cp >= 2304 && cp <= 2431 || cp >= 43232 && cp <= 43263) return "hi";
+  if (cp >= 3072 && cp <= 3199) return "te";
+  if (isSinhalaCodepoint(cp)) return "si";
+  if (isTibetanCodepoint(cp)) return "bo";
+  if (isKhmerCodepoint(cp)) return "km";
+  if (isMyanmarCodepoint(cp)) return "my";
+  if (isEthiopicCodepoint(cp)) return "am";
   if (cp >= 3584 && cp <= 3711) return "th";
   if (cp >= 12352 && cp <= 12543) return "ja";
   if (cp >= 44032 && cp <= 55215 || cp >= 4352 && cp <= 4607 || cp >= 12592 && cp <= 12687) return "ko";
@@ -320,6 +407,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) {
@@ -352,103 +443,826 @@ function splitTextByFont(str, fontEntries) {
   return runs;
 }
 
-// src/fonts/encoding.ts
-function toWinAnsi(str) {
-  if (!str) return "";
-  let r = "";
-  for (let i = 0; i < str.length; i++) {
-    const c = str.charCodeAt(i);
-    if (c >= 32 && c <= 126) r += str[i];
-    else if (c >= 160 && c <= 255) r += str[i];
-    else if (c === 8364) r += "\x80";
-    else if (c === 8218) r += "\x82";
-    else if (c === 402) r += "\x83";
-    else if (c === 8222) r += "\x84";
-    else if (c === 8230) r += "\x85";
-    else if (c === 8224) r += "\x86";
-    else if (c === 8225) r += "\x87";
-    else if (c === 710) r += "\x88";
-    else if (c === 8240) r += "\x89";
-    else if (c === 352) r += "\x8A";
-    else if (c === 8249) r += "\x8B";
-    else if (c === 338) r += "\x8C";
-    else if (c === 381) r += "\x8E";
-    else if (c === 8216) r += "\x91";
-    else if (c === 8217) r += "\x92";
-    else if (c === 8220) r += "\x93";
-    else if (c === 8221) r += "\x94";
-    else if (c === 8226) r += "\x95";
-    else if (c === 8211) r += "\x96";
-    else if (c === 8212) r += "\x97";
-    else if (c === 732) r += "\x98";
-    else if (c === 8482) r += "\x99";
-    else if (c === 353) r += "\x9A";
-    else if (c === 8250) r += "\x9B";
-    else if (c === 339) r += "\x9C";
-    else if (c === 382) r += "\x9E";
-    else if (c === 376) r += "\x9F";
-    else if (c === 160 || c === 8239) r += " ";
-    else if (c === 9 || c === 10 || c === 13) r += " ";
-    else if (c < 32) ; else r += "?";
-  }
-  return r;
-}
-function pdfString(str) {
-  const s = toWinAnsi(str);
-  return "(" + s.replace(/\\/g, "\\\\").replace(/\(/g, "\\(").replace(/\)/g, "\\)") + ")";
+// src/shaping/bidi.ts
+function classifyBidiType(cp) {
+  if (cp >= 768 && cp <= 879 || // Combining Diacritical Marks
+  cp >= 1425 && cp <= 1469 || // Hebrew marks
+  cp >= 1471 && cp <= 1471 || cp >= 1473 && cp <= 1474 || cp >= 1476 && cp <= 1477 || cp >= 1479 && cp <= 1479 || cp >= 1552 && cp <= 1562 || // Arabic marks
+  cp >= 1611 && cp <= 1631 || // Arabic harakat
+  cp >= 1648 && cp <= 1648 || // Arabic superscript alef
+  cp >= 1750 && cp <= 1756 || cp >= 1759 && cp <= 1764 || cp >= 1767 && cp <= 1768 || cp >= 1770 && cp <= 1773 || cp >= 65056 && cp <= 65071) return "NSM";
+  if (cp === 8203 || cp === 8204 || cp === 8205 || cp === 8206 || cp === 8207 || cp === 65279 || cp === 8294 || cp === 8295 || cp === 8296 || cp === 8297) return "BN";
+  if (cp >= 1632 && cp <= 1641) return "AN";
+  if (cp >= 1776 && cp <= 1785) return "AN";
+  if (cp >= 48 && cp <= 57) return "EN";
+  if (cp === 43 || cp === 45) return "ES";
+  if (cp === 35 || cp === 36 || cp === 37 || cp === 162 || cp === 163 || cp === 164 || cp === 165 || cp === 8364 || cp === 8377 || cp === 8378) return "ET";
+  if (cp === 44 || cp === 46 || cp === 47 || cp === 58 || cp === 160) return "CS";
+  if (cp === 32 || cp === 9 || cp === 10 || cp === 13 || cp === 12 || cp === 8192 || cp === 8202 || cp === 8232 || cp === 8233 || cp === 8239 || cp === 8287 || cp === 12288) return "WS";
+  if (cp >= 1536 && cp <= 1791) return "AL";
+  if (cp >= 1872 && cp <= 1919) return "AL";
+  if (cp >= 2208 && cp <= 2303) return "AL";
+  if (cp >= 64336 && cp <= 65023) return "AL";
+  if (cp >= 65136 && cp <= 65278) return "AL";
+  if (cp >= 1488 && cp <= 1514) return "R";
+  if (cp >= 1520 && cp <= 1524) return "R";
+  if (cp >= 1792 && cp <= 1871) return "R";
+  if (cp >= 1920 && cp <= 1983) return "R";
+  if (cp >= 64285 && cp <= 64335) return "R";
+  if (cp >= 65 && cp <= 90) return "L";
+  if (cp >= 97 && cp <= 122) return "L";
+  if (cp >= 192 && cp <= 591) return "L";
+  if (cp >= 880 && cp <= 1023) return "L";
+  if (cp >= 1024 && cp <= 1279) return "L";
+  if (cp >= 3584 && cp <= 3711) return "L";
+  if (cp >= 2304 && cp <= 2431) return "L";
+  if (cp >= 12352 && cp <= 12543) return "L";
+  if (cp >= 19968 && cp <= 40959) return "L";
+  if (cp >= 44032 && cp <= 55215) return "L";
+  if (cp >= 33 && cp <= 47) return "ON";
+  if (cp >= 58 && cp <= 64) return "ON";
+  if (cp >= 91 && cp <= 96) return "ON";
+  if (cp >= 123 && cp <= 126) return "ON";
+  if (cp >= 161 && cp <= 191) return "ON";
+  if (cp >= 8208 && cp <= 8231) return "ON";
+  if (cp >= 8240 && cp <= 8286) return "ON";
+  return "L";
 }
-function truncate(str, max) {
-  if (!str || str.length <= max) return str || "";
-  if (max <= 1) return "\u2026";
-  return str.slice(0, max - 1) + "\u2026";
+function detectParagraphLevel(types) {
+  for (const t of types) {
+    if (t === "L") return 0;
+    if (t === "R" || t === "AL") return 1;
+  }
+  return 0;
 }
-function helveticaWidth(str, sz) {
-  let w = 0;
-  for (let i = 0; i < str.length; i++) {
-    const cp = str.codePointAt(i) ?? 0;
-    if (cp > 65535) i++;
-    if (cp >= 48 && cp <= 57) w += 556;
-    else if (cp >= 65 && cp <= 90) w += 680;
-    else if (cp >= 97 && cp <= 122) w += 500;
-    else if (cp === 32) w += 278;
-    else if (cp === 46 || cp === 44) w += 278;
-    else if (cp === 43) w += 584;
-    else if (cp === 45) w += 333;
-    else if (cp === 47 || cp === 58) w += 278;
-    else if (cp === 8212) w += 1e3;
-    else if (cp === 8211) w += 556;
-    else if (cp === 8230) w += 1e3;
-    else if (cp === 8216 || cp === 8217) w += 222;
-    else if (cp === 8220 || cp === 8221) w += 333;
-    else if (cp === 8364) w += 556;
-    else w += 556;
+function resolveWeakTypes(types, paraLevel) {
+  const len = types.length;
+  let prevType = paraLevel === 0 ? "L" : "R";
+  for (let i = 0; i < len; i++) {
+    if (types[i] === "BN") continue;
+    if (types[i] === "NSM") {
+      types[i] = prevType;
+    }
+    prevType = types[i];
+  }
+  let lastStrong = paraLevel === 0 ? "L" : "R";
+  for (let i = 0; i < len; i++) {
+    if (types[i] === "BN") continue;
+    if (types[i] === "R" || types[i] === "L" || types[i] === "AL") {
+      lastStrong = types[i];
+    } else if (types[i] === "EN" && lastStrong === "AL") {
+      types[i] = "AN";
+    }
+  }
+  for (let i = 0; i < len; i++) {
+    if (types[i] === "AL") types[i] = "R";
+  }
+  for (let i = 1; i < len - 1; i++) {
+    if (types[i] === "BN") continue;
+    if (types[i] === "ES" && types[i - 1] === "EN" && types[i + 1] === "EN") {
+      types[i] = "EN";
+    } else if (types[i] === "CS") {
+      if (types[i - 1] === "EN" && types[i + 1] === "EN") types[i] = "EN";
+      else if (types[i - 1] === "AN" && types[i + 1] === "AN") types[i] = "AN";
+    }
+  }
+  for (let i = 0; i < len; i++) {
+    if (types[i] === "ET") {
+      let found = false;
+      for (let j = i - 1; j >= 0; j--) {
+        if (types[j] === "EN") {
+          found = true;
+          break;
+        }
+        if (types[j] !== "ET" && types[j] !== "BN") break;
+      }
+      if (!found) {
+        for (let j = i + 1; j < len; j++) {
+          if (types[j] === "EN") {
+            found = true;
+            break;
+          }
+          if (types[j] !== "ET" && types[j] !== "BN") break;
+        }
+      }
+      if (found) types[i] = "EN";
+    }
+  }
+  for (let i = 0; i < len; i++) {
+    if (types[i] === "ES" || types[i] === "ET" || types[i] === "CS") {
+      types[i] = "ON";
+    }
+  }
+  lastStrong = paraLevel === 0 ? "L" : "R";
+  for (let i = 0; i < len; i++) {
+    if (types[i] === "BN") continue;
+    if (types[i] === "L" || types[i] === "R") {
+      lastStrong = types[i];
+    } else if (types[i] === "EN" && lastStrong === "L") {
+      types[i] = "L";
+    }
   }
-  return w * sz / 1e3;
 }
-
-// src/shaping/gsub-driver.ts
-function tryLigature(gids, ligatures) {
-  if (!ligatures || gids.length < 2) return null;
-  const firstGid = gids[0];
-  const entries = ligatures[firstGid];
-  if (!entries) return null;
-  for (const entry of entries) {
-    const compCount = entry.length - 1;
-    if (compCount > gids.length - 1) continue;
-    let match = true;
-    for (let ci = 0; ci < compCount; ci++) {
-      if (gids[1 + ci] !== entry[1 + ci]) {
-        match = false;
+function resolveNeutralTypes(types, paraLevel) {
+  const len = types.length;
+  const paraDir = paraLevel === 0 ? "L" : "R";
+  for (let i = 0; i < len; i++) {
+    if (types[i] !== "ON" && types[i] !== "WS" && types[i] !== "BN") continue;
+    const start = i;
+    while (i < len && (types[i] === "ON" || types[i] === "WS" || types[i] === "BN")) i++;
+    const end = i;
+    let prevStrong = paraDir;
+    for (let j = start - 1; j >= 0; j--) {
+      if (types[j] === "L" || types[j] === "R" || types[j] === "EN" || types[j] === "AN") {
+        prevStrong = types[j] === "EN" || types[j] === "AN" ? "R" : types[j];
         break;
       }
     }
-    if (match) return { resultGid: entry[0], consumed: compCount + 1 };
+    let nextStrong = paraDir;
+    for (let j = end; j < len; j++) {
+      if (types[j] === "L" || types[j] === "R" || types[j] === "EN" || types[j] === "AN") {
+        nextStrong = types[j] === "EN" || types[j] === "AN" ? "R" : types[j];
+        break;
+      }
+    }
+    const resolved = prevStrong === nextStrong ? prevStrong : paraDir;
+    for (let j = start; j < end; j++) {
+      types[j] = resolved;
+    }
   }
-  return null;
 }
-
-// src/shaping/bengali-shaper.ts
-var HALANT = 2509;
+function assignLevels(types, paraLevel) {
+  const levels = [];
+  for (const t of types) {
+    if (paraLevel === 0) {
+      levels.push(t === "R" || t === "AN" ? 1 : 0);
+    } else {
+      levels.push(t === "L" ? 2 : 1);
+    }
+  }
+  return levels;
+}
+var SENTENCE_PUNCT = /* @__PURE__ */ new Set([
+  46,
+  // .
+  44,
+  // ,
+  59,
+  // ;
+  58,
+  // :
+  33,
+  // !
+  63
+  // ?
+]);
+function fixPunctuationAffinity(types, codePoints, len) {
+  for (let i = 1; i < len; i++) {
+    if (types[i] === "R" && SENTENCE_PUNCT.has(codePoints[i])) {
+      let prevIdx = i - 1;
+      while (prevIdx >= 0 && (types[prevIdx] === "WS" || types[prevIdx] === "BN")) prevIdx--;
+      if (prevIdx >= 0 && types[prevIdx] === "L") {
+        types[i] = "L";
+      }
+    }
+  }
+}
+function fixBracketPairing(types, codePoints, len) {
+  const OPEN_BRACKETS = {
+    40: 41,
+    // ( → )
+    91: 93,
+    // [ → ]
+    123: 125
+    // { → }
+  };
+  for (let i = 0; i < len; i++) {
+    const closer = OPEN_BRACKETS[codePoints[i]];
+    if (closer === void 0) continue;
+    let depth = 1;
+    let closeIdx = -1;
+    for (let j = i + 1; j < len; j++) {
+      if (codePoints[j] === codePoints[i]) depth++;
+      else if (codePoints[j] === closer) {
+        depth--;
+        if (depth === 0) {
+          closeIdx = j;
+          break;
+        }
+      }
+    }
+    if (closeIdx === -1) continue;
+    let hasL = false;
+    for (let j = i + 1; j < closeIdx; j++) {
+      if (types[j] === "L") {
+        hasL = true;
+        break;
+      }
+    }
+    if (hasL) {
+      types[i] = "L";
+      types[closeIdx] = "L";
+    }
+  }
+}
+function findOutermostIsolatePairs(codePoints) {
+  const pairs = [];
+  let i = 0;
+  while (i < codePoints.length) {
+    const cp = codePoints[i];
+    if (cp === 8294 || cp === 8295 || cp === 8296) {
+      let depth = 1;
+      let close = -1;
+      for (let j = i + 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) {
+            close = j;
+            break;
+          }
+        }
+      }
+      if (close === -1) {
+        i++;
+        continue;
+      }
+      const kind = cp === 8294 ? "LRI" : cp === 8295 ? "RLI" : "FSI";
+      pairs.push({ open: i, close, kind });
+      i = close + 1;
+    } else {
+      i++;
+    }
+  }
+  return pairs;
+}
+function normalizeBidiEmbeddings(text) {
+  const LRE = 8234, RLE = 8235, PDF_CP = 8236, LRO = 8237, RLO = 8238;
+  const LRI = 8294, RLI = 8295, PDI = 8297;
+  let hasEmbed = false;
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    if (c === LRE || c === RLE || c === PDF_CP || c === LRO || c === RLO) {
+      hasEmbed = true;
+      break;
+    }
+  }
+  if (!hasEmbed) return text;
+  const stack = [];
+  const out = [];
+  const MAX_DEPTH = 125;
+  for (let i = 0; i < text.length; ) {
+    const cp = text.codePointAt(i) ?? 0;
+    const cpLen = cp > 65535 ? 2 : 1;
+    if (cp === LRE || cp === RLE) {
+      if (stack.length >= MAX_DEPTH) {
+        i += cpLen;
+        continue;
+      }
+      stack.push("E");
+      out.push(cp === LRE ? LRI : RLI);
+      i += cpLen;
+    } 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);
+      i += cpLen;
+    }
+  }
+  let result = "";
+  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);
+  }
+  const codePoints = [];
+  const cpToStr = [];
+  for (let i = 0; i < text.length; ) {
+    cpToStr.push(i);
+    const cp = text.codePointAt(i) ?? 0;
+    codePoints.push(cp);
+    i += cp > 65535 ? 2 : 1;
+  }
+  cpToStr.push(text.length);
+  const isolates = findOutermostIsolatePairs(codePoints);
+  if (isolates.length === 0) {
+    return resolveBidiCore(text, codePoints, cpToStr);
+  }
+  const insideIsolate = new Array(codePoints.length).fill(false);
+  for (const p of isolates) {
+    for (let k = p.open; k <= p.close; k++) insideIsolate[k] = true;
+  }
+  const outerTypes = codePoints.map((cp, idx) => insideIsolate[idx] ? "BN" : classifyBidiType(cp));
+  const parentLevel = detectParagraphLevel(outerTypes);
+  const out = [];
+  const emitSegment = (cpStart, cpEnd, forced) => {
+    if (cpStart >= cpEnd) return;
+    const segText = text.substring(cpToStr[cpStart], cpToStr[cpEnd]);
+    const segCps = codePoints.slice(cpStart, cpEnd);
+    const baseStrIdx = cpToStr[cpStart];
+    const segCpToStr = cpToStr.slice(cpStart, cpEnd + 1).map((x) => x - baseStrIdx);
+    const segRuns = forced === void 0 ? resolveBidiRuns(segText) : resolveBidiCore(segText, segCps, segCpToStr, forced);
+    for (const r of segRuns) {
+      out.push({ text: r.text, level: r.level, start: r.start + baseStrIdx });
+    }
+  };
+  let cursor = 0;
+  for (const pair of isolates) {
+    emitSegment(cursor, pair.open, parentLevel);
+    const innerStart = pair.open + 1;
+    const innerEnd = pair.close;
+    let innerLevel;
+    if (pair.kind === "LRI") innerLevel = 0;
+    else if (pair.kind === "RLI") innerLevel = 1;
+    else {
+      const innerTypes = codePoints.slice(innerStart, innerEnd).map(classifyBidiType);
+      innerLevel = detectParagraphLevel(innerTypes);
+    }
+    if (innerStart < innerEnd) {
+      const innerText = text.substring(cpToStr[innerStart], cpToStr[innerEnd]);
+      const innerRuns = resolveBidiRunsForced(innerText, innerLevel);
+      const baseStrIdx = cpToStr[innerStart];
+      for (const r of innerRuns) {
+        out.push({ text: r.text, level: r.level, start: r.start + baseStrIdx });
+      }
+    }
+    cursor = pair.close + 1;
+  }
+  emitSegment(cursor, codePoints.length, parentLevel);
+  return out;
+}
+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; ) {
+    cpToStr.push(i);
+    const cp = text.codePointAt(i) ?? 0;
+    codePoints.push(cp);
+    i += cp > 65535 ? 2 : 1;
+  }
+  cpToStr.push(text.length);
+  const isolates = findOutermostIsolatePairs(codePoints);
+  if (isolates.length === 0) {
+    return resolveBidiCore(text, codePoints, cpToStr, forcedLevel);
+  }
+  const out = [];
+  const emit = (cpStart, cpEnd, forced) => {
+    if (cpStart >= cpEnd) return;
+    const segText = text.substring(cpToStr[cpStart], cpToStr[cpEnd]);
+    const segCps = codePoints.slice(cpStart, cpEnd);
+    const baseStrIdx = cpToStr[cpStart];
+    const segCpToStr = cpToStr.slice(cpStart, cpEnd + 1).map((x) => x - baseStrIdx);
+    const segRuns = resolveBidiCore(segText, segCps, segCpToStr, forced);
+    for (const r of segRuns) {
+      out.push({ text: r.text, level: r.level, start: r.start + baseStrIdx });
+    }
+  };
+  let cursor = 0;
+  for (const pair of isolates) {
+    emit(cursor, pair.open, forcedLevel);
+    const innerStart = pair.open + 1;
+    const innerEnd = pair.close;
+    let innerLevel;
+    if (pair.kind === "LRI") innerLevel = 0;
+    else if (pair.kind === "RLI") innerLevel = 1;
+    else {
+      const innerTypes = codePoints.slice(innerStart, innerEnd).map(classifyBidiType);
+      innerLevel = detectParagraphLevel(innerTypes);
+    }
+    if (innerStart < innerEnd) {
+      const innerText = text.substring(cpToStr[innerStart], cpToStr[innerEnd]);
+      const innerRuns = resolveBidiRunsForced(innerText, innerLevel);
+      const baseStrIdx = cpToStr[innerStart];
+      for (const r of innerRuns) {
+        out.push({ text: r.text, level: r.level, start: r.start + baseStrIdx });
+      }
+    }
+    cursor = pair.close + 1;
+  }
+  emit(cursor, codePoints.length, forcedLevel);
+  return out;
+}
+function resolveBidiCore(text, codePoints, cpToStr, forcedLevel) {
+  const len = codePoints.length;
+  if (len === 0) return [];
+  const types = codePoints.map(classifyBidiType);
+  const paraLevel = forcedLevel !== void 0 ? forcedLevel : detectParagraphLevel(types);
+  resolveWeakTypes(types, paraLevel);
+  resolveNeutralTypes(types, paraLevel);
+  if (paraLevel === 1) {
+    fixPunctuationAffinity(types, codePoints, len);
+    fixBracketPairing(types, codePoints, len);
+  }
+  const levels = assignLevels(types, paraLevel);
+  const runs = [];
+  let runStart = 0;
+  let runLevel = levels[0];
+  for (let i = 1; i <= len; i++) {
+    if (i === len || levels[i] !== runLevel) {
+      const start = cpToStr[runStart];
+      const end = cpToStr[i];
+      let runText = text.substring(start, end);
+      if (runLevel % 2 === 1) {
+        runText = reverseString(runText);
+      }
+      runs.push({ text: runText, level: runLevel, start });
+      if (i < len) {
+        runStart = i;
+        runLevel = levels[i];
+      }
+    }
+  }
+  if (paraLevel === 1 && runs.length > 1) {
+    runs.reverse();
+  }
+  return runs;
+}
+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;
+  }
+  return false;
+}
+function stripBidiControls(text) {
+  if (!text) return text;
+  let needs = false;
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    if (c === 8206 || c === 8207 || c >= 8234 && c <= 8238 || c >= 8294 && c <= 8297) {
+      needs = true;
+      break;
+    }
+  }
+  if (!needs) return text;
+  let out = "";
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    if (c === 8206 || c === 8207 || c >= 8234 && c <= 8238 || c >= 8294 && c <= 8297) continue;
+    out += text[i];
+  }
+  return out;
+}
+function reverseString(str) {
+  const cps = [];
+  for (let i = 0; i < str.length; ) {
+    const cp = str.codePointAt(i) ?? 0;
+    cps.push(cp);
+    i += cp > 65535 ? 2 : 1;
+  }
+  cps.reverse();
+  return String.fromCodePoint(...cps);
+}
+
+// src/fonts/encoding.ts
+function toWinAnsi(str) {
+  if (!str) return "";
+  let r = "";
+  for (let i = 0; i < str.length; i++) {
+    const c = str.charCodeAt(i);
+    if (c >= 32 && c <= 126) r += str[i];
+    else if (c >= 160 && c <= 255) r += str[i];
+    else if (c === 8364) r += "\x80";
+    else if (c === 8218) r += "\x82";
+    else if (c === 402) r += "\x83";
+    else if (c === 8222) r += "\x84";
+    else if (c === 8230) r += "\x85";
+    else if (c === 8224) r += "\x86";
+    else if (c === 8225) r += "\x87";
+    else if (c === 710) r += "\x88";
+    else if (c === 8240) r += "\x89";
+    else if (c === 352) r += "\x8A";
+    else if (c === 8249) r += "\x8B";
+    else if (c === 338) r += "\x8C";
+    else if (c === 381) r += "\x8E";
+    else if (c === 8216) r += "\x91";
+    else if (c === 8217) r += "\x92";
+    else if (c === 8220) r += "\x93";
+    else if (c === 8221) r += "\x94";
+    else if (c === 8226) r += "\x95";
+    else if (c === 8211) r += "\x96";
+    else if (c === 8212) r += "\x97";
+    else if (c === 732) r += "\x98";
+    else if (c === 8482) r += "\x99";
+    else if (c === 353) r += "\x9A";
+    else if (c === 8250) r += "\x9B";
+    else if (c === 339) r += "\x9C";
+    else if (c === 382) r += "\x9E";
+    else if (c === 376) r += "\x9F";
+    else if (c === 160 || c === 8239) r += " ";
+    else if (c === 9 || c === 10 || c === 13) r += " ";
+    else if (c < 32) ; else r += "?";
+  }
+  return r;
+}
+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";
+  return str.slice(0, max - 1) + "\u2026";
+}
+function helveticaWidth(str, sz) {
+  str = stripBidiControls(str);
+  let w = 0;
+  for (let i = 0; i < str.length; i++) {
+    const cp = str.codePointAt(i) ?? 0;
+    if (cp > 65535) i++;
+    if (cp >= 48 && cp <= 57) w += 556;
+    else if (cp >= 65 && cp <= 90) w += 680;
+    else if (cp >= 97 && cp <= 122) w += 500;
+    else if (cp === 32) w += 278;
+    else if (cp === 46 || cp === 44) w += 278;
+    else if (cp === 43) w += 584;
+    else if (cp === 45) w += 333;
+    else if (cp === 47 || cp === 58) w += 278;
+    else if (cp === 8212) w += 1e3;
+    else if (cp === 8211) w += 556;
+    else if (cp === 8230) w += 1e3;
+    else if (cp === 8216 || cp === 8217) w += 222;
+    else if (cp === 8220 || cp === 8221) w += 333;
+    else if (cp === 8364) w += 556;
+    else w += 556;
+  }
+  return w * sz / 1e3;
+}
+function helveticaBoldWidth(str, sz) {
+  str = stripBidiControls(str);
+  let w = 0;
+  for (let i = 0; i < str.length; i++) {
+    const cp = str.codePointAt(i) ?? 0;
+    if (cp > 65535) i++;
+    if (cp >= 48 && cp <= 57) w += 556;
+    else if (cp >= 65 && cp <= 90) w += 722;
+    else if (cp >= 97 && cp <= 122) w += 611;
+    else if (cp === 32) w += 278;
+    else if (cp === 46 || cp === 44) w += 278;
+    else if (cp === 43) w += 584;
+    else if (cp === 45) w += 333;
+    else if (cp === 47 || cp === 58) w += 278;
+    else if (cp === 8212) w += 1e3;
+    else if (cp === 8211) w += 556;
+    else if (cp === 8230) w += 1e3;
+    else if (cp === 8216 || cp === 8217) w += 278;
+    else if (cp === 8220 || cp === 8221) w += 500;
+    else if (cp === 8364) w += 556;
+    else w += 611;
+  }
+  return w * sz / 1e3;
+}
+
+// src/shaping/gsub-driver.ts
+function tryLigature(gids, ligatures) {
+  if (!ligatures || gids.length < 2) return null;
+  const firstGid = gids[0];
+  const entries = ligatures[firstGid];
+  if (!entries) return null;
+  for (const entry of entries) {
+    const compCount = entry.length - 1;
+    if (compCount > gids.length - 1) continue;
+    let match = true;
+    for (let ci = 0; ci < compCount; ci++) {
+      if (gids[1 + ci] !== entry[1 + ci]) {
+        match = false;
+        break;
+      }
+    }
+    if (match) return { resultGid: entry[0], consumed: compCount + 1 };
+  }
+  return null;
+}
+
+// src/shaping/use-lite.ts
+function devanagariCategory(cp) {
+  if (cp === 2305 || cp === 2306) return "Mabv";
+  if (cp === 2307) return "Mpst";
+  if (cp >= 2308 && cp <= 2324) return "V";
+  if (cp >= 2325 && cp <= 2361) return "B";
+  if (cp === 2362) return "Mabv";
+  if (cp === 2363) return "Mpst";
+  if (cp === 2364) return "Mblw";
+  if (cp === 2365) return "O";
+  if (cp === 2366) return "Mpst";
+  if (cp >= 2367 && cp <= 2368) return cp === 2367 ? "Mpre" : "Mpst";
+  if (cp >= 2369 && cp <= 2376) return "Mblw";
+  if (cp >= 2377 && cp <= 2380) return "Mpst";
+  if (cp === 2381) return "H";
+  if (cp >= 2382 && cp <= 2383) return "Mpre";
+  if (cp === 2384) return "O";
+  if (cp >= 2385 && cp <= 2391) return "Mabv";
+  if (cp >= 2392 && cp <= 2401) return "B";
+  if (cp >= 2402 && cp <= 2403) return "Mblw";
+  if (cp >= 2406 && cp <= 2415) return "N";
+  return "O";
+}
+function bengaliCategory(cp) {
+  if (cp === 2433) return "Mabv";
+  if (cp === 2434) return "Mpst";
+  if (cp === 2435) return "Mpst";
+  if (cp >= 2437 && cp <= 2452) return "V";
+  if (cp >= 2453 && cp <= 2489) return "B";
+  if (cp === 2492) return "Mblw";
+  if (cp === 2493) return "O";
+  if (cp === 2494) return "Mpst";
+  if (cp >= 2495 && cp <= 2496) return cp === 2495 ? "Mpre" : "Mpst";
+  if (cp >= 2497 && cp <= 2500) return "Mblw";
+  if (cp >= 2503 && cp <= 2504) return "Mpre";
+  if (cp >= 2507 && cp <= 2508) return "Mpre";
+  if (cp === 2509) return "H";
+  if (cp === 2510) return "B";
+  if (cp === 2519) return "Mpst";
+  if (cp >= 2524 && cp <= 2527) return "B";
+  if (cp >= 2528 && cp <= 2531) return "O";
+  if (cp >= 2534 && cp <= 2543) return "N";
+  return "O";
+}
+function tamilCategory(cp) {
+  if (cp === 2946) return "Mabv";
+  if (cp >= 2949 && cp <= 2964) return "V";
+  if (cp >= 2965 && cp <= 3001) return "B";
+  if (cp === 3006) return "Mpst";
+  if (cp === 3007) return "Mpst";
+  if (cp >= 3008 && cp <= 3010) return "Mpst";
+  if (cp >= 3014 && cp <= 3016) return "Mpre";
+  if (cp >= 3018 && cp <= 3020) return "Mpre";
+  if (cp === 3021) return "H";
+  if (cp === 3031) return "Mpst";
+  if (cp >= 3046 && cp <= 3055) return "N";
+  return "O";
+}
+function classifyUseCategory(cp) {
+  if (cp === 8204) return "ZWNJ";
+  if (cp === 8205) return "ZWJ";
+  if (cp >= 2304 && cp <= 2431) return devanagariCategory(cp);
+  if (cp >= 2432 && cp <= 2559) return bengaliCategory(cp);
+  if (cp >= 2944 && cp <= 3071) return tamilCategory(cp);
+  return "O";
+}
+
+// src/shaping/bengali-shaper.ts
+var HALANT = 2509;
 var NUKTA = 2492;
 var RA = 2480;
 function bengaliCharType(cp) {
@@ -473,10 +1287,563 @@ function bengaliCharType(cp) {
   if (cp === 2510) return 0;
   return -1;
 }
-function isConsonant(cp) {
-  return bengaliCharType(cp) === 0;
+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]);
+      i += 2;
+    }
+    let lastConsonantIdx = -1;
+    while (i < cps.length) {
+      const cc = cps[i];
+      const ct = bengaliCharType(cc);
+      if (ct === 0) {
+        lastConsonantIdx = syllable.length;
+        syllable.push(cc);
+        i++;
+        if (i < cps.length && cps[i] === NUKTA) {
+          syllable.push(cps[i]);
+          i++;
+        }
+        if (i < cps.length && cps[i] === HALANT) {
+          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 = j;
+            continue;
+          } else {
+            syllable.push(cps[i]);
+            i = j;
+            break;
+          }
+        }
+        break;
+      } else {
+        break;
+      }
+    }
+    baseIdx = lastConsonantIdx >= 0 ? lastConsonantIdx : 0;
+    while (i < cps.length) {
+      const ct = bengaliCharType(cps[i]);
+      if (ct >= 2 && ct <= 5) {
+        if (ct === 4) {
+          preMatras.push(syllable.length);
+        }
+        syllable.push(cps[i]);
+        i++;
+      } else {
+        break;
+      }
+    }
+    while (i < cps.length && bengaliCharType(cps[i]) === 6) {
+      syllable.push(cps[i]);
+      i++;
+    }
+    if (syllable.length === 0) {
+      syllable.push(cps[i] ?? 32);
+      i++;
+    }
+    clusters.push({
+      codepoints: syllable,
+      baseIndex: hasReph ? baseIdx + 2 : baseIdx,
+      // Adjust for reph prefix
+      hasReph,
+      preBaseMatras: preMatras
+    });
+  }
+  return clusters;
+}
+function shapeBengaliText(str, fontData) {
+  const { cmap, gsub, ligatures, markAnchors, widths, defaultWidth } = fontData;
+  const shaped = [];
+  function resolveGid(cp) {
+    const normCp = cp === 8239 || cp === 160 ? 32 : cp;
+    return cmap[normCp] || 0;
+  }
+  function resolveGidGsub(cp) {
+    const gid = resolveGid(cp);
+    if (gsub[gid] !== void 0) return gsub[gid];
+    return gid;
+  }
+  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 = buildBengaliClusters(str);
+  for (const cluster of clusters) {
+    const { codepoints, hasReph, preBaseMatras } = cluster;
+    const baseStart = hasReph ? 2 : 0;
+    let baseGid = 0;
+    for (let ci = baseStart; ci < codepoints.length; ci++) {
+      const ct = bengaliCharType(codepoints[ci]);
+      if (ct === 0) {
+        baseGid = resolveGid(codepoints[ci]);
+      } else if (ct >= 2) {
+        break;
+      }
+    }
+    const splitPostComponents = [];
+    for (const mIdx of preBaseMatras) {
+      if (mIdx < codepoints.length) {
+        const mCp = codepoints[mIdx];
+        if (mCp === 2507) {
+          emitGlyph(resolveGid(2503), false);
+          splitPostComponents.push(2494);
+        } else if (mCp === 2508) {
+          emitGlyph(resolveGid(2503), false);
+          splitPostComponents.push(2519);
+        } else {
+          emitGlyph(resolveGid(mCp), false);
+        }
+      }
+    }
+    const clusterGids = [];
+    const clusterEndIdx = [];
+    let matraStart = codepoints.length;
+    for (let ci = baseStart; ci < codepoints.length; ci++) {
+      const ct = bengaliCharType(codepoints[ci]);
+      if (ct === 0 || ct === 7 || ct === 8) {
+        clusterGids.push(resolveGid(codepoints[ci]));
+        clusterEndIdx.push(ci);
+      } else if (ct < 0 || ct === 1 || ct === 9) {
+        emitGlyph(resolveGid(codepoints[ci]), false);
+      } else {
+        matraStart = ci;
+        break;
+      }
+    }
+    let ligConsumed = 0;
+    const ligResult = tryLig(clusterGids);
+    if (ligResult) {
+      emitGlyph(ligResult.resultGid, false);
+      baseGid = ligResult.resultGid;
+      ligConsumed = ligResult.consumed;
+      let gi = ligConsumed;
+      while (gi < clusterGids.length) {
+        const subSeq = clusterGids.slice(gi);
+        const subLig = tryLig(subSeq);
+        if (subLig) {
+          emitGlyph(subLig.resultGid, false);
+          gi += subLig.consumed;
+        } else {
+          const origCi = clusterEndIdx[gi];
+          const ct = bengaliCharType(codepoints[origCi]);
+          if (ct === 7) {
+            emitGlyph(clusterGids[gi], true, baseGid);
+          } else {
+            emitGlyph(clusterGids[gi], false);
+          }
+          gi++;
+        }
+      }
+    } else {
+      for (let ci = baseStart; ci < matraStart; ci++) {
+        const cp = codepoints[ci];
+        const ct = bengaliCharType(cp);
+        if (ct === 0) {
+          emitGlyph(resolveGid(cp), false);
+        } else if (ct === 7) {
+          emitGlyph(resolveGid(cp), true, baseGid);
+        } else if (ct === 8) {
+          emitGlyph(resolveGid(cp), true, baseGid);
+        }
+      }
+    }
+    for (let ci = matraStart; ci < codepoints.length; ci++) {
+      const cp = codepoints[ci];
+      const ct = bengaliCharType(cp);
+      if (ct === 4) continue;
+      if (ct === 2 || ct === 3) {
+        emitGlyph(resolveGid(cp), true, baseGid);
+      } else if (ct === 5) {
+        emitGlyph(resolveGid(cp), false);
+      } else if (ct === 6) {
+        emitGlyph(resolveGid(cp), true, baseGid);
+      } else if (ct === 9) {
+        emitGlyph(resolveGid(cp), false);
+      } else {
+        emitGlyph(resolveGid(cp), false);
+      }
+    }
+    for (const postCp of splitPostComponents) {
+      emitGlyph(resolveGid(postCp), false);
+    }
+    if (hasReph) {
+      const raGid = resolveGidGsub(RA);
+      const halantGid = resolveGid(HALANT);
+      emitGlyph(raGid, true, baseGid);
+      emitGlyph(halantGid, true, baseGid);
+    }
+  }
+  return shaped;
+}
+
+// src/shaping/tamil-shaper.ts
+var PULLI = 3021;
+function tamilCharType(cp) {
+  if (cp === PULLI) return 7;
+  if (cp === 2946 || cp === 2947) return 6;
+  if (cp >= 2949 && cp <= 2964) return 1;
+  if (cp >= 2965 && cp <= 3001) return 0;
+  if (cp === 3007) return 4;
+  if (cp === 3014) return 4;
+  if (cp === 3015) return 4;
+  if (cp === 3016) return 4;
+  if (cp === 3018) return 4;
+  if (cp === 3019) return 4;
+  if (cp === 3020) return 4;
+  if (cp === 3006) return 5;
+  if (cp === 3008) return 5;
+  if (cp === 3009 || cp === 3010) return 2;
+  if (cp === 3031) return 5;
+  if (cp >= 3006 && cp <= 3020) return 2;
+  if (cp >= 3046 && cp <= 3055) return 9;
+  if (cp >= 3056 && cp <= 3066) return 9;
+  if (cp === 3024) return 6;
+  return -1;
+}
+function isConsonant2(cp) {
+  return tamilCharType(cp) === 0;
+}
+function buildTamilClusters(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 = 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++;
+      continue;
+    }
+    const syllable = [];
+    let lastConsonantIdx = -1;
+    const preMatras = [];
+    while (i < cps.length) {
+      const cc = cps[i];
+      const ct = tamilCharType(cc);
+      if (ct === 0) {
+        lastConsonantIdx = syllable.length;
+        syllable.push(cc);
+        i++;
+        if (i < cps.length && cps[i] === PULLI) {
+          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 = 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 = tamilCharType(cps[i]);
+      if (ct >= 2 && ct <= 5) {
+        if (ct === 4) {
+          preMatras.push(syllable.length);
+        }
+        syllable.push(cps[i]);
+        i++;
+      } else {
+        break;
+      }
+    }
+    while (i < cps.length && tamilCharType(cps[i]) === 6) {
+      syllable.push(cps[i]);
+      i++;
+    }
+    if (syllable.length === 0) {
+      syllable.push(cps[i] ?? 32);
+      i++;
+    }
+    clusters.push({
+      codepoints: syllable,
+      baseIndex: baseIdx,
+      preBaseMatras: preMatras
+    });
+  }
+  return clusters;
+}
+function shapeTamilText(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 = buildTamilClusters(str);
+  for (const cluster of clusters) {
+    const { codepoints, preBaseMatras } = cluster;
+    let baseGid = 0;
+    for (let ci = 0; ci < codepoints.length; ci++) {
+      const ct = tamilCharType(codepoints[ci]);
+      if (ct === 0) {
+        baseGid = resolveGid(codepoints[ci]);
+      } else if (ct >= 2) {
+        break;
+      }
+    }
+    const splitPostComponents = [];
+    for (const mIdx of preBaseMatras) {
+      if (mIdx < codepoints.length) {
+        const mCp = codepoints[mIdx];
+        if (mCp === 3018) {
+          emitGlyph(resolveGid(3014), false);
+          splitPostComponents.push(3006);
+        } else if (mCp === 3019) {
+          emitGlyph(resolveGid(3015), false);
+          splitPostComponents.push(3006);
+        } else if (mCp === 3020) {
+          emitGlyph(resolveGid(3014), false);
+          splitPostComponents.push(3031);
+        } else {
+          emitGlyph(resolveGid(mCp), false);
+        }
+      }
+    }
+    const clusterGids = [];
+    const clusterEndIdx = [];
+    let matraStart = codepoints.length;
+    for (let ci = 0; ci < codepoints.length; ci++) {
+      const ct = tamilCharType(codepoints[ci]);
+      if (ct === 0 || ct === 7) {
+        clusterGids.push(resolveGid(codepoints[ci]));
+        clusterEndIdx.push(ci);
+      } else if (ct >= 2) {
+        matraStart = ci;
+        break;
+      } else if (ct < 0) {
+        emitGlyph(resolveGid(codepoints[ci]), false);
+      } else if (ct === 1) {
+        emitGlyph(resolveGid(codepoints[ci]), false);
+      }
+    }
+    let ligConsumed = 0;
+    const ligResult = tryLig(clusterGids);
+    if (ligResult) {
+      emitGlyph(ligResult.resultGid, false);
+      baseGid = ligResult.resultGid;
+      ligConsumed = ligResult.consumed;
+      let gi = ligConsumed;
+      while (gi < clusterGids.length) {
+        const subSeq = clusterGids.slice(gi);
+        const subLig = tryLig(subSeq);
+        if (subLig) {
+          emitGlyph(subLig.resultGid, false);
+          gi += subLig.consumed;
+        } else {
+          const origCi = clusterEndIdx[gi];
+          const ct = tamilCharType(codepoints[origCi]);
+          if (ct === 7) {
+            emitGlyph(clusterGids[gi], true, baseGid);
+          } else {
+            emitGlyph(clusterGids[gi], false);
+          }
+          gi++;
+        }
+      }
+    } else {
+      for (let ci = 0; ci < matraStart; ci++) {
+        const cp = codepoints[ci];
+        const ct = tamilCharType(cp);
+        if (ct === 0) {
+          emitGlyph(resolveGid(cp), false);
+        } else if (ct === 7) {
+          emitGlyph(resolveGid(cp), true, baseGid);
+        }
+      }
+    }
+    for (let ci = matraStart; ci < codepoints.length; ci++) {
+      const cp = codepoints[ci];
+      const ct = tamilCharType(cp);
+      if (ct === 4) continue;
+      if (ct === 2 || ct === 3) {
+        emitGlyph(resolveGid(cp), true, baseGid);
+      } else if (ct === 5) {
+        emitGlyph(resolveGid(cp), false);
+      } else if (ct === 6) {
+        emitGlyph(resolveGid(cp), true, baseGid);
+      } else if (ct === 9) {
+        emitGlyph(resolveGid(cp), false);
+      } else {
+        emitGlyph(resolveGid(cp), false);
+      }
+    }
+    for (const postCp of splitPostComponents) {
+      emitGlyph(resolveGid(postCp), false);
+    }
+  }
+  return shaped;
+}
+
+// src/shaping/telugu-shaper.ts
+var VIRAMA = 3149;
+function teluguCharType(cp) {
+  if (cp === VIRAMA) return 7;
+  if (cp >= 3072 && cp <= 3076) return 6;
+  if (cp >= 3077 && cp <= 3092) return 1;
+  if (cp === 3133) return 1;
+  if (cp >= 3093 && cp <= 3129) return 0;
+  if (cp >= 3160 && cp <= 3162) return 0;
+  if (cp === 3134) return 5;
+  if (cp === 3135) return 2;
+  if (cp === 3136) return 2;
+  if (cp === 3137) return 5;
+  if (cp === 3138) return 5;
+  if (cp === 3139) return 2;
+  if (cp === 3140) return 2;
+  if (cp === 3142) return 2;
+  if (cp === 3143) return 2;
+  if (cp === 3144) return 2;
+  if (cp === 3146) return 5;
+  if (cp === 3147) return 5;
+  if (cp === 3148) return 5;
+  if (cp === 3170 || cp === 3171) return 3;
+  if (cp === 3157 || cp === 3158) return 6;
+  if (cp === 3168 || cp === 3169) return 1;
+  if (cp >= 3174 && cp <= 3183) return 9;
+  if (cp >= 3192 && cp <= 3199) return 9;
+  return -1;
+}
+function isConsonant3(cp) {
+  return teluguCharType(cp) === 0;
 }
-function buildBengaliClusters(str) {
+function buildTeluguClusters(str) {
   const clusters = [];
   const cps = [];
   for (let i2 = 0; i2 < str.length; ) {
@@ -487,41 +1854,285 @@ function buildBengaliClusters(str) {
   let i = 0;
   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 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 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]);
-      i += 2;
-    }
     let lastConsonantIdx = -1;
     while (i < cps.length) {
       const cc = cps[i];
-      const ct = bengaliCharType(cc);
+      const ct = sinhalaCharType(cc);
       if (ct === 0) {
         lastConsonantIdx = syllable.length;
         syllable.push(cc);
         i++;
-        if (i < cps.length && cps[i] === NUKTA) {
-          syllable.push(cps[i]);
-          i++;
-        }
-        if (i < cps.length && cps[i] === HALANT) {
-          if (i + 1 < cps.length && isConsonant(cps[i + 1])) {
+        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]);
-            i++;
+            if (zwj) syllable.push(8205);
+            i = j;
             continue;
           } else {
             syllable.push(cps[i]);
-            i++;
+            i = j;
             break;
           }
         }
@@ -530,20 +2141,17 @@ function buildBengaliClusters(str) {
         break;
       }
     }
-    baseIdx = lastConsonantIdx >= 0 ? lastConsonantIdx : 0;
+    const baseIdx = lastConsonantIdx >= 0 ? lastConsonantIdx : 0;
     while (i < cps.length) {
-      const ct = bengaliCharType(cps[i]);
+      const ct = sinhalaCharType(cps[i]);
       if (ct >= 2 && ct <= 5) {
-        if (ct === 4) {
-          preMatras.push(syllable.length);
-        }
         syllable.push(cps[i]);
         i++;
       } else {
         break;
       }
     }
-    while (i < cps.length && bengaliCharType(cps[i]) === 6) {
+    while (i < cps.length && sinhalaCharType(cps[i]) === 6) {
       syllable.push(cps[i]);
       i++;
     }
@@ -551,28 +2159,375 @@ function buildBengaliClusters(str) {
       syllable.push(cps[i] ?? 32);
       i++;
     }
-    clusters.push({
-      codepoints: syllable,
-      baseIndex: hasReph ? baseIdx + 2 : baseIdx,
-      // Adjust for reph prefix
-      hasReph,
-      preBaseMatras: preMatras
-    });
+    clusters.push({ codepoints: syllable, baseIndex: baseIdx });
   }
   return clusters;
 }
-function shapeBengaliText(str, fontData) {
-  const { cmap, gsub, ligatures, markAnchors, widths, defaultWidth } = fontData;
+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 resolveGidGsub(cp) {
-    const gid = resolveGid(cp);
-    if (gsub[gid] !== void 0) return gsub[gid];
-    return gid;
-  }
   function tryLig(gids) {
     return tryLigature(gids, ligatures);
   }
@@ -610,143 +2565,100 @@ function shapeBengaliText(str, fontData) {
       shaped.push({ gid, dx: 0, dy: 0, isZeroAdvance: false });
     }
   }
-  const clusters = buildBengaliClusters(str);
+  const clusters = buildKhmerClusters(str);
   for (const cluster of clusters) {
-    const { codepoints, hasReph, preBaseMatras } = cluster;
-    const baseStart = hasReph ? 2 : 0;
+    const { codepoints } = cluster;
     let baseGid = 0;
-    for (let ci = baseStart; ci < codepoints.length; ci++) {
-      const ct = bengaliCharType(codepoints[ci]);
-      if (ct === 0) {
+    for (let ci = 0; ci < codepoints.length; ci++) {
+      const ct = khmerCharType(codepoints[ci]);
+      if (ct === 0 || ct === 1) {
         baseGid = resolveGid(codepoints[ci]);
-      } else if (ct >= 2) {
         break;
       }
     }
-    const splitPostComponents = [];
-    for (const mIdx of preBaseMatras) {
-      if (mIdx < codepoints.length) {
-        const mCp = codepoints[mIdx];
-        if (mCp === 2507) {
-          emitGlyph(resolveGid(2503), false);
-          splitPostComponents.push(2494);
-        } else if (mCp === 2508) {
-          emitGlyph(resolveGid(2503), false);
-          splitPostComponents.push(2519);
-        } else {
-          emitGlyph(resolveGid(mCp), false);
-        }
-      }
+    for (let ci = 0; ci < codepoints.length; ci++) {
+      if (khmerCharType(codepoints[ci]) === 4) emitGlyph(resolveGid(codepoints[ci]), false);
     }
-    const clusterGids = [];
-    const clusterEndIdx = [];
-    let matraStart = codepoints.length;
-    for (let ci = baseStart; ci < codepoints.length; ci++) {
-      const ct = bengaliCharType(codepoints[ci]);
-      if (ct === 0 || ct === 7 || ct === 8) {
-        clusterGids.push(resolveGid(codepoints[ci]));
-        clusterEndIdx.push(ci);
-      } else if (ct < 0 || ct === 1 || ct === 9) {
-        emitGlyph(resolveGid(codepoints[ci]), false);
-      } else {
-        matraStart = ci;
+    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);
       }
     }
-    let ligConsumed = 0;
-    const ligResult = tryLig(clusterGids);
+    const ligResult = tryLig(stackGids);
     if (ligResult) {
       emitGlyph(ligResult.resultGid, false);
       baseGid = ligResult.resultGid;
-      ligConsumed = ligResult.consumed;
-      let gi = ligConsumed;
-      while (gi < clusterGids.length) {
-        const subSeq = clusterGids.slice(gi);
-        const subLig = tryLig(subSeq);
+      let gi = ligResult.consumed;
+      while (gi < stackGids.length) {
+        const subLig = tryLig(stackGids.slice(gi));
         if (subLig) {
           emitGlyph(subLig.resultGid, false);
           gi += subLig.consumed;
         } else {
-          const origCi = clusterEndIdx[gi];
-          const ct = bengaliCharType(codepoints[origCi]);
-          if (ct === 7) {
-            emitGlyph(clusterGids[gi], true, baseGid);
-          } else {
-            emitGlyph(clusterGids[gi], false);
-          }
+          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 ci = baseStart; ci < matraStart; ci++) {
-        const cp = codepoints[ci];
-        const ct = bengaliCharType(cp);
-        if (ct === 0) {
-          emitGlyph(resolveGid(cp), false);
-        } else if (ct === 7) {
-          emitGlyph(resolveGid(cp), true, baseGid);
-        } else if (ct === 8) {
-          emitGlyph(resolveGid(cp), true, baseGid);
-        }
+      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 = matraStart; ci < codepoints.length; ci++) {
+    for (let ci = markStart; ci < codepoints.length; ci++) {
       const cp = codepoints[ci];
-      const ct = bengaliCharType(cp);
-      if (ct === 4) continue;
-      if (ct === 2 || ct === 3) {
-        emitGlyph(resolveGid(cp), true, baseGid);
-      } else if (ct === 5) {
-        emitGlyph(resolveGid(cp), false);
-      } else if (ct === 6) {
-        emitGlyph(resolveGid(cp), true, baseGid);
-      } else if (ct === 9) {
-        emitGlyph(resolveGid(cp), false);
-      } else {
-        emitGlyph(resolveGid(cp), false);
-      }
-    }
-    for (const postCp of splitPostComponents) {
-      emitGlyph(resolveGid(postCp), false);
-    }
-    if (hasReph) {
-      const raGid = resolveGidGsub(RA);
-      const halantGid = resolveGid(HALANT);
-      emitGlyph(raGid, true, baseGid);
-      emitGlyph(halantGid, true, baseGid);
+      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/tamil-shaper.ts
-var PULLI = 3021;
-function tamilCharType(cp) {
-  if (cp === PULLI) return 7;
-  if (cp === 2946 || cp === 2947) return 6;
-  if (cp >= 2949 && cp <= 2964) return 1;
-  if (cp >= 2965 && cp <= 3001) return 0;
-  if (cp === 3007) return 4;
-  if (cp === 3014) return 4;
-  if (cp === 3015) return 4;
-  if (cp === 3016) return 4;
-  if (cp === 3018) return 4;
-  if (cp === 3019) return 4;
-  if (cp === 3020) return 4;
-  if (cp === 3006) return 5;
-  if (cp === 3008) return 5;
-  if (cp === 3009 || cp === 3010) return 2;
-  if (cp === 3031) return 5;
-  if (cp >= 3006 && cp <= 3020) return 2;
-  if (cp >= 3046 && cp <= 3055) return 9;
-  if (cp >= 3056 && cp <= 3066) return 9;
-  if (cp === 3024) return 6;
+// 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 isConsonant2(cp) {
-  return tamilCharType(cp) === 0;
+function isConsonant6(cp) {
+  return myanmarCharType(cp) === 0;
 }
-function buildTamilClusters(str) {
+function buildMyanmarClusters(str) {
   const clusters = [];
   const cps = [];
   for (let i2 = 0; i2 < str.length; ) {
@@ -757,68 +2669,46 @@ function buildTamilClusters(str) {
   let i = 0;
   while (i < cps.length) {
     const cp = cps[i];
-    const type = tamilCharType(cp);
-    if (type < 0 || cp < TAMIL_START || cp > TAMIL_END) {
-      clusters.push({ codepoints: [cp], baseIndex: 0, preBaseMatras: [] });
+    const type = myanmarCharType(cp);
+    if (type < 0 || cp < MYANMAR_START || cp > MYANMAR_END) {
+      clusters.push({ codepoints: [cp] });
       i++;
       continue;
     }
-    const syllable = [];
-    let lastConsonantIdx = -1;
-    const preMatras = [];
-    while (i < cps.length) {
-      const cc = cps[i];
-      const ct = tamilCharType(cc);
-      if (ct === 0) {
-        lastConsonantIdx = syllable.length;
-        syllable.push(cc);
-        i++;
-        if (i < cps.length && cps[i] === PULLI) {
-          if (i + 1 < cps.length && isConsonant2(cps[i + 1])) {
-            syllable.push(cps[i]);
-            i++;
-            continue;
-          } else {
-            syllable.push(cps[i]);
-            i++;
-            break;
-          }
-        }
-        break;
-      } else {
-        break;
-      }
+    if (type !== 0) {
+      clusters.push({ codepoints: [cp] });
+      i++;
+      continue;
     }
-    const baseIdx = lastConsonantIdx >= 0 ? lastConsonantIdx : 0;
-    while (i < cps.length) {
-      const ct = tamilCharType(cps[i]);
-      if (ct >= 2 && ct <= 5) {
-        if (ct === 4) {
-          preMatras.push(syllable.length);
-        }
-        syllable.push(cps[i]);
-        i++;
+    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 && tamilCharType(cps[i]) === 6) {
-      syllable.push(cps[i]);
+    while (i < cps.length && myanmarCharType(cps[i]) === 8) {
+      cluster.push(cps[i]);
       i++;
     }
-    if (syllable.length === 0) {
-      syllable.push(cps[i] ?? 32);
-      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: syllable,
-      baseIndex: baseIdx,
-      preBaseMatras: preMatras
-    });
+    clusters.push({ codepoints: cluster });
   }
   return clusters;
 }
-function shapeTamilText(str, fontData) {
+function shapeMyanmarText(str, fontData) {
   const { cmap, ligatures, markAnchors, widths, defaultWidth } = fontData;
   const shaped = [];
   function resolveGid(cp) {
@@ -862,106 +2752,68 @@ function shapeTamilText(str, fontData) {
       shaped.push({ gid, dx: 0, dy: 0, isZeroAdvance: false });
     }
   }
-  const clusters = buildTamilClusters(str);
+  const clusters = buildMyanmarClusters(str);
   for (const cluster of clusters) {
-    const { codepoints, preBaseMatras } = cluster;
+    const { codepoints } = cluster;
     let baseGid = 0;
     for (let ci = 0; ci < codepoints.length; ci++) {
-      const ct = tamilCharType(codepoints[ci]);
-      if (ct === 0) {
+      if (myanmarCharType(codepoints[ci]) === 0) {
         baseGid = resolveGid(codepoints[ci]);
-      } else if (ct >= 2) {
         break;
       }
     }
-    const splitPostComponents = [];
-    for (const mIdx of preBaseMatras) {
-      if (mIdx < codepoints.length) {
-        const mCp = codepoints[mIdx];
-        if (mCp === 3018) {
-          emitGlyph(resolveGid(3014), false);
-          splitPostComponents.push(3006);
-        } else if (mCp === 3019) {
-          emitGlyph(resolveGid(3015), false);
-          splitPostComponents.push(3006);
-        } else if (mCp === 3020) {
-          emitGlyph(resolveGid(3014), false);
-          splitPostComponents.push(3031);
-        } else {
-          emitGlyph(resolveGid(mCp), false);
-        }
-      }
-    }
-    const clusterGids = [];
-    const clusterEndIdx = [];
-    let matraStart = codepoints.length;
     for (let ci = 0; ci < codepoints.length; ci++) {
-      const ct = tamilCharType(codepoints[ci]);
-      if (ct === 0 || ct === 7) {
-        clusterGids.push(resolveGid(codepoints[ci]));
-        clusterEndIdx.push(ci);
-      } else if (ct >= 2) {
-        matraStart = ci;
-        break;
-      } else if (ct < 0) {
-        emitGlyph(resolveGid(codepoints[ci]), false);
-      } else if (ct === 1) {
-        emitGlyph(resolveGid(codepoints[ci]), false);
-      }
-    }
-    let ligConsumed = 0;
-    const ligResult = tryLig(clusterGids);
-    if (ligResult) {
-      emitGlyph(ligResult.resultGid, false);
-      baseGid = ligResult.resultGid;
-      ligConsumed = ligResult.consumed;
-      let gi = ligConsumed;
-      while (gi < clusterGids.length) {
-        const subSeq = clusterGids.slice(gi);
-        const subLig = tryLig(subSeq);
-        if (subLig) {
-          emitGlyph(subLig.resultGid, false);
-          gi += subLig.consumed;
-        } else {
-          const origCi = clusterEndIdx[gi];
-          const ct = tamilCharType(codepoints[origCi]);
-          if (ct === 7) {
-            emitGlyph(clusterGids[gi], true, baseGid);
-          } else {
-            emitGlyph(clusterGids[gi], false);
-          }
-          gi++;
-        }
-      }
-    } else {
-      for (let ci = 0; ci < matraStart; ci++) {
-        const cp = codepoints[ci];
-        const ct = tamilCharType(cp);
-        if (ct === 0) {
-          emitGlyph(resolveGid(cp), false);
-        } else if (ct === 7) {
-          emitGlyph(resolveGid(cp), true, baseGid);
-        }
-      }
+      if (myanmarCharType(codepoints[ci]) === 4) emitGlyph(resolveGid(codepoints[ci]), false);
     }
-    for (let ci = matraStart; ci < codepoints.length; ci++) {
+    const stackGids = [];
+    const stackEndIdx = [];
+    let markStart = codepoints.length;
+    for (let ci = 0; ci < codepoints.length; ci++) {
       const cp = codepoints[ci];
-      const ct = tamilCharType(cp);
-      if (ct === 4) continue;
-      if (ct === 2 || ct === 3) {
-        emitGlyph(resolveGid(cp), true, baseGid);
-      } else if (ct === 5) {
-        emitGlyph(resolveGid(cp), false);
-      } else if (ct === 6) {
-        emitGlyph(resolveGid(cp), true, baseGid);
-      } else if (ct === 9) {
-        emitGlyph(resolveGid(cp), false);
-      } else {
+      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);
       }
     }
-    for (const postCp of splitPostComponents) {
-      emitGlyph(resolveGid(postCp), 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;
@@ -1013,7 +2865,7 @@ function devanagariCharType(cp) {
   if (cp === 2384) return 1;
   return -1;
 }
-function isConsonant3(cp) {
+function isConsonant7(cp) {
   return devanagariCharType(cp) === 0;
 }
 function buildDevanagariClusters(str) {
@@ -1028,6 +2880,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++;
@@ -1036,7 +2892,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;
@@ -1054,13 +2910,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;
           }
         }
@@ -1308,533 +3175,514 @@ var ARABIC_PRES_FORMS = /* @__PURE__ */ new Map([
   [1609, { isol: 65263, fina: 65264 }],
   [1610, { isol: 65265, fina: 65266, init: 65267, medi: 65268 }]
 ]);
-var LAM_ALEF_PRES = /* @__PURE__ */ new Map([
-  [1570, [65269, 65270]],
-  // LAM + ALEF WITH MADDA ABOVE
-  [1571, [65271, 65272]],
-  // LAM + ALEF WITH HAMZA ABOVE
-  [1573, [65273, 65274]],
-  // LAM + ALEF WITH HAMZA BELOW
-  [1575, [65275, 65276]]
-  // LAM + ALEF
-]);
-function resolvePositionalForms(codePoints) {
-  const len = codePoints.length;
-  const forms = new Array(len).fill("isol");
-  const joining = codePoints.map(getJoiningType);
-  for (let i = 0; i < len; i++) {
-    if (joining[i] === "T" || joining[i] === "U") continue;
-    let prevJoin = "U";
-    for (let j = i - 1; j >= 0; j--) {
-      if (joining[j] !== "T") {
-        prevJoin = joining[j];
-        break;
-      }
-    }
-    let nextJoin = "U";
-    for (let j = i + 1; j < len; j++) {
-      if (joining[j] !== "T") {
-        nextJoin = joining[j];
-        break;
-      }
-    }
-    const joinsToPrev = prevJoin === "D" || prevJoin === "C";
-    const joinsToNext = (nextJoin === "D" || nextJoin === "R" || nextJoin === "C") && (joining[i] === "D" || joining[i] === "C");
-    if (joinsToPrev && joinsToNext) {
-      forms[i] = "medi";
-    } else if (joinsToPrev) {
-      forms[i] = "fina";
-    } else if (joinsToNext) {
-      forms[i] = "init";
-    } else {
-      forms[i] = "isol";
-    }
-  }
-  return forms;
-}
-var LAM = 1604;
-var ALEF_VARIANTS = /* @__PURE__ */ new Set([1570, 1571, 1573, 1575]);
-function isLamAlef(cp1, cp2) {
-  return cp1 === LAM && ALEF_VARIANTS.has(cp2);
-}
-function shapeArabicText(str, fontData) {
-  if (!str) return [];
-  const codePoints = [];
-  for (let i = 0; i < str.length; ) {
-    const cp = str.codePointAt(i) ?? 0;
-    codePoints.push(cp);
-    i += cp > 65535 ? 2 : 1;
-  }
-  const forms = resolvePositionalForms(codePoints);
-  const glyphs = [];
-  const cmap = fontData.cmap;
-  const widths = fontData.widths;
-  const defaultWidth = fontData.defaultWidth;
-  const markAnchors = fontData.markAnchors;
-  let lastBaseGid = 0;
-  for (let i = 0; i < codePoints.length; i++) {
-    const cp = codePoints[i];
-    if (i < codePoints.length - 1 && isLamAlef(cp, codePoints[i + 1])) {
-      const ligForms = LAM_ALEF_PRES.get(codePoints[i + 1]);
-      if (ligForms) {
-        const isFinal = forms[i] === "medi" || forms[i] === "fina";
-        const ligCP = isFinal ? ligForms[1] : ligForms[0];
-        const ligGid = cmap[ligCP];
-        if (ligGid) {
-          glyphs.push({ gid: ligGid, dx: 0, dy: 0, isZeroAdvance: false });
-          lastBaseGid = ligGid;
-          i++;
-          continue;
-        }
-      }
-    }
-    let gid = cmap[cp] ?? 0;
-    const presForm = ARABIC_PRES_FORMS.get(cp);
-    if (presForm) {
-      const form = forms[i];
-      let presCP;
-      if (form === "init") presCP = presForm.init;
-      else if (form === "medi") presCP = presForm.medi;
-      else if (form === "fina") presCP = presForm.fina;
-      else presCP = presForm.isol;
-      if (presCP) {
-        const presGid = cmap[presCP];
-        if (presGid) gid = presGid;
-      }
-    }
-    const joining = getJoiningType(cp);
-    const isZeroAdvance = joining === "T";
-    if (isZeroAdvance && lastBaseGid !== 0) {
-      const baseAdv = widths[lastBaseGid] !== void 0 ? widths[lastBaseGid] : defaultWidth;
-      const offset = positionMarkOnBase(markAnchors, gid, lastBaseGid, baseAdv);
-      if (offset) {
-        glyphs.push({ gid, dx: offset.dx, dy: offset.dy, isZeroAdvance: true });
-        continue;
-      }
-    }
-    glyphs.push({ gid, dx: 0, dy: 0, isZeroAdvance });
-    if (!isZeroAdvance) lastBaseGid = gid;
-  }
-  return glyphs;
-}
-
-// src/shaping/bidi.ts
-function classifyBidiType(cp) {
-  if (cp >= 768 && cp <= 879 || // Combining Diacritical Marks
-  cp >= 1425 && cp <= 1469 || // Hebrew marks
-  cp >= 1471 && cp <= 1471 || cp >= 1473 && cp <= 1474 || cp >= 1476 && cp <= 1477 || cp >= 1479 && cp <= 1479 || cp >= 1552 && cp <= 1562 || // Arabic marks
-  cp >= 1611 && cp <= 1631 || // Arabic harakat
-  cp >= 1648 && cp <= 1648 || // Arabic superscript alef
-  cp >= 1750 && cp <= 1756 || cp >= 1759 && cp <= 1764 || cp >= 1767 && cp <= 1768 || cp >= 1770 && cp <= 1773 || cp >= 65056 && cp <= 65071) return "NSM";
-  if (cp === 8203 || cp === 8204 || cp === 8205 || cp === 8206 || cp === 8207 || cp === 65279 || cp === 8294 || cp === 8295 || cp === 8296 || cp === 8297) return "BN";
-  if (cp >= 1632 && cp <= 1641) return "AN";
-  if (cp >= 1776 && cp <= 1785) return "AN";
-  if (cp >= 48 && cp <= 57) return "EN";
-  if (cp === 43 || cp === 45) return "ES";
-  if (cp === 35 || cp === 36 || cp === 37 || cp === 162 || cp === 163 || cp === 164 || cp === 165 || cp === 8364 || cp === 8377 || cp === 8378) return "ET";
-  if (cp === 44 || cp === 46 || cp === 47 || cp === 58 || cp === 160) return "CS";
-  if (cp === 32 || cp === 9 || cp === 10 || cp === 13 || cp === 12 || cp === 8192 || cp === 8202 || cp === 8232 || cp === 8233 || cp === 8239 || cp === 8287 || cp === 12288) return "WS";
-  if (cp >= 1536 && cp <= 1791) return "AL";
-  if (cp >= 1872 && cp <= 1919) return "AL";
-  if (cp >= 2208 && cp <= 2303) return "AL";
-  if (cp >= 64336 && cp <= 65023) return "AL";
-  if (cp >= 65136 && cp <= 65278) return "AL";
-  if (cp >= 1488 && cp <= 1514) return "R";
-  if (cp >= 1520 && cp <= 1524) return "R";
-  if (cp >= 1792 && cp <= 1871) return "R";
-  if (cp >= 1920 && cp <= 1983) return "R";
-  if (cp >= 64285 && cp <= 64335) return "R";
-  if (cp >= 65 && cp <= 90) return "L";
-  if (cp >= 97 && cp <= 122) return "L";
-  if (cp >= 192 && cp <= 591) return "L";
-  if (cp >= 880 && cp <= 1023) return "L";
-  if (cp >= 1024 && cp <= 1279) return "L";
-  if (cp >= 3584 && cp <= 3711) return "L";
-  if (cp >= 2304 && cp <= 2431) return "L";
-  if (cp >= 12352 && cp <= 12543) return "L";
-  if (cp >= 19968 && cp <= 40959) return "L";
-  if (cp >= 44032 && cp <= 55215) return "L";
-  if (cp >= 33 && cp <= 47) return "ON";
-  if (cp >= 58 && cp <= 64) return "ON";
-  if (cp >= 91 && cp <= 96) return "ON";
-  if (cp >= 123 && cp <= 126) return "ON";
-  if (cp >= 161 && cp <= 191) return "ON";
-  if (cp >= 8208 && cp <= 8231) return "ON";
-  if (cp >= 8240 && cp <= 8286) return "ON";
-  return "L";
-}
-function detectParagraphLevel(types) {
-  for (const t of types) {
-    if (t === "L") return 0;
-    if (t === "R" || t === "AL") return 1;
-  }
-  return 0;
-}
-function resolveWeakTypes(types, paraLevel) {
-  const len = types.length;
-  let prevType = paraLevel === 0 ? "L" : "R";
-  for (let i = 0; i < len; i++) {
-    if (types[i] === "BN") continue;
-    if (types[i] === "NSM") {
-      types[i] = prevType;
-    }
-    prevType = types[i];
-  }
-  let lastStrong = paraLevel === 0 ? "L" : "R";
-  for (let i = 0; i < len; i++) {
-    if (types[i] === "BN") continue;
-    if (types[i] === "R" || types[i] === "L" || types[i] === "AL") {
-      lastStrong = types[i];
-    } else if (types[i] === "EN" && lastStrong === "AL") {
-      types[i] = "AN";
-    }
-  }
-  for (let i = 0; i < len; i++) {
-    if (types[i] === "AL") types[i] = "R";
-  }
-  for (let i = 1; i < len - 1; i++) {
-    if (types[i] === "BN") continue;
-    if (types[i] === "ES" && types[i - 1] === "EN" && types[i + 1] === "EN") {
-      types[i] = "EN";
-    } else if (types[i] === "CS") {
-      if (types[i - 1] === "EN" && types[i + 1] === "EN") types[i] = "EN";
-      else if (types[i - 1] === "AN" && types[i + 1] === "AN") types[i] = "AN";
-    }
-  }
-  for (let i = 0; i < len; i++) {
-    if (types[i] === "ET") {
-      let found = false;
-      for (let j = i - 1; j >= 0; j--) {
-        if (types[j] === "EN") {
-          found = true;
-          break;
-        }
-        if (types[j] !== "ET" && types[j] !== "BN") break;
-      }
-      if (!found) {
-        for (let j = i + 1; j < len; j++) {
-          if (types[j] === "EN") {
-            found = true;
-            break;
-          }
-          if (types[j] !== "ET" && types[j] !== "BN") break;
-        }
-      }
-      if (found) types[i] = "EN";
-    }
-  }
-  for (let i = 0; i < len; i++) {
-    if (types[i] === "ES" || types[i] === "ET" || types[i] === "CS") {
-      types[i] = "ON";
-    }
-  }
-  lastStrong = paraLevel === 0 ? "L" : "R";
-  for (let i = 0; i < len; i++) {
-    if (types[i] === "BN") continue;
-    if (types[i] === "L" || types[i] === "R") {
-      lastStrong = types[i];
-    } else if (types[i] === "EN" && lastStrong === "L") {
-      types[i] = "L";
-    }
-  }
-}
-function resolveNeutralTypes(types, paraLevel) {
-  const len = types.length;
-  const paraDir = paraLevel === 0 ? "L" : "R";
+var LAM_ALEF_PRES = /* @__PURE__ */ new Map([
+  [1570, [65269, 65270]],
+  // LAM + ALEF WITH MADDA ABOVE
+  [1571, [65271, 65272]],
+  // LAM + ALEF WITH HAMZA ABOVE
+  [1573, [65273, 65274]],
+  // LAM + ALEF WITH HAMZA BELOW
+  [1575, [65275, 65276]]
+  // LAM + ALEF
+]);
+function resolvePositionalForms(codePoints) {
+  const len = codePoints.length;
+  const forms = new Array(len).fill("isol");
+  const joining = codePoints.map(getJoiningType);
   for (let i = 0; i < len; i++) {
-    if (types[i] !== "ON" && types[i] !== "WS" && types[i] !== "BN") continue;
-    const start = i;
-    while (i < len && (types[i] === "ON" || types[i] === "WS" || types[i] === "BN")) i++;
-    const end = i;
-    let prevStrong = paraDir;
-    for (let j = start - 1; j >= 0; j--) {
-      if (types[j] === "L" || types[j] === "R" || types[j] === "EN" || types[j] === "AN") {
-        prevStrong = types[j] === "EN" || types[j] === "AN" ? "R" : types[j];
+    if (joining[i] === "T" || joining[i] === "U") continue;
+    let prevJoin = "U";
+    for (let j = i - 1; j >= 0; j--) {
+      if (joining[j] !== "T") {
+        prevJoin = joining[j];
         break;
       }
     }
-    let nextStrong = paraDir;
-    for (let j = end; j < len; j++) {
-      if (types[j] === "L" || types[j] === "R" || types[j] === "EN" || types[j] === "AN") {
-        nextStrong = types[j] === "EN" || types[j] === "AN" ? "R" : types[j];
+    let nextJoin = "U";
+    for (let j = i + 1; j < len; j++) {
+      if (joining[j] !== "T") {
+        nextJoin = joining[j];
         break;
       }
     }
-    const resolved = prevStrong === nextStrong ? prevStrong : paraDir;
-    for (let j = start; j < end; j++) {
-      types[j] = resolved;
-    }
-  }
-}
-function assignLevels(types, paraLevel) {
-  const levels = [];
-  for (const t of types) {
-    if (paraLevel === 0) {
-      levels.push(t === "R" || t === "AN" ? 1 : 0);
+    const joinsToPrev = prevJoin === "D" || prevJoin === "C";
+    const joinsToNext = (nextJoin === "D" || nextJoin === "R" || nextJoin === "C") && (joining[i] === "D" || joining[i] === "C");
+    if (joinsToPrev && joinsToNext) {
+      forms[i] = "medi";
+    } else if (joinsToPrev) {
+      forms[i] = "fina";
+    } else if (joinsToNext) {
+      forms[i] = "init";
     } else {
-      levels.push(t === "L" ? 2 : 1);
+      forms[i] = "isol";
     }
   }
-  return levels;
+  return forms;
 }
-var SENTENCE_PUNCT = /* @__PURE__ */ new Set([
-  46,
-  // .
-  44,
-  // ,
-  59,
-  // ;
-  58,
-  // :
-  33,
-  // !
-  63
-  // ?
-]);
-function fixPunctuationAffinity(types, codePoints, len) {
-  for (let i = 1; i < len; i++) {
-    if (types[i] === "R" && SENTENCE_PUNCT.has(codePoints[i])) {
-      let prevIdx = i - 1;
-      while (prevIdx >= 0 && (types[prevIdx] === "WS" || types[prevIdx] === "BN")) prevIdx--;
-      if (prevIdx >= 0 && types[prevIdx] === "L") {
-        types[i] = "L";
-      }
-    }
-  }
+var LAM = 1604;
+var ALEF_VARIANTS = /* @__PURE__ */ new Set([1570, 1571, 1573, 1575]);
+function isLamAlef(cp1, cp2) {
+  return cp1 === LAM && ALEF_VARIANTS.has(cp2);
 }
-function fixBracketPairing(types, codePoints, len) {
-  const OPEN_BRACKETS = {
-    40: 41,
-    // ( → )
-    91: 93,
-    // [ → ]
-    123: 125
-    // { → }
-  };
-  for (let i = 0; i < len; i++) {
-    const closer = OPEN_BRACKETS[codePoints[i]];
-    if (closer === void 0) continue;
-    let depth = 1;
-    let closeIdx = -1;
-    for (let j = i + 1; j < len; j++) {
-      if (codePoints[j] === codePoints[i]) depth++;
-      else if (codePoints[j] === closer) {
-        depth--;
-        if (depth === 0) {
-          closeIdx = j;
-          break;
+function shapeArabicText(str, fontData) {
+  if (!str) return [];
+  const codePoints = [];
+  for (let i = 0; i < str.length; ) {
+    const cp = str.codePointAt(i) ?? 0;
+    codePoints.push(cp);
+    i += cp > 65535 ? 2 : 1;
+  }
+  const forms = resolvePositionalForms(codePoints);
+  const glyphs = [];
+  const cmap = fontData.cmap;
+  const widths = fontData.widths;
+  const defaultWidth = fontData.defaultWidth;
+  const markAnchors = fontData.markAnchors;
+  let lastBaseGid = 0;
+  for (let i = 0; i < codePoints.length; i++) {
+    const cp = codePoints[i];
+    if (i < codePoints.length - 1 && isLamAlef(cp, codePoints[i + 1])) {
+      const ligForms = LAM_ALEF_PRES.get(codePoints[i + 1]);
+      if (ligForms) {
+        const isFinal = forms[i] === "medi" || forms[i] === "fina";
+        const ligCP = isFinal ? ligForms[1] : ligForms[0];
+        const ligGid = cmap[ligCP];
+        if (ligGid) {
+          glyphs.push({ gid: ligGid, dx: 0, dy: 0, isZeroAdvance: false });
+          lastBaseGid = ligGid;
+          i++;
+          continue;
         }
       }
     }
-    if (closeIdx === -1) continue;
-    let hasL = false;
-    for (let j = i + 1; j < closeIdx; j++) {
-      if (types[j] === "L") {
-        hasL = true;
-        break;
+    let gid = cmap[cp] ?? 0;
+    const presForm = ARABIC_PRES_FORMS.get(cp);
+    if (presForm) {
+      const form = forms[i];
+      let presCP;
+      if (form === "init") presCP = presForm.init;
+      else if (form === "medi") presCP = presForm.medi;
+      else if (form === "fina") presCP = presForm.fina;
+      else presCP = presForm.isol;
+      if (presCP) {
+        const presGid = cmap[presCP];
+        if (presGid) gid = presGid;
       }
     }
-    if (hasL) {
-      types[i] = "L";
-      types[closeIdx] = "L";
-    }
-  }
-}
-function findOutermostIsolatePairs(codePoints) {
-  const pairs = [];
-  let i = 0;
-  while (i < codePoints.length) {
-    const cp = codePoints[i];
-    if (cp === 8294 || cp === 8295 || cp === 8296) {
-      let depth = 1;
-      let close = -1;
-      for (let j = i + 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) {
-            close = j;
-            break;
-          }
-        }
-      }
-      if (close === -1) {
-        i++;
+    const joining = getJoiningType(cp);
+    const isZeroAdvance = joining === "T";
+    if (isZeroAdvance && lastBaseGid !== 0) {
+      const baseAdv = widths[lastBaseGid] !== void 0 ? widths[lastBaseGid] : defaultWidth;
+      const offset = positionMarkOnBase(markAnchors, gid, lastBaseGid, baseAdv);
+      if (offset) {
+        glyphs.push({ gid, dx: offset.dx, dy: offset.dy, isZeroAdvance: true });
         continue;
       }
-      const kind = cp === 8294 ? "LRI" : cp === 8295 ? "RLI" : "FSI";
-      pairs.push({ open: i, close, kind });
-      i = close + 1;
-    } else {
-      i++;
     }
+    glyphs.push({ gid, dx: 0, dy: 0, isZeroAdvance });
+    if (!isZeroAdvance) lastBaseGid = gid;
   }
-  return pairs;
+  return glyphs;
 }
-function resolveBidiRuns(text) {
-  if (!text) return [];
-  const codePoints = [];
-  const cpToStr = [];
-  for (let i = 0; i < text.length; ) {
-    cpToStr.push(i);
-    const cp = text.codePointAt(i) ?? 0;
-    codePoints.push(cp);
-    i += cp > 65535 ? 2 : 1;
-  }
-  cpToStr.push(text.length);
-  const isolates = findOutermostIsolatePairs(codePoints);
-  if (isolates.length === 0) {
-    return resolveBidiCore(text, codePoints, cpToStr);
-  }
-  const insideIsolate = new Array(codePoints.length).fill(false);
-  for (const p of isolates) {
-    for (let k = p.open; k <= p.close; k++) insideIsolate[k] = true;
-  }
-  const outerTypes = codePoints.map((cp, idx) => insideIsolate[idx] ? "BN" : classifyBidiType(cp));
-  const parentLevel = detectParagraphLevel(outerTypes);
-  const out = [];
-  const emitSegment = (cpStart, cpEnd, forced) => {
-    if (cpStart >= cpEnd) return;
-    const segText = text.substring(cpToStr[cpStart], cpToStr[cpEnd]);
-    const segCps = codePoints.slice(cpStart, cpEnd);
-    const baseStrIdx = cpToStr[cpStart];
-    const segCpToStr = cpToStr.slice(cpStart, cpEnd + 1).map((x) => x - baseStrIdx);
-    const segRuns = forced === void 0 ? resolveBidiRuns(segText) : resolveBidiCore(segText, segCps, segCpToStr, forced);
-    for (const r of segRuns) {
-      out.push({ text: r.text, level: r.level, start: r.start + baseStrIdx });
-    }
-  };
-  let cursor = 0;
-  for (const pair of isolates) {
-    emitSegment(cursor, pair.open, parentLevel);
-    const innerStart = pair.open + 1;
-    const innerEnd = pair.close;
-    let innerLevel;
-    if (pair.kind === "LRI") innerLevel = 0;
-    else if (pair.kind === "RLI") innerLevel = 1;
-    else {
-      const innerTypes = codePoints.slice(innerStart, innerEnd).map(classifyBidiType);
-      innerLevel = detectParagraphLevel(innerTypes);
-    }
-    if (innerStart < innerEnd) {
-      const innerText = text.substring(cpToStr[innerStart], cpToStr[innerEnd]);
-      const innerRuns = resolveBidiRunsForced(innerText, innerLevel);
-      const baseStrIdx = cpToStr[innerStart];
-      for (const r of innerRuns) {
-        out.push({ text: r.text, level: r.level, start: r.start + baseStrIdx });
-      }
-    }
-    cursor = pair.close + 1;
+
+// src/fonts/font-loader.ts
+var _fontBinaryCache = /* @__PURE__ */ new WeakMap();
+function getDecodedFontBytes(fontData) {
+  const cached = _fontBinaryCache.get(fontData);
+  if (cached) return cached;
+  let bytes;
+  if (typeof atob === "function") {
+    const binaryStr = atob(fontData.ttfBase64);
+    bytes = new Uint8Array(binaryStr.length);
+    for (let i = 0; i < binaryStr.length; i++) bytes[i] = binaryStr.charCodeAt(i);
+  } else {
+    const buf = globalThis["Buffer"];
+    bytes = buf.from(fontData.ttfBase64, "base64");
   }
-  emitSegment(cursor, codePoints.length, parentLevel);
-  return out;
+  _fontBinaryCache.set(fontData, bytes);
+  return bytes;
 }
-function resolveBidiRunsForced(text, forcedLevel) {
-  if (!text) return [];
-  const codePoints = [];
-  const cpToStr = [];
-  for (let i = 0; i < text.length; ) {
-    cpToStr.push(i);
-    const cp = text.codePointAt(i) ?? 0;
-    codePoints.push(cp);
-    i += cp > 65535 ? 2 : 1;
-  }
-  cpToStr.push(text.length);
-  const isolates = findOutermostIsolatePairs(codePoints);
-  if (isolates.length === 0) {
-    return resolveBidiCore(text, codePoints, cpToStr, forcedLevel);
+
+// 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) };
   }
-  const out = [];
-  const emit = (cpStart, cpEnd, forced) => {
-    if (cpStart >= cpEnd) return;
-    const segText = text.substring(cpToStr[cpStart], cpToStr[cpEnd]);
-    const segCps = codePoints.slice(cpStart, cpEnd);
-    const baseStrIdx = cpToStr[cpStart];
-    const segCpToStr = cpToStr.slice(cpStart, cpEnd + 1).map((x) => x - baseStrIdx);
-    const segRuns = resolveBidiCore(segText, segCps, segCpToStr, forced);
-    for (const r of segRuns) {
-      out.push({ text: r.text, level: r.level, start: r.start + baseStrIdx });
-    }
+  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
   };
-  let cursor = 0;
-  for (const pair of isolates) {
-    emit(cursor, pair.open, forcedLevel);
-    const innerStart = pair.open + 1;
-    const innerEnd = pair.close;
-    let innerLevel;
-    if (pair.kind === "LRI") innerLevel = 0;
-    else if (pair.kind === "RLI") innerLevel = 1;
-    else {
-      const innerTypes = codePoints.slice(innerStart, innerEnd).map(classifyBidiType);
-      innerLevel = detectParagraphLevel(innerTypes);
-    }
-    if (innerStart < innerEnd) {
-      const innerText = text.substring(cpToStr[innerStart], cpToStr[innerEnd]);
-      const innerRuns = resolveBidiRunsForced(innerText, innerLevel);
-      const baseStrIdx = cpToStr[innerStart];
-      for (const r of innerRuns) {
-        out.push({ text: r.text, level: r.level, start: r.start + baseStrIdx });
-      }
-    }
-    cursor = pair.close + 1;
+}
+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;
   }
-  emit(cursor, codePoints.length, forcedLevel);
   return out;
 }
-function resolveBidiCore(text, codePoints, cpToStr, forcedLevel) {
-  const len = codePoints.length;
-  if (len === 0) return [];
-  const types = codePoints.map(classifyBidiType);
-  const paraLevel = forcedLevel !== void 0 ? forcedLevel : detectParagraphLevel(types);
-  resolveWeakTypes(types, paraLevel);
-  resolveNeutralTypes(types, paraLevel);
-  if (paraLevel === 1) {
-    fixPunctuationAffinity(types, codePoints, len);
-    fixBracketPairing(types, codePoints, len);
-  }
-  const levels = assignLevels(types, paraLevel);
-  const runs = [];
-  let runStart = 0;
-  let runLevel = levels[0];
-  for (let i = 1; i <= len; i++) {
-    if (i === len || levels[i] !== runLevel) {
-      const start = cpToStr[runStart];
-      const end = cpToStr[i];
-      let runText = text.substring(start, end);
-      if (runLevel % 2 === 1) {
-        runText = reverseString(runText);
-      }
-      runs.push({ text: runText, level: runLevel, start });
-      if (i < len) {
-        runStart = i;
-        runLevel = levels[i];
+
+// 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");
   }
-  if (paraLevel === 1 && runs.length > 1) {
-    runs.reverse();
-  }
-  return runs;
+  return ops.join("\n");
 }
-function containsRTL(text) {
-  for (let i = 0; i < text.length; ) {
-    const cp = text.codePointAt(i) ?? 0;
-    const t = classifyBidiType(cp);
-    if (t === "R" || t === "AL") return true;
-    i += cp > 65535 ? 2 : 1;
+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");
+    }
   }
-  return false;
+  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
+  };
 }
-function reverseString(str) {
-  const cps = [];
-  for (let i = 0; i < str.length; ) {
-    const cp = str.codePointAt(i) ?? 0;
-    cps.push(cp);
-    i += cp > 65535 ? 2 : 1;
+
+// 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;
   }
-  cps.reverse();
-  return String.fromCodePoint(...cps);
+  return { useGlyph, forms };
 }
 
 // src/core/encoding-context.ts
@@ -1941,13 +3789,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"
@@ -1960,6 +3809,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,
@@ -1969,7 +3819,11 @@ 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)) {
         const bidiRuns = resolveBidiRuns(str);
@@ -2035,6 +3889,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;
@@ -2092,6 +3996,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;
@@ -2107,6 +4066,9 @@ function createEncodingContext(fontEntries, pdfA = false) {
       });
     },
     ps(str) {
+      if (!str) return "<>";
+      str = _norm(str);
+      str = stripBidiControls(str);
       if (!str) return "<>";
       const { cmap } = primary.fontData;
       if (containsRTL(str)) {
@@ -2134,7 +4096,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;
@@ -2146,7 +4108,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) {
@@ -2228,24 +4190,6 @@ function buildSubsetWidthArray(widths, usedGids) {
   return parts.join(" ");
 }
 
-// src/fonts/font-loader.ts
-var _fontBinaryCache = /* @__PURE__ */ new WeakMap();
-function getDecodedFontBytes(fontData) {
-  const cached = _fontBinaryCache.get(fontData);
-  if (cached) return cached;
-  let bytes;
-  if (typeof atob === "function") {
-    const binaryStr = atob(fontData.ttfBase64);
-    bytes = new Uint8Array(binaryStr.length);
-    for (let i = 0; i < binaryStr.length; i++) bytes[i] = binaryStr.charCodeAt(i);
-  } else {
-    const buf = globalThis["Buffer"];
-    bytes = buf.from(fontData.ttfBase64, "base64");
-  }
-  _fontBinaryCache.set(fontData, bytes);
-  return bytes;
-}
-
 // src/fonts/font-subsetter.ts
 function subsetTTF(ttfInput, usedGids) {
   try {
@@ -2559,7 +4503,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());
@@ -2767,45 +4711,64 @@ 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");
 }
-function txtR(str, rightX, y, font, sz, enc) {
-  const width = enc.isUnicode ? enc.tw(str, sz) : helveticaWidth(toWinAnsi(str), sz);
+function txtR(str, rightX, y, font, sz, enc, bold = false) {
+  const width = enc.isUnicode ? enc.tw(str, sz) : bold ? helveticaBoldWidth(str, sz) : helveticaWidth(toWinAnsi(str), sz);
   return txt(str, rightX - width, y, font, sz, enc);
 }
-function txtC(str, leftX, y, font, sz, colW, enc) {
-  const width = enc.isUnicode ? enc.tw(str, sz) : helveticaWidth(toWinAnsi(str), sz);
+function txtC(str, leftX, y, font, sz, colW, enc, bold = false) {
+  const width = enc.isUnicode ? enc.tw(str, sz) : bold ? helveticaBoldWidth(str, sz) : helveticaWidth(toWinAnsi(str), sz);
   return txt(str, leftX + (colW - width) / 2, y, font, sz, enc);
 }
 function txtTagged(str, x, y, font, sz, enc, mcid) {
   return wrapSpan(txt(str, x, y, font, sz, enc), str, mcid);
 }
-function txtRTagged(str, rightX, y, font, sz, enc, mcid) {
-  return wrapSpan(txtR(str, rightX, y, font, sz, enc), str, mcid);
+function txtRTagged(str, rightX, y, font, sz, enc, mcid, bold = false) {
+  return wrapSpan(txtR(str, rightX, y, font, sz, enc, bold), str, mcid);
 }
-function txtCTagged(str, leftX, y, font, sz, colW, enc, mcid) {
-  return wrapSpan(txtC(str, leftX, y, font, sz, colW, enc), str, mcid);
+function txtCTagged(str, leftX, y, font, sz, colW, enc, mcid, bold = false) {
+  return wrapSpan(txtC(str, leftX, y, font, sz, colW, enc, bold), str, mcid);
 }
 function encodePdfTextString(str) {
   let ascii = true;
@@ -2879,12 +4842,12 @@ var DEFAULT_COLUMNS = [
   { f: 0.18, a: "c", mx: 20, mxH: 20 }
 ];
 function computeColumnPositions(columns, marginLeft, contentWidth) {
-  const n = columns.length;
-  const cwi = new Array(n).fill(0);
-  const fixed = new Array(n).fill(false);
+  const n2 = columns.length;
+  const cwi = new Array(n2).fill(0);
+  const fixed = new Array(n2).fill(false);
   let totalFixed = 0;
   let freeWeight = 0;
-  for (let i = 0; i < n; i++) {
+  for (let i = 0; i < n2; i++) {
     const col = columns[i];
     let w = col.f * contentWidth;
     let clamped = false;
@@ -2906,13 +4869,13 @@ function computeColumnPositions(columns, marginLeft, contentWidth) {
   }
   const remaining = contentWidth - totalFixed;
   if (freeWeight > 0) {
-    for (let i = 0; i < n; i++) {
+    for (let i = 0; i < n2; i++) {
       if (!fixed[i]) cwi[i] = columns[i].f / freeWeight * remaining;
     }
   }
-  const cx = new Array(n);
+  const cx = new Array(n2);
   let x = marginLeft;
-  for (let i = 0; i < n; i++) {
+  for (let i = 0; i < n2; i++) {
     cx[i] = x;
     x += cwi[i];
   }
@@ -2938,8 +4901,8 @@ function parseColor(input) {
     `Invalid color format: ${JSON.stringify(input)}. Expected "#RRGGBB", "#RGB", [r, g, b] (0\u2013255), or "R G B" (0.0\u20131.0).`
   );
 }
-function fmtChannel(n) {
-  const clamped = Math.max(0, Math.min(1, n));
+function fmtChannel(n2) {
+  const clamped = Math.max(0, Math.min(1, n2));
   const rounded = Math.round(clamped * 1e3) / 1e3;
   return String(rounded);
 }
@@ -2981,8 +4944,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.`
       );
@@ -3122,8 +5085,8 @@ var MD5_K = new Uint32Array([
   718787259,
   3951481745
 ]);
-function rotl32(x, n) {
-  return (x << n | x >>> 32 - n) >>> 0;
+function rotl32(x, n2) {
+  return (x << n2 | x >>> 32 - n2) >>> 0;
 }
 function md5(input) {
   const len = input.length;
@@ -3263,17 +5226,17 @@ function _buildTableHeader(y, headers, enc, cx, cwi, columns, cw, mgL, mgR, pgW,
       const thEl = { type: "TH", children: [mcref] };
       thChildren.push(thEl);
       if (columns[i].a === "r") {
-        ops.push(txtRTagged(t, cx[i] + cwi[i] - 3, y - TH_H + 4, enc.f2, fs.th, enc, mcid));
+        ops.push(txtRTagged(t, cx[i] + cwi[i] - 3, y - TH_H + 4, enc.f2, fs.th, enc, mcid, true));
       } else if (columns[i].a === "c") {
-        ops.push(txtCTagged(t, cx[i], y - TH_H + 4, enc.f2, fs.th, cwi[i], enc, mcid));
+        ops.push(txtCTagged(t, cx[i], y - TH_H + 4, enc.f2, fs.th, cwi[i], enc, mcid, true));
       } else {
         ops.push(txtTagged(t, cx[i] + 3, y - TH_H + 4, enc.f2, fs.th, enc, mcid));
       }
     } else {
       if (columns[i].a === "r") {
-        ops.push(txtR(t, cx[i] + cwi[i] - 3, y - TH_H + 4, enc.f2, fs.th, enc));
+        ops.push(txtR(t, cx[i] + cwi[i] - 3, y - TH_H + 4, enc.f2, fs.th, enc, true));
       } else if (columns[i].a === "c") {
-        ops.push(txtC(t, cx[i], y - TH_H + 4, enc.f2, fs.th, cwi[i], enc));
+        ops.push(txtC(t, cx[i], y - TH_H + 4, enc.f2, fs.th, cwi[i], enc, true));
       } else {
         ops.push(txt(t, cx[i] + 3, y - TH_H + 4, enc.f2, fs.th, enc));
       }
@@ -3361,6 +5324,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");
   }
@@ -3386,14 +5352,14 @@ function buildPDF(params, layoutOptions) {
   const fontEntries = params.fontEntries || (fontData ? [{ fontData, fontRef: "/F3", lang: "unknown" }] : []);
   const pdfaConfig = resolvePdfAConfig();
   const tagged = pdfaConfig.enabled;
-  const enc = createEncodingContext(fontEntries, tagged);
+  const enc = createEncodingContext(fontEntries, tagged, false);
   const footerTpl = {
     left: footerText || void 0,
     right: "{page}/{pages}"
   };
   const headerH = 0;
   const dateNow = /* @__PURE__ */ new Date();
-  const pad2d = (n) => String(n).padStart(2, "0");
+  const pad2d = (n2) => String(n2).padStart(2, "0");
   const dateStr = `${dateNow.getFullYear()}-${pad2d(dateNow.getMonth() + 1)}-${pad2d(dateNow.getDate())}`;
   const infoCount = infoItems.length;
   const page1Header = TITLE_LN + 16 + infoCount * INFO_LN + 8 + BAL_H + 10;
@@ -3415,6 +5381,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;
@@ -3544,8 +5513,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];
@@ -3603,8 +5572,8 @@ function buildPDF(params, layoutOptions) {
       kids.push(`${pageObjStart + p * 2} 0 R`);
     }
     emitObj(2, `<< /Type /Pages /Kids [${kids.join(" ")}] /Count ${totalPages} >>`);
-    emitObj(3, "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding >>");
-    emitObj(4, "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica-Bold /Encoding /WinAnsiEncoding >>");
+    emitObj(3, `<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding${baseFontToUniRef} >>`);
+    emitObj(4, `<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica-Bold /Encoding /WinAnsiEncoding${baseFontToUniRef} >>`);
     let wmGsResLatin = "";
     let wmImgResLatin = "";
     for (let p = 0; p < totalPages; p++) {
@@ -3621,13 +5590,18 @@ function buildPDF(params, layoutOptions) {
   }
   const baseObjCount = enc.isUnicode ? 4 + fontEntries.length * 5 + wmExtraObjs + totalPages * 2 : 4 + wmExtraObjs + totalPages * 2;
   const infoObjNum = baseObjCount + 1;
-  const { pdfDate, xmpDate: isoDate } = buildPdfMetadata();
+  const { pdfDate, xmpDate: isoDate } = buildPdfMetadata(layoutOptions?.creationDate);
   const infoTitle = params.docTitle || title || "";
   emitObj(
     infoObjNum,
     `<< /Title ${encodePdfTextString(infoTitle)} /Producer (pdfnative) /CreationDate (${pdfDate}) >>`
   );
   let totalObjs = infoObjNum;
+  if (latinToUniObjNum) {
+    const cmap = buildWinAnsiToUnicodeCMap();
+    emitStreamObj(latinToUniObjNum, `<< /Length ${cmap.length}`, cmap);
+    totalObjs = latinToUniObjNum;
+  }
   let xmpObjNum = 0;
   let outputIntentObjNum = 0;
   if (tagged) {
@@ -3683,7 +5657,7 @@ endobj
   }
   const writer = { emit, emitObj, emitStreamObj, offset: getOffset, adjustOffset, objOffsets, parts };
   writeXrefTrailer(writer, totalObjs, infoObjNum, encState, `${infoTitle}|${pdfDate}`);
-  return parts.join("");
+  return parts;
 }
 
 // src/worker/pdf-worker.ts