pdfnative 1.3.0 → 1.5.0

package/dist/index.cjs

@@ -2,8 +2,13 @@
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn2, res) => function __init() {
-  return fn2 && (res = (0, fn2[__getOwnPropNames(fn2)[0]])(fn2 = 0)), res;
+var __esm = (fn2, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn2 && (res = (0, fn2[__getOwnPropNames(fn2)[0]])(fn2 = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -2319,6 +2324,16 @@ var MYANMAR_EXTENDED_A_END = 43647;
 var MYANMAR_EXTENDED_B_START = 43488;
 var MYANMAR_EXTENDED_B_END = 43519;
 var MYANMAR_VIRAMA = 4153;
+var MATH_OPERATORS_START = 8704;
+var MATH_OPERATORS_END = 8959;
+var SUPPLEMENTAL_MATH_OPERATORS_START = 10752;
+var SUPPLEMENTAL_MATH_OPERATORS_END = 11007;
+var GEOMETRIC_SHAPES_START = 9632;
+var GEOMETRIC_SHAPES_END = 9727;
+var MISC_MATH_SYMBOLS_A_START = 10176;
+var MISC_MATH_SYMBOLS_A_END = 10223;
+var MISC_MATH_SYMBOLS_B_START = 10624;
+var MISC_MATH_SYMBOLS_B_END = 10751;
 var EMOJI_RANGES = [
   [127744, 128511],
   // Miscellaneous Symbols and Pictographs
@@ -2397,6 +2412,9 @@ function isMyanmarCodepoint(cp) {
 function isDevanagariCodepoint(cp) {
   return cp >= DEVANAGARI_START && cp <= DEVANAGARI_END || cp >= DEVANAGARI_EXT_START && cp <= DEVANAGARI_EXT_END;
 }
+function isMathCodepoint(cp) {
+  return cp >= MATH_OPERATORS_START && cp <= MATH_OPERATORS_END || cp >= SUPPLEMENTAL_MATH_OPERATORS_START && cp <= SUPPLEMENTAL_MATH_OPERATORS_END || cp >= GEOMETRIC_SHAPES_START && cp <= GEOMETRIC_SHAPES_END || cp >= MISC_MATH_SYMBOLS_A_START && cp <= MISC_MATH_SYMBOLS_A_END || cp >= MISC_MATH_SYMBOLS_B_START && cp <= MISC_MATH_SYMBOLS_B_END;
+}
 function isEmojiCodepoint(cp) {
   if (cp >= FITZPATRICK_START && cp <= FITZPATRICK_END) return true;
   for (const [lo, hi] of EMOJI_RANGES) {
@@ -2483,10 +2501,16 @@ function containsDevanagari(str) {
   }
   return false;
 }
+function containsMath(str) {
+  for (let i = 0; i < str.length; i++) {
+    if (isMathCodepoint(str.charCodeAt(i))) return true;
+  }
+  return false;
+}
 
 // src/shaping/script-detect.ts
 function needsUnicodeFont(lang) {
-  return ["th", "ja", "zh", "ko", "el", "hi", "te", "tr", "vi", "pl", "ar", "he", "ru", "ka", "hy", "am", "si", "bo", "km", "my", "emoji"].includes(lang);
+  return ["th", "ja", "zh", "ko", "el", "hi", "te", "tr", "vi", "pl", "ar", "he", "ru", "ka", "hy", "am", "si", "bo", "km", "my", "math", "emoji"].includes(lang);
 }
 function detectFallbackLangs(texts, primaryLang) {
   const needed = /* @__PURE__ */ new Set();
@@ -2587,6 +2611,10 @@ function detectFallbackLangs(texts, primaryLang) {
         needed.add("hy");
         continue;
       }
+      if (isMathCodepoint(cp)) {
+        needed.add("math");
+        continue;
+      }
       if (isEmojiCodepoint(cp)) {
         needed.add("emoji");
         continue;
@@ -2617,6 +2645,7 @@ function detectCharLang(cp) {
   if (cp >= 1024 && cp <= 1279 || cp >= 1280 && cp <= 1327) return "ru";
   if (cp >= 4256 && cp <= 4351 || cp >= 11520 && cp <= 11567) return "ka";
   if (cp >= 1328 && cp <= 1423 || cp >= 64275 && cp <= 64279) return "hy";
+  if (isMathCodepoint(cp)) return "math";
   if (isEmojiCodepoint(cp)) return "emoji";
   return null;
 }
@@ -5981,15 +6010,86 @@ function radialShadingDict(p, m) {
   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 colorAtOffset(stops, t) {
+  if (stops.length === 0) return [0, 0, 0, 255];
+  const sorted = stops.slice().sort((a, b) => a.offset - b.offset);
+  if (t <= sorted[0].offset) return sorted[0].color;
+  const last = sorted[sorted.length - 1];
+  if (t >= last.offset) return last.color;
+  for (let i = 0; i < sorted.length - 1; i++) {
+    const a = sorted[i], b = sorted[i + 1];
+    if (t >= a.offset && t <= b.offset) {
+      const span = b.offset - a.offset || 1;
+      const f = (t - a.offset) / span;
+      return [
+        Math.round(a.color[0] + (b.color[0] - a.color[0]) * f),
+        Math.round(a.color[1] + (b.color[1] - a.color[1]) * f),
+        Math.round(a.color[2] + (b.color[2] - a.color[2]) * f),
+        Math.round(a.color[3] + (b.color[3] - a.color[3]) * f)
+      ];
+    }
+  }
+  return last.color;
+}
+function emitSweep(p, cx, cy, maxR, body, gsFor, blendMode) {
+  const start = p.startAngle;
+  const end = p.endAngle;
+  const span = end - start;
+  if (Math.abs(span) < 0.01) {
+    const c = colorAtOffset(p.stops, 0);
+    const gs = gsFor(c[3] / 255, blendMode);
+    if (gs) body.push(`/${gs} gs`);
+    body.push(`${ch(c[0])} ${ch(c[1])} ${ch(c[2])} rg`);
+    body.push(`${n(cx - maxR)} ${n(cy - maxR)} ${n(2 * maxR)} ${n(2 * maxR)} re`);
+    body.push("f");
+    return;
+  }
+  const steps = Math.max(12, Math.min(180, Math.ceil(Math.abs(span) / 3)));
+  const r = maxR * 1.5;
+  const rad = Math.PI / 180;
+  for (let i = 0; i < steps; i++) {
+    const a0 = start + span * i / steps;
+    const a1 = start + span * (i + 1) / steps;
+    const tMid = (i + 0.5) / steps;
+    const c = colorAtOffset(p.stops, tMid);
+    const gs = gsFor(c[3] / 255, blendMode);
+    body.push("q");
+    if (gs) body.push(`/${gs} gs`);
+    body.push(`${ch(c[0])} ${ch(c[1])} ${ch(c[2])} rg`);
+    const x0 = cx + r * Math.cos(a0 * rad), y0 = cy + r * Math.sin(a0 * rad);
+    const x1 = cx + r * Math.cos(a1 * rad), y1 = cy + r * Math.sin(a1 * rad);
+    body.push(`${n(cx)} ${n(cy)} m ${n(x0)} ${n(y0)} l ${n(x1)} ${n(y1)} l h`);
+    body.push("f");
+    body.push("Q");
+  }
+}
 function renderColorGlyph(glyph, outlines, unitsPerEm) {
   const body = [];
   const shadings = [];
   const extGStates = [];
-  const alphaMap = /* @__PURE__ */ new Map();
+  const gsMap = /* @__PURE__ */ new Map();
   let shadingIdx = 0;
+  const gsFor = (alpha, bm) => {
+    const a = Math.max(0, Math.min(1, alpha));
+    const needAlpha = a < 0.999;
+    const needBm = bm !== void 0 && bm !== "Normal";
+    if (!needAlpha && !needBm) return "";
+    const key = `${needAlpha ? a.toFixed(3) : "1"}|${needBm ? bm : ""}`;
+    let name = gsMap.get(key);
+    if (!name) {
+      name = `Gs${gsMap.size}`;
+      gsMap.set(key, name);
+      const parts = [];
+      if (needAlpha) parts.push(`/ca ${n(a)}`, `/CA ${n(a)}`);
+      if (needBm) parts.push(`/BM /${bm}`);
+      extGStates.push({ name, dict: `<< ${parts.join(" ")} >>` });
+    }
+    return name;
+  };
   let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
   for (const layer of glyph.layers) {
     const m = layer.transform ?? ID;
+    const bm = layer.blendMode;
     const contours = outlines(layer.glyphId);
     if (contours.length === 0) continue;
     const path = contoursToPath(contours, m);
@@ -6004,26 +6104,36 @@ function renderColorGlyph(glyph, outlines, unitsPerEm) {
     }
     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`);
-      }
+      const gs = gsFor(c[3] / 255, bm);
+      if (gs) 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 if (layer.paint.kind === "sweep") {
+      const [cx, cy] = tx(m, layer.paint.center[0], layer.paint.center[1]);
+      let r2 = 0;
+      for (const contour of contours) {
+        for (const pt of contour) {
+          const [px, py] = tx(m, pt.x, pt.y);
+          const d = (px - cx) * (px - cx) + (py - cy) * (py - cy);
+          if (d > r2) r2 = d;
+        }
+      }
+      const maxR = Math.sqrt(r2) || 1;
+      body.push("q");
+      body.push(path);
+      body.push("W n");
+      emitSweep(layer.paint, cx, cy, maxR, body, gsFor, bm);
+      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");
+      const gs = gsFor(1, bm);
+      if (gs) body.push(`/${gs} gs`);
       body.push(path);
       body.push("W n");
       body.push(`/${name} sh`);
@@ -6165,6 +6275,10 @@ function buildTextRunsWithFallback(text, fontRef, fd, sz, trackGid, pdfA = false
   for (let i = 0; i < text.length; ) {
     const rawCp = text.codePointAt(i) ?? 0;
     const charLen = rawCp > 65535 ? 2 : 1;
+    if (rawCp < 32 || rawCp === 127) {
+      i += charLen;
+      continue;
+    }
     const cp = rawCp === 8239 || rawCp === 160 ? 32 : rawCp;
     const char = text.substring(i, i + charLen);
     const gid = fd.cmap[cp] ?? 0;
@@ -8531,9 +8645,238 @@ function buildPDFBytes(params, layoutOptions) {
   return toBytes(buildPDF(params, layoutOptions));
 }
 
+// src/core/pdf-outline.ts
+function buildOutlineObjects(items, startObjNum, pageObjNumFor, defaultY, fmtNum3, pageCount) {
+  const rootObjNum = startObjNum;
+  const nodes = [];
+  let nextObj = startObjNum + 1;
+  function alloc(list, parentObjNum, depth) {
+    let first = 0;
+    let last = 0;
+    let prev = 0;
+    let visibleCount = 0;
+    const siblingNodes = [];
+    for (const item of list) {
+      const objNum = nextObj++;
+      const open = item.open !== false;
+      const node = {
+        item,
+        objNum,
+        parentObjNum,
+        depth,
+        firstChildObjNum: 0,
+        lastChildObjNum: 0,
+        prevObjNum: prev,
+        nextObjNum: 0,
+        openDescendantCount: 0,
+        open
+      };
+      if (prev !== 0) {
+        const prevNode = siblingNodes[siblingNodes.length - 1];
+        prevNode.nextObjNum = objNum;
+      }
+      nodes.push(node);
+      siblingNodes.push(node);
+      if (first === 0) first = objNum;
+      last = objNum;
+      prev = objNum;
+      visibleCount++;
+      const children = item.children;
+      if (children && children.length > 0) {
+        const sub = alloc(children, objNum, depth + 1);
+        node.firstChildObjNum = sub.first;
+        node.lastChildObjNum = sub.last;
+        node.openDescendantCount = sub.visibleCount;
+        if (open) visibleCount += sub.visibleCount;
+      }
+    }
+    return { first, last, visibleCount };
+  }
+  const top = alloc(items, rootObjNum, 0);
+  const objects = [];
+  objects.push([
+    rootObjNum,
+    `<< /Type /Outlines /First ${top.first} 0 R /Last ${top.last} 0 R /Count ${top.visibleCount} >>`
+  ]);
+  for (const node of nodes) {
+    const it = node.item;
+    const pageIdx = Math.max(0, Math.min(pageCount - 1, it.pageIndex | 0));
+    const pageObj = pageObjNumFor(pageIdx);
+    const y = it.y ?? defaultY;
+    const parts = [
+      `/Title ${encodePdfTextString(it.title)}`,
+      `/Parent ${node.parentObjNum} 0 R`
+    ];
+    if (node.prevObjNum !== 0) parts.push(`/Prev ${node.prevObjNum} 0 R`);
+    if (node.nextObjNum !== 0) parts.push(`/Next ${node.nextObjNum} 0 R`);
+    if (node.firstChildObjNum !== 0) {
+      parts.push(`/First ${node.firstChildObjNum} 0 R`);
+      parts.push(`/Last ${node.lastChildObjNum} 0 R`);
+      const count = node.open ? node.openDescendantCount : -node.openDescendantCount;
+      parts.push(`/Count ${count}`);
+    }
+    parts.push(`/Dest [${pageObj} 0 R /XYZ 0 ${fmtNum3(y)} null]`);
+    const flags = (it.bold ? 2 : 0) | (it.italic ? 1 : 0);
+    if (flags !== 0) parts.push(`/F ${flags}`);
+    if (it.color) parts.push(`/C [${it.color}]`);
+    objects.push([node.objNum, `<< ${parts.join(" ")} >>`]);
+  }
+  return { objects, rootObjNum, totalObjects: nodes.length + 1 };
+}
+
+// src/core/pdf-page-labels.ts
+var STYLE_OP = {
+  decimal: "D",
+  roman: "r",
+  Roman: "R",
+  alpha: "a",
+  Alpha: "A"
+};
+function escapePdfLiteral(s) {
+  return s.replace(/[\\()]/g, (c) => "\\" + c);
+}
+function buildPageLabelsDict(ranges, pageCount) {
+  if (ranges.length === 0) {
+    throw new Error("pageLabels must contain at least one range");
+  }
+  const sorted = [...ranges].sort((a, b) => a.startPage - b.startPage);
+  let prev = -1;
+  const nums = [];
+  for (const r of sorted) {
+    const idx = r.startPage | 0;
+    if (idx < 0 || idx >= pageCount) {
+      throw new Error(`pageLabels range startPage ${idx} out of bounds (0-${pageCount - 1})`);
+    }
+    if (idx <= prev) {
+      throw new Error(`pageLabels ranges must have strictly increasing, unique startPage values (got ${idx} after ${prev})`);
+    }
+    prev = idx;
+    const entryParts = [];
+    const style = r.style ?? "decimal";
+    if (style !== "none") {
+      entryParts.push(`/S /${STYLE_OP[style]}`);
+    }
+    if (r.prefix !== void 0 && r.prefix !== "") {
+      entryParts.push(`/P (${escapePdfLiteral(r.prefix)})`);
+    }
+    if (r.start !== void 0 && r.start !== 1) {
+      if (!Number.isInteger(r.start) || r.start < 1) {
+        throw new Error(`pageLabels range start must be a positive integer (got ${r.start})`);
+      }
+      entryParts.push(`/St ${r.start}`);
+    }
+    nums.push(`${idx} << ${entryParts.join(" ")} >>`);
+  }
+  return `<< /Nums [${nums.join(" ")}] >>`;
+}
+
+// src/core/pdf-viewer-prefs.ts
+var PAGE_LAYOUT = {
+  singlePage: "SinglePage",
+  oneColumn: "OneColumn",
+  twoColumnLeft: "TwoColumnLeft",
+  twoColumnRight: "TwoColumnRight",
+  twoPageLeft: "TwoPageLeft",
+  twoPageRight: "TwoPageRight"
+};
+var PAGE_MODE = {
+  useNone: "UseNone",
+  useOutlines: "UseOutlines",
+  useThumbs: "UseThumbs",
+  fullScreen: "FullScreen",
+  useOC: "UseOC",
+  useAttachments: "UseAttachments"
+};
+var NON_FS_PAGE_MODE = {
+  useNone: "UseNone",
+  useOutlines: "UseOutlines",
+  useThumbs: "UseThumbs",
+  useOC: "UseOC"
+};
+function buildViewerPreferences(prefs) {
+  const pageLayout = prefs.pageLayout ? PAGE_LAYOUT[prefs.pageLayout] : void 0;
+  const pageMode = prefs.pageMode ? PAGE_MODE[prefs.pageMode] : void 0;
+  const entries = [];
+  const bool = (key, v) => {
+    if (v !== void 0) entries.push(`/${key} ${v ? "true" : "false"}`);
+  };
+  bool("HideToolbar", prefs.hideToolbar);
+  bool("HideMenubar", prefs.hideMenubar);
+  bool("HideWindowUI", prefs.hideWindowUI);
+  bool("FitWindow", prefs.fitWindow);
+  bool("CenterWindow", prefs.centerWindow);
+  bool("DisplayDocTitle", prefs.displayDocTitle);
+  if (prefs.nonFullScreenPageMode) {
+    entries.push(`/NonFullScreenPageMode /${NON_FS_PAGE_MODE[prefs.nonFullScreenPageMode]}`);
+  }
+  if (prefs.direction) {
+    entries.push(`/Direction /${prefs.direction === "r2l" ? "R2L" : "L2R"}`);
+  }
+  if (prefs.printScaling) {
+    entries.push(`/PrintScaling /${prefs.printScaling === "none" ? "None" : "AppDefault"}`);
+  }
+  const dict = entries.length > 0 ? ` /ViewerPreferences << ${entries.join(" ")} >>` : "";
+  return { pageLayout, pageMode, dict };
+}
+
 // src/core/pdf-document.ts
 init_pdf_encrypt();
 
+// src/core/pdf-layout-debug.ts
+function resolveDebugOptions(debug) {
+  if (!debug) return null;
+  if (debug === true) {
+    return { showMargins: true, showContentBounds: true, showCells: true };
+  }
+  const showMargins = debug.showMargins === true;
+  const showContentBounds = debug.showContentBounds === true;
+  const showCells = debug.showCells === true;
+  if (!showMargins && !showContentBounds && !showCells) return null;
+  return { showMargins, showContentBounds, showCells };
+}
+var COL_MARGIN = "0 0.45 0.95";
+var COL_BLOCK = "0.90 0.20 0.30";
+var COL_CELL = "0 0.62 0.30";
+function rectOp(x, y, w, h, color, lineW) {
+  return `q ${color} RG ${fmtNum(lineW)} w ${fmtNum(x)} ${fmtNum(y)} ${fmtNum(w)} ${fmtNum(h)} re S Q`;
+}
+function marginBoxOps(pgW, pgH, mg, footerH) {
+  const x = mg.l;
+  const yBottom = mg.b + footerH;
+  const w = pgW - mg.l - mg.r;
+  const h = pgH - mg.t - yBottom;
+  return rectOp(x, yBottom, w, h, COL_MARGIN, 0.5);
+}
+function blockBoundsOps(x, width, yTop, yBottom) {
+  const h = yTop - yBottom;
+  if (h <= 0) return "";
+  return rectOp(x, yBottom, width, h, COL_BLOCK, 0.4);
+}
+function tableCellOps(plan, slice, yTop) {
+  const drawCaption = slice ? slice.drawCaption : true;
+  const drawHeader = slice ? slice.drawHeader : true;
+  const fromRow = slice ? slice.fromRow : 0;
+  const toRow = slice ? slice.toRow : plan.rowHeights.length;
+  const parts = [];
+  let y = yTop - (drawCaption ? plan.captionHeight : 0);
+  if (drawHeader) {
+    const hBottom = y - plan.headerHeight;
+    for (let c = 0; c < plan.cx.length; c++) {
+      parts.push(rectOp(plan.cx[c], hBottom, plan.cwi[c], plan.headerHeight, COL_CELL, 0.3));
+    }
+    y = hBottom;
+  }
+  for (let r = fromRow; r < toRow; r++) {
+    const rh = plan.rowHeights[r];
+    const rBottom = y - rh;
+    for (let c = 0; c < plan.cx.length; c++) {
+      parts.push(rectOp(plan.cx[c], rBottom, plan.cwi[c], rh, COL_CELL, 0.3));
+    }
+    y = rBottom;
+  }
+  return parts.join("\n");
+}
+
 // src/core/pdf-form.ts
 var DEFAULT_FIELD_HEIGHT_TEXT = 22;
 var DEFAULT_FIELD_HEIGHT_MULTILINE = 60;
@@ -10668,6 +11011,51 @@ function getNum(attrs, name, def = 0) {
   const v = getAttr(attrs, name);
   return v !== void 0 ? +v : def;
 }
+function getLen(attrs, name) {
+  const v = getAttr(attrs, name);
+  if (v === void 0) return void 0;
+  const n2 = parseFloat(v);
+  return Number.isFinite(n2) ? n2 : void 0;
+}
+function decodeSvgEntities(s) {
+  return s.replace(/&(#x[0-9a-fA-F]+|#[0-9]+|[a-zA-Z]+);/g, (_m, ent) => {
+    if (ent[0] === "#") {
+      const cp = ent[1] === "x" || ent[1] === "X" ? parseInt(ent.slice(2), 16) : parseInt(ent.slice(1), 10);
+      return Number.isFinite(cp) && cp >= 0 && cp <= 1114111 ? String.fromCodePoint(cp) : "";
+    }
+    switch (ent) {
+      case "amp":
+        return "&";
+      case "lt":
+        return "<";
+      case "gt":
+        return ">";
+      case "quot":
+        return '"';
+      case "apos":
+        return "'";
+      case "nbsp":
+        return "\xA0";
+      default:
+        return "";
+    }
+  });
+}
+function stripSvgTags(raw) {
+  let out = "";
+  let inTag = false;
+  for (const ch2 of raw) {
+    if (ch2 === "<") inTag = true;
+    else if (ch2 === ">") inTag = false;
+    else if (!inTag) out += ch2;
+  }
+  return out;
+}
+function sanitizeSvgText(raw) {
+  const noTags = stripSvgTags(raw);
+  const decoded = decodeSvgEntities(noTags);
+  return decoded.replace(/[\u0000-\u001F\u007F-\u009F]+/g, " ").replace(/\s+/g, " ").trim();
+}
 function rectToPath(x, y, w, h, rx, ry) {
   if (w <= 0 || h <= 0) return "";
   if (rx <= 0 && ry <= 0) {
@@ -10749,7 +11137,60 @@ function parseSvgMarkup(svg) {
       });
     }
   }
-  return { elements, viewBox };
+  const textElements = parseSvgText(svg);
+  return { elements, textElements, viewBox };
+}
+function parseSvgText(svg) {
+  const out = [];
+  const textRe = /<text\b([^>]*)>([\s\S]*?)<\/text>/gi;
+  let tm;
+  while ((tm = textRe.exec(svg)) !== null) {
+    const attrs = tm[1];
+    const inner = tm[2];
+    const baseX = getLen(attrs, "x") ?? 0;
+    const baseY = getLen(attrs, "y") ?? 0;
+    const baseSize = getLen(attrs, "font-size") ?? 16;
+    const baseFillRaw = getAttr(attrs, "fill");
+    const baseFill = baseFillRaw ? normalizeSvgColor(baseFillRaw) : void 0;
+    const baseAnchor = normalizeAnchor(getAttr(attrs, "text-anchor"));
+    const tspanRe = /<tspan\b([^>]*)>([\s\S]*?)<\/tspan>/gi;
+    let sm;
+    let penX = baseX;
+    let penY = baseY;
+    let found = false;
+    while ((sm = tspanRe.exec(inner)) !== null) {
+      found = true;
+      const sa = sm[1];
+      const text = sanitizeSvgText(sm[2]);
+      const ax = getLen(sa, "x");
+      const ay = getLen(sa, "y");
+      const adx = getLen(sa, "dx");
+      const ady = getLen(sa, "dy");
+      penX = ax !== void 0 ? ax : penX + (adx ?? 0);
+      penY = ay !== void 0 ? ay : penY + (ady ?? 0);
+      if (!text) continue;
+      const fillRaw = getAttr(sa, "fill");
+      out.push({
+        text,
+        x: penX,
+        y: penY,
+        fontSize: getLen(sa, "font-size") ?? baseSize,
+        fill: fillRaw ? normalizeSvgColor(fillRaw) : baseFill,
+        anchor: normalizeAnchor(getAttr(sa, "text-anchor")) ?? baseAnchor
+      });
+    }
+    if (!found) {
+      const text = sanitizeSvgText(inner);
+      if (text) {
+        out.push({ text, x: baseX, y: baseY, fontSize: baseSize, fill: baseFill, anchor: baseAnchor });
+      }
+    }
+  }
+  return out;
+}
+function normalizeAnchor(v) {
+  if (v === "middle" || v === "end" || v === "start") return v;
+  return void 0;
 }
 var fn = (n2) => n2.toFixed(2);
 function resolveColor(color, fallback) {
@@ -10785,36 +11226,62 @@ function buildPathOps(segments, fillRgb, strokeRgb, strokeWidth) {
   ops.push("Q");
   return ops.join("\n");
 }
-function renderSvg(data, x, y, w, h, options) {
+function renderSvg(data, x, y, w, h, options, enc) {
   if (!data || w <= 0 || h <= 0) return "";
   const isSvgMarkup = data.trimStart().charAt(0) === "<";
   let vb;
   let elements;
+  let textElements = [];
   if (isSvgMarkup) {
     const parsed = parseSvgMarkup(data);
     vb = options?.viewBox ?? parsed.viewBox ?? [0, 0, w, h];
     elements = parsed.elements;
+    textElements = parsed.textElements;
   } else {
     vb = options?.viewBox ?? [0, 0, w, h];
     elements = [{ pathData: data }];
   }
-  if (elements.length === 0 || vb[2] <= 0 || vb[3] <= 0) return "";
+  if (elements.length === 0 && textElements.length === 0 || vb[2] <= 0 || vb[3] <= 0) return "";
   const sx = w / vb[2];
   const sy = h / vb[3];
-  const cmOp = `${fn(sx)} 0 0 ${fn(-sy)} ${fn(x - vb[0] * sx)} ${fn(y + vb[1] * sy)} cm`;
+  const tx2 = x - vb[0] * sx;
+  const ty = y + vb[1] * sy;
+  const cmOp = `${fn(sx)} 0 0 ${fn(-sy)} ${fn(tx2)} ${fn(ty)} cm`;
   const defaultFill = resolveColor(options?.fill, "0 0 0");
   const defaultStroke = resolveColor(options?.stroke, null);
   const defaultSw = options?.strokeWidth ?? 1;
-  const allOps = ["q", cmOp];
+  const shapeOps = [];
   for (const elem of elements) {
     const segments = parseSvgPath(elem.pathData);
     if (segments.length === 0) continue;
     const fillRgb = resolveColor(elem.fill, defaultFill);
     const strokeRgb = resolveColor(elem.stroke, defaultStroke);
     const sw = elem.strokeWidth ?? defaultSw;
-    allOps.push(buildPathOps(segments, fillRgb, strokeRgb, sw));
-  }
-  allOps.push("Q");
+    shapeOps.push(buildPathOps(segments, fillRgb, strokeRgb, sw));
+  }
+  const textOps = [];
+  if (enc && textElements.length > 0) {
+    for (const t of textElements) {
+      const szPdf = t.fontSize * sy;
+      if (szPdf <= 0 || !t.text) continue;
+      const pdfBaseX = t.x * sx + tx2;
+      const pdfBaseY = -sy * t.y + ty;
+      const width = enc.tw(t.text, szPdf);
+      const anchorOffset = t.anchor === "middle" ? width / 2 : t.anchor === "end" ? width : 0;
+      const pdfX = pdfBaseX - anchorOffset;
+      const fillRgb = resolveColor(t.fill, "0 0 0");
+      textOps.push("q");
+      if (fillRgb) textOps.push(`${fillRgb} rg`);
+      textOps.push(txt(t.text, pdfX, pdfBaseY, enc.f1, szPdf, enc));
+      textOps.push("Q");
+    }
+  }
+  if (shapeOps.length === 0 && textOps.length === 0) return "";
+  const allOps = [];
+  if (shapeOps.length > 0) {
+    allOps.push("q", cmOp, ...shapeOps, "Q");
+  }
+  allOps.push(...textOps);
   return allOps.join("\n");
 }
 
@@ -11022,23 +11489,36 @@ function renderList(block, y, enc, mgL, cw, tagCtx, documentChildren) {
   const sz = block.fontSize ?? DEFAULT_LIST_SIZE;
   const lineH = sz * DEFAULT_LINE_HEIGHT;
   const color = "0.216 0.255 0.318";
-  const availW = cw - LIST_INDENT - BULLET_MARK_WIDTH;
   ops.push(`${color} rg`);
-  const listChildren = [];
-  for (let idx = 0; idx < block.items.length; idx++) {
-    const item = block.items[idx];
-    const marker = block.style === "bullet" ? "\u2022" : `${idx + 1}.`;
-    const lines = wrapText(item, availW, sz, enc);
+  const root = renderListLevel(block.items, block.style, 0, y, sz, lineH, enc, mgL, cw, tagCtx);
+  ops.push(...root.ops);
+  if (tagCtx?.tagged && root.struct && root.struct.children.length > 0) {
+    documentChildren.push(root.struct);
+  }
+  return { ops, y: root.y };
+}
+function renderListLevel(items, style, depth, y, sz, lineH, enc, mgL, cw, tagCtx) {
+  const ops = [];
+  const indent = LIST_INDENT * (depth + 1);
+  const markerX = mgL + indent;
+  const xOffset = markerX + BULLET_MARK_WIDTH;
+  const availW = cw - indent - BULLET_MARK_WIDTH;
+  const levelChildren = [];
+  for (let idx = 0; idx < items.length; idx++) {
+    const entry = items[idx];
+    const text = typeof entry === "string" ? entry : entry.text;
+    const children = typeof entry === "string" ? void 0 : entry.items;
+    const marker = style === "bullet" ? "\u2022" : `${idx + 1}.`;
+    const lines = wrapText(text, availW, sz, enc);
     const liChildren = [];
     if (tagCtx?.tagged) {
       const mcid = tagCtx.mcidAlloc.next(tagCtx.pageObjNum);
       liChildren.push({ mcid, pageObjNum: tagCtx.pageObjNum });
-      ops.push(txtTagged(marker, mgL + LIST_INDENT, y - sz, enc.f1, sz, enc, mcid));
+      ops.push(txtTagged(marker, markerX, y - sz, enc.f1, sz, enc, mcid));
     } else {
-      ops.push(txt(marker, mgL + LIST_INDENT, y - sz, enc.f1, sz, enc));
+      ops.push(txt(marker, markerX, y - sz, enc.f1, sz, enc));
     }
     for (let li = 0; li < lines.length; li++) {
-      const xOffset = mgL + LIST_INDENT + BULLET_MARK_WIDTH;
       if (li === 0) {
         if (tagCtx?.tagged) {
           const mcid = tagCtx.mcidAlloc.next(tagCtx.pageObjNum);
@@ -11059,14 +11539,20 @@ function renderList(block, y, enc, mgL, cw, tagCtx, documentChildren) {
       }
     }
     y -= lineH + LIST_ITEM_SPACING;
+    if (children && children.length > 0) {
+      const sub = renderListLevel(children, style, depth + 1, y, sz, lineH, enc, mgL, cw, tagCtx);
+      ops.push(...sub.ops);
+      y = sub.y;
+      if (tagCtx?.tagged && sub.struct && sub.struct.children.length > 0) {
+        liChildren.push(sub.struct);
+      }
+    }
     if (tagCtx?.tagged && liChildren.length > 0) {
-      listChildren.push({ type: "LI", children: liChildren });
+      levelChildren.push({ type: "LI", children: liChildren });
     }
   }
-  if (tagCtx?.tagged && listChildren.length > 0) {
-    documentChildren.push({ type: "L", children: listChildren });
-  }
-  return { ops, y };
+  const struct = tagCtx?.tagged ? { type: "L", children: levelChildren } : void 0;
+  return { ops, y, struct };
 }
 var DEFAULT_ZEBRA_COLOR = "0.969 0.973 0.984";
 var CAPTION_FONT_SIZE = 9;
@@ -11101,7 +11587,7 @@ function planTable(block, enc, mgL, cw) {
     headerLines.push(lines);
     if (lines.length > headerMaxLines) headerMaxLines = lines.length;
   }
-  const headerHeight = headerMaxLines === 1 ? TH_H : Math.max(TH_H, headerMaxLines * fs.th * TABLE_LINE_HEIGHT + CELL_PAD_BOTTOM + 2);
+  const headerHeight = headerMaxLines === 1 ? TH_H : Math.max(TH_H, headerMaxLines * fs.th * TABLE_LINE_HEIGHT + pad + 2);
   const rowLines = [];
   const rowHeights = [];
   for (let r = 0; r < block.rows.length; r++) {
@@ -11114,7 +11600,7 @@ function planTable(block, enc, mgL, cw) {
       if (lines.length > maxLines) maxLines = lines.length;
     }
     rowLines.push(cells);
-    const h = maxLines === 1 ? minRowH : Math.max(minRowH, maxLines * fs.td * TABLE_LINE_HEIGHT + CELL_PAD_BOTTOM + 2);
+    const h = maxLines === 1 ? minRowH : Math.max(minRowH, maxLines * fs.td * TABLE_LINE_HEIGHT + pad + 2);
     rowHeights.push(h);
   }
   const captionLines = block.caption ? wrapText(block.caption, cw, CAPTION_FONT_SIZE, enc) : [];
@@ -11154,6 +11640,30 @@ function renderTable(block, y, enc, mgL, mgR, pgW, cw, tagCtx, documentChildren,
   const clip = block.clipCells !== false;
   const zebraColor = resolveZebraColor(block.zebra);
   const wrapMode = block.wrap ?? "auto";
+  const borders = block.cellBorders;
+  const borderSides = borders ? {
+    top: borders.all === true || borders.top === true,
+    right: borders.all === true || borders.right === true,
+    bottom: borders.all === true || borders.bottom === true,
+    left: borders.all === true || borders.left === true
+  } : null;
+  const borderColor = borders?.color ? parseColor(borders.color) : "0.8 0.8 0.8";
+  const borderWidth = borders?.width ?? 0.5;
+  const borderDash = borders?.style === "dashed" ? "[3] 0 d" : borders?.style === "dotted" ? `[${fmtNum(borderWidth)} ${fmtNum(borderWidth * 2)}] 0 d` : null;
+  const cellBorderOps = (cellX, cellW, top, h) => {
+    if (!borderSides || !borderSides.top && !borderSides.right && !borderSides.bottom && !borderSides.left) {
+      return [];
+    }
+    const o = [];
+    o.push(`${fmtNum(borderWidth)} w ${borderColor} RG${borderDash ? " " + borderDash : ""}`);
+    const x0 = cellX, x1 = cellX + cellW, y0 = top - h, y1 = top;
+    if (borderSides.top) o.push(`${fmtNum(x0)} ${fmtNum(y1)} m ${fmtNum(x1)} ${fmtNum(y1)} l S`);
+    if (borderSides.bottom) o.push(`${fmtNum(x0)} ${fmtNum(y0)} m ${fmtNum(x1)} ${fmtNum(y0)} l S`);
+    if (borderSides.left) o.push(`${fmtNum(x0)} ${fmtNum(y0)} m ${fmtNum(x0)} ${fmtNum(y1)} l S`);
+    if (borderSides.right) o.push(`${fmtNum(x1)} ${fmtNum(y0)} m ${fmtNum(x1)} ${fmtNum(y1)} l S`);
+    if (borderDash) o.push("[] 0 d");
+    return o;
+  };
   const clipCell = (op, i, top, h) => clip ? `q ${fmtNum(cx[i])} ${fmtNum(top - h)} ${fmtNum(cwi[i])} ${fmtNum(h)} re W n
 ${op}
 Q` : op;
@@ -11162,9 +11672,21 @@ Q` : op;
     const out = [];
     const lineH = sz * TABLE_LINE_HEIGHT;
     const padBottom = isHeader ? HEADER_PAD_BOTTOM : CELL_PAD_BOTTOM;
+    const vAlign = col.vAlign ?? block.cellVAlign;
     for (let li = 0; li < lines.length; li++) {
       const t = lines.length === 1 && wrapMode === "never" ? truncate(lines[li], isHeader && col.mxH !== void 0 ? col.mxH : col.mx) : lines[li];
-      const baselineY = lines.length === 1 ? rowTop - rowH + padBottom : rowTop - pad - sz + sz * 0.2 - li * lineH;
+      let baselineY;
+      if (vAlign) {
+        const blockH = lines.length * lineH;
+        let offset;
+        if (vAlign === "top") offset = pad;
+        else if (vAlign === "bottom") offset = rowH - blockH - pad;
+        else offset = (rowH - blockH) / 2;
+        if (offset < pad) offset = pad;
+        baselineY = rowTop - offset - li * lineH - sz + sz * 0.2;
+      } else {
+        baselineY = lines.length === 1 ? rowTop - rowH + padBottom : rowTop - pad - sz + sz * 0.2 - li * lineH;
+      }
       let op;
       if (mcRefsOut !== null && tagCtx?.tagged) {
         const mcid = tagCtx.mcidAlloc.next(tagCtx.pageObjNum);
@@ -11219,6 +11741,7 @@ Q` : op;
     for (let i = 0; i < block.headers.length && i < columns.length; i++) {
       const cellRefs = tagCtx?.tagged ? [] : null;
       ops.push(...emitCell(headerLines[i] ?? [""], i, y, headerHeight, enc.f2, fs.th, cellRefs, true));
+      ops.push(...cellBorderOps(cx[i], cwi[i], y, headerHeight));
       if (cellRefs && cellRefs.length > 0) {
         thChildren.push({ type: "TH", children: cellRefs });
       }
@@ -11246,6 +11769,7 @@ Q` : op;
       ops.push(`${color} rg`);
       const cellRefs = tagCtx?.tagged ? [] : null;
       ops.push(...emitCell(cells[i] ?? [""], i, y, rowH, font, fs.td, cellRefs, false));
+      ops.push(...cellBorderOps(cx[i], cwi[i], y, rowH));
       if (cellRefs && cellRefs.length > 0) {
         tdChildren.push({ type: "TD", children: cellRefs });
       }
@@ -11502,7 +12026,7 @@ function renderBarcodeBlock(block, y, mgL, cw, tagCtx, documentChildren) {
   y = by - 6;
   return { ops, y };
 }
-function renderSvgBlock(block, y, mgL, cw, tagCtx, documentChildren) {
+function renderSvgBlock(block, y, mgL, cw, tagCtx, documentChildren, enc) {
   const ops = [];
   const w = block.width ?? DEFAULT_SVG_SIZE;
   const h = block.height ?? DEFAULT_SVG_SIZE;
@@ -11518,7 +12042,7 @@ function renderSvgBlock(block, y, mgL, cw, tagCtx, documentChildren) {
     stroke: block.stroke,
     strokeWidth: block.strokeWidth,
     viewBox: block.viewBox
-  });
+  }, enc);
   if (svgOps) {
     if (tagCtx?.tagged) {
       const mcid = tagCtx.mcidAlloc.next(tagCtx.pageObjNum);
@@ -11617,13 +12141,20 @@ function estimateBlockHeight(block, enc, cw, headings) {
     case "list": {
       const sz = block.fontSize ?? DEFAULT_LIST_SIZE;
       const lineH = sz * DEFAULT_LINE_HEIGHT;
-      const availW = cw - LIST_INDENT - BULLET_MARK_WIDTH;
-      let h = 0;
-      for (const item of block.items) {
-        const lines = wrapText(item, availW, sz, enc);
-        h += lineH + (lines.length - 1) * lineH + LIST_ITEM_SPACING;
-      }
-      return h;
+      const measureLevel = (items, depth) => {
+        const availW = cw - LIST_INDENT * (depth + 1) - BULLET_MARK_WIDTH;
+        let acc = 0;
+        for (const entry of items) {
+          const text = typeof entry === "string" ? entry : entry.text;
+          const lines = wrapText(text, availW, sz, enc);
+          acc += lineH + (lines.length - 1) * lineH + LIST_ITEM_SPACING;
+          if (typeof entry !== "string" && entry.items && entry.items.length > 0) {
+            acc += measureLevel(entry.items, depth + 1);
+          }
+        }
+        return acc;
+      };
+      return measureLevel(block.items, 0);
     }
     case "table": {
       return TH_H + block.rows.length * ROW_H + 6;
@@ -11693,6 +12224,7 @@ function assembleDocumentParts(params, layoutOptions) {
   if (watermarkOpts) {
     validateWatermark(watermarkOpts, layout?.tagged);
   }
+  const debugOpts = resolveDebugOptions(layout?.debug);
   const attachments = layout?.attachments;
   validateAttachments(attachments, layout?.tagged);
   const mcidAlloc = tagged ? createMCIDAllocator() : void 0;
@@ -11880,6 +12412,10 @@ function assembleDocumentParts(params, layoutOptions) {
     const tagCtx = tagged && mcidAlloc ? { tagged: true, mcidAlloc, pageObjNum} : void 0;
     const ops = [];
     let y = pgH - mg.t;
+    const debugOps = [];
+    if (debugOpts?.showMargins) {
+      debugOps.push(marginBoxOps(pgW, pgH, mg, FT_H));
+    }
     if (headerTpl) {
       const hOps = renderPageTemplate(
         headerTpl,
@@ -11920,6 +12456,7 @@ function assembleDocumentParts(params, layoutOptions) {
     }
     const blocks = pageBlocks[p] ?? [];
     for (const block of blocks) {
+      const yBefore = debugOpts ? y : 0;
       switch (block.type) {
         case "heading": {
           if (headingDestIdx < headingDests.length) {
@@ -12000,7 +12537,7 @@ function assembleDocumentParts(params, layoutOptions) {
           break;
         }
         case "svg": {
-          const result = renderSvgBlock(block, y, mg.l, cw, tagCtx, documentChildren);
+          const result = renderSvgBlock(block, y, mg.l, cw, tagCtx, documentChildren, enc);
           ops.push(...result.ops);
           y = result.y;
           break;
@@ -12012,6 +12549,19 @@ function assembleDocumentParts(params, layoutOptions) {
           break;
         }
       }
+      if (debugOpts) {
+        if (debugOpts.showContentBounds) {
+          const bo = blockBoundsOps(mg.l, cw, yBefore, y);
+          if (bo) debugOps.push(bo);
+        }
+        if (debugOpts.showCells) {
+          if (block.type === "__tableSlice") {
+            debugOps.push(tableCellOps(block.slice.plan, block.slice, yBefore));
+          } else if (block.type === "table") {
+            debugOps.push(tableCellOps(planTable(block, enc, mg.l, cw), void 0, yBefore));
+          }
+        }
+      }
     }
     if (wmState?.foregroundOps) {
       ops.push(wmState.foregroundOps);
@@ -12032,6 +12582,9 @@ function assembleDocumentParts(params, layoutOptions) {
       documentChildren
     );
     ops.push(...ftOps);
+    if (debugOps.length > 0) {
+      ops.push(...debugOps);
+    }
     pageStreams.push(ops.join("\n"));
   }
   const annotsByPage = /* @__PURE__ */ new Map();
@@ -12481,6 +13034,41 @@ function assembleDocumentParts(params, layoutOptions) {
       totalObjs += efResult.totalObjects;
     }
   }
+  let pageLabelsStr = "";
+  if (params.pageLabels && params.pageLabels.length > 0) {
+    pageLabelsStr = ` /PageLabels ${buildPageLabelsDict(params.pageLabels, totalPages)}`;
+  }
+  const viewerPrefs = layout?.viewerPreferences ? buildViewerPreferences(layout.viewerPreferences) : void 0;
+  let viewerPrefsStr = viewerPrefs?.dict ?? "";
+  if (viewerPrefs?.pageLayout) {
+    viewerPrefsStr = ` /PageLayout /${viewerPrefs.pageLayout}${viewerPrefsStr}`;
+  }
+  let outlineCatalogStr = "";
+  if (params.outline) {
+    const items = params.outline === "auto" ? autoOutlineFromHeadings(headingDests) : params.outline.map(mapOutlineItem);
+    if (items.length > 0) {
+      const outlineStart = totalObjs + 1;
+      const built = buildOutlineObjects(
+        items,
+        outlineStart,
+        (pageIndex) => pageObjStart + pageIndex * 2,
+        pgH - mg.t,
+        fmtNum,
+        totalPages
+      );
+      for (const [objNum, content] of built.objects) {
+        emitObj(objNum, content);
+      }
+      totalObjs = outlineStart + built.totalObjects - 1;
+      outlineCatalogStr = ` /Outlines ${built.rootObjNum} 0 R`;
+      if (!viewerPrefs?.pageMode) {
+        outlineCatalogStr += " /PageMode /UseOutlines";
+      }
+    }
+  }
+  if (viewerPrefs?.pageMode) {
+    viewerPrefsStr = ` /PageMode /${viewerPrefs.pageMode}${viewerPrefsStr}`;
+  }
   let destsStr = "";
   if (hasToc && headingDests.length > 0) {
     const destEntries = headingDests.map((h) => {
@@ -12510,7 +13098,7 @@ function assembleDocumentParts(params, layoutOptions) {
     acroFormStr = ` ${buildAcroFormDict(fieldObjNums, formFontObjNum)}`;
   }
   if (tagged) {
-    let catalogContent = `<< /Type /Catalog /Pages 2 0 R /MarkInfo << /Marked true >> /StructTreeRoot ${structTreeRootObjNum} 0 R /Metadata ${xmpObjNum} 0 R /OutputIntents [${outputIntentObjNum} 0 R]${destsStr}${acroFormStr}`;
+    let catalogContent = `<< /Type /Catalog /Pages 2 0 R /MarkInfo << /Marked true >> /StructTreeRoot ${structTreeRootObjNum} 0 R /Metadata ${xmpObjNum} 0 R /OutputIntents [${outputIntentObjNum} 0 R]${destsStr}${acroFormStr}${outlineCatalogStr}${pageLabelsStr}${viewerPrefsStr}`;
     if (afArrayStr) {
       catalogContent += ` /AF [${afArrayStr}] ${embeddedFilesNamesDict}`;
     }
@@ -12532,8 +13120,8 @@ endobj
         }
       }
     }
-  } else if (destsStr || acroFormStr) {
-    const catalogContent = `<< /Type /Catalog /Pages 2 0 R${destsStr}${acroFormStr} >>`;
+  } else if (destsStr || acroFormStr || outlineCatalogStr || pageLabelsStr || viewerPrefsStr) {
+    const catalogContent = `<< /Type /Catalog /Pages 2 0 R${destsStr}${acroFormStr}${outlineCatalogStr}${pageLabelsStr}${viewerPrefsStr} >>`;
     const oldCatalog = "1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n\n";
     const newCatalog = `1 0 obj
 ${catalogContent}
@@ -12559,6 +13147,207 @@ endobj
 function buildDocumentPDFBytes(params, layoutOptions) {
   return toBytes(buildDocumentPDF(params, layoutOptions));
 }
+function mapOutlineItem(item) {
+  return {
+    title: item.title,
+    pageIndex: item.pageIndex,
+    y: item.y,
+    bold: item.bold,
+    italic: item.italic,
+    open: item.open,
+    color: item.color !== void 0 ? parseColor(item.color) : void 0,
+    children: item.children ? item.children.map(mapOutlineItem) : void 0
+  };
+}
+function autoOutlineFromHeadings(headings) {
+  const root = [];
+  const stack = [];
+  for (const h of headings) {
+    const node = {
+      title: h.text,
+      pageIndex: h.pageIndex,
+      y: h.y,
+      children: []
+    };
+    while (stack.length > 0 && stack[stack.length - 1].level >= h.level) {
+      stack.pop();
+    }
+    if (stack.length === 0) {
+      root.push(node);
+    } else {
+      stack[stack.length - 1].children.push(node);
+    }
+    stack.push({ level: h.level, children: node.children });
+  }
+  return root;
+}
+
+// src/core/pdf-layout-inspect.ts
+var TITLE_BAND_H = 22 + 12;
+function inspectDocumentLayout(params, layoutOptions) {
+  if (!params || typeof params !== "object" || !Array.isArray(params.blocks)) {
+    throw new Error("inspectDocumentLayout: params.blocks must be an array");
+  }
+  const layout = layoutOptions ?? params.layout;
+  const pgW = layout?.pageWidth ?? PG_W;
+  const pgH = layout?.pageHeight ?? PG_H;
+  const mg = layout?.margins ?? { ...DEFAULT_MARGINS };
+  const cw = pgW - mg.l - mg.r;
+  const fontEntries = params.fontEntries ? [...params.fontEntries] : [];
+  const tagged = resolvePdfAConfig(layout?.tagged).enabled;
+  const enc = createEncodingContext(fontEntries, tagged, layout?.normalize ?? false);
+  const headerH = layout?.headerTemplate ? HEADER_H : 0;
+  const availableH = pgH - mg.t - mg.b - FT_H - headerH;
+  const pages = [[]];
+  let remainH = availableH;
+  let curY = pgH - mg.t - headerH;
+  if (params.title) {
+    remainH -= TITLE_BAND_H;
+    curY -= TITLE_BAND_H;
+  }
+  const newPage = () => {
+    pages.push([]);
+    remainH = availableH;
+    curY = pgH - mg.t - headerH;
+  };
+  for (const block of params.blocks) {
+    if (block.type === "pageBreak") {
+      newPage();
+      continue;
+    }
+    if (block.type === "table") {
+      const plan = planTable(block, enc, mg.l, cw);
+      const repeatHeader = block.repeatHeader !== false;
+      const totalRows = block.rows.length;
+      if (totalRows === 0) {
+        const totalH = plan.captionHeight + plan.headerHeight + plan.trailerSpacing;
+        if (totalH > remainH && pages[pages.length - 1].length > 0) newPage();
+        pages[pages.length - 1].push({ type: "table", page: pages.length - 1, x: mg.l, top: curY, width: cw, height: totalH });
+        remainH -= totalH;
+        curY -= totalH;
+        continue;
+      }
+      let rowIdx = 0;
+      let isFirstSlice = true;
+      while (rowIdx < totalRows) {
+        const drawCaption = isFirstSlice;
+        const drawHeader = isFirstSlice || repeatHeader;
+        const tCapH = drawCaption ? plan.captionHeight : 0;
+        const tHdrH = drawHeader ? plan.headerHeight : 0;
+        const availableForRows = remainH - tCapH - tHdrH - plan.trailerSpacing;
+        let usedH = 0;
+        let count = 0;
+        while (rowIdx + count < totalRows && usedH + plan.rowHeights[rowIdx + count] <= availableForRows) {
+          usedH += plan.rowHeights[rowIdx + count];
+          count++;
+        }
+        if (count === 0 && pages[pages.length - 1].length > 0) {
+          newPage();
+          continue;
+        }
+        if (count === 0) count = 1;
+        rowIdx += count;
+        const isFinalSlice = rowIdx >= totalRows;
+        const sliceH = tCapH + tHdrH + usedH + (isFinalSlice ? plan.trailerSpacing : 0);
+        pages[pages.length - 1].push({ type: "table", page: pages.length - 1, x: mg.l, top: curY, width: cw, height: sliceH });
+        remainH -= sliceH;
+        curY -= sliceH;
+        isFirstSlice = false;
+        if (!isFinalSlice) newPage();
+      }
+      continue;
+    }
+    const blockH = estimateBlockHeight(block, enc, cw);
+    if (blockH > remainH && pages[pages.length - 1].length > 0) newPage();
+    pages[pages.length - 1].push({ type: block.type, page: pages.length - 1, x: mg.l, top: curY, width: cw, height: blockH });
+    remainH -= blockH;
+    curY -= blockH;
+  }
+  const inspectedPages = pages.map((blocks, index) => ({ index, blocks }));
+  return {
+    pageWidth: pgW,
+    pageHeight: pgH,
+    margins: { t: mg.t, r: mg.r, b: mg.b, l: mg.l },
+    totalPages: Math.max(1, pages.length),
+    pages: inspectedPages
+  };
+}
+
+// src/core/pdf-annot-markup.ts
+var SUBTYPE = {
+  text: "Text",
+  highlight: "Highlight",
+  underline: "Underline",
+  strikeout: "StrikeOut",
+  squiggly: "Squiggly",
+  square: "Square",
+  circle: "Circle",
+  line: "Line",
+  freetext: "FreeText"
+};
+function rectStr(r) {
+  return `[${fmtNum(r[0])} ${fmtNum(r[1])} ${fmtNum(r[2])} ${fmtNum(r[3])}]`;
+}
+function quadFromRect(r) {
+  const [x1, y1, x2, y2] = r;
+  return [x1, y2, x2, y2, x1, y1, x2, y1];
+}
+function commonEntries(a) {
+  const parts = [];
+  if (a.contents !== void 0) parts.push(`/Contents ${encodePdfTextString(a.contents)}`);
+  if (a.title !== void 0) parts.push(`/T ${encodePdfTextString(a.title)}`);
+  if (a.color !== void 0) parts.push(`/C [${parseColor(a.color)}]`);
+  if (a.opacity !== void 0) parts.push(`/CA ${fmtNum(a.opacity)}`);
+  if (a.modified !== void 0) parts.push(`/M ${encodePdfTextString(a.modified)}`);
+  parts.push(`/F ${a.flags ?? 4}`);
+  return parts.join(" ");
+}
+function buildAnnotation(annot, objNum) {
+  return `${objNum} 0 obj
+${buildAnnotationBody(annot)}
+endobj`;
+}
+function buildAnnotationBody(annot) {
+  const entries = [
+    `/Type /Annot`,
+    `/Subtype /${SUBTYPE[annot.type]}`,
+    `/Rect ${rectStr(annot.rect)}`,
+    commonEntries(annot)
+  ];
+  switch (annot.type) {
+    case "text": {
+      if (annot.open !== void 0) entries.push(`/Open ${annot.open ? "true" : "false"}`);
+      if (annot.icon !== void 0) entries.push(`/Name /${annot.icon}`);
+      break;
+    }
+    case "highlight":
+    case "underline":
+    case "strikeout":
+    case "squiggly": {
+      const quad = annot.quadPoints && annot.quadPoints.length >= 8 ? annot.quadPoints : quadFromRect(annot.rect);
+      entries.push(`/QuadPoints [${quad.map(fmtNum).join(" ")}]`);
+      break;
+    }
+    case "square":
+    case "circle": {
+      if (annot.interiorColor !== void 0) entries.push(`/IC [${parseColor(annot.interiorColor)}]`);
+      entries.push(`/BS << /W ${fmtNum(annot.borderWidth ?? 1)} >>`);
+      break;
+    }
+    case "line": {
+      entries.push(`/L [${fmtNum(annot.start[0])} ${fmtNum(annot.start[1])} ${fmtNum(annot.end[0])} ${fmtNum(annot.end[1])}]`);
+      entries.push(`/BS << /W ${fmtNum(annot.borderWidth ?? 1)} >>`);
+      break;
+    }
+    case "freetext": {
+      const sz = annot.fontSize ?? 12;
+      const col = annot.color !== void 0 ? parseColor(annot.color) : "0 0 0";
+      entries.push(`/DA (/Helv ${fmtNum(sz)} Tf ${col} rg)`);
+      break;
+    }
+  }
+  return `<< ${entries.filter(Boolean).join(" ")} >>`;
+}
 
 // src/core/pdf-signature.ts
 init_sha();
@@ -12568,6 +13357,17 @@ init_asn1();
 init_sha();
 init_rsa();
 init_ecdsa();
+
+// src/crypto/crypto-provider.ts
+var _cryptoProvider = null;
+function setCryptoProvider(provider) {
+  _cryptoProvider = provider;
+}
+function getCryptoProvider() {
+  return _cryptoProvider;
+}
+
+// src/crypto/cms.ts
 var OID_SIGNED_DATA = new Uint8Array([42, 134, 72, 134, 247, 13, 1, 7, 2]);
 var OID_DATA = new Uint8Array([42, 134, 72, 134, 247, 13, 1, 7, 1]);
 var OID_SHA256 = new Uint8Array([96, 134, 72, 1, 101, 3, 4, 2, 1]);
@@ -12627,18 +13427,26 @@ function buildSignerInfo(options) {
   const signedAttrsContent = concatUint8Arrays(attrContentType, attrMessageDigest, attrSigningTime);
   const signedAttrsImplicit = derWrap(160, signedAttrsContent);
   const signedAttrsForSig = derSet(attrContentType, attrMessageDigest, attrSigningTime);
-  const attrsHash = sha256(signedAttrsForSig);
+  const provider = options.provider ?? getCryptoProvider();
   let sigAlgId;
   let signatureValue;
   if (algorithm === "rsa-sha256") {
-    if (!options.rsaKey) throw new Error("RSA private key required for rsa-sha256");
     sigAlgId = derSequence(derOid(OID_SHA256_RSA), derNull());
-    signatureValue = rsaSignHash(attrsHash, options.rsaKey);
+    if (provider) {
+      signatureValue = provider.sign(signedAttrsForSig, algorithm);
+    } else {
+      if (!options.rsaKey) throw new Error("RSA private key (or a crypto provider) required for rsa-sha256");
+      signatureValue = rsaSignHash(sha256(signedAttrsForSig), options.rsaKey);
+    }
   } else if (algorithm === "ecdsa-sha256") {
-    if (!options.ecKey) throw new Error("ECDSA private key required for ecdsa-sha256");
     sigAlgId = derSequence(derOid(OID_ECDSA_SHA256));
-    const { r, s } = ecdsaSignHash(attrsHash, options.ecKey);
-    signatureValue = encodeDerSignature(r, s);
+    if (provider) {
+      signatureValue = provider.sign(signedAttrsForSig, algorithm);
+    } else {
+      if (!options.ecKey) throw new Error("ECDSA private key (or a crypto provider) required for ecdsa-sha256");
+      const { r, s } = ecdsaSignHash(sha256(signedAttrsForSig), options.ecKey);
+      signatureValue = encodeDerSignature(r, s);
+    }
   } else {
     throw new Error(`Unsupported algorithm: ${algorithm}`);
   }
@@ -12717,7 +13525,8 @@ function signPdfBytes(pdfBytes, options) {
     rsaKey: options.rsaKey,
     ecKey: options.ecKey,
     algorithm,
-    signingTime: options.signingTime
+    signingTime: options.signingTime,
+    provider: options.provider
   };
   const cms = buildCmsSignedData(cmsOptions);
   if (cms.length * 2 > hexLen) {
@@ -13887,6 +14696,28 @@ function openPdf(bytes) {
     if (!entry || entry.type === 0) return null;
     return resolveRef({ num, gen: entry.gen });
   }
+  let _pageRefs;
+  function collectPageRefs() {
+    if (_pageRefs) return _pageRefs;
+    const catalog = getCatalog();
+    const refs = [];
+    const walk = (nodeVal, depth) => {
+      if (depth > 100) return;
+      const node = resolveValue2(nodeVal);
+      if (!isDict(node)) return;
+      if (dictGetName(node, "Type") === "Page") {
+        if (isRef(nodeVal)) refs.push(nodeVal);
+        return;
+      }
+      const kids = node.get("Kids");
+      if (isArray(kids)) {
+        for (const k of kids) walk(k, depth + 1);
+      }
+    };
+    walk(catalog.get("Pages") ?? null, 0);
+    _pageRefs = refs;
+    return refs;
+  }
   function decodeStreamData(stream) {
     let data = stream.data;
     const filterName = dictGetName(stream.dict, "Filter");
@@ -13938,10 +14769,107 @@ function openPdf(bytes) {
       const info = resolveValue2(infoRef);
       return isDict(info) ? info : null;
     },
+    getPageLabels() {
+      const catalog = getCatalog();
+      const plVal = resolveValue2(catalog.get("PageLabels") ?? null);
+      if (!isDict(plVal)) return null;
+      const entries = /* @__PURE__ */ new Map();
+      collectNumberTree(plVal, resolveValue2, entries);
+      if (entries.size === 0) return null;
+      const ranges = [];
+      for (const startPage of [...entries.keys()].sort((a, b) => a - b)) {
+        const dict = resolveValue2(entries.get(startPage) ?? null);
+        if (!isDict(dict)) continue;
+        const range = { startPage };
+        const sOp = dictGetName(dict, "S");
+        range.style = sOp === void 0 ? "none" : STYLE_FROM_OP[sOp] ?? "none";
+        const prefix = dict.get("P");
+        if (typeof prefix === "string") range.prefix = prefix;
+        const start = dictGetNum(dict, "St");
+        if (start !== void 0) range.start = start;
+        ranges.push(range);
+      }
+      return ranges.length > 0 ? ranges : null;
+    },
+    getAnnotations(pageIndex) {
+      const pages = collectPages();
+      if (pageIndex < 0 || pageIndex >= pages.length) return [];
+      const annotsVal = resolveValue2(pages[pageIndex].get("Annots") ?? null);
+      if (!isArray(annotsVal)) return [];
+      const out = [];
+      for (const a of annotsVal) {
+        const d = resolveValue2(a);
+        if (!isDict(d)) continue;
+        const subtype = dictGetName(d, "Subtype") ?? "";
+        const rectVal = resolveValue2(d.get("Rect") ?? null);
+        let rect = null;
+        if (isArray(rectVal) && rectVal.length === 4 && rectVal.every((n2) => typeof n2 === "number")) {
+          rect = [rectVal[0], rectVal[1], rectVal[2], rectVal[3]];
+        }
+        const parsed = { subtype, rect };
+        const contents = d.get("Contents");
+        if (typeof contents === "string") parsed.contents = decodePdfTextString(contents);
+        const title = d.get("T");
+        if (typeof title === "string") parsed.title = decodePdfTextString(title);
+        const c = resolveValue2(d.get("C") ?? null);
+        if (isArray(c)) {
+          const nums = c.filter((x) => typeof x === "number");
+          if (nums.length > 0) parsed.color = nums;
+        }
+        const qp = resolveValue2(d.get("QuadPoints") ?? null);
+        if (isArray(qp)) {
+          parsed.quadPoints = qp.filter((x) => typeof x === "number");
+        }
+        const action = resolveValue2(d.get("A") ?? null);
+        if (isDict(action)) {
+          const uri = action.get("URI");
+          if (typeof uri === "string") parsed.url = uri;
+        }
+        out.push(parsed);
+      }
+      return out;
+    },
+    getPageRef(pageIndex) {
+      const refs = collectPageRefs();
+      return pageIndex >= 0 && pageIndex < refs.length ? refs[pageIndex] : null;
+    },
     decodeStream: decodeStreamData,
     getObject
   };
 }
+function decodePdfTextString(raw) {
+  if (raw.length >= 2 && raw.charCodeAt(0) === 254 && raw.charCodeAt(1) === 255) {
+    let out = "";
+    for (let i = 2; i + 1 < raw.length; i += 2) {
+      out += String.fromCharCode(raw.charCodeAt(i) << 8 | raw.charCodeAt(i + 1));
+    }
+    return out;
+  }
+  return raw;
+}
+var STYLE_FROM_OP = {
+  D: "decimal",
+  r: "roman",
+  R: "Roman",
+  a: "alpha",
+  A: "Alpha"
+};
+function collectNumberTree(node, resolve, out) {
+  const nums = resolve(node.get("Nums") ?? null);
+  if (isArray(nums)) {
+    for (let i = 0; i + 1 < nums.length; i += 2) {
+      const key = resolve(nums[i]);
+      if (typeof key === "number") out.set(key, nums[i + 1]);
+    }
+  }
+  const kids = resolve(node.get("Kids") ?? null);
+  if (isArray(kids)) {
+    for (const kid of kids) {
+      const kd = resolve(kid);
+      if (isDict(kd)) collectNumberTree(kd, resolve, out);
+    }
+  }
+}
 function flattenPageTree(node, resolve, pages) {
   const type = dictGetName(node, "Type");
   if (type === "Page") {
@@ -14076,6 +15004,21 @@ function createModifier(reader) {
     if (modified.has(num)) return modified.get(num) ?? null;
     return reader.getObject(num);
   }
+  function addAnnotation(pageIndex, annotationBody) {
+    const pageRef = reader.getPageRef(pageIndex);
+    if (!pageRef) throw new Error(`addAnnotation: no page at index ${pageIndex}`);
+    const objNum = addRawObject(annotationBody);
+    const page = getObject(pageRef.num);
+    if (!isDict(page)) throw new Error(`addAnnotation: page ${pageIndex} is not a dictionary`);
+    const clone = new Map(page);
+    const existing = clone.get("Annots");
+    const resolved = isRef(existing) ? reader.resolveValue(existing) : existing;
+    const annots = isArray(resolved) ? [...resolved] : [];
+    annots.push({ type: "ref", num: objNum, gen: 0 });
+    clone.set("Annots", annots);
+    setObject(pageRef.num, clone);
+    return objNum;
+  }
   function save() {
     if (modified.size === 0) {
       return reader.bytes;
@@ -14121,6 +15064,7 @@ ${xrefOffset}
     setObject,
     addObject,
     addRawObject,
+    addAnnotation,
     getObject,
     save,
     get nextObjNum() {
@@ -14534,6 +15478,68 @@ async function streamByteLength(stream) {
   }
   return total;
 }
+async function streamToFile(stream, filePath, opts) {
+  let fs;
+  try {
+    fs = await import('fs');
+  } catch {
+    throw new Error("streamToFile requires a Node.js environment (node:fs is unavailable)");
+  }
+  const signal = opts?.signal;
+  if (signal?.aborted) throw new Error("streamToFile aborted before start");
+  const ws = fs.createWriteStream(filePath);
+  let bytesWritten = 0;
+  const onAbort = () => {
+    ws.destroy(new Error("streamToFile aborted"));
+  };
+  signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    await new Promise((resolve, reject) => {
+      ws.on("error", reject);
+      ws.on("open", () => resolve());
+    });
+    for await (const chunk of stream) {
+      if (signal?.aborted) throw new Error("streamToFile aborted");
+      bytesWritten += chunk.length;
+      const ok = ws.write(chunk);
+      if (!ok) {
+        await new Promise((resolve, reject) => {
+          const onErr = (e) => {
+            ws.off("drain", onDrain);
+            reject(e);
+          };
+          const onDrain = () => {
+            ws.off("error", onErr);
+            resolve();
+          };
+          ws.once("drain", onDrain);
+          ws.once("error", onErr);
+        });
+      }
+    }
+    if (signal?.aborted) throw new Error("streamToFile aborted");
+    await new Promise((resolve, reject) => {
+      ws.end((err) => err ? reject(err) : resolve());
+    });
+  } catch (err) {
+    await new Promise((resolve) => {
+      if (ws.closed) {
+        resolve();
+        return;
+      }
+      ws.once("close", () => resolve());
+      ws.destroy();
+    });
+    try {
+      fs.rmSync(filePath, { force: true });
+    } catch {
+    }
+    throw err;
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+  }
+  return { bytesWritten, path: filePath };
+}
 var DEFAULT_CHUNK_SIZE = 65536;
 var MIN_CHUNK_SIZE = 1024;
 var MAX_CHUNK_SIZE = 16777216;
@@ -14749,6 +15755,123 @@ async function initCrypto() {
   initEcdsaAsn12(asn1);
 }
 
+// src/fonts/font-validator.ts
+var SFNT_MAGIC = /* @__PURE__ */ new Set([
+  65536,
+  // TrueType outlines
+  1330926671,
+  // 'OTTO' — CFF/OpenType outlines
+  1953658213,
+  // 'true' — legacy Apple TrueType
+  1953784678
+  // 'ttcf' — TrueType Collection
+]);
+function decodeBase64Prefix(b64, maxBytes) {
+  if (!/^[A-Za-z0-9+/]*={0,2}$/.test(b64)) return null;
+  if (b64.length % 4 !== 0) return null;
+  const g = globalThis;
+  try {
+    const atobFn = g["atob"];
+    if (typeof atobFn === "function") {
+      const need = Math.ceil(maxBytes / 3 * 4 / 4) * 4;
+      const slice = b64.slice(0, Math.min(b64.length, need));
+      const bin = atobFn(slice);
+      const out = new Uint8Array(Math.min(bin.length, maxBytes));
+      for (let i = 0; i < out.length; i++) out[i] = bin.charCodeAt(i) & 255;
+      return out;
+    }
+    const bufCtor = g["Buffer"];
+    if (bufCtor?.from) {
+      return bufCtor.from(b64, "base64").subarray(0, maxBytes);
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function validateFontData(data) {
+  const errors = [];
+  const warnings = [];
+  if (data === null || typeof data !== "object") {
+    return { valid: false, errors: ["font data must be a non-null object"], warnings };
+  }
+  const f = data;
+  const m = f.metrics;
+  if (!m || typeof m !== "object") {
+    errors.push("missing or invalid `metrics` object");
+  } else {
+    const finiteFields = ["unitsPerEm", "numGlyphs", "ascent", "descent", "capHeight", "stemV"];
+    const mRec = m;
+    for (const k of finiteFields) {
+      const v = mRec[k];
+      if (typeof v !== "number" || !Number.isFinite(v)) {
+        errors.push(`metrics.${String(k)} must be a finite number`);
+      }
+    }
+    if (typeof m.unitsPerEm === "number" && m.unitsPerEm <= 0) {
+      errors.push("metrics.unitsPerEm must be positive");
+    }
+    if (!Array.isArray(m.bbox) || m.bbox.length !== 4 || !m.bbox.every((n2) => typeof n2 === "number" && Number.isFinite(n2))) {
+      errors.push("metrics.bbox must be a 4-number array [xMin yMin xMax yMax]");
+    }
+  }
+  if (typeof f.fontName !== "string" || f.fontName.length === 0) {
+    errors.push("`fontName` must be a non-empty string");
+  }
+  const cmap = f.cmap;
+  let cmapEntries = 0;
+  if (!cmap || typeof cmap !== "object") {
+    errors.push("missing or invalid `cmap` (codepoint \u2192 glyph id map)");
+  } else {
+    cmapEntries = Object.keys(cmap).length;
+    if (cmapEntries === 0) {
+      errors.push("`cmap` is empty \u2014 the font maps no characters");
+    }
+  }
+  const widths = f.widths;
+  if (!widths || typeof widths !== "object") {
+    errors.push("missing or invalid `widths` (glyph id \u2192 advance map)");
+  }
+  if (cmap && typeof cmap === "object" && widths && typeof widths === "object") {
+    const numGlyphs = m && typeof m.numGlyphs === "number" ? m.numGlyphs : Infinity;
+    let missingWidth = 0;
+    let outOfRange = 0;
+    for (const gid of Object.values(cmap)) {
+      if (typeof gid !== "number" || !Number.isInteger(gid) || gid < 0) {
+        outOfRange++;
+        continue;
+      }
+      if (Number.isFinite(numGlyphs) && gid >= numGlyphs) outOfRange++;
+      if (widths[gid] === void 0) missingWidth++;
+    }
+    if (outOfRange > 0) {
+      errors.push(`${outOfRange} cmap entr${outOfRange === 1 ? "y maps" : "ies map"} to an out-of-range glyph id`);
+    }
+    if (missingWidth > 0) {
+      warnings.push(`${missingWidth} cmap glyph id(s) have no explicit width (defaultWidth will be used)`);
+    }
+  }
+  if (typeof f.pdfWidthArray !== "string" || f.pdfWidthArray.length === 0) {
+    errors.push("`pdfWidthArray` must be a non-empty PDF /W array string");
+  } else if (!/^\s*\d/.test(f.pdfWidthArray)) {
+    warnings.push("`pdfWidthArray` does not begin with a glyph index \u2014 verify the /W array format");
+  }
+  if (typeof f.ttfBase64 !== "string" || f.ttfBase64.length === 0) {
+    errors.push("`ttfBase64` must be a non-empty base64 string");
+  } else {
+    const head = decodeBase64Prefix(f.ttfBase64, 4);
+    if (!head || head.length < 4) {
+      errors.push("`ttfBase64` is not valid base64");
+    } else {
+      const magic = (head[0] << 24 | head[1] << 16 | head[2] << 8 | head[3]) >>> 0;
+      if (!SFNT_MAGIC.has(magic)) {
+        errors.push(`\`ttfBase64\` is not an SFNT font (unexpected magic 0x${magic.toString(16).padStart(8, "0")})`);
+      }
+    }
+  }
+  return { valid: errors.length === 0, errors, warnings };
+}
+
 // src/fonts/colr-parser.ts
 var IDENTITY = [1, 0, 0, 1, 0, 0];
 function compose(outer, inner) {
@@ -14865,6 +15988,22 @@ function resolveFill(ctx, offset, m) {
       const s = avgScale(m);
       return { kind: "radial", c0: apply(m, x0, y0), r0: r0 * s, c1: apply(m, x1, y1), r1: r1 * s, stops, extend };
     }
+    case 8: {
+      const colorLineOffset = getUint24(view, offset + 1);
+      const cx = view.getInt16(offset + 4), cy = view.getInt16(offset + 6);
+      const startAngle = f2dot14(view, offset + 8) * 180;
+      const endAngle = f2dot14(view, offset + 10) * 180;
+      const { stops, extend } = readColorLine(ctx, offset + colorLineOffset);
+      const rot = Math.atan2(m[1], m[0]) * 180 / Math.PI;
+      return {
+        kind: "sweep",
+        center: apply(m, cx, cy),
+        startAngle: startAngle + rot,
+        endAngle: endAngle + rot,
+        stops,
+        extend
+      };
+    }
     case 12: {
       const subOffset = getUint24(view, offset + 1);
       const transformOffset = getUint24(view, offset + 4);
@@ -14894,7 +16033,7 @@ function readAffine(view, pos) {
   const dy = fixed(view, pos + 20);
   return [xx, yx, xy, yy, dx, dy];
 }
-function collectLayers(ctx, offset, m, out, depth) {
+function collectLayers(ctx, offset, m, out, depth, blendMode) {
   if (depth > 16) throw new UnsupportedPaint("paint recursion too deep");
   const { view } = ctx;
   const format = view.getUint8(offset);
@@ -14906,7 +16045,7 @@ function collectLayers(ctx, offset, m, out, depth) {
       for (let i = 0; i < numLayers; i++) {
         const idx = firstLayerIndex + i;
         const paintOffset = view.getUint32(ctx.layerListBase + 4 + idx * 4);
-        collectLayers(ctx, ctx.layerListBase + paintOffset, m, out, depth + 1);
+        collectLayers(ctx, ctx.layerListBase + paintOffset, m, out, depth + 1, blendMode);
       }
       return;
     }
@@ -14914,39 +16053,91 @@ function collectLayers(ctx, offset, m, out, depth) {
       const subOffset = getUint24(view, offset + 1);
       const glyphId = view.getUint16(offset + 4);
       const paint = resolveFill(ctx, offset + subOffset, IDENTITY);
-      out.push(m === IDENTITY ? { glyphId, paint } : { glyphId, paint, transform: m });
+      const layer = m === IDENTITY ? { glyphId, paint } : { glyphId, paint, transform: m };
+      out.push(blendMode ? { ...layer, blendMode } : layer);
       return;
     }
     case 11: {
       const glyphId = view.getUint16(offset + 1);
       const paintOffset = baseGlyphPaintOffset(ctx, glyphId);
       if (paintOffset === null) throw new UnsupportedPaint("PaintColrGlyph missing base");
-      collectLayers(ctx, paintOffset, m, out, depth + 1);
+      collectLayers(ctx, paintOffset, m, out, depth + 1, blendMode);
       return;
     }
     case 12: {
       const subOffset = getUint24(view, offset + 1);
       const transformOffset = getUint24(view, offset + 4);
       const t = readAffine(view, offset + transformOffset);
-      collectLayers(ctx, offset + subOffset, compose(m, t), out, depth + 1);
+      collectLayers(ctx, offset + subOffset, compose(m, t), out, depth + 1, blendMode);
       return;
     }
     case 14: {
       const subOffset = getUint24(view, offset + 1);
       const dx = view.getInt16(offset + 4), dy = view.getInt16(offset + 6);
-      collectLayers(ctx, offset + subOffset, compose(m, [1, 0, 0, 1, dx, dy]), out, depth + 1);
+      collectLayers(ctx, offset + subOffset, compose(m, [1, 0, 0, 1, dx, dy]), out, depth + 1, blendMode);
       return;
     }
     case 16: {
       const subOffset = getUint24(view, offset + 1);
       const sx = f2dot14(view, offset + 4), sy = f2dot14(view, offset + 6);
-      collectLayers(ctx, offset + subOffset, compose(m, [sx, 0, 0, sy, 0, 0]), out, depth + 1);
+      collectLayers(ctx, offset + subOffset, compose(m, [sx, 0, 0, sy, 0, 0]), out, depth + 1, blendMode);
+      return;
+    }
+    case 32: {
+      const sourceOffset = getUint24(view, offset + 1);
+      const mode = view.getUint8(offset + 4);
+      const backdropOffset = getUint24(view, offset + 5);
+      const bm = compositeModeToBlendMode(mode);
+      if (bm === null) throw new UnsupportedPaint(`composite mode ${mode}`);
+      collectLayers(ctx, offset + backdropOffset, m, out, depth + 1, blendMode);
+      collectLayers(ctx, offset + sourceOffset, m, out, depth + 1, bm === "Normal" ? blendMode : bm);
       return;
     }
     default:
       throw new UnsupportedPaint(`structural paint format ${format}`);
   }
 }
+function compositeModeToBlendMode(mode) {
+  switch (mode) {
+    case 3:
+      return "Normal";
+    // SRC_OVER
+    case 13:
+      return "Screen";
+    case 14:
+      return "Overlay";
+    case 15:
+      return "Darken";
+    case 16:
+      return "Lighten";
+    case 17:
+      return "ColorDodge";
+    case 18:
+      return "ColorBurn";
+    case 19:
+      return "HardLight";
+    case 20:
+      return "SoftLight";
+    case 21:
+      return "Difference";
+    case 22:
+      return "Exclusion";
+    case 23:
+      return "Multiply";
+    case 24:
+      return "Hue";
+    case 25:
+      return "Saturation";
+    case 26:
+      return "Color";
+    case 27:
+      return "Luminosity";
+    // 0 CLEAR, 1 SRC, 2 DEST, 4 DEST_OVER, 5 SRC_IN, 6 DEST_IN, 7 SRC_OUT,
+    // 8 DEST_OUT, 9 SRC_ATOP, 10 DEST_ATOP, 11 XOR, 12 PLUS → unsupported.
+    default:
+      return null;
+  }
+}
 function baseGlyphPaintOffset(ctx, glyphId) {
   const { view, colrBase } = ctx;
   const baseGlyphListOffset = view.getUint32(colrBase + 14);
@@ -15022,6 +16213,314 @@ function parseColrCpal(bytes) {
   return Object.keys(result).length ? result : null;
 }
 
+// src/parser/pdf-pagetree.ts
+init_pdf_encrypt();
+var MAX_MERGE_SOURCES = 50;
+var DEFAULT_MEDIA_BOX = "[0 0 612 792]";
+var INHERITABLE_KEYS = ["MediaBox", "CropBox", "Rotate"];
+var MAX_COPY_DEPTH = 2e3;
+var DEFAULT_MAX_OUTPUT_SIZE = 256 * 1024 * 1024;
+function resolveMaxOutputSize(value) {
+  if (value === void 0) return DEFAULT_MAX_OUTPUT_SIZE;
+  if (typeof value !== "number" || Number.isNaN(value) || value <= 0) {
+    throw new Error(
+      `maxOutputSize must be a positive number or Infinity (got ${String(value)})`
+    );
+  }
+  return value;
+}
+function mergePdfs(sources, opts) {
+  if (sources.length === 0) throw new Error("mergePdfs requires at least one source PDF");
+  if (sources.length > MAX_MERGE_SOURCES) {
+    throw new Error(`mergePdfs supports at most ${MAX_MERGE_SOURCES} sources (got ${sources.length})`);
+  }
+  resolveMaxOutputSize(opts?.maxOutputSize);
+  const specs = [];
+  for (const src of sources) {
+    const reader = openPdf(src);
+    assertNotEncrypted(reader);
+    const count = reader.pageCount;
+    for (let i = 0; i < count; i++) specs.push({ reader, pageIndex: i });
+  }
+  return assemble(specs, opts ?? {});
+}
+function extractPages(src, pageIndices, opts) {
+  if (pageIndices.length === 0) throw new Error("extractPages requires at least one page index");
+  resolveMaxOutputSize(opts?.maxOutputSize);
+  const reader = openPdf(src);
+  assertNotEncrypted(reader);
+  const count = reader.pageCount;
+  const specs = [];
+  for (const idx of pageIndices) {
+    if (!Number.isInteger(idx) || idx < 0 || idx >= count) {
+      throw new Error(`extractPages page index ${idx} out of range (0-${count - 1})`);
+    }
+    specs.push({ reader, pageIndex: idx });
+  }
+  return assemble(specs, opts ?? {});
+}
+function splitPdf(src, ranges, opts) {
+  if (ranges.length === 0) throw new Error("splitPdf requires at least one range");
+  resolveMaxOutputSize(opts?.maxOutputSize);
+  const reader = openPdf(src);
+  assertNotEncrypted(reader);
+  const count = reader.pageCount;
+  const out = [];
+  for (const range of ranges) {
+    const start = range.start | 0;
+    const end = (range.end ?? range.start) | 0;
+    if (start < 0 || end < start || end >= count) {
+      throw new Error(`splitPdf range [${start}, ${end}] invalid for ${count}-page document`);
+    }
+    const specs = [];
+    for (let i = start; i <= end; i++) specs.push({ reader, pageIndex: i });
+    out.push(assemble(specs, opts ?? {}));
+  }
+  return out;
+}
+function assertNotEncrypted(reader) {
+  if (reader.trailer.get("Encrypt") !== void 0) {
+    throw new Error("Encrypted PDFs are not supported by the page-tree API (decrypt first)");
+  }
+}
+function resolveInherited(reader, page, key) {
+  let node = page;
+  const seen = /* @__PURE__ */ new Set();
+  while (node && !seen.has(node)) {
+    seen.add(node);
+    const v = node.get(key);
+    if (v !== void 0) return v;
+    const parent = node.get("Parent");
+    if (parent === void 0) break;
+    const resolved = reader.resolveValue(parent);
+    node = isDict(resolved) ? resolved : void 0;
+  }
+  return void 0;
+}
+function assemble(specs, opts) {
+  const ctx = {
+    nextNum: 3,
+    bodies: /* @__PURE__ */ new Map(),
+    memo: /* @__PURE__ */ new Map(),
+    maxOutputSize: resolveMaxOutputSize(opts.maxOutputSize),
+    totalBytes: 0
+  };
+  const pageNums = [];
+  for (const spec of specs) {
+    pageNums.push(copyPage(ctx, spec, opts));
+  }
+  const kids = pageNums.map((n2) => `${n2} 0 R`).join(" ");
+  setBody(ctx, 2, `<< /Type /Pages /Kids [${kids}] /Count ${pageNums.length} >>`);
+  setBody(ctx, 1, "<< /Type /Catalog /Pages 2 0 R >>");
+  return serializeDocument(ctx);
+}
+function accountBytes(ctx, n2) {
+  ctx.totalBytes += n2;
+  if (ctx.totalBytes > ctx.maxOutputSize) {
+    throw new Error(
+      `page-tree output exceeded the ${ctx.maxOutputSize}-byte maxOutputSize limit (raise MergeOptions.maxOutputSize or pass Infinity to disable)`
+    );
+  }
+}
+function setBody(ctx, num, body) {
+  accountBytes(ctx, body.length);
+  ctx.bodies.set(num, body);
+}
+function memoFor(ctx, reader) {
+  let m = ctx.memo.get(reader);
+  if (!m) {
+    m = /* @__PURE__ */ new Map();
+    ctx.memo.set(reader, m);
+  }
+  return m;
+}
+function copyPage(ctx, spec, opts) {
+  const { reader, pageIndex } = spec;
+  const page = reader.getPage(pageIndex);
+  const pageNum = ctx.nextNum++;
+  const parts = ["/Type /Page", "/Parent 2 0 R"];
+  for (const key of INHERITABLE_KEYS) {
+    const v = resolveInherited(reader, page, key);
+    if (v !== void 0) {
+      parts.push(`/${key} ${serializeValue2(rewrite(ctx, reader, v))}`);
+    } else if (key === "MediaBox") {
+      parts.push(`/MediaBox ${DEFAULT_MEDIA_BOX}`);
+    }
+  }
+  const res = resolveInherited(reader, page, "Resources");
+  parts.push(`/Resources ${res !== void 0 ? serializeValue2(rewrite(ctx, reader, res)) : "<< >>"}`);
+  const contents = page.get("Contents");
+  if (contents !== void 0) {
+    parts.push(`/Contents ${serializeValue2(rewrite(ctx, reader, contents))}`);
+  }
+  if (!opts.dropAnnotations) {
+    const annots = filterAnnotations(ctx, reader, page);
+    if (annots) parts.push(`/Annots ${annots}`);
+  }
+  setBody(ctx, pageNum, `<< ${parts.join(" ")} >>`);
+  return pageNum;
+}
+function filterAnnotations(ctx, reader, page) {
+  const annotsVal = page.get("Annots");
+  if (annotsVal === void 0) return void 0;
+  const arr = reader.resolveValue(annotsVal);
+  if (!isArray(arr)) return void 0;
+  const kept = [];
+  for (const a of arr) {
+    const ad = reader.resolveValue(a);
+    if (!isDict(ad)) continue;
+    if (dictGetName(ad, "Subtype") !== "Link") continue;
+    const action = reader.resolveValue(ad.get("A") ?? null);
+    if (!isDict(action) || dictGetName(action, "S") !== "URI") continue;
+    const clean = /* @__PURE__ */ new Map();
+    for (const [k, v] of ad) {
+      if (k === "P" || k === "Parent") continue;
+      clean.set(k, rewrite(ctx, reader, v));
+    }
+    kept.push(serializeValue2(clean));
+  }
+  return kept.length > 0 ? `[${kept.join(" ")}]` : void 0;
+}
+function copyObject(ctx, reader, srcNum, srcGen, depth = 0) {
+  const memo = memoFor(ctx, reader);
+  const existing = memo.get(srcNum);
+  if (existing !== void 0) return existing;
+  const newNum = ctx.nextNum++;
+  memo.set(srcNum, newNum);
+  const resolved = reader.resolve({ type: "ref", num: srcNum, gen: srcGen });
+  if (isStream(resolved)) {
+    ctx.bodies.set(newNum, serializeStreamBody(ctx, reader, resolved, depth));
+  } else {
+    const body = serializeValue2(rewrite(ctx, reader, resolved, depth));
+    setBody(ctx, newNum, body);
+  }
+  return newNum;
+}
+function rewrite(ctx, reader, val, depth = 0) {
+  if (depth > MAX_COPY_DEPTH) {
+    throw new Error(
+      `page-tree copy exceeded maximum object nesting depth (${MAX_COPY_DEPTH}) \u2014 malformed or adversarial PDF`
+    );
+  }
+  if (isRef(val)) {
+    const entry = reader.xref.entries.get(val.num);
+    if (!entry || entry.type === 0) return null;
+    const newNum = copyObject(ctx, reader, val.num, val.gen, depth + 1);
+    return { type: "ref", num: newNum, gen: 0 };
+  }
+  if (isArray(val)) return val.map((v) => rewrite(ctx, reader, v, depth + 1));
+  if (isStream(val)) {
+    return val;
+  }
+  if (isDict(val)) {
+    const out = /* @__PURE__ */ new Map();
+    for (const [k, v] of val) out.set(k, rewrite(ctx, reader, v, depth + 1));
+    return out;
+  }
+  return val;
+}
+function serializeStreamBody(ctx, reader, stream, depth = 0) {
+  accountBytes(ctx, stream.data.length);
+  const dict = /* @__PURE__ */ new Map();
+  for (const [k, v] of stream.dict) {
+    if (k === "Length") continue;
+    dict.set(k, rewrite(ctx, reader, v, depth + 1));
+  }
+  dict.set("Length", stream.data.length);
+  let body = serializeDict2(dict);
+  body += "\nstream\n";
+  body += bytesToLatin1(stream.data);
+  body += "\nendstream";
+  accountBytes(ctx, body.length - stream.data.length);
+  return body;
+}
+function serializeValue2(val) {
+  if (val === null) return "null";
+  if (typeof val === "boolean") return val ? "true" : "false";
+  if (typeof val === "number") {
+    if (Number.isInteger(val)) return String(val);
+    return val.toFixed(4).replace(/\.?0+$/, "");
+  }
+  if (typeof val === "string") return `(${escapePdfStr2(val)})`;
+  if (isName(val)) return `/${val.value}`;
+  if (isRef(val)) return `${val.num} ${val.gen} R`;
+  if (isArray(val)) return "[" + val.map(serializeValue2).join(" ") + "]";
+  if (isStream(val)) return serializeDict2(val.dict);
+  if (isDict(val)) return serializeDict2(val);
+  return "null";
+}
+function serializeDict2(dict) {
+  let s = "<<";
+  for (const [key, val] of dict) s += ` /${key} ${serializeValue2(val)}`;
+  s += " >>";
+  return s;
+}
+function escapePdfStr2(s) {
+  return s.replace(/[\\()]/g, (c) => "\\" + c);
+}
+function bytesToLatin1(bytes) {
+  let s = "";
+  const CHUNK = 32768;
+  for (let i = 0; i < bytes.length; i += CHUNK) {
+    s += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
+  }
+  return s;
+}
+function serializeDocument(ctx) {
+  const maxNum = ctx.nextNum - 1;
+  const parts = [];
+  const offsets = new Array(maxNum + 1).fill(0);
+  let offset = 0;
+  function push(s) {
+    parts.push(s);
+    offset += s.length;
+  }
+  push("%PDF-1.7\n");
+  push("%\xE2\xE3\xCF\xD3\n");
+  for (let num = 1; num <= maxNum; num++) {
+    const body = ctx.bodies.get(num);
+    if (body === void 0) continue;
+    offsets[num] = offset;
+    push(`${num} 0 obj
+${body}
+endobj
+`);
+  }
+  const xrefOffset = offset;
+  const size = maxNum + 1;
+  let xref = `xref
+0 ${size}
+0000000000 65535 f 
+`;
+  for (let num = 1; num <= maxNum; num++) {
+    xref += `${String(offsets[num]).padStart(10, "0")} 00000 n 
+`;
+  }
+  push(xref);
+  const id = bytesToHex(md5(latin1ToBytes(parts.join(""))));
+  push(`trailer
+<< /Size ${size} /Root 1 0 R /ID [<${id}> <${id}>] >>
+`);
+  push(`startxref
+${xrefOffset}
+%%EOF
+`);
+  const full = parts.join("");
+  const out = new Uint8Array(full.length);
+  for (let i = 0; i < full.length; i++) out[i] = full.charCodeAt(i) & 255;
+  return out;
+}
+function latin1ToBytes(s) {
+  const out = new Uint8Array(s.length);
+  for (let i = 0; i < s.length; i++) out[i] = s.charCodeAt(i) & 255;
+  return out;
+}
+function bytesToHex(bytes) {
+  let s = "";
+  for (let i = 0; i < bytes.length; i++) s += bytes[i].toString(16).padStart(2, "0");
+  return s;
+}
+
 // src/parser/pdf-ua-validator.ts
 function pageContentText(reader, page) {
   const contents = page.get("Contents");
@@ -15205,6 +16704,8 @@ exports.WORKER_TIMEOUT_MS = WORKER_TIMEOUT_MS;
 exports.addSignaturePlaceholder = addSignaturePlaceholder;
 exports.applyDecodeFilter = applyDecodeFilter;
 exports.buildAcroFormDict = buildAcroFormDict;
+exports.buildAnnotation = buildAnnotation;
+exports.buildAnnotationBody = buildAnnotationBody;
 exports.buildAppearanceStreamDict = buildAppearanceStreamDict;
 exports.buildCmsSignedData = buildCmsSignedData;
 exports.buildDocumentPDF = buildDocumentPDF;
@@ -15239,6 +16740,7 @@ exports.containsDevanagari = containsDevanagari;
 exports.containsEthiopic = containsEthiopic;
 exports.containsHebrew = containsHebrew;
 exports.containsKhmer = containsKhmer;
+exports.containsMath = containsMath;
 exports.containsMyanmar = containsMyanmar;
 exports.containsRTL = containsRTL;
 exports.containsSinhala = containsSinhala;
@@ -15284,11 +16786,13 @@ exports.encodePdfTextString = encodePdfTextString;
 exports.estimateCmsSize = estimateCmsSize;
 exports.estimateContentsSize = estimateContentsSize;
 exports.extractGlyphContours = extractGlyphContours;
+exports.extractPages = extractPages;
 exports.findStartxref = findStartxref;
 exports.generateDataMatrix = generateDataMatrix;
 exports.generatePDFInWorker = generatePDFInWorker;
 exports.generatePDFMainThread = generatePDFMainThread;
 exports.generateQR = generateQR;
+exports.getCryptoProvider = getCryptoProvider;
 exports.getMaxInflateOutputSize = getMaxInflateOutputSize;
 exports.getRegisteredLangs = getRegisteredLangs;
 exports.getTrailerRef = getTrailerRef;
@@ -15301,6 +16805,7 @@ exports.inflateSync = inflateSync;
 exports.initCrypto = initCrypto;
 exports.initNodeCompression = initNodeCompression;
 exports.initNodeDecompression_parser = initNodeDecompression;
+exports.inspectDocumentLayout = inspectDocumentLayout;
 exports.isArmenianCodepoint = isArmenianCodepoint;
 exports.isArray = isArray;
 exports.isBengaliCodepoint = isBengaliCodepoint;
@@ -15311,6 +16816,7 @@ exports.isEthiopicCodepoint = isEthiopicCodepoint;
 exports.isGeorgianCodepoint = isGeorgianCodepoint;
 exports.isKhmerCodepoint = isKhmerCodepoint;
 exports.isLinkAnnotation = isLinkAnnotation;
+exports.isMathCodepoint = isMathCodepoint;
 exports.isMyanmarCodepoint = isMyanmarCodepoint;
 exports.isName = isName;
 exports.isRef = isRef;
@@ -15322,6 +16828,7 @@ exports.isTeluguCodepoint = isTeluguCodepoint;
 exports.isTibetanCodepoint = isTibetanCodepoint;
 exports.isValidPdfRgb = isValidPdfRgb;
 exports.loadFontData = loadFontData;
+exports.mergePdfs = mergePdfs;
 exports.nameValue = nameValue;
 exports.needsUnicodeFont = needsUnicodeFont;
 exports.normalizeBidiEmbeddings = normalizeBidiEmbeddings;
@@ -15361,6 +16868,7 @@ exports.rsaSign = rsaSign;
 exports.rsaSignHash = rsaSignHash;
 exports.rsaVerify = rsaVerify;
 exports.rsaVerifyHash = rsaVerifyHash;
+exports.setCryptoProvider = setCryptoProvider;
 exports.setDeflateImpl = setDeflateImpl;
 exports.setInflateImpl = setInflateImpl;
 exports.setMaxInflateOutputSize = setMaxInflateOutputSize;
@@ -15378,8 +16886,10 @@ exports.shapeThaiText = shapeThaiText;
 exports.shapeTibetanText = shapeTibetanText;
 exports.signPdfBytes = signPdfBytes;
 exports.slugify = slugify;
+exports.splitPdf = splitPdf;
 exports.splitTextByFont = splitTextByFont;
 exports.streamByteLength = streamByteLength;
+exports.streamToFile = streamToFile;
 exports.stripBidiControls = stripBidiControls;
 exports.toBytes = toBytes;
 exports.toWinAnsi = toWinAnsi;
@@ -15387,6 +16897,7 @@ exports.truncate = truncate;
 exports.truncateToWidth = truncateToWidth;
 exports.validateAttachments = validateAttachments;
 exports.validateDocumentStreamable = validateDocumentStreamable;
+exports.validateFontData = validateFontData;
 exports.validatePdfUA = validatePdfUA;
 exports.validateTableStreamable = validateTableStreamable;
 exports.validateURL = validateURL;