pdfnative 1.3.0 → 1.4.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)
@@ -5981,15 +5986,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 +6080,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`);
@@ -8531,6 +8617,180 @@ 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();
 
@@ -11022,23 +11282,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 +11332,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;
@@ -11154,6 +11433,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 +11465,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 +11534,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 +11562,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 });
       }
@@ -11617,13 +11934,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;
@@ -12481,6 +12805,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 +12869,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 +12891,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 +12918,40 @@ 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-signature.ts
 init_sha();
@@ -12568,6 +12961,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 +13031,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 +13129,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) {
@@ -14534,6 +14947,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 +15224,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 +15457,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 +15502,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 +15514,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 +15522,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 +15682,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");
@@ -15284,11 +16252,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;
@@ -15322,6 +16292,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 +16332,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 +16350,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 +16361,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;