modern-pdf-lib 0.25.0 → 0.26.0

package/dist/{src-Db6Qknoz.mjs → src-QZWP21qF.mjs}

@@ -1,6 +1,8 @@
-import { A as buildAnnotationDict, Bt as rectangle, Gt as setLineWidth, Jt as beginText, K as restoreState, O as PdfAnnotation, Pt as fill, Xt as moveText, Y as saveState, Yt as endText, en as setFont, et as applyFillColor, qt as stroke, sn as showText, tt as applyStrokeColor } from "./pdfPage-B_d9HmkG.mjs";
+import { A as buildAnnotationDict, Bt as rectangle, Gt as setLineWidth, Jt as beginText, K as restoreState, O as PdfAnnotation, Pt as fill, Xt as moveText, Y as saveState, Yt as endText, en as setFont, et as applyFillColor, qt as stroke, sn as showText, tt as applyStrokeColor } from "./pdfPage-BJIE5hc6.mjs";
 import { i as PdfName, l as PdfStream, n as PdfBool, o as PdfNumber, r as PdfDict, t as PdfArray, u as PdfString } from "./pdfObjects-uEsWlfzU.mjs";
-import { A as parseDerTlv, E as encodeUTCTime, O as extractIssuerAndSerial, P as findSignatures, S as encodeOctetString, T as encodeSet, _ as detectNamedCurve, g as detectKeyAlgorithm, h as decodeOidBytes, j as toBuffer, k as getSubtle, v as encodeContextTag, w as encodeSequence, x as encodeOID, y as encodeInteger } from "./pdfDocument-B0_XwS4X.mjs";
+import { B as mergePdfs, D as encodeSequence, L as findSignatures, M as getSubtle, N as parseDerTlv, O as encodeSet, P as toBuffer, S as encodeInteger, T as encodeOctetString, b as detectNamedCurve, j as extractIssuerAndSerial, k as encodeUTCTime, r as createPdf, t as PdfDocument, v as decodeOidBytes, w as encodeOID, x as encodeContextTag, y as detectKeyAlgorithm } from "./pdfDocument-D7aFSQEY.mjs";
+import { v as numVal } from "./pdfForm-C3mC9FoQ.mjs";
+import { r as detectRuntime } from "./loader-CVB-c_3Z.mjs";
 import { deflateSync } from "fflate";
 
 //#region src/core/incrementalWriter.ts
@@ -274,8 +276,8 @@ function compressStream(stream, level) {
 * @returns              The incremental save result.
 */
 async function saveDocumentIncremental(originalBytes, doc, options) {
-	const { buildDocumentStructure } = await import("./pdfCatalog-3yMIhJtt.mjs").then((n) => n.o);
-	const { PdfPage: _PdfPage } = await import("./pdfPage-B_d9HmkG.mjs").then((n) => n.r);
+	const { buildDocumentStructure } = await import("./pdfCatalog-CnKMAtIo.mjs").then((n) => n.o);
+	const { PdfPage: _PdfPage } = await import("./pdfPage-BJIE5hc6.mjs").then((n) => n.r);
 	const registry = doc.getRegistry();
 	const structure = buildDocumentStructure(doc.getInternalPages().map((p) => p.finalize()), {
 		producer: doc.getProducer(),
@@ -342,6 +344,457 @@ var PDFOperator = class PDFOperator {
 	}
 };
 
+//#endregion
+//#region src/accessibility/pdfUaValidator.ts
+/** Heading elements for hierarchy validation. */
+const HEADING_TYPES = new Set([
+	"H1",
+	"H2",
+	"H3",
+	"H4",
+	"H5",
+	"H6"
+]);
+/** Heading level by type name. */
+const HEADING_LEVEL = {
+	H1: 1,
+	H2: 2,
+	H3: 3,
+	H4: 4,
+	H5: 5,
+	H6: 6
+};
+/** Illustration types that require alt text per PDF/UA. */
+const ILLUSTRATION_TYPES = new Set([
+	"Figure",
+	"Formula",
+	"Form"
+]);
+/** Standard 14 PDF fonts that must be embedded for PDF/UA. */
+const STANDARD_14_FONTS = new Set([
+	"Courier",
+	"Courier-Bold",
+	"Courier-Oblique",
+	"Courier-BoldOblique",
+	"Helvetica",
+	"Helvetica-Bold",
+	"Helvetica-Oblique",
+	"Helvetica-BoldOblique",
+	"Times-Roman",
+	"Times-Bold",
+	"Times-Italic",
+	"Times-BoldItalic",
+	"Symbol",
+	"ZapfDingbats"
+]);
+/**
+* Validate a PDF document against PDF/UA-1 (ISO 14289-1) requirements.
+*
+* Performs the following checks:
+* 1. Structure tree presence (/StructTreeRoot, /MarkInfo)
+* 2. Document language (/Lang)
+* 3. Document title and /DisplayDocTitle
+* 4. Heading hierarchy (sequential, no skips)
+* 5. Alt text on all illustration elements (Figure, Formula, Form)
+* 6. Table header cells (TH) with scope
+* 7. List structure (L/LI/Lbl/LBody)
+* 8. Reading order via structure tree
+* 9. Font embedding (no unembedded standard 14 fonts)
+* 10. Color contrast (AA: 4.5:1, AAA: 7:1)
+* 11. Bookmarks for navigation
+* 12. Tab order (/Tabs /S) on pages
+*
+* @param doc    The PDF document to validate.
+* @param level  The PDF/UA conformance level (default: `'UA1'`).
+* @returns      A {@link PdfUaValidationResult} with errors and warnings.
+*
+* @example
+* ```ts
+* import { createPdf } from 'modern-pdf-lib';
+* import { validatePdfUa } from 'modern-pdf-lib/accessibility';
+*
+* const doc = createPdf();
+* const result = validatePdfUa(doc);
+* if (!result.valid) {
+*   for (const err of result.errors) {
+*     console.error(`[${err.code}] ${err.message}`);
+*   }
+* }
+* ```
+*/
+function validatePdfUa(doc, level = "UA1") {
+	const errors = [];
+	const warnings = [];
+	checkStructureTree(doc, errors);
+	checkLanguage(doc, errors);
+	checkTitle(doc, errors, warnings);
+	const tree = doc.getStructureTree();
+	if (tree) {
+		const allElements = tree.getAllElements();
+		checkHeadingHierarchy(allElements, errors);
+		checkAltText(allElements, errors);
+		checkTableHeaders(allElements, errors, warnings);
+		checkListStructure(allElements, errors, warnings);
+		checkReadingOrder(doc, warnings);
+	}
+	checkFontEmbedding$1(doc, errors);
+	checkColorContrast(doc, warnings);
+	checkBookmarks(doc, warnings);
+	checkTabOrder(doc, warnings);
+	return {
+		valid: errors.length === 0,
+		level,
+		errors,
+		warnings
+	};
+}
+/**
+* Auto-fix PDF/UA issues that can be corrected programmatically.
+*
+* Applies the following corrections when the relevant requirement is
+* not already satisfied:
+* - Sets `/Lang` to `'en'` if the document has no language.
+* - Sets the document title to `'Untitled'` if missing, and enables
+*   `/DisplayDocTitle` in viewer preferences.
+* - Adds `/MarkInfo` by creating a structure tree if none exists.
+* - Sets `/Tabs /S` (structure order) on every page.
+*
+* Returns a result listing what was fixed and what remains unfixable
+* (e.g. missing alt text, heading skips — those require manual
+* content changes).
+*
+* @param doc  The PDF document to fix in-place.
+* @returns    A {@link PdfUaEnforcementResult} describing what was done.
+*
+* @example
+* ```ts
+* import { createPdf } from 'modern-pdf-lib';
+* import { enforcePdfUa, validatePdfUa } from 'modern-pdf-lib/accessibility';
+*
+* const doc = createPdf();
+* doc.addPage();
+* const result = enforcePdfUa(doc);
+* console.log('Fixed:', result.fixed);
+* console.log('Unfixable:', result.unfixable.length);
+* ```
+*/
+function enforcePdfUa(doc) {
+	const fixed = [];
+	if (doc.getLanguage() === void 0 || doc.getLanguage().length === 0) {
+		doc.setLanguage("en");
+		fixed.push("Set document language to \"en\"");
+	}
+	if (doc.getTitle() === void 0 || doc.getTitle().trim().length === 0) {
+		doc.setTitle("Untitled", { showInWindowTitleBar: true });
+		fixed.push("Set document title to \"Untitled\" with DisplayDocTitle");
+	} else {
+		const prefs = doc.getViewerPreferences();
+		if (!prefs.getDisplayDocTitle()) {
+			prefs.setDisplayDocTitle(true);
+			fixed.push("Enabled DisplayDocTitle in viewer preferences");
+		}
+	}
+	if (!doc.getStructureTree()) {
+		doc.createStructureTree();
+		fixed.push("Created structure tree (MarkInfo / StructTreeRoot)");
+	}
+	const pageCount = doc.getPageCount();
+	let tabOrderFixed = false;
+	for (let i = 0; i < pageCount; i++) {
+		const page = doc.getPage(i);
+		if (page.getTabOrder() !== "S") {
+			page.setTabOrder("S");
+			tabOrderFixed = true;
+		}
+	}
+	if (tabOrderFixed) fixed.push("Set tab order to structure order (/Tabs /S) on all pages");
+	return {
+		fixed,
+		unfixable: validatePdfUa(doc).errors
+	};
+}
+/**
+* Check that the document has a structure tree with MarkInfo.
+* PDF/UA-1 requires /StructTreeRoot and /MarkInfo with /Marked true.
+*
+* @internal
+*/
+function checkStructureTree(doc, errors) {
+	if (!doc.getStructureTree()) {
+		errors.push({
+			code: "UA-STRUCT-001",
+			message: "Document has no structure tree (/StructTreeRoot). PDF/UA requires a tagged document with a complete structure tree.",
+			clause: "7.1"
+		});
+		errors.push({
+			code: "UA-STRUCT-002",
+			message: "Document is not marked (/MarkInfo with /Marked true is required). A structure tree must be created for PDF/UA compliance.",
+			clause: "7.1"
+		});
+	}
+}
+/**
+* Check that the document language is set (/Lang).
+*
+* @internal
+*/
+function checkLanguage(doc, errors) {
+	const lang = doc.getLanguage();
+	if (lang === void 0) errors.push({
+		code: "UA-META-001",
+		message: "Document has no language set (/Lang). PDF/UA requires the document catalog to specify a natural language.",
+		clause: "7.2"
+	});
+	else if (lang.length === 0) errors.push({
+		code: "UA-META-002",
+		message: "Document language (/Lang) is an empty string.",
+		clause: "7.2"
+	});
+	else if (!/^[a-zA-Z]{2,3}(-[a-zA-Z0-9]+)*$/.test(lang)) errors.push({
+		code: "UA-META-003",
+		message: `Document language "${lang}" does not appear to be a valid BCP 47 tag.`,
+		clause: "7.2"
+	});
+}
+/**
+* Check that the document title is set and /DisplayDocTitle is enabled.
+*
+* @internal
+*/
+function checkTitle(doc, errors, warnings) {
+	const title = doc.getTitle();
+	if (title === void 0) errors.push({
+		code: "UA-META-004",
+		message: "Document has no title. PDF/UA requires a descriptive document title in the metadata.",
+		clause: "7.1"
+	});
+	else if (title.trim().length === 0) errors.push({
+		code: "UA-META-005",
+		message: "Document title is empty or whitespace-only.",
+		clause: "7.1"
+	});
+	if (!doc.getViewerPreferences().getDisplayDocTitle()) errors.push({
+		code: "UA-META-006",
+		message: "/DisplayDocTitle must be true in viewer preferences. PDF/UA requires the document title to be displayed in the title bar.",
+		clause: "7.1"
+	});
+}
+/**
+* Check that heading hierarchy is sequential (no skipped levels).
+* For example, H1 followed directly by H3 without an H2 is a violation.
+*
+* @internal
+*/
+function checkHeadingHierarchy(elements, errors) {
+	const headings = elements.filter((e) => HEADING_TYPES.has(e.type));
+	if (headings.length === 0) return;
+	const firstHeading = headings[0];
+	if (firstHeading.type !== "H1") errors.push({
+		code: "UA-STRUCT-003",
+		message: `First heading should be H1, found ${firstHeading.type}. The document heading hierarchy must start at level 1.`,
+		clause: "7.4.2",
+		element: firstHeading,
+		pageIndex: firstHeading.pageIndex
+	});
+	let lastLevel = 0;
+	for (const h of headings) {
+		const level = HEADING_LEVEL[h.type];
+		if (level === void 0) continue;
+		if (level > lastLevel + 1 && lastLevel > 0) errors.push({
+			code: "UA-STRUCT-004",
+			message: `Heading level skipped: ${h.type} follows H${lastLevel} (expected H${lastLevel + 1}). Heading levels must be sequential without gaps.`,
+			clause: "7.4.2",
+			element: h,
+			pageIndex: h.pageIndex
+		});
+		lastLevel = level;
+	}
+}
+/**
+* Check that all illustration elements have /Alt or /ActualText.
+*
+* @internal
+*/
+function checkAltText(elements, errors) {
+	for (const elem of elements) {
+		if (!ILLUSTRATION_TYPES.has(elem.type)) continue;
+		if (elem.options.altText === void 0 && elem.options.actualText === void 0) errors.push({
+			code: "UA-STRUCT-005",
+			message: `${elem.type} element has no /Alt or /ActualText. PDF/UA requires alternative text for all illustration elements.`,
+			clause: "7.3",
+			element: elem,
+			pageIndex: elem.pageIndex
+		});
+		else if (elem.options.altText !== void 0 && elem.options.altText.trim().length === 0) errors.push({
+			code: "UA-STRUCT-006",
+			message: `${elem.type} element has empty /Alt text. Alternative text must be meaningful and descriptive.`,
+			clause: "7.3",
+			element: elem,
+			pageIndex: elem.pageIndex
+		});
+	}
+}
+/**
+* Check table structure: tables must have TH (header) cells.
+* Tables without headers get an error; tables with TH but without
+* scope attributes get a warning.
+*
+* @internal
+*/
+function checkTableHeaders(elements, errors, warnings) {
+	const tables = elements.filter((e) => e.type === "Table");
+	for (const table of tables) {
+		if (!table.children.some((c) => c.type === "TR" || c.type === "THead" || c.type === "TBody" || c.type === "TFoot")) {
+			errors.push({
+				code: "UA-TABLE-001",
+				message: "Table element has no TR, THead, TBody, or TFoot children. Tables must have a valid row structure.",
+				clause: "7.5",
+				element: table,
+				pageIndex: table.pageIndex
+			});
+			continue;
+		}
+		if (table.findAll("TH").length === 0) warnings.push({
+			code: "UA-TABLE-002",
+			message: "Table has no TH (header) cells. PDF/UA recommends that tables identify header cells for accessibility.",
+			element: table,
+			pageIndex: table.pageIndex
+		});
+		const rows = table.findAll("TR");
+		for (const row of rows) if (!row.children.some((c) => c.type === "TH" || c.type === "TD")) errors.push({
+			code: "UA-TABLE-003",
+			message: "TR element has no TH or TD children.",
+			clause: "7.5",
+			element: row,
+			pageIndex: row.pageIndex
+		});
+	}
+}
+/**
+* Check list structure: L must contain LI, LI should contain LBody.
+*
+* @internal
+*/
+function checkListStructure(elements, errors, warnings) {
+	const lists = elements.filter((e) => e.type === "L");
+	for (const list of lists) if (!list.children.some((c) => c.type === "LI")) errors.push({
+		code: "UA-LIST-001",
+		message: "L (list) element has no LI children. Lists must contain list item elements.",
+		clause: "7.4.3",
+		element: list,
+		pageIndex: list.pageIndex
+	});
+	const items = elements.filter((e) => e.type === "LI");
+	for (const item of items) {
+		if (!item.children.some((c) => c.type === "LBody")) warnings.push({
+			code: "UA-LIST-002",
+			message: "LI element has no LBody child. List items should contain an LBody element for proper structure.",
+			element: item,
+			pageIndex: item.pageIndex
+		});
+		if (!item.parent || item.parent.type !== "L") errors.push({
+			code: "UA-LIST-003",
+			message: "LI element is not a direct child of an L (list) element.",
+			clause: "7.4.3",
+			element: item,
+			pageIndex: item.pageIndex
+		});
+	}
+}
+/**
+* Check that content has a logical reading order via the structure tree.
+* Verifies that MCIDs are in ascending order within each page.
+*
+* @internal
+*/
+function checkReadingOrder(doc, warnings) {
+	const tree = doc.getStructureTree();
+	if (!tree) return;
+	const withMcid = tree.getAllElements().filter((e) => e.mcid !== void 0 && e.pageIndex !== void 0);
+	if (withMcid.length === 0 && doc.getPageCount() > 0) {
+		warnings.push({
+			code: "UA-STRUCT-007",
+			message: "Structure tree has no elements with MCIDs assigned. Content may not be properly tagged for reading order."
+		});
+		return;
+	}
+	const byPage = Map.groupBy(withMcid, (elem) => elem.pageIndex);
+	for (const [pageIdx, elems] of byPage) for (let i = 1; i < elems.length; i++) {
+		const curr = elems[i];
+		const prev = elems[i - 1];
+		if (curr.mcid < prev.mcid) {
+			warnings.push({
+				code: "UA-STRUCT-008",
+				message: `Page ${pageIdx + 1}: MCID ${curr.mcid} (${curr.type}) appears after MCID ${prev.mcid} (${prev.type}) but has a lower MCID, indicating a potential reading order issue.`,
+				element: curr,
+				pageIndex: pageIdx
+			});
+			break;
+		}
+	}
+}
+/**
+* Check that all fonts are embedded (no standard 14 fallback).
+* PDF/UA requires all fonts to be embedded.
+*
+* @internal
+*/
+function checkFontEmbedding$1(doc, errors) {
+	const embeddedFonts = doc.getEmbeddedFonts();
+	for (const [fontName] of embeddedFonts) if (STANDARD_14_FONTS.has(fontName)) errors.push({
+		code: "UA-FONT-001",
+		message: `Font "${fontName}" is a standard 14 font used without full embedding. PDF/UA requires all fonts to be embedded with their glyph data.`,
+		clause: "7.21.3.1"
+	});
+}
+/**
+* Check color contrast (informational / best-practice).
+*
+* Full contrast checking requires rendered pixel data, which is
+* beyond the scope of a structural validator.  This check issues a
+* warning when the document has content, reminding authors to verify
+* contrast manually.
+*
+* WCAG 2.1 thresholds:
+* - AA: 4.5:1 for normal text, 3:1 for large text
+* - AAA: 7:1 for normal text, 4.5:1 for large text
+*
+* @internal
+*/
+function checkColorContrast(doc, warnings) {
+	if (doc.getPageCount() > 0) warnings.push({
+		code: "UA-CONTRAST-001",
+		message: "Color contrast cannot be fully validated structurally. Verify that text meets WCAG 2.1 contrast ratios (AA: 4.5:1 for normal text, AAA: 7:1)."
+	});
+}
+/**
+* Check that the document has bookmarks for navigation.
+* PDF/UA recommends bookmarks for documents with multiple pages.
+*
+* @internal
+*/
+function checkBookmarks(doc, warnings) {
+	if (doc.getOutlines().items.length === 0 && doc.getPageCount() > 1) warnings.push({
+		code: "UA-NAV-001",
+		message: "Document has multiple pages but no bookmarks (outlines). PDF/UA recommends bookmarks for navigating multi-page documents."
+	});
+}
+/**
+* Check that pages specify tab order as structure order (/Tabs /S).
+* PDF/UA requires /Tabs /S to ensure assistive technology follows
+* the logical structure order.
+*
+* @internal
+*/
+function checkTabOrder(doc, warnings) {
+	const pageCount = doc.getPageCount();
+	for (let i = 0; i < pageCount; i++) if (doc.getPage(i).getTabOrder() !== "S") warnings.push({
+		code: "UA-PAGE-001",
+		message: `Page ${i + 1} does not specify tab order as structure order (/Tabs /S). PDF/UA requires pages to use structure-based tab order.`,
+		pageIndex: i
+	});
+}
+
 //#endregion
 //#region src/annotation/types/textAnnotation.ts
 /**
@@ -528,7 +981,7 @@ var PdfLinkAnnotation = class PdfLinkAnnotation extends PdfAnnotation {
 * Reference: PDF 1.7 spec, Section 12.5.5 (Appearance Streams).
 */
 /** Format a number for content stream operators. */
-function n$3(value) {
+function n$5(value) {
 	if (Number.isInteger(value)) return value.toString();
 	const s = value.toFixed(4).replace(/\.?0+$/, "");
 	return s === "-0" ? "0" : s;
@@ -575,16 +1028,16 @@ function generateSquareAppearance(annot) {
 		if (wObj && wObj.kind === "number") borderWidth = wObj.value;
 	}
 	let ops = "";
-	if (opacity < 1) ops += `${n$3(opacity)} ca ${n$3(opacity)} CA\n`;
+	if (opacity < 1) ops += `${n$5(opacity)} ca ${n$5(opacity)} CA\n`;
 	if (interiorColor) {
-		ops += `${n$3(interiorColor.r)} ${n$3(interiorColor.g)} ${n$3(interiorColor.b)} rg\n`;
-		ops += `${n$3(borderWidth / 2)} ${n$3(borderWidth / 2)} ${n$3(w - borderWidth)} ${n$3(h - borderWidth)} re\n`;
+		ops += `${n$5(interiorColor.r)} ${n$5(interiorColor.g)} ${n$5(interiorColor.b)} rg\n`;
+		ops += `${n$5(borderWidth / 2)} ${n$5(borderWidth / 2)} ${n$5(w - borderWidth)} ${n$5(h - borderWidth)} re\n`;
 		ops += "f\n";
 	}
-	if (color) ops += `${n$3(color.r)} ${n$3(color.g)} ${n$3(color.b)} RG\n`;
+	if (color) ops += `${n$5(color.r)} ${n$5(color.g)} ${n$5(color.b)} RG\n`;
 	else ops += "0 0 0 RG\n";
-	ops += `${n$3(borderWidth)} w\n`;
-	ops += `${n$3(borderWidth / 2)} ${n$3(borderWidth / 2)} ${n$3(w - borderWidth)} ${n$3(h - borderWidth)} re\n`;
+	ops += `${n$5(borderWidth)} w\n`;
+	ops += `${n$5(borderWidth / 2)} ${n$5(borderWidth / 2)} ${n$5(w - borderWidth)} ${n$5(h - borderWidth)} re\n`;
 	ops += "S\n";
 	return buildAppearanceStream(ops, [
 		0,
@@ -625,19 +1078,19 @@ function generateCircleAppearance(annot) {
 	const kx = KAPPA * adjRx;
 	const ky = KAPPA * adjRy;
 	let ops = "";
-	if (opacity < 1) ops += `${n$3(opacity)} ca ${n$3(opacity)} CA\n`;
-	const ellipsePath = `${n$3(cx)} ${n$3(cy + adjRy)} m\n${n$3(cx + kx)} ${n$3(cy + adjRy)} ${n$3(cx + adjRx)} ${n$3(cy + ky)} ${n$3(cx + adjRx)} ${n$3(cy)} c\n${n$3(cx + adjRx)} ${n$3(cy - ky)} ${n$3(cx + kx)} ${n$3(cy - adjRy)} ${n$3(cx)} ${n$3(cy - adjRy)} c\n${n$3(cx - kx)} ${n$3(cy - adjRy)} ${n$3(cx - adjRx)} ${n$3(cy - ky)} ${n$3(cx - adjRx)} ${n$3(cy)} c\n${n$3(cx - adjRx)} ${n$3(cy + ky)} ${n$3(cx - kx)} ${n$3(cy + adjRy)} ${n$3(cx)} ${n$3(cy + adjRy)} c\n`;
+	if (opacity < 1) ops += `${n$5(opacity)} ca ${n$5(opacity)} CA\n`;
+	const ellipsePath = `${n$5(cx)} ${n$5(cy + adjRy)} m\n${n$5(cx + kx)} ${n$5(cy + adjRy)} ${n$5(cx + adjRx)} ${n$5(cy + ky)} ${n$5(cx + adjRx)} ${n$5(cy)} c\n${n$5(cx + adjRx)} ${n$5(cy - ky)} ${n$5(cx + kx)} ${n$5(cy - adjRy)} ${n$5(cx)} ${n$5(cy - adjRy)} c\n${n$5(cx - kx)} ${n$5(cy - adjRy)} ${n$5(cx - adjRx)} ${n$5(cy - ky)} ${n$5(cx - adjRx)} ${n$5(cy)} c\n${n$5(cx - adjRx)} ${n$5(cy + ky)} ${n$5(cx - kx)} ${n$5(cy + adjRy)} ${n$5(cx)} ${n$5(cy + adjRy)} c\n`;
 	if (interiorColor) {
-		ops += `${n$3(interiorColor.r)} ${n$3(interiorColor.g)} ${n$3(interiorColor.b)} rg\n`;
-		if (color) ops += `${n$3(color.r)} ${n$3(color.g)} ${n$3(color.b)} RG\n`;
+		ops += `${n$5(interiorColor.r)} ${n$5(interiorColor.g)} ${n$5(interiorColor.b)} rg\n`;
+		if (color) ops += `${n$5(color.r)} ${n$5(color.g)} ${n$5(color.b)} RG\n`;
 		else ops += "0 0 0 RG\n";
-		ops += `${n$3(borderWidth)} w\n`;
+		ops += `${n$5(borderWidth)} w\n`;
 		ops += ellipsePath;
 		ops += "B\n";
 	} else {
-		if (color) ops += `${n$3(color.r)} ${n$3(color.g)} ${n$3(color.b)} RG\n`;
+		if (color) ops += `${n$5(color.r)} ${n$5(color.g)} ${n$5(color.b)} RG\n`;
 		else ops += "0 0 0 RG\n";
-		ops += `${n$3(borderWidth)} w\n`;
+		ops += `${n$5(borderWidth)} w\n`;
 		ops += ellipsePath;
 		ops += "S\n";
 	}
@@ -677,12 +1130,12 @@ function generateLineAppearance(annot) {
 		if (wObj && wObj.kind === "number") borderWidth = wObj.value;
 	}
 	let ops = "";
-	if (opacity < 1) ops += `${n$3(opacity)} ca ${n$3(opacity)} CA\n`;
-	if (color) ops += `${n$3(color.r)} ${n$3(color.g)} ${n$3(color.b)} RG\n`;
+	if (opacity < 1) ops += `${n$5(opacity)} ca ${n$5(opacity)} CA\n`;
+	if (color) ops += `${n$5(color.r)} ${n$5(color.g)} ${n$5(color.b)} RG\n`;
 	else ops += "0 0 0 RG\n";
-	ops += `${n$3(borderWidth)} w\n`;
-	ops += `${n$3(lx1)} ${n$3(ly1)} m\n`;
-	ops += `${n$3(lx2)} ${n$3(ly2)} l\n`;
+	ops += `${n$5(borderWidth)} w\n`;
+	ops += `${n$5(lx1)} ${n$5(ly1)} m\n`;
+	ops += `${n$5(lx2)} ${n$5(ly2)} l\n`;
 	ops += "S\n";
 	return buildAppearanceStream(ops, [
 		0,
@@ -705,8 +1158,8 @@ function generateHighlightAppearance(annot) {
 	};
 	const opacity = annot.getOpacity();
 	let ops = "";
-	if (opacity < 1) ops += `${n$3(opacity)} ca\n`;
-	ops += `${n$3(color.r)} ${n$3(color.g)} ${n$3(color.b)} rg\n`;
+	if (opacity < 1) ops += `${n$5(opacity)} ca\n`;
+	ops += `${n$5(color.r)} ${n$5(color.g)} ${n$5(color.b)} rg\n`;
 	const qpObj = annot.getDict().get("/QuadPoints");
 	if (qpObj && qpObj.kind === "array" && qpObj.items.length >= 8) {
 		const points = qpObj.items.filter((item) => item.kind === "number").map((item) => item.value);
@@ -719,14 +1172,14 @@ function generateHighlightAppearance(annot) {
 			const qy3 = points[i + 5] - y1;
 			const qx4 = points[i + 6] - x1;
 			const qy4 = points[i + 7] - y1;
-			ops += `${n$3(qx1)} ${n$3(qy1)} m\n`;
-			ops += `${n$3(qx2)} ${n$3(qy2)} l\n`;
-			ops += `${n$3(qx4)} ${n$3(qy4)} l\n`;
-			ops += `${n$3(qx3)} ${n$3(qy3)} l\n`;
+			ops += `${n$5(qx1)} ${n$5(qy1)} m\n`;
+			ops += `${n$5(qx2)} ${n$5(qy2)} l\n`;
+			ops += `${n$5(qx4)} ${n$5(qy4)} l\n`;
+			ops += `${n$5(qx3)} ${n$5(qy3)} l\n`;
 			ops += "f\n";
 		}
 	} else {
-		ops += `0 0 ${n$3(w)} ${n$3(h)} re\n`;
+		ops += `0 0 ${n$5(w)} ${n$5(h)} re\n`;
 		ops += "f\n";
 	}
 	return buildAppearanceStream(ops, [
@@ -749,7 +1202,7 @@ function generateUnderlineAppearance(annot) {
 		b: 1
 	};
 	let ops = "";
-	ops += `${n$3(color.r)} ${n$3(color.g)} ${n$3(color.b)} RG\n`;
+	ops += `${n$5(color.r)} ${n$5(color.g)} ${n$5(color.b)} RG\n`;
 	ops += "1 w\n";
 	const qpObj = annot.getDict().get("/QuadPoints");
 	if (qpObj && qpObj.kind === "array" && qpObj.items.length >= 8) {
@@ -759,13 +1212,13 @@ function generateUnderlineAppearance(annot) {
 			const by1 = points[i + 5] - y1;
 			const bx2 = points[i + 6] - x1;
 			const by2 = points[i + 7] - y1;
-			ops += `${n$3(bx1)} ${n$3(by1)} m\n`;
-			ops += `${n$3(bx2)} ${n$3(by2)} l\n`;
+			ops += `${n$5(bx1)} ${n$5(by1)} m\n`;
+			ops += `${n$5(bx2)} ${n$5(by2)} l\n`;
 			ops += "S\n";
 		}
 	} else {
 		ops += `0 0 m\n`;
-		ops += `${n$3(w)} 0 l\n`;
+		ops += `${n$5(w)} 0 l\n`;
 		ops += "S\n";
 	}
 	return buildAppearanceStream(ops, [
@@ -788,18 +1241,18 @@ function generateSquigglyAppearance(annot) {
 		b: 0
 	};
 	let ops = "";
-	ops += `${n$3(color.r)} ${n$3(color.g)} ${n$3(color.b)} RG\n`;
+	ops += `${n$5(color.r)} ${n$5(color.g)} ${n$5(color.b)} RG\n`;
 	ops += "0.5 w\n";
 	const amplitude = 2;
 	const period = 4;
-	ops += `0 ${n$3(amplitude)} m\n`;
+	ops += `0 ${n$5(amplitude)} m\n`;
 	for (let x = 0; x < w; x += period) {
 		const x1p = Math.min(x + period / 2, w);
 		const x2p = Math.min(x + period, w);
 		const y1p = x % (period * 2) < period ? 0 : amplitude * 2;
 		const y2p = x % (period * 2) < period ? amplitude * 2 : 0;
-		ops += `${n$3(x1p)} ${n$3(y1p)} l\n`;
-		if (x2p <= w) ops += `${n$3(x2p)} ${n$3(y2p)} l\n`;
+		ops += `${n$5(x1p)} ${n$5(y1p)} l\n`;
+		if (x2p <= w) ops += `${n$5(x2p)} ${n$5(y2p)} l\n`;
 	}
 	ops += "S\n";
 	return buildAppearanceStream(ops, [
@@ -822,7 +1275,7 @@ function generateStrikeOutAppearance(annot) {
 		b: 0
 	};
 	let ops = "";
-	ops += `${n$3(color.r)} ${n$3(color.g)} ${n$3(color.b)} RG\n`;
+	ops += `${n$5(color.r)} ${n$5(color.g)} ${n$5(color.b)} RG\n`;
 	ops += "1 w\n";
 	const qpObj = annot.getDict().get("/QuadPoints");
 	if (qpObj && qpObj.kind === "array" && qpObj.items.length >= 8) {
@@ -831,14 +1284,14 @@ function generateStrikeOutAppearance(annot) {
 			const midY = ((points[i + 1] - y1 + (points[i + 3] - y1)) / 2 + (points[i + 5] - y1 + (points[i + 7] - y1)) / 2) / 2;
 			const leftX = Math.min(points[i] - x1, points[i + 4] - x1);
 			const rightX = Math.max(points[i + 2] - x1, points[i + 6] - x1);
-			ops += `${n$3(leftX)} ${n$3(midY)} m\n`;
-			ops += `${n$3(rightX)} ${n$3(midY)} l\n`;
+			ops += `${n$5(leftX)} ${n$5(midY)} m\n`;
+			ops += `${n$5(rightX)} ${n$5(midY)} l\n`;
 			ops += "S\n";
 		}
 	} else {
 		const midY = h / 2;
-		ops += `0 ${n$3(midY)} m\n`;
-		ops += `${n$3(w)} ${n$3(midY)} l\n`;
+		ops += `0 ${n$5(midY)} m\n`;
+		ops += `${n$5(w)} ${n$5(midY)} l\n`;
 		ops += "S\n";
 	}
 	return buildAppearanceStream(ops, [
@@ -862,8 +1315,8 @@ function generateInkAppearance(annot) {
 	};
 	const opacity = annot.getOpacity();
 	let ops = "";
-	if (opacity < 1) ops += `${n$3(opacity)} ca ${n$3(opacity)} CA\n`;
-	ops += `${n$3(color.r)} ${n$3(color.g)} ${n$3(color.b)} RG\n`;
+	if (opacity < 1) ops += `${n$5(opacity)} ca ${n$5(opacity)} CA\n`;
+	ops += `${n$5(color.r)} ${n$5(color.g)} ${n$5(color.b)} RG\n`;
 	ops += "1 w\n";
 	ops += "1 J\n";
 	const inkListObj = annot.getDict().get("/InkList");
@@ -871,8 +1324,8 @@ function generateInkAppearance(annot) {
 		if (pathObj.kind !== "array") continue;
 		const points = pathObj.items.filter((item) => item.kind === "number").map((item) => item.value);
 		if (points.length >= 2) {
-			ops += `${n$3(points[0] - x1)} ${n$3(points[1] - y1)} m\n`;
-			for (let i = 2; i + 1 < points.length; i += 2) ops += `${n$3(points[i] - x1)} ${n$3(points[i + 1] - y1)} l\n`;
+			ops += `${n$5(points[0] - x1)} ${n$5(points[1] - y1)} m\n`;
+			for (let i = 2; i + 1 < points.length; i += 2) ops += `${n$5(points[i] - x1)} ${n$5(points[i + 1] - y1)} l\n`;
 			ops += "S\n";
 		}
 	}
@@ -910,9 +1363,9 @@ function generateFreeTextAppearance(annot) {
 	ops += "BT\n";
 	const margin = 2;
 	const textY = h - fontSize - margin;
-	if (align === 1) ops += `${n$3(w / 2)} ${n$3(textY)} Td\n`;
-	else if (align === 2) ops += `${n$3(w - margin)} ${n$3(textY)} Td\n`;
-	else ops += `${n$3(margin)} ${n$3(textY)} Td\n`;
+	if (align === 1) ops += `${n$5(w / 2)} ${n$5(textY)} Td\n`;
+	else if (align === 2) ops += `${n$5(w - margin)} ${n$5(textY)} Td\n`;
+	else ops += `${n$5(margin)} ${n$5(textY)} Td\n`;
 	const escapedText = text.replace(/\\/g, "\\\\").replace(/\(/g, "\\(").replace(/\)/g, "\\)");
 	ops += `(${escapedText}) Tj\n`;
 	ops += "ET\n";
@@ -4019,6 +4472,29 @@ function isLinearized(pdfBytes) {
 	const header = decoder$2.decode(pdfBytes.subarray(0, searchWindow));
 	return /\/Linearized\s+[\d.]+/.test(header);
 }
+/**
+* Extract linearization information from a linearized PDF.
+*
+* @param pdfBytes  The raw PDF bytes.
+* @returns         The linearization info, or `null` if not linearized.
+*/
+function getLinearizationInfo(pdfBytes) {
+	if (!isLinearized(pdfBytes)) return null;
+	const searchWindow = Math.min(pdfBytes.length, 2048);
+	const header = decoder$2.decode(pdfBytes.subarray(0, searchWindow));
+	const versionMatch = /\/Linearized\s+([\d.]+)/.exec(header);
+	const lengthMatch = /\/L\s+(\d+)/.exec(header);
+	const primaryMatch = /\/O\s+(\d+)/.exec(header);
+	const pageCountMatch = /\/N\s+(\d+)/.exec(header);
+	const endFirstMatch = /\/E\s+(\d+)/.exec(header);
+	return {
+		version: versionMatch ? parseFloat(versionMatch[1]) : 1,
+		length: lengthMatch ? parseInt(lengthMatch[1], 10) : pdfBytes.length,
+		primaryPage: primaryMatch ? parseInt(primaryMatch[1], 10) : 0,
+		pageCount: pageCountMatch ? parseInt(pageCountMatch[1], 10) : 0,
+		firstPageOffset: endFirstMatch ? parseInt(endFirstMatch[1], 10) : 0
+	};
+}
 /** Find a string in the byte array, starting from `start`. */
 function findString(data, str, start = 0) {
 	const bytes = encoder$2.encode(str);
@@ -4048,7 +4524,7 @@ function findStartXref(data) {
 	if (idx < 0) return -1;
 	const lines = tail.slice(idx + 9).trim().split(/[\r\n]+/);
 	const xrefOffset = parseInt(lines[0], 10);
-	return isNaN(xrefOffset) ? -1 : xrefOffset;
+	return Number.isNaN(xrefOffset) ? -1 : xrefOffset;
 }
 function parseXrefTable(data, xrefOffset) {
 	const entries = /* @__PURE__ */ new Map();
@@ -4058,7 +4534,7 @@ function parseXrefTable(data, xrefOffset) {
 		const line = readLine(data, pos);
 		if (line.line.startsWith("trailer")) break;
 		const parts = line.line.trim().split(/\s+/);
-		if (parts.length === 2) {
+		if (parts.length === 2 && /^\d+$/.test(parts[0]) && /^\d+$/.test(parts[1])) {
 			const startObj = parseInt(parts[0], 10);
 			const count = parseInt(parts[1], 10);
 			pos = line.nextOffset;
@@ -4085,7 +4561,11 @@ function parseXrefTable(data, xrefOffset) {
 		trailer: {
 			size: sizeMatch ? parseInt(sizeMatch[1], 10) : 0,
 			rootRef: rootMatch ? `${rootMatch[1]} ${rootMatch[2]} R` : "1 0 R",
-			infoRef: infoMatch ? `${infoMatch[1]} ${infoMatch[2]} R` : void 0
+			rootObjNum: rootMatch ? parseInt(rootMatch[1], 10) : 1,
+			rootGenNum: rootMatch ? parseInt(rootMatch[2], 10) : 0,
+			infoRef: infoMatch ? `${infoMatch[1]} ${infoMatch[2]} R` : void 0,
+			infoObjNum: infoMatch ? parseInt(infoMatch[1], 10) : 0,
+			infoGenNum: infoMatch ? parseInt(infoMatch[2], 10) : 0
 		}
 	};
 }
@@ -4096,16 +4576,266 @@ function extractObject(data, offset) {
 	return data.subarray(offset, endIdx + 6);
 }
 /**
+* Recursively walk references from a set of root object numbers.
+* Returns all transitively referenced object numbers.
+*/
+function walkReferences(rootObjNums, objects, maxDepth = 20) {
+	const visited = /* @__PURE__ */ new Set();
+	function walk(objNum, depth) {
+		if (depth > maxDepth) return;
+		if (visited.has(objNum)) return;
+		visited.add(objNum);
+		const objBytes = objects.get(objNum);
+		if (!objBytes) return;
+		const refMatches = decoder$2.decode(objBytes).matchAll(/(\d+)\s+\d+\s+R/g);
+		for (const rm of refMatches) {
+			const refNum = parseInt(rm[1], 10);
+			if (objects.has(refNum)) walk(refNum, depth + 1);
+		}
+	}
+	for (const root of rootObjNums) walk(root, 0);
+	return visited;
+}
+/**
+* Find all page object numbers from the /Pages tree.
+*/
+function findPageObjectNumbers(pagesObjNum, objects) {
+	const pageNums = [];
+	function walkPages(objNum) {
+		const objBytes = objects.get(objNum);
+		if (!objBytes) return;
+		const str = decoder$2.decode(objBytes);
+		const typeMatch = /\/Type\s*\/(\w+)/.exec(str);
+		if (!typeMatch) return;
+		if (typeMatch[1] === "Page") {
+			pageNums.push(objNum);
+			return;
+		}
+		if (typeMatch[1] === "Pages") {
+			const kidsMatch = /\/Kids\s*\[([\s\S]*?)\]/.exec(str);
+			if (kidsMatch) {
+				const refs = kidsMatch[1].match(/(\d+)\s+\d+\s+R/g);
+				if (refs) for (const ref of refs) walkPages(parseInt(ref.split(" ")[0], 10));
+			}
+		}
+	}
+	walkPages(pagesObjNum);
+	return pageNums;
+}
+/**
+* Classify objects into per-page sets.
+* Shared objects (referenced by multiple pages) are tracked separately.
+*/
+function classifyObjects(pageObjNums, catalogObjNum, pagesObjNum, objects) {
+	const pages = [];
+	for (const pageObjNum of pageObjNums) {
+		const referencedObjects = walkReferences([pageObjNum], objects);
+		pages.push({
+			pageObjNum,
+			referencedObjects
+		});
+	}
+	const catalogObjects = /* @__PURE__ */ new Set();
+	catalogObjects.add(catalogObjNum);
+	catalogObjects.add(pagesObjNum);
+	const refCount = /* @__PURE__ */ new Map();
+	for (const page of pages) for (const objNum of page.referencedObjects) refCount.set(objNum, (refCount.get(objNum) ?? 0) + 1);
+	const sharedObjects = /* @__PURE__ */ new Set();
+	for (const [objNum, count] of refCount) if (count > 1 || catalogObjects.has(objNum)) sharedObjects.add(objNum);
+	for (const page of pages) for (const objNum of sharedObjects) page.referencedObjects.delete(objNum);
+	return {
+		pages,
+		sharedObjects,
+		catalogObjects
+	};
+}
+/**
+* Build a page offset hint table (§F.4.1).
+*
+* The table is a header followed by per-page entries that describe
+* how many objects and bytes each page consumes.
+*/
+function buildPageOffsetHintTable(pages, offsets, objectSizes) {
+	const nPages = pages.length;
+	if (nPages === 0) return new Uint8Array(0);
+	const pageStats = [];
+	for (const page of pages) {
+		const allObjs = [page.pageObjNum, ...page.referencedObjects];
+		let totalBytes = 0;
+		let firstObj = page.pageObjNum;
+		for (const objNum of allObjs) {
+			const size = objectSizes.get(objNum) ?? 0;
+			totalBytes += size;
+			if (objNum < firstObj) firstObj = objNum;
+		}
+		pageStats.push({
+			objCount: allObjs.length,
+			totalBytes,
+			firstObjNum: firstObj
+		});
+	}
+	const leastObjCount = Math.min(...pageStats.map((p) => p.objCount));
+	const maxObjDiff = Math.max(...pageStats.map((p) => p.objCount - leastObjCount));
+	const bitsForObjDiff = maxObjDiff > 0 ? Math.ceil(Math.log2(maxObjDiff + 1)) : 0;
+	const leastPageLen = Math.min(...pageStats.map((p) => p.totalBytes));
+	const maxLenDiff = Math.max(...pageStats.map((p) => p.totalBytes - leastPageLen));
+	const bitsForLenDiff = maxLenDiff > 0 ? Math.ceil(Math.log2(maxLenDiff + 1)) : 0;
+	const firstPageObjOffset = offsets.get(pages[0].pageObjNum) ?? 0;
+	const totalSize = 36 + nPages * 8;
+	const data = new Uint8Array(totalSize);
+	let pos = 0;
+	writeU32BE(data, pos, leastObjCount);
+	pos += 4;
+	writeU32BE(data, pos, firstPageObjOffset);
+	pos += 4;
+	writeU32BE(data, pos, bitsForObjDiff);
+	pos += 4;
+	writeU32BE(data, pos, leastPageLen);
+	pos += 4;
+	writeU32BE(data, pos, bitsForLenDiff);
+	pos += 4;
+	writeU32BE(data, pos, 0);
+	pos += 4;
+	writeU32BE(data, pos, 0);
+	pos += 4;
+	writeU32BE(data, pos, 0);
+	pos += 4;
+	writeU32BE(data, pos, 0);
+	pos += 4;
+	for (const stat of pageStats) {
+		writeU32BE(data, pos, stat.objCount - leastObjCount);
+		pos += 4;
+		writeU32BE(data, pos, stat.totalBytes - leastPageLen);
+		pos += 4;
+	}
+	return data;
+}
+/**
+* Build a shared object hint table (§F.4.2).
+*
+* This describes shared objects — objects referenced by multiple pages.
+*/
+function buildSharedObjectHintTable(sharedObjectNums, offsets, objectSizes) {
+	const nShared = sharedObjectNums.length;
+	if (nShared === 0) return new Uint8Array(0);
+	const totalSize = 20 + nShared * 8;
+	const data = new Uint8Array(totalSize);
+	let pos = 0;
+	const sizes = sharedObjectNums.map((n) => objectSizes.get(n) ?? 0);
+	const leastLen = sizes.length > 0 ? Math.min(...sizes) : 0;
+	const maxLenDiff = sizes.length > 0 ? Math.max(...sizes) - leastLen : 0;
+	const bitsForLenDiff = maxLenDiff > 0 ? Math.ceil(Math.log2(maxLenDiff + 1)) : 0;
+	const firstObjNum = sharedObjectNums.length > 0 ? Math.min(...sharedObjectNums) : 0;
+	const firstObjOffset = offsets.get(firstObjNum) ?? 0;
+	writeU32BE(data, pos, firstObjNum);
+	pos += 4;
+	writeU32BE(data, pos, firstObjOffset);
+	pos += 4;
+	writeU32BE(data, pos, nShared);
+	pos += 4;
+	writeU32BE(data, pos, leastLen);
+	pos += 4;
+	writeU32BE(data, pos, bitsForLenDiff);
+	pos += 4;
+	for (let i = 0; i < nShared; i++) {
+		const off = offsets.get(sharedObjectNums[i]) ?? 0;
+		const size = objectSizes.get(sharedObjectNums[i]) ?? 0;
+		writeU32BE(data, pos, off);
+		pos += 4;
+		writeU32BE(data, pos, size);
+		pos += 4;
+	}
+	return data;
+}
+/** Write a 4-byte big-endian unsigned integer. */
+function writeU32BE(buf, offset, value) {
+	buf[offset] = value >>> 24 & 255;
+	buf[offset + 1] = value >>> 16 & 255;
+	buf[offset + 2] = value >>> 8 & 255;
+	buf[offset + 3] = value & 255;
+}
+/** Compute minimum bytes to represent a value in big-endian. */
+function bytesNeeded(value) {
+	if (value <= 255) return 1;
+	if (value <= 65535) return 2;
+	if (value <= 16777215) return 3;
+	return 4;
+}
+/** Write big-endian integer of given byte width. */
+function writeIntBE(buf, offset, width, value) {
+	for (let i = width - 1; i >= 0; i--) {
+		buf[offset + i] = value & 255;
+		value = value >>> 8;
+	}
+}
+/**
+* Build a cross-reference stream (PDF 1.5+, §7.5.8).
+*
+* Returns the complete indirect object bytes including the `N G obj`
+* header and `endobj`.
+*/
+function buildXrefStream(xrefObjNum, totalSize, entries, rootRef, infoRef, prevXrefOffset) {
+	let maxField2 = 0;
+	let maxField3 = 65535;
+	for (const e of entries.values()) {
+		if (e.field2 > maxField2) maxField2 = e.field2;
+		if (e.field3 > maxField3) maxField3 = e.field3;
+	}
+	const w0 = 1;
+	const w1 = bytesNeeded(maxField2);
+	const w2 = bytesNeeded(maxField3);
+	const entryWidth = w0 + w1 + w2;
+	const streamData = new Uint8Array(totalSize * entryWidth);
+	let pos = 0;
+	writeIntBE(streamData, pos, w0, 0);
+	pos += w0;
+	writeIntBE(streamData, pos, w1, 0);
+	pos += w1;
+	writeIntBE(streamData, pos, w2, 65535);
+	pos += w2;
+	for (let i = 1; i < totalSize; i++) {
+		const entry = entries.get(i);
+		if (entry) {
+			writeIntBE(streamData, pos, w0, entry.type);
+			pos += w0;
+			writeIntBE(streamData, pos, w1, entry.field2);
+			pos += w1;
+			writeIntBE(streamData, pos, w2, entry.field3);
+			pos += w2;
+		} else {
+			writeIntBE(streamData, pos, w0, 0);
+			pos += w0;
+			writeIntBE(streamData, pos, w1, 0);
+			pos += w1;
+			writeIntBE(streamData, pos, w2, 0);
+			pos += w2;
+		}
+	}
+	let dictStr = `<< /Type /XRef /Size ${totalSize}`;
+	dictStr += ` /W [${w0} ${w1} ${w2}]`;
+	dictStr += ` /Root ${rootRef}`;
+	if (infoRef) dictStr += ` /Info ${infoRef}`;
+	if (prevXrefOffset !== void 0) dictStr += ` /Prev ${prevXrefOffset}`;
+	dictStr += ` /Length ${streamData.length}`;
+	dictStr += " >>";
+	const objStr = `${xrefObjNum} 0 obj\n${dictStr}\nstream\n`;
+	const objEnd = "\nendstream\nendobj\n";
+	const headerBytes = encoder$2.encode(objStr);
+	const footerBytes = encoder$2.encode(objEnd);
+	const result = new Uint8Array(headerBytes.length + streamData.length + footerBytes.length);
+	result.set(headerBytes, 0);
+	result.set(streamData, headerBytes.length);
+	result.set(footerBytes, headerBytes.length + streamData.length);
+	return result;
+}
+/**
 * Linearize a PDF document for fast web viewing.
 *
 * This reorganizes the PDF so that:
-* 1. A linearization parameter dictionary appears first
+* 1. A linearization parameter dictionary appears first (§F.2)
 * 2. Objects needed for the first page appear early in the file
-* 3. A hint table describes page offsets
-*
-* Note: This is a simplified linearization. For production use with
-* very large documents, a full implementation following PDF spec
-* Appendix F is recommended.
+* 3. A primary hint stream describes page offsets and shared objects (§F.4)
+* 4. Cross-reference streams are used for all xref data (§7.5.8)
 *
 * @param pdfBytes  The raw PDF bytes.
 * @param options   Linearization options.
@@ -4125,52 +4855,38 @@ async function linearizePdf(pdfBytes, options) {
 	const { entries, trailer } = xrefResult;
 	const objects = /* @__PURE__ */ new Map();
 	for (const [objNum, entry] of entries) if (entry.inUse && objNum > 0) objects.set(objNum, extractObject(pdfBytes, entry.offset));
-	const rootObjNum = parseInt(trailer.rootRef.split(" ")[0], 10);
+	if (objects.size === 0) throw new Error("Cannot linearize: no objects found");
+	const rootObjNum = trailer.rootObjNum;
 	const catalogBytes = objects.get(rootObjNum);
-	let pagesObjNum = 0;
-	if (catalogBytes) {
-		const catalogStr = decoder$2.decode(catalogBytes);
-		const pagesMatch = /\/Pages\s+(\d+)\s+\d+\s+R/.exec(catalogStr);
-		if (pagesMatch) pagesObjNum = parseInt(pagesMatch[1], 10);
-	}
-	let firstPageObjNum = 0;
-	const pagesBytes = objects.get(pagesObjNum);
-	if (pagesBytes) {
-		const pagesStr = decoder$2.decode(pagesBytes);
-		const kidsMatch = /\/Kids\s*\[([\s\S]*?)\]/.exec(pagesStr);
-		if (kidsMatch) {
-			const refs = kidsMatch[1].match(/(\d+)\s+\d+\s+R/g);
-			if (refs && refs.length > _firstPage) {
-				const ref = refs[_firstPage];
-				firstPageObjNum = parseInt(ref.split(" ")[0], 10);
-			}
-		}
-	}
-	const firstPageObjects = /* @__PURE__ */ new Set();
-	firstPageObjects.add(rootObjNum);
-	firstPageObjects.add(pagesObjNum);
-	if (firstPageObjNum > 0) firstPageObjects.add(firstPageObjNum);
-	if (firstPageObjNum > 0) {
-		const pageBytes = objects.get(firstPageObjNum);
-		if (pageBytes) {
-			const refMatches = decoder$2.decode(pageBytes).matchAll(/(\d+)\s+\d+\s+R/g);
-			for (const rm of refMatches) {
-				const refNum = parseInt(rm[1], 10);
-				if (objects.has(refNum)) {
-					firstPageObjects.add(refNum);
-					const innerBytes = objects.get(refNum);
-					if (innerBytes) {
-						const innerRefs = decoder$2.decode(innerBytes).matchAll(/(\d+)\s+\d+\s+R/g);
-						for (const ir of innerRefs) {
-							const irNum = parseInt(ir[1], 10);
-							if (objects.has(irNum)) firstPageObjects.add(irNum);
-						}
-					}
-				}
-			}
-		}
-	}
-	const remainingObjects = [...new Set(objects.keys()).difference(firstPageObjects)].sort((a, b) => a - b);
+	if (!catalogBytes) throw new Error("Cannot linearize: catalog object not found");
+	const catalogStr = decoder$2.decode(catalogBytes);
+	const pagesMatch = /\/Pages\s+(\d+)\s+\d+\s+R/.exec(catalogStr);
+	const pagesObjNum = pagesMatch ? parseInt(pagesMatch[1], 10) : 0;
+	if (pagesObjNum === 0) throw new Error("Cannot linearize: /Pages not found in catalog");
+	const pageObjNums = findPageObjectNumbers(pagesObjNum, objects);
+	const pageCount = pageObjNums.length;
+	if (pageCount === 0) throw new Error("Cannot linearize: no pages found");
+	const firstPageIdx = Math.min(_firstPage, pageCount - 1);
+	const firstPageObjNum = pageObjNums[firstPageIdx];
+	const classification = classifyObjects(pageObjNums, rootObjNum, pagesObjNum, objects);
+	const firstPageExclusiveObjects = classification.pages[firstPageIdx].referencedObjects;
+	const firstPageObjNums = /* @__PURE__ */ new Set();
+	firstPageObjNums.add(rootObjNum);
+	firstPageObjNums.add(pagesObjNum);
+	firstPageObjNums.add(firstPageObjNum);
+	for (const objNum of firstPageExclusiveObjects) firstPageObjNums.add(objNum);
+	for (const objNum of classification.sharedObjects) firstPageObjNums.add(objNum);
+	if (trailer.infoObjNum > 0 && objects.has(trailer.infoObjNum)) firstPageObjNums.add(trailer.infoObjNum);
+	const remainingObjNums = [];
+	for (const objNum of objects.keys()) if (!firstPageObjNums.has(objNum)) remainingObjNums.push(objNum);
+	remainingObjNums.sort((a, b) => a - b);
+	const maxOrigObjNum = Math.max(...objects.keys(), 0);
+	const linObjNum = maxOrigObjNum + 1;
+	const hintObjNum = maxOrigObjNum + 2;
+	const totalObjectCount = maxOrigObjNum + 3;
+	const firstPageObjNumsSorted = [...firstPageObjNums].sort((a, b) => a - b);
+	const objectSizes = /* @__PURE__ */ new Map();
+	for (const [objNum, objBytes] of objects) objectSizes.set(objNum, objBytes.length + 1);
 	const chunks = [];
 	const newOffsets = /* @__PURE__ */ new Map();
 	let currentOffset = 0;
@@ -4185,10 +4901,7 @@ async function linearizePdf(pdfBytes, options) {
 	}
 	writeStr("%PDF-1.7\n");
 	writeStr("%âãÏÓ\n");
-	const linObjNum = trailer.size;
 	const linDictOffset = currentOffset;
-	const linDictPlaceholder = currentOffset;
-	const pageCount = pagesBytes ? decoder$2.decode(pagesBytes).match(/\/Count\s+(\d+)/)?.[1] ?? "1" : "1";
 	writeStr(`${linObjNum} 0 obj\n`);
 	writeStr(`<< /Linearized 1.0\n`);
 	writeStr(`   /L 0000000000\n`);
@@ -4196,11 +4909,11 @@ async function linearizePdf(pdfBytes, options) {
 	writeStr(`   /E 0000000000\n`);
 	writeStr(`   /N ${pageCount}\n`);
 	writeStr(`   /T 0000000000\n`);
+	writeStr(`   /H [0000000000 0000000000]\n`);
 	writeStr(">>\n");
 	writeStr("endobj\n");
 	newOffsets.set(linObjNum, linDictOffset);
-	const firstPageObjNums = firstPageObjects.values().toArray().sort((a, b) => a - b);
-	for (const objNum of firstPageObjNums) {
+	for (const objNum of firstPageObjNumsSorted) {
 		const objBytes = objects.get(objNum);
 		if (objBytes) {
 			newOffsets.set(objNum, currentOffset);
@@ -4209,7 +4922,22 @@ async function linearizePdf(pdfBytes, options) {
 		}
 	}
 	const endOfFirstPage = currentOffset;
-	for (const objNum of remainingObjects) {
+	const hintStreamStart = currentOffset;
+	const pageOffsetHints = buildPageOffsetHintTable(classification.pages, newOffsets, objectSizes);
+	const sharedObjectHints = buildSharedObjectHintTable([...classification.sharedObjects].sort((a, b) => a - b), newOffsets, objectSizes);
+	const hintStreamData = new Uint8Array(pageOffsetHints.length + sharedObjectHints.length);
+	hintStreamData.set(pageOffsetHints, 0);
+	hintStreamData.set(sharedObjectHints, pageOffsetHints.length);
+	const sharedHintOffset = pageOffsetHints.length;
+	writeStr(`${hintObjNum} 0 obj\n`);
+	writeStr(`<< /Length ${hintStreamData.length} /S ${sharedHintOffset} >>\n`);
+	writeStr("stream\n");
+	writeBytes(hintStreamData);
+	writeStr("\nendstream\n");
+	writeStr("endobj\n");
+	newOffsets.set(hintObjNum, hintStreamStart);
+	const hintStreamLength = currentOffset - hintStreamStart;
+	for (const objNum of remainingObjNums) {
 		const objBytes = objects.get(objNum);
 		if (objBytes) {
 			newOffsets.set(objNum, currentOffset);
@@ -4217,34 +4945,200 @@ async function linearizePdf(pdfBytes, options) {
 			writeStr("\n");
 		}
 	}
-	const hintObjNum = linObjNum + 1;
-	const hintData = buildSimpleHintStream(firstPageObjNums, remainingObjects, newOffsets);
-	const hintOffset = currentOffset;
-	writeStr(`${hintObjNum} 0 obj\n`);
-	writeStr(`<< /Length ${hintData.length} /S ${hintData.length} >>\n`);
-	writeStr("stream\n");
-	writeBytes(hintData);
-	writeStr("\nendstream\n");
-	writeStr("endobj\n");
-	newOffsets.set(hintObjNum, hintOffset);
-	const totalSize = linObjNum + 2;
-	const mainXrefOffset = currentOffset;
+	const xrefEntries = /* @__PURE__ */ new Map();
+	for (const [objNum, offset] of newOffsets) xrefEntries.set(objNum, {
+		type: 1,
+		field2: offset,
+		field3: 0
+	});
+	const mainXrefObjNum = totalObjectCount;
+	const mainXrefOffset = currentOffset;
+	writeBytes(buildXrefStream(mainXrefObjNum, mainXrefObjNum + 1, xrefEntries, trailer.rootRef, trailer.infoRef));
+	writeStr("startxref\n");
+	writeStr(`${mainXrefOffset}\n`);
+	writeStr("%%EOF\n");
+	const fileLength = currentOffset;
+	const result = new Uint8Array(fileLength);
+	let pos = 0;
+	for (const chunk of chunks) {
+		result.set(chunk, pos);
+		pos += chunk.length;
+	}
+	patchNumber(result, linDictOffset, "/L ", fileLength);
+	patchNumber(result, linDictOffset, "/E ", endOfFirstPage);
+	patchNumber(result, linDictOffset, "/T ", mainXrefOffset);
+	patchHintArray(result, linDictOffset, hintStreamStart, hintStreamLength);
+	return result;
+}
+/**
+* Remove linearization artifacts from a PDF, producing a normal
+* (non-linearized) PDF.
+*
+* This:
+* 1. Strips the linearization parameter dictionary
+* 2. Removes hint streams
+* 3. Rebuilds the xref table without linearization ordering constraints
+* 4. Removes any /Linearized key from the output
+*
+* If the input PDF is not linearized, it is returned unchanged.
+*
+* @param pdfBytes  The raw PDF bytes.
+* @returns         A non-linearized PDF.
+*/
+async function delinearizePdf(pdfBytes) {
+	if (!isLinearized(pdfBytes)) return pdfBytes;
+	const startXref = findStartXref(pdfBytes);
+	if (startXref < 0) return pdfBytes;
+	if (!decoder$2.decode(pdfBytes.subarray(startXref, Math.min(startXref + 40, pdfBytes.length))).startsWith("xref")) return delinearizeByScanning(pdfBytes);
+	let xrefResult;
+	try {
+		xrefResult = parseXrefTable(pdfBytes, startXref);
+	} catch {
+		return delinearizeByScanning(pdfBytes);
+	}
+	const { entries, trailer } = xrefResult;
+	if (entries.size === 0 || entries.size === 1 && entries.has(0)) return delinearizeByScanning(pdfBytes);
+	const trailerStart = findString(pdfBytes, "trailer", startXref);
+	if (trailerStart >= 0) {
+		const trailerEnd = findString(pdfBytes, ">>", trailerStart) + 2;
+		const trailerStr = decoder$2.decode(pdfBytes.subarray(trailerStart, trailerEnd));
+		const prevMatch = /\/Prev\s+(\d+)/.exec(trailerStr);
+		if (prevMatch) {
+			const prevOffset = parseInt(prevMatch[1], 10);
+			try {
+				const prevXref = parseXrefTable(pdfBytes, prevOffset);
+				for (const [objNum, entry] of prevXref.entries) if (!entries.has(objNum)) entries.set(objNum, entry);
+			} catch {}
+		}
+	}
+	const objects = /* @__PURE__ */ new Map();
+	const linDictObjNums = /* @__PURE__ */ new Set();
+	for (const [objNum, entry] of entries) if (entry.inUse && objNum > 0) {
+		const objBytes = extractObject(pdfBytes, entry.offset);
+		const objStr = decoder$2.decode(objBytes);
+		if (/\/Linearized\s+[\d.]+/.test(objStr)) {
+			linDictObjNums.add(objNum);
+			continue;
+		}
+		if (linDictObjNums.size > 0 && isHintStream(objStr)) continue;
+		objects.set(objNum, objBytes);
+	}
+	return rebuildNormalPdf(objects, trailer);
+}
+/**
+* Check if an object string looks like a hint stream.
+* Hint streams are streams with specific characteristics:
+* they contain /S entries and /Length but no /Type.
+*/
+function isHintStream(objStr) {
+	return /<<[^>]*\/S\s+\d+[^>]*>>[\s\S]*\bstream\b/.test(objStr) && !/\/Type\s*\//.test(objStr) && !/\/Subtype\s*\//.test(objStr) && !/\/Filter\s*\//.test(objStr);
+}
+/**
+* Fallback delinearization that scans for indirect objects
+* instead of relying on xref parsing (handles xref streams).
+*
+* Uses byte-level scanning with `findString` to locate object
+* markers, which avoids problems with binary stream content being
+* misinterpreted as text by regex.
+*/
+function delinearizeByScanning(pdfBytes) {
+	const objects = /* @__PURE__ */ new Map();
+	const str = decoder$2.decode(pdfBytes);
+	const rootMatch = /\/Root\s+(\d+)\s+(\d+)\s+R/.exec(str);
+	const infoMatch = /\/Info\s+(\d+)\s+(\d+)\s+R/.exec(str);
+	const trailer = {
+		size: 0,
+		rootRef: rootMatch ? `${rootMatch[1]} ${rootMatch[2]} R` : "1 0 R",
+		rootObjNum: rootMatch ? parseInt(rootMatch[1], 10) : 1,
+		rootGenNum: rootMatch ? parseInt(rootMatch[2], 10) : 0,
+		infoRef: infoMatch ? `${infoMatch[1]} ${infoMatch[2]} R` : void 0,
+		infoObjNum: infoMatch ? parseInt(infoMatch[1], 10) : 0,
+		infoGenNum: infoMatch ? parseInt(infoMatch[2], 10) : 0
+	};
+	let searchPos = 0;
+	while (searchPos < pdfBytes.length) {
+		const markerPos = findString(pdfBytes, " 0 obj", searchPos);
+		if (markerPos < 0) break;
+		let numStart = markerPos - 1;
+		while (numStart >= 0 && pdfBytes[numStart] >= 48 && pdfBytes[numStart] <= 57) numStart--;
+		numStart++;
+		if (numStart > 0) {
+			const prevByte = pdfBytes[numStart - 1];
+			if (prevByte !== 10 && prevByte !== 13 && prevByte !== 32) {
+				searchPos = markerPos + 6;
+				continue;
+			}
+		}
+		if (numStart >= markerPos) {
+			searchPos = markerPos + 6;
+			continue;
+		}
+		const objNumStr = decoder$2.decode(pdfBytes.subarray(numStart, markerPos));
+		const objNum = parseInt(objNumStr, 10);
+		if (Number.isNaN(objNum)) {
+			searchPos = markerPos + 6;
+			continue;
+		}
+		const objStart = numStart;
+		const objBytes = extractObject(pdfBytes, objStart);
+		const objStr = decoder$2.decode(objBytes);
+		const endObjPos = findString(pdfBytes, "endobj", objStart);
+		if (endObjPos < 0) {
+			searchPos = markerPos + 6;
+			continue;
+		}
+		searchPos = endObjPos + 6;
+		if (/\/Linearized\s+[\d.]+/.test(objStr)) continue;
+		if (/\/Type\s*\/XRef/.test(objStr)) continue;
+		if (isHintStream(objStr)) continue;
+		objects.set(objNum, objBytes);
+	}
+	trailer.size = objects.size > 0 ? Math.max(...objects.keys(), 0) + 1 : 1;
+	return rebuildNormalPdf(objects, trailer);
+}
+/**
+* Rebuild a normal (non-linearized) PDF from collected objects.
+*/
+function rebuildNormalPdf(objects, trailer) {
+	const chunks = [];
+	const newOffsets = /* @__PURE__ */ new Map();
+	let currentOffset = 0;
+	function writeStr(s) {
+		const bytes = encoder$2.encode(s);
+		chunks.push(bytes);
+		currentOffset += bytes.length;
+	}
+	function writeBytes(data) {
+		chunks.push(data);
+		currentOffset += data.length;
+	}
+	writeStr("%PDF-1.7\n");
+	writeStr("%âãÏÓ\n");
+	const sortedObjNums = [...objects.keys()].sort((a, b) => a - b);
+	for (const objNum of sortedObjNums) {
+		const objBytes = objects.get(objNum);
+		newOffsets.set(objNum, currentOffset);
+		writeBytes(objBytes);
+		writeStr("\n");
+	}
+	const xrefSize = (sortedObjNums.length > 0 ? Math.max(...sortedObjNums) : 0) + 1;
+	const xrefOffset = currentOffset;
 	writeStr("xref\n");
-	writeStr(`0 ${totalSize}\n`);
+	writeStr(`0 ${xrefSize}\n`);
 	writeStr("0000000000 65535 f \n");
-	for (let i = 1; i < totalSize; i++) {
+	for (let i = 1; i < xrefSize; i++) {
 		const off = newOffsets.get(i);
 		if (off !== void 0) writeStr(`${off.toString().padStart(10, "0")} 00000 n \n`);
 		else writeStr("0000000000 00000 f \n");
 	}
 	writeStr("trailer\n");
 	writeStr("<<\n");
-	writeStr(`/Size ${totalSize}\n`);
+	writeStr(`/Size ${xrefSize}\n`);
 	writeStr(`/Root ${trailer.rootRef}\n`);
 	if (trailer.infoRef) writeStr(`/Info ${trailer.infoRef}\n`);
 	writeStr(">>\n");
 	writeStr("startxref\n");
-	writeStr(`${mainXrefOffset}\n`);
+	writeStr(`${xrefOffset}\n`);
 	writeStr("%%EOF\n");
 	const fileLength = currentOffset;
 	const result = new Uint8Array(fileLength);
@@ -4253,24 +5147,8 @@ async function linearizePdf(pdfBytes, options) {
 		result.set(chunk, pos);
 		pos += chunk.length;
 	}
-	patchNumber(result, linDictPlaceholder, "/L ", fileLength);
-	patchNumber(result, linDictPlaceholder, "/E ", endOfFirstPage);
-	patchNumber(result, linDictPlaceholder, "/T ", mainXrefOffset);
 	return result;
 }
-/** Build a simplified hint stream. */
-function buildSimpleHintStream(firstPageObjs, remainingObjs, offsets) {
-	const allObjNums = [...firstPageObjs, ...remainingObjs];
-	const data = new Uint8Array(allObjNums.length * 4);
-	for (let i = 0; i < allObjNums.length; i++) {
-		const off = offsets.get(allObjNums[i]) ?? 0;
-		data[i * 4] = off >>> 24 & 255;
-		data[i * 4 + 1] = off >>> 16 & 255;
-		data[i * 4 + 2] = off >>> 8 & 255;
-		data[i * 4 + 3] = off & 255;
-	}
-	return data;
-}
 /** Patch a 10-digit number placeholder in the output. */
 function patchNumber(data, searchStart, prefix, value) {
 	const prefixBytes = encoder$2.encode(prefix);
@@ -4283,6 +5161,21 @@ function patchNumber(data, searchStart, prefix, value) {
 		return;
 	}
 }
+/**
+* Patch the /H [offset length] hint array in the linearization dict.
+*/
+function patchHintArray(data, searchStart, hintOffset, hintLength) {
+	const prefix = encoder$2.encode("/H [");
+	const searchEnd = Math.min(searchStart + 500, data.length);
+	outer: for (let i = searchStart; i < searchEnd - prefix.length; i++) {
+		for (let j = 0; j < prefix.length; j++) if (data[i + j] !== prefix[j]) continue outer;
+		const combined = `${hintOffset.toString().padStart(10, "0")} ${hintLength.toString().padStart(10, "0")}`;
+		const numBytes = encoder$2.encode(combined);
+		const writeStart = i + prefix.length;
+		for (let k = 0; k < numBytes.length && writeStart + k < data.length; k++) data[writeStart + k] = numBytes[k];
+		return;
+	}
+}
 
 //#endregion
 //#region src/utils/binary.ts
@@ -6321,6 +7214,99 @@ async function enforcePdfAFull(pdfBytes, level, options = {}) {
 	};
 }
 
+//#endregion
+//#region src/annotation/applyRedactions.ts
+/** Format a number for PDF operator output. */
+function n$4(value) {
+	if (Number.isInteger(value)) return value.toString();
+	const s = value.toFixed(6).replace(/\.?0+$/, "");
+	return s === "-0" ? "0" : s;
+}
+/**
+* Check whether an annotation is a /Redact subtype.
+*/
+function isRedactAnnotation(annot) {
+	return annot.getType() === "Redact";
+}
+/**
+* Build the PDF operator string that renders the redaction overlay.
+*
+* The operators draw a filled rectangle in the interior colour
+* and optionally render overlay text on top.
+*/
+function buildRedactionOperators(rect, interiorColor, overlayText) {
+	const [x1, y1, x2, y2] = rect;
+	const x = Math.min(x1, x2);
+	const y = Math.min(y1, y2);
+	const w = Math.abs(x2 - x1);
+	const h = Math.abs(y2 - y1);
+	const { r, g, b } = interiorColor ?? {
+		r: 0,
+		g: 0,
+		b: 0
+	};
+	let ops = "";
+	ops += "q\n";
+	ops += `${n$4(r)} ${n$4(g)} ${n$4(b)} rg\n`;
+	ops += `${n$4(x)} ${n$4(y)} ${n$4(w)} ${n$4(h)} re\n`;
+	ops += "f\n";
+	if (overlayText) {
+		const tc = r * .299 + g * .587 + b * .114 > .5 ? 0 : 1;
+		const fontSize = Math.min(h * .6, 10);
+		const textX = x + 2;
+		const textY = y + h / 2 - fontSize / 3;
+		ops += `${n$4(tc)} ${n$4(tc)} ${n$4(tc)} rg\n`;
+		ops += "BT\n";
+		ops += `/Helvetica ${n$4(fontSize)} Tf\n`;
+		ops += `${n$4(textX)} ${n$4(textY)} Td\n`;
+		const escaped = overlayText.replaceAll("\\", "\\\\").replaceAll("(", "\\(").replaceAll(")", "\\)");
+		ops += `(${escaped}) Tj\n`;
+		ops += "ET\n";
+	}
+	ops += "Q\n";
+	return ops;
+}
+/**
+* Apply a single redaction annotation on a page.
+*
+* Draws the redaction overlay and removes the annotation from the page.
+*
+* @returns `true` if the annotation was a redaction and was applied.
+*/
+function applyOneRedaction(page, annot) {
+	if (!isRedactAnnotation(annot)) return false;
+	const ops = buildRedactionOperators(annot.getRect(), annot.getInteriorColor(), annot.getOverlayText());
+	page.pushOperators(ops);
+	page.removeAnnotation(annot);
+	return true;
+}
+/**
+* Apply a single redaction annotation identified by page and annotation
+* index.
+*
+* @param doc         The PDF document.
+* @param pageIndex   Zero-based page index.
+* @param annotIndex  Zero-based annotation index within the page.
+* @returns           A {@link RedactionResult} (appliedCount 0 or 1).
+* @throws            RangeError if pageIndex or annotIndex is out of bounds.
+* @throws            TypeError if the annotation at annotIndex is not a
+*                    /Redact annotation.
+*/
+function applyRedaction(doc, pageIndex, annotIndex) {
+	const pages = doc.getPages();
+	if (pageIndex < 0 || pageIndex >= pages.length) throw new RangeError(`applyRedaction: pageIndex ${pageIndex} out of range [0, ${pages.length - 1}]`);
+	const page = pages[pageIndex];
+	const annotations = page.getAnnotations();
+	if (annotIndex < 0 || annotIndex >= annotations.length) throw new RangeError(`applyRedaction: annotIndex ${annotIndex} out of range [0, ${annotations.length - 1}]`);
+	const annot = annotations[annotIndex];
+	if (!isRedactAnnotation(annot)) throw new TypeError(`applyRedaction: annotation at index ${annotIndex} is type '${annot.getType()}', not 'Redact'`);
+	applyOneRedaction(page, annot);
+	return {
+		appliedCount: 1,
+		pages: [pageIndex]
+	};
+}
+
 //#endregion
 //#region src/assets/image/imageOptimize.ts
 /**
@@ -6786,7 +7772,7 @@ async function recompressDeflate(image, level) {
 * @internal
 */
 async function recompressJpeg(image, quality, progressive = false, chromaSubsampling = "4:2:0") {
-	const { encodeJpegWasm, isJpegWasmReady } = await import("./bridge-CcivG_Sm.mjs").then((n) => n.t);
+	const { encodeJpegWasm, isJpegWasmReady } = await import("./bridge-DaS-gzEd.mjs").then((n) => n.t);
 	if (isJpegWasmReady()) {
 		let pixels = image.pixels;
 		let channels = image.channels;
@@ -10018,7 +11004,7 @@ function encodeCode128(data) {
 	return valuesToModules(encodeCode128Values(data));
 }
 /** Format a number for PDF output. */
-function n$2(value) {
+function n$3(value) {
 	if (Number.isInteger(value)) return value.toString();
 	const s = value.toFixed(6).replace(/\.?0+$/, "");
 	return s === "-0" ? "0" : s;
@@ -10054,7 +11040,7 @@ function code128ToOperators(matrix, x, y, options) {
 		else if (!isBar && barStart !== -1) {
 			const barX = startX + barStart * moduleWidth;
 			const barWidth = (i - barStart) * moduleWidth;
-			ops += `${n$2(barX)} ${n$2(y)} ${n$2(barWidth)} ${n$2(height)} re\n`;
+			ops += `${n$3(barX)} ${n$3(y)} ${n$3(barWidth)} ${n$3(height)} re\n`;
 			barStart = -1;
 		}
 	}
@@ -10629,7 +11615,7 @@ function encodeCode39(data, includeCheckDigit = false, wideToNarrowRatio = 3) {
 	};
 }
 /** Format a number for PDF output. */
-function n$1(value) {
+function n$2(value) {
 	if (Number.isInteger(value)) return value.toString();
 	const s = value.toFixed(6).replace(/\.?0+$/, "");
 	return s === "-0" ? "0" : s;
@@ -10665,7 +11651,7 @@ function code39ToOperators(matrix, x, y, options) {
 		else if (!isBar && barStart !== -1) {
 			const barX = startX + barStart * moduleWidth;
 			const barWidth = (i - barStart) * moduleWidth;
-			ops += `${n$1(barX)} ${n$1(y)} ${n$1(barWidth)} ${n$1(height)} re\n`;
+			ops += `${n$2(barX)} ${n$2(y)} ${n$2(barWidth)} ${n$2(height)} re\n`;
 			barStart = -1;
 		}
 	}
@@ -10738,7 +11724,7 @@ function encodeItf(data, wideToNarrowRatio = 3) {
 	};
 }
 /** Format a number for PDF output. */
-function n(value) {
+function n$1(value) {
 	if (Number.isInteger(value)) return value.toString();
 	const s = value.toFixed(6).replace(/\.?0+$/, "");
 	return s === "-0" ? "0" : s;
@@ -10772,8 +11758,8 @@ function itfToOperators(matrix, x, y, options) {
 	const startX = x + quietZone * moduleWidth;
 	const totalWidth = matrix.width * moduleWidth;
 	if (bearerBars) {
-		ops += `${n(startX)} ${n(y)} ${n(totalWidth)} ${n(bearerBarWidth)} re\n`;
-		ops += `${n(startX)} ${n(y + height - bearerBarWidth)} ${n(totalWidth)} ${n(bearerBarWidth)} re\n`;
+		ops += `${n$1(startX)} ${n$1(y)} ${n$1(totalWidth)} ${n$1(bearerBarWidth)} re\n`;
+		ops += `${n$1(startX)} ${n$1(y + height - bearerBarWidth)} ${n$1(totalWidth)} ${n$1(bearerBarWidth)} re\n`;
 	}
 	const barY = bearerBars ? y + bearerBarWidth : y;
 	const barHeight = bearerBars ? height - 2 * bearerBarWidth : height;
@@ -10784,7 +11770,7 @@ function itfToOperators(matrix, x, y, options) {
 		else if (!isBar && barStart !== -1) {
 			const barX = startX + barStart * moduleWidth;
 			const barW = (i - barStart) * moduleWidth;
-			ops += `${n(barX)} ${n(barY)} ${n(barW)} ${n(barHeight)} re\n`;
+			ops += `${n$1(barX)} ${n$1(barY)} ${n$1(barW)} ${n$1(barHeight)} re\n`;
 			barStart = -1;
 		}
 	}
@@ -14611,6 +15597,601 @@ var ExceededMaxLengthError = class extends Error {
 	}
 };
 
+//#endregion
+//#region src/form/formFlatten.ts
+/**
+* @module form/formFlatten
+*
+* Flatten interactive form fields into static page content.
+*
+* Form flattening converts interactive AcroForm fields into non-editable
+* page content by merging each field's appearance stream into the page's
+* content stream as a Form XObject, then removing the interactive form
+* structure (widget annotations and the AcroForm dictionary).
+*
+* This is a common enterprise requirement for producing final,
+* non-editable PDFs (e.g. invoices, contracts, government forms).
+*
+* Reference: PDF 1.7 spec, SS12.5.5 (Appearance Streams),
+*            SS12.7 (Interactive Forms).
+*/
+/** Format a number for PDF content stream output. */
+function n(value) {
+	if (Number.isInteger(value)) return value.toString();
+	const s = value.toFixed(6).replace(/\.?0+$/, "");
+	return s === "-0" ? "0" : s;
+}
+/**
+* Get the normal (/N) appearance stream from a field's widget dictionary.
+*
+* Checks the /AP dictionary for a /N entry that is a PdfStream.
+* If /AP is absent or /N is not a stream, returns `undefined`.
+*/
+function getAppearanceStream(widgetDict) {
+	const ap = widgetDict.get("/AP");
+	if (ap === void 0 || ap.kind !== "dict") return void 0;
+	const nObj = ap.get("/N");
+	if (nObj === void 0) return void 0;
+	if (nObj.kind === "stream") return nObj;
+	if (nObj.kind === "dict") {
+		const nDict = nObj;
+		const asObj = widgetDict.get("/AS");
+		if (asObj !== void 0 && asObj.kind === "name") {
+			const stateName = asObj.value;
+			const stateStream = nDict.get(stateName);
+			if (stateStream !== void 0 && stateStream.kind === "stream") return stateStream;
+		}
+		for (const [key, value] of nDict) if ((key.startsWith("/") ? key.slice(1) : key) !== "Off" && value.kind === "stream") return value;
+	}
+}
+/**
+* Extract the widget rectangle as `[x1, y1, x2, y2]`.
+*/
+function getWidgetRect(widgetDict) {
+	const rectObj = widgetDict.get("/Rect");
+	if (rectObj !== void 0 && rectObj.kind === "array") {
+		const arr = rectObj;
+		return [
+			numVal(arr.items[0]) ?? 0,
+			numVal(arr.items[1]) ?? 0,
+			numVal(arr.items[2]) ?? 0,
+			numVal(arr.items[3]) ?? 0
+		];
+	}
+	return [
+		0,
+		0,
+		0,
+		0
+	];
+}
+/**
+* Build the content stream operators that paint a Form XObject
+* at the position and size defined by the widget rectangle.
+*
+* Uses the XObject's BBox to determine scaling. If no BBox is found,
+* the widget dimensions are used as a 1:1 mapping.
+*/
+function buildFlattenOps(xObjectName, rect, appearance) {
+	const [x1, y1, x2, y2] = rect;
+	const width = Math.abs(x2 - x1);
+	const height = Math.abs(y2 - y1);
+	if (width <= 0 || height <= 0) return "";
+	let bboxWidth = width;
+	let bboxHeight = height;
+	const bboxObj = appearance.dict.get("/BBox");
+	if (bboxObj !== void 0 && bboxObj.kind === "array") {
+		const bboxArr = bboxObj;
+		const bx1 = numVal(bboxArr.items[0]) ?? 0;
+		const by1 = numVal(bboxArr.items[1]) ?? 0;
+		const bx2 = numVal(bboxArr.items[2]) ?? width;
+		const by2 = numVal(bboxArr.items[3]) ?? height;
+		bboxWidth = Math.abs(bx2 - bx1);
+		bboxHeight = Math.abs(by2 - by1);
+	}
+	const sx = bboxWidth > 0 ? width / bboxWidth : 1;
+	const sy = bboxHeight > 0 ? height / bboxHeight : 1;
+	let ops = "";
+	ops += "q\n";
+	ops += `${n(sx)} 0 0 ${n(sy)} ${n(Math.min(x1, x2))} ${n(Math.min(y1, y2))} cm\n`;
+	ops += `/${xObjectName} Do\n`;
+	ops += "Q\n";
+	return ops;
+}
+/**
+* Check whether a field should be skipped based on flatten options.
+*/
+function shouldSkipField(field, options) {
+	if (options.preserveReadOnly && field.isReadOnly()) return true;
+	return false;
+}
+/** Monotonically increasing counter for unique XObject names. */
+let flattenXObjectCounter = 0;
+/**
+* Flatten a single field: extract its appearance, build operators,
+* and return the result without mutating any form/page state.
+*/
+function flattenSingleField(field) {
+	const result = {
+		ops: "",
+		xObjects: []
+	};
+	const generatedAppearance = field.generateAppearance();
+	const widgetDict = field.getWidgetDict();
+	const appearance = getAppearanceStream(widgetDict) ?? generatedAppearance;
+	const rect = getWidgetRect(widgetDict);
+	const w = Math.abs(rect[2] - rect[0]);
+	const h = Math.abs(rect[3] - rect[1]);
+	if (w <= 0 || h <= 0) return result;
+	if (!appearance.dict.has("/Type")) appearance.dict.set("/Type", PdfName.of("XObject"));
+	if (!appearance.dict.has("/Subtype")) appearance.dict.set("/Subtype", PdfName.of("Form"));
+	if (!appearance.dict.has("/BBox")) appearance.dict.set("/BBox", PdfArray.fromNumbers([
+		0,
+		0,
+		w,
+		h
+	]));
+	const xObjName = `FlatField${flattenXObjectCounter++}`;
+	const ops = buildFlattenOps(xObjName, rect, appearance);
+	if (ops.length > 0) {
+		result.ops = ops;
+		result.xObjects.push({
+			name: xObjName,
+			stream: appearance
+		});
+	}
+	return result;
+}
+/**
+* Flatten ALL form fields into static page content.
+*
+* For each field in the document's AcroForm:
+* 1. Generate / retrieve the field's appearance stream
+* 2. Embed the appearance as a Form XObject in the page's content stream
+* 3. Remove the widget annotation from the page
+* 4. Remove the field from the AcroForm
+*
+* After all fields are processed, the /AcroForm dictionary is cleared.
+*
+* @param form     The document's PdfForm.
+* @param options  Optional flatten options.
+* @returns An object describing the flatten operations performed, suitable
+*          for the caller to apply to page content streams and resources.
+*/
+function flattenForm(form, options = {}) {
+	return flattenFieldList(form, form.getFields(), options, true);
+}
+/**
+* Flatten a SINGLE field by name.
+*
+* Locates the field in the form, merges its appearance into the page
+* content, removes the widget annotation, and removes the field from
+* the AcroForm's /Fields array. Other fields remain interactive.
+*
+* @param form       The document's PdfForm.
+* @param fieldName  The name of the field to flatten (partial or fully-qualified).
+* @param options    Optional flatten options.
+* @returns An object describing the flatten operations performed.
+* @throws If the field is not found.
+*/
+function flattenField(form, fieldName, options = {}) {
+	const field = form.getField(fieldName);
+	if (field === void 0) throw new Error(`Form field "${fieldName}" not found.`);
+	return flattenFieldList(form, [field], options, false);
+}
+/**
+* Flatten specific fields by name.
+*
+* @param form        The document's PdfForm.
+* @param fieldNames  Array of field names to flatten.
+* @param options     Optional flatten options.
+* @returns An object describing the flatten operations performed.
+* @throws If any field name is not found.
+*/
+function flattenFields(form, fieldNames, options = {}) {
+	const fields = [];
+	for (const name of fieldNames) {
+		const field = form.getField(name);
+		if (field === void 0) throw new Error(`Form field "${name}" not found.`);
+		fields.push(field);
+	}
+	return flattenFieldList(form, fields, options, false);
+}
+/**
+* Internal workhorse: flatten a list of fields and optionally
+* clear the AcroForm entirely.
+*/
+function flattenFieldList(form, fields, options, removeAcroForm) {
+	const result = {
+		contentOps: "",
+		xObjects: [],
+		flattenedFields: [],
+		skippedFields: [],
+		acroFormRemoved: false
+	};
+	for (const field of fields) {
+		if (shouldSkipField(field, options)) {
+			result.skippedFields.push(field.getFullName());
+			continue;
+		}
+		const fieldResult = flattenSingleField(field);
+		result.contentOps += fieldResult.ops;
+		result.xObjects.push(...fieldResult.xObjects);
+		result.flattenedFields.push(field.getFullName());
+		try {
+			form.removeField(field.getFullName());
+		} catch {
+			try {
+				form.removeField(field.getName());
+			} catch {}
+		}
+	}
+	if (removeAcroForm) {
+		if (form.getFields().length === 0 && result.skippedFields.length === 0) result.acroFormRemoved = true;
+	}
+	return result;
+}
+
+//#endregion
+//#region src/core/outlines.ts
+/**
+* Add a bookmark entry to the document's outline tree.
+*
+* @param doc      The document to add the bookmark to.
+* @param options  Bookmark configuration (title, page, nesting, style).
+* @returns        A {@link BookmarkRef} identifying the new bookmark.
+*/
+function addBookmark(doc, options) {
+	const { title, pageIndex, parent, y, bold, italic, color, isOpen } = options;
+	const dest = y !== void 0 ? {
+		type: "page",
+		pageIndex,
+		fit: "FitH",
+		top: y
+	} : {
+		type: "page",
+		pageIndex,
+		fit: "Fit"
+	};
+	const itemOptions = {};
+	if (bold !== void 0) itemOptions.bold = bold;
+	if (italic !== void 0) itemOptions.italic = italic;
+	if (color !== void 0) itemOptions.color = color;
+	if (isOpen !== void 0) itemOptions.isOpen = isOpen;
+	let item;
+	if (parent !== void 0) item = parent._item.addChild(title, dest, itemOptions);
+	else item = doc.getOutlines().addItem(title, dest, itemOptions);
+	return { _item: item };
+}
+/**
+* Return the bookmark tree for the document.
+*
+* Returns an array of top-level {@link BookmarkNode} objects, each
+* with a `children` array for nested bookmarks.
+*
+* @param doc  The document to read bookmarks from.
+* @returns    The bookmark tree.
+*/
+function getBookmarks(doc) {
+	return doc.getOutlines().items.map(itemToNode);
+}
+/**
+* Remove a specific bookmark from the document.
+*
+* If the bookmark has children, they are also removed.
+*
+* @param doc  The document to modify.
+* @param ref  The handle of the bookmark to remove.
+* @throws     If the bookmark is not found in the tree.
+*/
+function removeBookmark(doc, ref) {
+	const tree = doc.getOutlines();
+	const target = ref._item;
+	const topIndex = tree.items.indexOf(target);
+	if (topIndex !== -1) {
+		tree.items.splice(topIndex, 1);
+		return;
+	}
+	if (removeFromChildren(tree.items, target)) return;
+	throw new Error("Bookmark not found in the outline tree");
+}
+/**
+* Remove all bookmarks from the document.
+*
+* @param doc  The document to clear bookmarks from.
+*/
+function removeAllBookmarks(doc) {
+	const tree = doc.getOutlines();
+	tree.items.length = 0;
+}
+/**
+* Convert a PdfOutlineItem to a BookmarkNode recursively.
+* @internal
+*/
+function itemToNode(item) {
+	const dest = item.destination;
+	return {
+		title: item.title,
+		pageIndex: dest.pageIndex ?? 0,
+		y: dest.top,
+		bold: item.bold,
+		italic: item.italic,
+		color: item.color,
+		children: item.children.map(itemToNode),
+		ref: { _item: item }
+	};
+}
+/**
+* Recursively search for and remove a target item from nested children.
+* @internal
+*/
+function removeFromChildren(items, target) {
+	for (const item of items) {
+		const childIndex = item.children.indexOf(target);
+		if (childIndex !== -1) {
+			item.children.splice(childIndex, 1);
+			return true;
+		}
+		if (removeFromChildren(item.children, target)) return true;
+	}
+	return false;
+}
+
+//#endregion
+//#region src/batch/batchProcessor.ts
+/**
+* @module batch/batchProcessor
+*
+* Parallel batch processing for multiple PDF documents.
+*
+* Uses `worker_threads` when running in Node.js for true parallelism,
+* and falls back to concurrent (but single-threaded) `Promise.all`
+* processing in other runtimes (browsers, Cloudflare Workers, Deno, Bun).
+*
+* Entry points:
+* - {@link processBatch} — run an arbitrary operation on multiple PDFs
+* - {@link batchMerge} — merge multiple PDFs in parallel chunks
+* - {@link batchFlatten} — flatten forms across many PDFs
+*
+* @packageDocumentation
+*/
+/**
+* Process an array of tasks with bounded concurrency.
+*
+* Unlike a simple `Promise.all`, this ensures at most `concurrency`
+* tasks run simultaneously, which is critical when each task may
+* allocate significant memory (parsing/saving a PDF).
+*/
+async function runWithConcurrency(tasks, concurrency) {
+	const results = new Array(tasks.length);
+	let nextIndex = 0;
+	const worker = async () => {
+		while (nextIndex < tasks.length) {
+			const idx = nextIndex++;
+			results[idx] = await tasks[idx]();
+		}
+	};
+	const workers = Array.from({ length: Math.min(concurrency, tasks.length) }, () => worker());
+	await Promise.all(workers);
+	return results;
+}
+/**
+* Process multiple PDFs in parallel (or with bounded concurrency).
+*
+* Each input `Uint8Array` is loaded as a {@link PdfDocument}, the
+* caller-supplied `operation` is applied, and the resulting bytes
+* are collected.
+*
+* In Node.js, true parallelism is available via `worker_threads`
+* (though this implementation uses async concurrency for simplicity
+* and to avoid serialization overhead). In all runtimes the
+* concurrency limiter ensures memory pressure stays manageable.
+*
+* @param files      Array of raw PDF bytes.
+* @param operation  An async function that receives a loaded
+*                   {@link PdfDocument} and returns the processed
+*                   PDF as `Uint8Array`.
+* @param options    Concurrency and progress options.
+* @returns          A {@link BatchResult} with outputs, success
+*                   count, and any per-file errors.
+*/
+async function processBatch(files, operation, options) {
+	if (files.length === 0) return {
+		outputs: [],
+		successCount: 0,
+		errors: /* @__PURE__ */ new Map()
+	};
+	const defaultConcurrency = detectRuntime() === "node" ? 4 : files.length;
+	const concurrency = options?.concurrency ?? defaultConcurrency;
+	const onProgress = options?.onProgress;
+	let doneCount = 0;
+	const errors = /* @__PURE__ */ new Map();
+	const outputs = new Array(files.length);
+	await runWithConcurrency(files.map((fileBytes, idx) => async () => {
+		try {
+			outputs[idx] = await operation(await PdfDocument.load(fileBytes));
+		} catch (err) {
+			errors.set(idx, err instanceof Error ? err : new Error(String(err)));
+			outputs[idx] = new Uint8Array(0);
+		} finally {
+			doneCount++;
+			onProgress?.(doneCount, files.length);
+		}
+	}), Math.max(1, concurrency));
+	return {
+		outputs,
+		successCount: files.length - errors.size,
+		errors
+	};
+}
+/**
+* Merge multiple PDFs in parallel chunks, then merge the chunks.
+*
+* For large collections this is significantly faster than sequential
+* merging because parsing and page-copying can overlap.
+*
+* @param files    Array of raw PDF bytes to merge (in order).
+* @param options  Concurrency and progress options.
+* @returns        The merged PDF as `Uint8Array`.
+*/
+async function batchMerge(files, options) {
+	if (files.length === 0) return createPdf().save();
+	if (files.length === 1) return (await PdfDocument.load(files[0])).save();
+	const concurrency = options?.concurrency ?? 4;
+	const onProgress = options?.onProgress;
+	const chunkSize = Math.max(1, Math.ceil(files.length / concurrency));
+	const chunks = [];
+	for (let i = 0; i < files.length; i += chunkSize) chunks.push(files.slice(i, i + chunkSize));
+	let doneChunks = 0;
+	const result = await mergePdfs(await runWithConcurrency(chunks.map((chunk) => async () => {
+		const docs = [];
+		for (const fileBytes of chunk) docs.push(await PdfDocument.load(fileBytes));
+		const merged = await mergePdfs(docs);
+		doneChunks++;
+		onProgress?.(doneChunks, chunks.length + 1);
+		return merged;
+	}), concurrency));
+	onProgress?.(chunks.length + 1, chunks.length + 1);
+	return result.save();
+}
+/**
+* Flatten interactive form fields across many PDFs.
+*
+* Each PDF is loaded, its form is flattened (field values are burned
+* into page content), and the result is saved.
+*
+* @param files    Array of raw PDF bytes.
+* @param options  Concurrency and progress options.
+* @returns        A {@link BatchResult} with flattened PDF outputs.
+*/
+async function batchFlatten(files, options) {
+	return processBatch(files, async (doc) => {
+		try {
+			doc.getForm().flatten();
+		} catch {}
+		return doc.save();
+	}, options);
+}
+
+//#endregion
+//#region src/wasm/inlineWasm.ts
+/**
+* @module wasm/inlineWasm
+*
+* Provides runtime access to inline (base64-encoded) WASM module bytes.
+*
+* This module is the runtime companion to the build-time code generation
+* script `scripts/generate-inline-wasm.ts`. It imports the generated
+* constants from `inlineWasm.generated.ts` and exposes a single function,
+* {@link getInlineWasmBytes}, that decodes a module's base64 string into
+* a `Uint8Array` on demand.
+*
+* Design:
+* - The heavy lifting (reading WASM files, base64 encoding) happens at
+*   **build time** via the code generation script.
+* - At **runtime**, only a single base64 decode is needed per module,
+*   and the result is cached.
+* - This approach avoids shipping base64 strings in the default bundle.
+*   The generated file is only imported when inline WASM is needed
+*   (e.g., as a fallback when no WASM path is configured).
+*
+* @packageDocumentation
+*/
+/**
+* The set of all WASM module names supported by the library.
+*
+* These correspond to the crate directories under `src/wasm/`.
+*/
+const WASM_MODULE_NAMES = [
+	"libdeflate",
+	"png",
+	"ttf",
+	"shaping",
+	"jbig2",
+	"jpeg"
+];
+/** Cache of decoded WASM bytes, keyed by module name. */
+const decodedCache = /* @__PURE__ */ new Map();
+/**
+* Retrieve the decoded WASM bytes for a given module name.
+*
+* On first call for a module, the base64 string from the generated file
+* is decoded into a `Uint8Array`. Subsequent calls return the cached
+* result.
+*
+* @param name  The WASM module name (e.g., `'libdeflate'`, `'png'`).
+* @returns     The decoded WASM binary as a `Uint8Array`.
+* @throws      If the module name is unknown or the generated file does
+*              not contain data for the requested module.
+*
+* @example
+* ```ts
+* const wasmBytes = getInlineWasmBytes('libdeflate');
+* const module = await WebAssembly.compile(wasmBytes);
+* ```
+*/
+function getInlineWasmBytes(name) {
+	if (!isValidModuleName(name)) throw new Error(`Unknown WASM module: "${name}". Valid modules: ${WASM_MODULE_NAMES.join(", ")}`);
+	const cached = decodedCache.get(name);
+	if (cached) return cached;
+	let base64Data;
+	try {
+		const moduleData = requireGenerated().INLINE_WASM_MODULES[name];
+		if (!moduleData) throw new Error(`WASM module "${name}" is not available in the generated inline data. Run \`npm run generate:wasm-inline\` to regenerate.`);
+		base64Data = moduleData;
+	} catch (err) {
+		if (err instanceof Error && err.message.includes("is not available")) throw err;
+		throw new Error(`Failed to load inline WASM data for module "${name}". The generated file may not exist. Run \`npm run generate:wasm-inline\` to generate it. Original error: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	const bytes = Uint8Array.fromBase64(base64Data);
+	decodedCache.set(name, bytes);
+	return bytes;
+}
+/**
+* Check whether a given module name is a valid WASM module name.
+*
+* @param name  The name to check.
+* @returns     `true` if the name is one of the known WASM modules.
+*/
+function isValidModuleName(name) {
+	return WASM_MODULE_NAMES.includes(name);
+}
+/**
+* Check whether inline WASM data is available for a given module.
+*
+* Returns `true` if the generated file contains base64 data for the
+* requested module. Returns `false` if the generated file does not
+* exist or does not include the module.
+*
+* @param name  The WASM module name.
+* @returns     `true` if inline bytes can be retrieved for this module.
+*/
+function hasInlineWasmData(name) {
+	if (!isValidModuleName(name)) return false;
+	try {
+		return name in requireGenerated().INLINE_WASM_MODULES;
+	} catch {
+		return false;
+	}
+}
+/** Cached reference to the generated module, loaded once. */
+let generatedModule;
+/**
+* Lazily load and cache the generated module.
+*
+* Uses a dynamic import expression to avoid hard compile-time dependency
+* on the generated file (which may not exist during development).
+*/
+function requireGenerated() {
+	if (generatedModule) return generatedModule;
+	try {
+		throw new Error("Inline WASM data not loaded. Call loadInlineWasmModule() first, or run `npm run generate:wasm-inline`.");
+	} catch (err) {
+		if (generatedModule) return generatedModule;
+		throw err;
+	}
+}
+
 //#endregion
 //#region src/index.ts
 /** Whether initWasm has already completed successfully. */
@@ -14638,19 +16219,19 @@ async function initWasm(options) {
 	if (wasmInitialized) return;
 	const inits = [];
 	if (options.deflate || options.deflateWasm) inits.push((async () => {
-		const { initDeflateWasm } = await import("./libdeflateWasm-8b91Vmia.mjs").then((n) => n.r);
+		const { initDeflateWasm } = await import("./libdeflateWasm-CcA1W04G.mjs").then((n) => n.r);
 		await initDeflateWasm(options.deflateWasm);
 	})());
 	if (options.png || options.pngWasm) inits.push((async () => {
-		const { initPngWasm } = await import("./pngEmbed-BWAbEUKF.mjs").then((n) => n.n);
+		const { initPngWasm } = await import("./pngEmbed-CGi7cym7.mjs").then((n) => n.n);
 		await initPngWasm(options.pngWasm);
 	})());
 	if (options.fonts || options.fontWasm) inits.push((async () => {
-		const { initSubsetWasm } = await import("./fontSubset-D-vQQems.mjs").then((n) => n.r);
+		const { initSubsetWasm } = await import("./fontSubset-BGFDIMmT.mjs").then((n) => n.r);
 		await initSubsetWasm(options.fontWasm);
 	})());
 	if (options.jpeg || options.jpegWasm) inits.push((async () => {
-		const { initJpegWasm } = await import("./bridge-CcivG_Sm.mjs").then((n) => n.t);
+		const { initJpegWasm } = await import("./bridge-DaS-gzEd.mjs").then((n) => n.t);
 		await initJpegWasm(options.jpegWasm);
 	})());
 	await Promise.all(inits);
@@ -14658,5 +16239,5 @@ async function initWasm(options) {
 }
 
 //#endregion
-export { encodeCode128Values as $, addFieldLock as $t, readEan13 as A, PdfUnderlineAnnotation as An, isValidLevel as At, upcAToOperators as B, generateUnderlineAppearance as Bn, enforcePdfA as Bt, borderedPreset as C, PdfLineAnnotation as Cn, buildAfArray as Ct, readBarcode as D, PdfHighlightAnnotation as Dn, validateXmpMetadata as Dt, stripedPreset as E, PdfSquareAnnotation as En, parseXmpMetadata as Et, pdf417ToOperators as F, generateInkAppearance as Fn, buildOutputIntent as Ft, encodeEan8 as G, saveDocumentIncremental as Gn, findChangedObjects as Gt, ean13ToOperators as H, PdfTextAnnotation as Hn, isLinearized as Ht, dataMatrixToOperators as I, generateLineAppearance as In, SRGB_ICC_PROFILE as It, code39ToOperators as J, embedLtvData as Jt, encodeItf as K, saveIncremental as Kn, optimizeIncrementalSave as Kt, encodeDataMatrix as L, generateSquareAppearance as Ln, generateSrgbIccProfile as Lt, calculateBarcodeDimensions as M, generateCircleAppearance as Mn, generateWinAnsiToUnicodeCmap as Mt, renderStyledBarcode as N, generateFreeTextAppearance as Nn, generateZapfDingbatsToUnicodeCmap as Nt, readCode128 as O, PdfSquigglyAnnotation as On, getProfile as Ot, encodePdf417 as P, generateHighlightAppearance as Pn, getToUnicodeCmap as Pt, encodeCode128 as Q, diffSignedContent as Qt, calculateUpcCheckDigit as R, generateSquigglyAppearance as Rn, detectTransparency as Rt, applyTablePreset as S, PdfCircleAnnotation as Sn, stripProhibitedFeatures as St, professionalPreset as T, PdfPolygonAnnotation as Tn, extractXmpMetadata as Tt, ean8ToOperators as U, PDFOperator as Un, linearizePdf as Ut, calculateEanCheckDigit as V, PdfLinkAnnotation as Vn, validatePdfA as Vt, encodeEan13 as W, ChangeTracker as Wn, computeObjectHash as Wt, encodeCode39 as X, addCounterSignature as Xt, computeCode39CheckDigit as Y, hasLtvData as Yt, code128ToOperators as Z, getCounterSignatures as Zt, estimateTextWidth as _, PdfCaretAnnotation as _n, recompressImage as _t, FieldAlreadyExistsError as a, getCertificationLevel as an, recompressWebP as at, wrapText as b, PdfInkAnnotation as bn, generatePdfAXmpBytes as bt, ForeignPageError as c, appendIncrementalUpdate as cn, convertTiffCmykToRgb as ct, NoSuchFieldError as d, saveIncrementalWithSignaturePreservation as dn, extractJpegMetadata as dt, buildFieldLockDict as en, valuesToModules as et, RemovePageFromEmptyDocumentError as f, validateByteRangeIntegrity as fn, injectJpegMetadata as ft, ellipsisText as g, PdfFileAttachmentAnnotation as gn, optimizeImage as gt, applyOverflow as h, requestTimestamp as hn, estimateJpegQuality as ht, ExceededMaxLengthError as i, buildDocMdpReference as in, encodePngFromPixels as it, readEan8 as j, PdfFreeTextAnnotation as jn, generateSymbolToUnicodeCmap as jt, readCode39 as k, PdfStrikeOutAnnotation as kn, getSupportedLevels as kt, InvalidFieldNamePartError as l, findExistingSignatures as ln, embedTiffCmyk as lt, UnexpectedFieldTypeError as m, parseTimestampResponse as mn, downscaleImage as mt, CombedTextLayoutError as n, detectModifications as nn, canDirectEmbed as nt, FieldExistsAsNonTerminalError as o, setCertificationLevel as on, webpToJpeg as ot, RichTextFieldReadError as p, buildTimestampRequest as pn, analyzeJpegMarkers as pt, itfToOperators as q, buildDssDictionary as qt, EncryptedPdfError as r, MdpPermission as rn, embedTiffDirect as rt, FontNotEmbeddedError as s, validateSignatureChain as sn, webpToPng as st, initWasm as t, getFieldLocks as tn, PdfWorker as tt, MissingOnValueCheckError as u, parseExistingTrailer as un, isCmykTiff as ut, shrinkFontSize as v, PdfPopupAnnotation as vn, enforcePdfAFull as vt, minimalPreset as w, PdfPolyLineAnnotation as wn, createAssociatedFile as wt, applyPreset as x, PdfStampAnnotation as xn, countOccurrences as xt, truncateText as y, PdfRedactAnnotation as yn, generatePdfAXmp as yt, encodeUpcA as z, generateStrikeOutAppearance as zn, flattenTransparency as zt };
-//# sourceMappingURL=src-Db6Qknoz.mjs.map
+export { upcAToOperators as $, generateSquareAppearance as $n, flattenTransparency as $t, estimateTextWidth as A, parseTimestampResponse as An, recompressImage as At, readBarcode as B, PdfPolyLineAnnotation as Bn, parseXmpMetadata as Bt, MissingOnValueCheckError as C, validateSignatureChain as Cn, isCmykTiff as Ct, UnexpectedFieldTypeError as D, saveIncrementalWithSignaturePreservation as Dn, downscaleImage as Dt, RichTextFieldReadError as E, parseExistingTrailer as En, analyzeJpegMarkers as Et, applyTablePreset as F, PdfRedactAnnotation as Fn, countOccurrences as Ft, calculateBarcodeDimensions as G, PdfStrikeOutAnnotation as Gn, generateSymbolToUnicodeCmap as Gt, readCode39 as H, PdfSquareAnnotation as Hn, getProfile as Ht, borderedPreset as I, PdfInkAnnotation as In, stripProhibitedFeatures as It, pdf417ToOperators as J, generateCircleAppearance as Jn, getToUnicodeCmap as Jt, renderStyledBarcode as K, PdfUnderlineAnnotation as Kn, generateWinAnsiToUnicodeCmap as Kt, minimalPreset as L, PdfStampAnnotation as Ln, buildAfArray as Lt, truncateText as M, PdfFileAttachmentAnnotation as Mn, enforcePdfAFull as Mt, wrapText as N, PdfCaretAnnotation as Nn, generatePdfAXmp as Nt, applyOverflow as O, validateByteRangeIntegrity as On, estimateJpegQuality as Ot, applyPreset as P, PdfPopupAnnotation as Pn, generatePdfAXmpBytes as Pt, encodeUpcA as Q, generateLineAppearance as Qn, detectTransparency as Qt, professionalPreset as R, PdfCircleAnnotation as Rn, createAssociatedFile as Rt, InvalidFieldNamePartError as S, setCertificationLevel as Sn, embedTiffCmyk as St, RemovePageFromEmptyDocumentError as T, findExistingSignatures as Tn, injectJpegMetadata as Tt, readEan13 as U, PdfHighlightAnnotation as Un, getSupportedLevels as Ut, readCode128 as V, PdfPolygonAnnotation as Vn, validateXmpMetadata as Vt, readEan8 as W, PdfSquigglyAnnotation as Wn, isValidLevel as Wt, encodeDataMatrix as X, generateHighlightAppearance as Xn, SRGB_ICC_PROFILE as Xt, dataMatrixToOperators as Y, generateFreeTextAppearance as Yn, buildOutputIntent as Yt, calculateUpcCheckDigit as Z, generateInkAppearance as Zn, generateSrgbIccProfile as Zt, ExceededMaxLengthError as _, getFieldLocks as _n, encodePngFromPixels as _t, batchFlatten as a, linearizePdf as an, enforcePdfUa as ar, encodeItf as at, FontNotEmbeddedError as b, buildDocMdpReference as bn, webpToPng as bt, addBookmark as c, optimizeIncrementalSave as cn, ChangeTracker as cr, computeCode39CheckDigit as ct, removeBookmark as d, hasLtvData as dn, encodeCode128 as dt, enforcePdfA as en, generateSquigglyAppearance as er, calculateEanCheckDigit as et, flattenField as f, addCounterSignature as fn, encodeCode128Values as ft, EncryptedPdfError as g, buildFieldLockDict as gn, embedTiffDirect as gt, CombedTextLayoutError as h, addFieldLock as hn, canDirectEmbed as ht, isValidModuleName as i, isLinearized as in, PdfTextAnnotation as ir, encodeEan8 as it, shrinkFontSize as j, requestTimestamp as jn, applyRedaction as jt, ellipsisText as k, buildTimestampRequest as kn, optimizeImage as kt, getBookmarks as l, buildDssDictionary as ln, saveDocumentIncremental as lr, encodeCode39 as lt, flattenForm as m, diffSignedContent as mn, PdfWorker as mt, getInlineWasmBytes as n, delinearizePdf as nn, generateUnderlineAppearance as nr, ean8ToOperators as nt, batchMerge as o, computeObjectHash as on, validatePdfUa as or, itfToOperators as ot, flattenFields as p, getCounterSignatures as pn, valuesToModules as pt, encodePdf417 as q, PdfFreeTextAnnotation as qn, generateZapfDingbatsToUnicodeCmap as qt, hasInlineWasmData as r, getLinearizationInfo as rn, PdfLinkAnnotation as rr, encodeEan13 as rt, processBatch as s, findChangedObjects as sn, PDFOperator as sr, code39ToOperators as st, initWasm as t, validatePdfA as tn, generateStrikeOutAppearance as tr, ean13ToOperators as tt, removeAllBookmarks as u, embedLtvData as un, saveIncremental as ur, code128ToOperators as ut, FieldAlreadyExistsError as v, detectModifications as vn, recompressWebP as vt, NoSuchFieldError as w, appendIncrementalUpdate as wn, extractJpegMetadata as wt, ForeignPageError as x, getCertificationLevel as xn, convertTiffCmykToRgb as xt, FieldExistsAsNonTerminalError as y, MdpPermission as yn, webpToJpeg as yt, stripedPreset as z, PdfLineAnnotation as zn, extractXmpMetadata as zt };
+//# sourceMappingURL=src-QZWP21qF.mjs.map