modern-pdf-lib 0.9.0

package/dist/index.mjs

@@ -0,0 +1,4306 @@
+import { $ as setFillColor, $t as showTextArray, A as endMarkedContent, At as moveTo, B as saveState, Bt as endText, C as beginArtifact, Ct as ellipsePath, D as beginMarkedContentWithProperties, Dt as fillEvenOdd, E as beginMarkedContentSequence, Et as fillAndStroke, F as radians, Ft as setLineJoin, G as applyFillColor, Gt as setFont, H as setGraphicsState, Ht as moveTextSetLeading, I as radiansToDegrees, It as setLineWidth, J as colorToComponents, Jt as setTextMatrix, K as applyStrokeColor, Kt as setFontSize, L as restoreState, Lt as setMiterLimit, M as concatMatrix, Mt as setDashPattern, N as degrees, Nt as setFlatness, O as createMarkedContentScope, Ot as fillEvenOddAndStroke, P as degreesToRadians, Pt as setLineCap, Q as setColorSpace, Qt as showText, R as rotate, Rt as stroke, S as createAnnotation, St as curveToInitial, T as beginMarkedContent, Tt as fill, U as skew, Ut as nextLine, V as scale, Vt as moveText, W as translate, Wt as setCharacterSpacing, X as grayscale, Xt as setTextRise, Y as componentsToColor, Yt as setTextRenderingMode, Z as rgb, Zt as setWordSpacing, _ as parseSvgTransform, _t as closeFillAndStroke, a as applyRedactions, at as setStrokeColorCmyk, b as annotationFromDict, bt as curveTo, c as PdfLayer, ct as setStrokeColorSpace, d as endLayerContent, dt as drawImageXObject, en as showTextHex, et as setFillColorCmyk, f as drawSvgOnPage, ft as drawXObject, g as parseSvgPath, gt as closeAndStroke, h as parseSvgColor, ht as clipEvenOdd, i as wrapText, it as setStrokeColor, j as wrapInMarkedContent, jt as rectangle, k as endArtifact, kt as lineTo, l as PdfLayerManager, lt as setStrokingColor, m as parseSvg, mt as clip, n as PdfPage, nn as showTextWithSpacing, nt as setFillColorRgb, o as getRedactionMarks, ot as setStrokeColorGray, p as svgToPdfOperators, pt as circlePath, q as cmyk, qt as setLeading, rt as setFillingColor, s as markForRedaction, st as setStrokeColorRgb, t as PageSizes, tn as showTextNextLine, tt as setFillColorGray, u as beginLayerContent, ut as drawImageWithMatrix, v as AnnotationFlags, vt as closeFillEvenOddAndStroke, w as beginArtifactWithType, wt as endPath, x as buildAnnotationDict, xt as curveToFinal, y as PdfAnnotation, yt as closePath, z as rotationMatrix, zt as beginText } from "./pdfPage-DZA6XJzR.mjs";
+import { a as formatPdfDate, c as PdfBool, d as PdfNull, f as PdfNumber, g as PdfString, h as PdfStream, i as buildPageTree, l as PdfDict, m as PdfRef, n as buildDocumentStructure, p as PdfObjectRegistry, r as buildInfoDict, s as PdfArray, t as buildCatalog, u as PdfName } from "./pdfCatalog-Dk4qUVvx.mjs";
+import { $ as checkAccessibility, A as buildEmbeddedFilesNameTree, At as EmbeddedFont, B as encodeLength, C as generateSignatureAppearance, Ct as aesEncryptCBC, D as addWatermark, Dt as base64Encode, E as PdfField, Et as base64Decode, F as signPdf, G as encodeSet, H as encodeOctetString, I as buildPkcs7Signature, J as parseDerTlv, K as encodeUTCTime, L as decodeOidBytes, M as verifySignature, Mt as PdfStreamWriter, N as verifySignatures, Nt as PdfWriter, O as addWatermarkToPage, Ot as isOpenTypeCFF, P as getSignatures, Pt as serializePdf, Q as prepareForSigning, R as encodeContextTag, S as generateRadioAppearance, St as aesDecryptCBC, T as FieldFlags, Tt as md5, U as encodePrintableString, V as encodeOID, W as encodeSequence, X as embedSignature, Y as computeSignatureHash, Z as findSignatures, _ as PdfTextField, _t as sha256, a as PdfDocument, at as buildViewerPreferencesDict, b as generateDropdownAppearance, bt as decodePermissions, c as embedPageAsFormXObject, ct as createXmpStream, d as PdfSignatureField, dt as PdfOutlineTree, et as isAccessible, f as PdfButtonField, ft as loadPdf, g as PdfCheckboxField, gt as verifyUserPassword, h as PdfRadioGroup, ht as verifyOwnerPassword, i as splitPdf, it as PdfViewerPreferences, j as getAttachments, jt as extractMetrics, k as attachFile, kt as isTrueType, l as decodeStream, lt as parseXmpMetadata, m as PdfDropdownField, mt as computeFileEncryptionKey, nt as PdfStructureElement, o as StandardFonts, ot as parseViewerPreferences, p as PdfListboxField, pt as PdfEncryptionHandler, q as encodeUtf8String, r as mergePdfs, rt as PdfStructureTree, s as createPdf, st as buildXmpMetadata, t as copyPages, tt as summarizeIssues, u as PdfForm, ut as PdfOutlineItem, v as generateButtonAppearance, vt as sha384, w as generateTextAppearance, wt as rc4, x as generateListboxAppearance, xt as encodePermissions, y as generateCheckboxAppearance, yt as sha512, z as encodeInteger } from "./documentMerge-CNPWlWic.mjs";
+import { deflateSync } from "fflate";
+
+//#region src/utils/pdfValueHelpers.ts
+/**
+* @module utils/pdfValueHelpers
+*
+* Convenience helpers for converting between JS values and PDF object types.
+* These match the pdf-lib helper API surface.
+*/
+/**
+* Create a {@link PdfName} from a string.
+*
+* @param value  The name value (with or without leading `/`).
+*/
+function asPDFName(value) {
+	return PdfName.of(value);
+}
+/**
+* Create a {@link PdfNumber} from a numeric value.
+*
+* @param value  The number.
+*/
+function asPDFNumber(value) {
+	return PdfNumber.of(value);
+}
+/**
+* Extract a numeric value from a {@link PdfObject}.
+*
+* Returns `undefined` if the object is not a PdfNumber.
+*
+* @param obj  The PDF object to inspect.
+*/
+function asNumber(obj) {
+	if (obj.kind === "number") return obj.value;
+}
+
+//#endregion
+//#region src/core/enums.ts
+/**
+* PDF blend modes (PDF 1.4+, Table 136).
+* Applied via ExtGState /BM key.
+*/
+const BlendMode = {
+	Normal: "Normal",
+	Multiply: "Multiply",
+	Screen: "Screen",
+	Overlay: "Overlay",
+	Darken: "Darken",
+	Lighten: "Lighten",
+	ColorDodge: "ColorDodge",
+	ColorBurn: "ColorBurn",
+	HardLight: "HardLight",
+	SoftLight: "SoftLight",
+	Difference: "Difference",
+	Exclusion: "Exclusion"
+};
+/**
+* PDF text rendering modes (Table 106).
+* Applied via the Tr operator inside a text object.
+*/
+const TextRenderingMode = {
+	Fill: 0,
+	Outline: 1,
+	FillAndOutline: 2,
+	Invisible: 3,
+	FillAndClip: 4,
+	OutlineAndClip: 5,
+	FillAndOutlineAndClip: 6,
+	Clip: 7
+};
+/**
+* PDF line cap styles (Table 54).
+* Applied via the J operator.
+*/
+const LineCapStyle = {
+	Butt: 0,
+	Round: 1,
+	Projecting: 2
+};
+/**
+* PDF line join styles (Table 55).
+* Applied via the j operator.
+*/
+const LineJoinStyle = {
+	Miter: 0,
+	Round: 1,
+	Bevel: 2
+};
+/**
+* Text alignment for form fields and layout operations.
+*/
+const TextAlignment = {
+	Left: 0,
+	Center: 1,
+	Right: 2
+};
+/**
+* Image alignment for layout operations.
+*/
+const ImageAlignment = {
+	Left: 0,
+	Center: 1,
+	Right: 2
+};
+/**
+* Preset parsing speeds — maps to objectsPerTick values in LoadPdfOptions.
+*
+* Lower values keep the main thread more responsive but parse more slowly.
+*/
+const ParseSpeeds = {
+	Fastest: Infinity,
+	Fast: 500,
+	Medium: 100,
+	Slow: 10
+};
+
+//#endregion
+//#region src/core/pageManipulation.ts
+/**
+* Resolve a PageSize input to a `[width, height]` tuple.
+*
+* @param size  Page size as a tuple, object, or undefined (defaults to A4).
+* @returns     A `[width, height]` tuple in PDF points.
+*/
+function resolveSize(size) {
+	const resolved = size ?? PageSizes.A4;
+	if (Array.isArray(resolved)) return [resolved[0], resolved[1]];
+	return [resolved.width, resolved.height];
+}
+/**
+* Validate that a page index is within bounds.
+*
+* @param index      The index to validate.
+* @param pageCount  The total number of pages.
+* @param operation  A description of the operation for error messages.
+* @throws RangeError if the index is out of bounds.
+*/
+function validateIndex(index, pageCount, operation) {
+	if (!Number.isInteger(index) || index < 0 || index >= pageCount) throw new RangeError(`${operation}: index ${index} out of range [0, ${pageCount - 1}]`);
+}
+/**
+* Validate that a page index is valid for insertion (0 to pageCount inclusive).
+*
+* @param index      The index to validate.
+* @param pageCount  The total number of pages.
+* @param operation  A description of the operation for error messages.
+* @throws RangeError if the index is out of bounds.
+*/
+function validateInsertIndex(index, pageCount, operation) {
+	if (!Number.isInteger(index) || index < 0 || index > pageCount) throw new RangeError(`${operation}: index ${index} out of range [0, ${pageCount}]`);
+}
+/**
+* Validate that a rotation angle is a multiple of 90.
+*
+* @param angle  The rotation angle in degrees.
+* @throws Error if the angle is not a valid rotation.
+*/
+function validateRotation(angle) {
+	if (angle % 90 !== 0) throw new Error(`rotatePage: angle must be a multiple of 90, got ${angle}`);
+}
+/**
+* Insert a new blank page into the document at the specified position.
+*
+* All existing pages at `index` and beyond are shifted to make room.
+*
+* @param doc    The PdfDocument to modify.
+* @param index  Zero-based position at which to insert the page.
+*               Must be in the range `[0, pageCount]`.
+* @param size   Optional page size. Defaults to A4.
+* @returns      The newly created PdfPage.
+*
+* @example
+* ```ts
+* import { createPdf, insertPage, PageSizes } from 'modern-pdf';
+*
+* const doc = createPdf();
+* doc.addPage();
+* const newPage = insertPage(doc, 0, PageSizes.Letter); // insert at front
+* ```
+*/
+function insertPage(doc, index, size) {
+	const pages = doc.getInternalPages();
+	const registry = doc.getRegistry();
+	validateInsertIndex(index, pages.length, "insertPage");
+	const [w, h] = resolveSize(size);
+	const page = new PdfPage(w, h, registry);
+	doc.registerFontsOnPage(page);
+	pages.splice(index, 0, page);
+	return page;
+}
+/**
+* Remove a page from the document by its zero-based index.
+*
+* @param doc    The PdfDocument to modify.
+* @param index  Zero-based index of the page to remove.
+* @throws       RangeError if the index is out of bounds.
+*
+* @example
+* ```ts
+* removePage(doc, 0); // Remove the first page
+* ```
+*/
+function removePage(doc, index) {
+	const pages = doc.getInternalPages();
+	validateIndex(index, pages.length, "removePage");
+	pages.splice(index, 1);
+}
+/**
+* Move a page from one position to another within the document.
+*
+* The page at `fromIndex` is removed and then inserted at `toIndex`
+* (computed after the removal).
+*
+* @param doc        The PdfDocument to modify.
+* @param fromIndex  Current zero-based index of the page to move.
+* @param toIndex    Target zero-based index. Must be in range
+*                   `[0, pageCount - 1]` after removal.
+* @throws           RangeError if either index is out of bounds.
+*
+* @example
+* ```ts
+* movePage(doc, 2, 0); // Move page 2 to the front
+* ```
+*/
+function movePage(doc, fromIndex, toIndex) {
+	const pages = doc.getInternalPages();
+	validateIndex(fromIndex, pages.length, "movePage (fromIndex)");
+	const [page] = pages.splice(fromIndex, 1);
+	if (toIndex < 0 || toIndex > pages.length) {
+		pages.splice(fromIndex, 0, page);
+		throw new RangeError(`movePage (toIndex): index ${toIndex} out of range [0, ${pages.length}]`);
+	}
+	pages.splice(toIndex, 0, page);
+}
+/**
+* Rotate a page by the specified angle.
+*
+* The angle is cumulative with any existing rotation set on the page.
+* The page's `/Rotate` entry in the page dictionary will be set when
+* the document is saved.
+*
+* @param doc    The PdfDocument to modify.
+* @param index  Zero-based index of the page to rotate.
+* @param angle  Rotation angle in degrees. Must be a multiple of 90.
+*               Common values: 90, 180, 270, -90.
+* @throws       RangeError if the index is out of bounds.
+* @throws       Error if the angle is not a multiple of 90.
+*
+* @example
+* ```ts
+* rotatePage(doc, 0, 90); // Rotate first page 90 degrees clockwise
+* ```
+*/
+function rotatePage(doc, index, angle) {
+	const pages = doc.getInternalPages();
+	validateIndex(index, pages.length, "rotatePage");
+	validateRotation(angle);
+	const page = pages[index];
+	const newRotation = (((page.getRotation?.() ?? 0) + angle) % 360 + 360) % 360;
+	page.setRotation(newRotation);
+}
+/**
+* Set a crop box on a page.
+*
+* The crop box defines the visible region of the page when displayed
+* or printed. It defaults to the media box if not set.
+*
+* @param doc      The PdfDocument to modify.
+* @param index    Zero-based index of the page.
+* @param cropBox  The crop box rectangle.
+* @throws         RangeError if the index is out of bounds.
+*
+* @example
+* ```ts
+* cropPage(doc, 0, { x: 50, y: 50, width: 495, height: 742 });
+* ```
+*/
+function cropPage(doc, index, cropBox) {
+	const pages = doc.getInternalPages();
+	validateIndex(index, pages.length, "cropPage");
+	pages[index].setCropBox(cropBox.x, cropBox.y, cropBox.width, cropBox.height);
+}
+/**
+* Get the size of a page.
+*
+* @param doc    The PdfDocument.
+* @param index  Zero-based page index.
+* @returns      A `{ width, height }` object in PDF points.
+*/
+function getPageSize(doc, index) {
+	const pages = doc.getInternalPages();
+	validateIndex(index, pages.length, "getPageSize");
+	const page = pages[index];
+	return {
+		width: page.width,
+		height: page.height
+	};
+}
+/**
+* Resize a page by setting its media box.
+*
+* Note: This changes the page dimensions but does not scale existing
+* content. Content that was drawn at coordinates beyond the new
+* dimensions may be clipped.
+*
+* @param doc    The PdfDocument to modify.
+* @param index  Zero-based page index.
+* @param size   New page size.
+*/
+function resizePage(doc, index, size) {
+	const pages = doc.getInternalPages();
+	validateIndex(index, pages.length, "resizePage");
+	const [w, h] = resolveSize(size);
+	pages[index].setMediaBox(0, 0, w, h);
+}
+/**
+* Reverse the page order of the entire document.
+*
+* @param doc  The PdfDocument to modify.
+*/
+function reversePages(doc) {
+	doc.getInternalPages().reverse();
+}
+/**
+* Remove multiple pages at once, given their zero-based indices.
+*
+* Indices are processed in descending order to avoid shifting issues.
+*
+* @param doc      The PdfDocument to modify.
+* @param indices  Array of zero-based page indices to remove.
+* @throws         RangeError if any index is out of bounds.
+*/
+function removePages(doc, indices) {
+	const pages = doc.getInternalPages();
+	for (const index of indices) validateIndex(index, pages.length, "removePages");
+	const sorted = new Set(indices).values().toArray().sort((a, b) => b - a);
+	for (const index of sorted) pages.splice(index, 1);
+}
+/**
+* Rotate all pages in the document by the specified angle.
+*
+* @param doc    The PdfDocument to modify.
+* @param angle  Rotation angle in degrees (must be a multiple of 90).
+*/
+function rotateAllPages(doc, angle) {
+	validateRotation(angle);
+	const pages = doc.getInternalPages();
+	for (const page of pages) {
+		const newRotation = (((page.getRotation?.() ?? 0) + angle) % 360 + 360) % 360;
+		page.setRotation(newRotation);
+	}
+}
+
+//#endregion
+//#region src/core/layout.ts
+/**
+* Break text into lines that fit within `maxWidth`, measuring each line's
+* width.  Explicit newlines (`\n`) are always honoured.
+*
+* The returned `height` is the total vertical extent: one line's ascent
+* plus `(n-1) * lineHeight`.
+*/
+function layoutMultilineText(text, options) {
+	const { font, fontSize, maxWidth, wordBreaks } = options;
+	const lineHeight = options.lineHeight ?? fontSize * 1.2;
+	const rawLines = text.split("\n");
+	const allLines = [];
+	for (const rawLine of rawLines) if (maxWidth > 0) {
+		const wrapped = wrapText(rawLine, maxWidth, font, fontSize, wordBreaks);
+		for (const line of wrapped) allLines.push({
+			text: line,
+			width: font.widthOfTextAtSize(line, fontSize)
+		});
+	} else allLines.push({
+		text: rawLine,
+		width: font.widthOfTextAtSize(rawLine, fontSize)
+	});
+	return {
+		lines: allLines,
+		height: allLines.length > 0 ? font.heightAtSize(fontSize) + (allLines.length - 1) * lineHeight : 0
+	};
+}
+/**
+* Layout text into evenly-spaced cells for combed text fields.
+*
+* Each character is centred within its cell.  Characters beyond
+* `cellCount` are silently truncated.
+*/
+function layoutCombedText(text, options) {
+	const { font, fontSize, cellCount, cellWidth } = options;
+	return text.slice(0, cellCount).split("").map((char, i) => {
+		const charWidth = font.widthOfTextAtSize(char, fontSize);
+		return {
+			char,
+			x: i * cellWidth + cellWidth / 2 - charWidth / 2,
+			width: charWidth
+		};
+	});
+}
+/**
+* Compute the largest font size (in points) at which `text` fits within
+* the given width (and optionally height) constraints.
+*
+* Uses binary search between `minSize` (default 4) and `maxSize`
+* (default 500), converging to within 0.1 pt.
+*/
+function computeFontSize(text, options) {
+	const { font, maxWidth, wordBreaks } = options;
+	const maxHeight = options.maxHeight ?? Infinity;
+	const minSize = options.minSize ?? 4;
+	const maxSize = options.maxSize ?? 500;
+	let lo = minSize;
+	let hi = maxSize;
+	for (let i = 0; i < 40; i++) {
+		const mid = (lo + hi) / 2;
+		const layout = layoutMultilineText(text, {
+			font,
+			fontSize: mid,
+			maxWidth,
+			lineHeight: options.lineHeight,
+			wordBreaks
+		});
+		if (layout.height <= maxHeight && layout.lines.every((line) => line.width <= maxWidth)) lo = mid;
+		else hi = mid;
+		if (hi - lo < .1) break;
+	}
+	return Math.floor(lo * 10) / 10;
+}
+/**
+* Layout a single line of text with optional alignment within bounds.
+*
+* Unlike {@link layoutMultilineText}, this does not perform any wrapping.
+* It simply measures the text, computes alignment offsets, and returns
+* the positioned line.
+*
+* @param text     The text to lay out (single line, no newlines).
+* @param options  Font, size, bounds, alignment.
+* @returns        The measured line and its position offsets.
+*/
+function layoutSinglelineText(text, options) {
+	const { font, fontSize, bounds, alignment } = options;
+	const width = font.widthOfTextAtSize(text, fontSize);
+	const height = font.heightAtSize(fontSize);
+	let x = 0;
+	let y = 0;
+	if (bounds) {
+		y = (bounds.height - height) / 2;
+		switch (alignment) {
+			case 1:
+				x = (bounds.width - width) / 2;
+				break;
+			case 2:
+				x = bounds.width - width;
+				break;
+			default:
+				x = 0;
+				break;
+		}
+	}
+	return {
+		line: {
+			text,
+			width,
+			height
+		},
+		x,
+		y
+	};
+}
+
+//#endregion
+//#region src/core/incrementalWriter.ts
+/**
+* @module core/incrementalWriter
+*
+* Incremental save support for PDF documents.
+*
+* An incremental save appends new/modified objects to the end of the
+* original PDF file, followed by a new cross-reference section and
+* trailer that references the original xref via the `/Prev` key.
+*
+* This is critical for:
+* 1. **Signature preservation** — Digital signatures are invalidated by
+*    full rewrites. Incremental saves preserve the original bytes
+*    exactly, so signatures remain valid.
+* 2. **Performance on large files** — Only modified objects are written,
+*    so saving a small change to a 100MB PDF takes milliseconds.
+* 3. **Undo history** — Each incremental save is a layer that can be
+*    peeled back to restore the previous state.
+*
+* Reference: PDF 1.7 spec, SS7.5.6 (Incremental Updates).
+*
+* @packageDocumentation
+*/
+/**
+* Tracks which objects have been added or modified since the document
+* was loaded. Only these objects are written during an incremental save.
+*/
+var ChangeTracker = class {
+	/** Set of object numbers that are new (not in the original file). */
+	newObjects = /* @__PURE__ */ new Set();
+	/** Set of object numbers that existed but have been modified. */
+	modifiedObjects = /* @__PURE__ */ new Set();
+	/** The highest object number from the original file. */
+	originalMaxObjNum;
+	constructor(originalMaxObjNum) {
+		this.originalMaxObjNum = originalMaxObjNum;
+	}
+	/**
+	* Mark an object as new (did not exist in the original file).
+	*/
+	markNew(objectNumber) {
+		this.newObjects.add(objectNumber);
+	}
+	/**
+	* Mark an object as modified (existed in the original file).
+	*/
+	markModified(objectNumber) {
+		if (objectNumber <= this.originalMaxObjNum) this.modifiedObjects.add(objectNumber);
+		else this.newObjects.add(objectNumber);
+	}
+	/**
+	* Check if an object is new or modified.
+	*/
+	isChanged(objectNumber) {
+		return this.newObjects.has(objectNumber) || this.modifiedObjects.has(objectNumber);
+	}
+	/**
+	* Get all changed object numbers (new + modified).
+	*/
+	getChangedObjects() {
+		return this.newObjects.union(this.modifiedObjects);
+	}
+	/**
+	* Get the count of changed objects.
+	*/
+	get changedCount() {
+		return this.newObjects.union(this.modifiedObjects).size;
+	}
+};
+const encoder$2 = new TextEncoder();
+/**
+* Growable byte buffer for building the incremental appendix.
+*/
+var ByteBuffer = class {
+	chunks = [];
+	_offset = 0;
+	get offset() {
+		return this._offset;
+	}
+	write(data) {
+		this.chunks.push(data);
+		this._offset += data.length;
+	}
+	writeString(str) {
+		this.write(encoder$2.encode(str));
+	}
+	toUint8Array() {
+		const result = new Uint8Array(this._offset);
+		let pos = 0;
+		for (const chunk of this.chunks) {
+			result.set(chunk, pos);
+			pos += chunk.length;
+		}
+		return result;
+	}
+};
+/**
+* Find the `startxref` offset in the original PDF bytes.
+*
+* Scans backward from the end of the file looking for the `startxref`
+* keyword, then parses the numeric offset on the following line.
+*
+* @param data  The original PDF bytes.
+* @returns     The byte offset of the original cross-reference section.
+* @throws      Error if `startxref` is not found.
+*/
+function findOriginalXrefOffset(data) {
+	const decoder = new TextDecoder("latin1");
+	const searchStart = Math.max(0, data.length - 1024);
+	const tail = decoder.decode(data.subarray(searchStart));
+	const idx = tail.lastIndexOf("startxref");
+	if (idx === -1) throw new Error("Incremental save: could not find \"startxref\" in the original PDF. The file may be corrupted.");
+	const match = tail.substring(idx + 9).trim().match(/^(\d+)/);
+	if (!match) throw new Error("Incremental save: could not parse xref offset after \"startxref\".");
+	return parseInt(match[1], 10);
+}
+/**
+* Find the /Size value from the original trailer.
+*
+* @param data  The original PDF bytes.
+* @returns     The /Size value from the trailer.
+*/
+function findOriginalTrailerSize(data) {
+	const decoder = new TextDecoder("latin1");
+	const searchStart = Math.max(0, data.length - 2048);
+	const sizeMatch = decoder.decode(data.subarray(searchStart)).match(/\/Size\s+(\d+)/);
+	if (sizeMatch) return parseInt(sizeMatch[1], 10);
+	throw new Error("Incremental save: could not find /Size in the original trailer.");
+}
+/**
+* Perform an incremental save of a PDF document.
+*
+* Takes the original file bytes and a registry of objects (some new,
+* some modified), and appends only the changed objects plus a new xref
+* section and trailer.
+*
+* The resulting bytes form a valid PDF file that preserves the original
+* content byte-for-byte and appends the modifications.
+*
+* @param originalBytes  The original PDF file bytes (unmodified).
+* @param registry       The object registry containing all objects
+*                       (original + new/modified).
+* @param structure      Document structure references (catalog, info, pages).
+* @param changedObjects Set of object numbers that are new or modified.
+* @param options        Optional save options (compression, etc.).
+* @returns              The complete incremental save result.
+*
+* @example
+* ```ts
+* const result = saveIncremental(originalBytes, registry, structure, changedObjects);
+* await writeFile('output.pdf', result.bytes);
+* ```
+*/
+function saveIncremental(originalBytes, registry, structure, changedObjects, options) {
+	const compress = options?.compress ?? true;
+	const compressionLevel = options?.compressionLevel ?? 6;
+	const prevXrefOffset = findOriginalXrefOffset(originalBytes);
+	let originalSize;
+	try {
+		originalSize = findOriginalTrailerSize(originalBytes);
+	} catch {
+		originalSize = registry.nextNumber;
+	}
+	const buf = new ByteBuffer();
+	buf.writeString("\n");
+	const xrefOffsets = /* @__PURE__ */ new Map();
+	for (const entry of registry) {
+		if (!changedObjects.has(entry.ref.objectNumber)) continue;
+		if (compress && entry.object.kind === "stream") compressStream(entry.object, compressionLevel);
+		const offset = originalBytes.length + buf.offset;
+		xrefOffsets.set(entry.ref.objectNumber, offset);
+		buf.writeString(`${entry.ref.toObjectHeader()}\n`);
+		entry.object.serialize(buf);
+		buf.writeString(`\n${entry.ref.toObjectFooter()}\n`);
+	}
+	let newSize = originalSize;
+	for (const objNum of changedObjects) if (objNum + 1 > newSize) newSize = objNum + 1;
+	if (registry.nextNumber > newSize) newSize = registry.nextNumber;
+	const xrefOffset = originalBytes.length + buf.offset;
+	const subsections = buildXrefSubsections(xrefOffsets.keys().toArray().sort((a, b) => a - b), xrefOffsets);
+	buf.writeString("xref\n");
+	for (const subsection of subsections) {
+		buf.writeString(`${subsection.startObjNum} ${subsection.entries.length}\n`);
+		for (const entry of subsection.entries) buf.writeString(`${entry.offset.toString().padStart(10, "0")} ${entry.generation.toString().padStart(5, "0")} ${entry.type} \n`);
+	}
+	buf.writeString("trailer\n");
+	buf.writeString("<<\n");
+	buf.writeString(`/Size ${newSize}\n`);
+	buf.writeString(`/Root ${structure.catalogRef.objectNumber} ${structure.catalogRef.generationNumber} R\n`);
+	buf.writeString(`/Info ${structure.infoRef.objectNumber} ${structure.infoRef.generationNumber} R\n`);
+	buf.writeString(`/Prev ${prevXrefOffset}\n`);
+	buf.writeString(">>\n");
+	buf.writeString("startxref\n");
+	buf.writeString(`${xrefOffset}\n`);
+	buf.writeString("%%EOF\n");
+	const appendix = buf.toUint8Array();
+	const result = new Uint8Array(originalBytes.length + appendix.length);
+	result.set(originalBytes, 0);
+	result.set(appendix, originalBytes.length);
+	return {
+		bytes: result,
+		newXrefOffset: xrefOffset
+	};
+}
+/**
+* Group consecutive object numbers into xref subsections.
+*
+* For example, objects [3, 4, 5, 10, 11] become two subsections:
+* - `3 3` (objects 3, 4, 5)
+* - `10 2` (objects 10, 11)
+*/
+function buildXrefSubsections(sortedObjNums, offsets) {
+	if (sortedObjNums.length === 0) return [];
+	const subsections = [];
+	let currentStart = sortedObjNums[0];
+	let currentEntries = [{
+		offset: offsets.get(currentStart),
+		generation: 0,
+		type: "n"
+	}];
+	for (let i = 1; i < sortedObjNums.length; i++) {
+		const objNum = sortedObjNums[i];
+		if (objNum === sortedObjNums[i - 1] + 1) currentEntries.push({
+			offset: offsets.get(objNum),
+			generation: 0,
+			type: "n"
+		});
+		else {
+			subsections.push({
+				startObjNum: currentStart,
+				entries: currentEntries
+			});
+			currentStart = objNum;
+			currentEntries = [{
+				offset: offsets.get(objNum),
+				generation: 0,
+				type: "n"
+			}];
+		}
+	}
+	subsections.push({
+		startObjNum: currentStart,
+		entries: currentEntries
+	});
+	return subsections;
+}
+/**
+* Apply FlateDecode compression to a stream if it's not already compressed.
+*/
+function compressStream(stream, level) {
+	if (stream.dict.has("/Filter")) return;
+	if (stream.data.length === 0) return;
+	const compressed = deflateSync(stream.data, { level });
+	if (compressed.length < stream.data.length) {
+		stream.dict.set("/Filter", PdfName.of("FlateDecode"));
+		stream.data = compressed;
+		stream.syncLength();
+	}
+}
+/**
+* Perform an incremental save given the original bytes and a PdfDocument.
+*
+* This is a convenience wrapper that builds the document structure,
+* determines which objects have changed, and calls `saveIncremental`.
+*
+* @param originalBytes  The original PDF file bytes.
+* @param doc            The modified PdfDocument.
+* @param options        Optional save options.
+* @returns              The incremental save result.
+*/
+async function saveDocumentIncremental(originalBytes, doc, options) {
+	const { buildDocumentStructure } = await import("./pdfCatalog-Dk4qUVvx.mjs").then((n) => n.o);
+	const { PdfPage: _PdfPage } = await import("./pdfPage-DZA6XJzR.mjs").then((n) => n.r);
+	const registry = doc.getRegistry();
+	const structure = buildDocumentStructure(doc.getInternalPages().map((p) => p.finalize()), {
+		producer: doc.getProducer(),
+		creationDate: doc.getCreationDate(),
+		modDate: doc.getModDate() ?? /* @__PURE__ */ new Date(),
+		title: doc.getTitle(),
+		author: doc.getAuthor(),
+		subject: doc.getSubject(),
+		keywords: doc.getKeywords(),
+		creator: doc.getCreator()
+	}, registry);
+	const originalSize = findOriginalTrailerSize(originalBytes);
+	const changedObjects = /* @__PURE__ */ new Set();
+	for (const entry of registry) if (entry.ref.objectNumber >= originalSize) changedObjects.add(entry.ref.objectNumber);
+	changedObjects.add(structure.catalogRef.objectNumber);
+	changedObjects.add(structure.infoRef.objectNumber);
+	changedObjects.add(structure.pagesRef.objectNumber);
+	return saveIncremental(originalBytes, registry, structure, changedObjects, options);
+}
+
+//#endregion
+//#region src/core/operators/index.ts
+/**
+* A first-class representation of a single PDF content-stream operator.
+*
+* In pdf-lib, operators are typed objects rather than raw strings. This
+* class provides the same capability while remaining interoperable with
+* the string-based operator functions above.
+*
+* ```ts
+* const op = PDFOperator.of('m', 100, 200);   // moveTo(100, 200)
+* page.pushOperators(op.toString());
+* ```
+*/
+var PDFOperator = class PDFOperator {
+	/**
+	* Create a new operator.
+	*
+	* @param name      The PDF operator name (e.g. `'m'`, `'l'`, `'re'`, `'Tj'`).
+	* @param operands  Numeric, string, or name operands.
+	*/
+	static of(name, ...operands) {
+		return new PDFOperator(name, operands);
+	}
+	constructor(name, operands) {
+		this.name = name;
+		this.operands = operands;
+	}
+	/**
+	* Serialize this operator to its PDF content-stream representation.
+	*
+	* @returns A string like `"100 200 m\n"`.
+	*/
+	toString() {
+		if (this.operands.length === 0) return `${this.name}\n`;
+		return `${this.operands.map((op) => {
+			if (typeof op === "number") {
+				if (Number.isInteger(op)) return op.toString();
+				const s = op.toFixed(6).replace(/\.?0+$/, "");
+				return s === "-0" ? "0" : s;
+			}
+			return op;
+		}).join(" ")} ${this.name}\n`;
+	}
+};
+
+//#endregion
+//#region src/annotation/types/textAnnotation.ts
+/**
+* @module annotation/types/textAnnotation
+*
+* Sticky note (text) annotation — a small icon that, when clicked,
+* opens a popup window containing the annotation text.
+*
+* Reference: PDF 1.7 spec, Section 12.5.6.4 (Text Annotations).
+*/
+/**
+* A sticky note annotation (subtype /Text).
+*
+* Displays a small icon on the page; clicking the icon opens a popup
+* containing the annotation's text.
+*/
+var PdfTextAnnotation = class PdfTextAnnotation extends PdfAnnotation {
+	constructor(dict) {
+		super("Text", dict);
+	}
+	/**
+	* Create a new text (sticky note) annotation.
+	*/
+	static create(options) {
+		const annot = new PdfTextAnnotation(buildAnnotationDict("Text", options));
+		if (options.icon !== void 0) annot.setIcon(options.icon);
+		if (options.open !== void 0) annot.setOpen(options.open);
+		return annot;
+	}
+	/**
+	* Create a PdfTextAnnotation from an existing dictionary.
+	*/
+	static fromDict(dict, resolver) {
+		return new PdfTextAnnotation(dict);
+	}
+	/** Get the icon name. Defaults to 'Note'. */
+	getIcon() {
+		const obj = this.dict.get("/Name");
+		if (obj && obj.kind === "name") return obj.value.startsWith("/") ? obj.value.slice(1) : obj.value;
+		return "Note";
+	}
+	/** Set the icon name. */
+	setIcon(icon) {
+		this.dict.set("/Name", PdfName.of(icon));
+	}
+	/** Whether the popup is initially open. */
+	isOpen() {
+		const obj = this.dict.get("/Open");
+		if (obj && obj.kind === "bool") return obj.value;
+		return false;
+	}
+	/** Set the initial open state. */
+	setOpen(open) {
+		this.dict.set("/Open", PdfBool.of(open));
+	}
+};
+
+//#endregion
+//#region src/annotation/types/linkAnnotation.ts
+/**
+* @module annotation/types/linkAnnotation
+*
+* Link annotation — a clickable region that navigates to a destination
+* within the document or opens an external URL.
+*
+* Reference: PDF 1.7 spec, Section 12.5.6.5 (Link Annotations).
+*/
+/**
+* A link annotation (subtype /Link).
+*
+* Provides navigation to a destination within the document or to an
+* external URI.
+*/
+var PdfLinkAnnotation = class PdfLinkAnnotation extends PdfAnnotation {
+	constructor(dict) {
+		super("Link", dict);
+	}
+	/**
+	* Create a new link annotation.
+	*/
+	static create(options) {
+		const annot = new PdfLinkAnnotation(buildAnnotationDict("Link", options));
+		if (options.url !== void 0) annot.setUrl(options.url);
+		if (options.pageIndex !== void 0) annot.setDestination(options.pageIndex, options.fit);
+		if (options.highlightMode !== void 0) annot.setHighlightMode(options.highlightMode);
+		return annot;
+	}
+	/**
+	* Create from an existing dictionary.
+	*/
+	static fromDict(dict, resolver) {
+		return new PdfLinkAnnotation(dict);
+	}
+	/**
+	* Get the destination (named dest string or explicit dest array).
+	*
+	* Returns:
+	* - A string for named destinations.
+	* - An array `[pageIndex, fitMode, ...params]` for explicit destinations.
+	* - `undefined` if no destination is set.
+	*/
+	getDestination() {
+		const obj = this.dict.get("/Dest");
+		if (!obj) return void 0;
+		if (obj.kind === "string") return obj.value;
+		if (obj.kind === "array" && obj.items.length >= 2) {
+			const fitObj = obj.items[1];
+			const fitName = fitObj && fitObj.kind === "name" ? fitObj.value.startsWith("/") ? fitObj.value.slice(1) : fitObj.value : "Fit";
+			const pageNum = obj.items[0] && obj.items[0].kind === "number" ? obj.items[0].value : 0;
+			const extra = [];
+			for (let i = 2; i < obj.items.length; i++) {
+				const item = obj.items[i];
+				if (item && item.kind === "number") extra.push(item.value);
+			}
+			return [
+				pageNum,
+				fitName,
+				...extra
+			];
+		}
+	}
+	/**
+	* Set an explicit destination (page index + fit mode).
+	*
+	* @param pageIndex  Zero-based page index.
+	* @param fit        Fit mode (defaults to 'Fit').
+	*/
+	setDestination(pageIndex, fit) {
+		const fitName = fit ?? "Fit";
+		this.dict.set("/Dest", PdfArray.of([PdfNumber.of(pageIndex), PdfName.of(fitName)]));
+	}
+	/** Get the URL if this is a URI link. */
+	getUrl() {
+		const action = this.dict.get("/A");
+		if (action && action.kind === "dict") {
+			const uri = action.get("/URI");
+			if (uri && uri.kind === "string") return uri.value;
+		}
+	}
+	/** Set the URL (creates a /URI action). */
+	setUrl(url) {
+		const action = new PdfDict();
+		action.set("/S", PdfName.of("URI"));
+		action.set("/URI", PdfString.literal(url));
+		this.dict.set("/A", action);
+	}
+	/** Get the highlight mode. Defaults to 'Invert'. */
+	getHighlightMode() {
+		const obj = this.dict.get("/H");
+		if (obj && obj.kind === "name") return {
+			N: "None",
+			I: "Invert",
+			O: "Outline",
+			P: "Push",
+			None: "None",
+			Invert: "Invert",
+			Outline: "Outline",
+			Push: "Push"
+		}[obj.value.startsWith("/") ? obj.value.slice(1) : obj.value] ?? "Invert";
+		return "Invert";
+	}
+	/** Set the highlight mode. */
+	setHighlightMode(mode) {
+		this.dict.set("/H", PdfName.of({
+			None: "N",
+			Invert: "I",
+			Outline: "O",
+			Push: "P"
+		}[mode]));
+	}
+};
+
+//#endregion
+//#region src/annotation/appearanceGenerator.ts
+/**
+* @module annotation/appearanceGenerator
+*
+* Generates /AP (appearance) streams for annotations.
+*
+* Appearance streams are Form XObjects that define how an annotation
+* looks when rendered.  Each appearance is a content stream with
+* its own resource dictionary and bounding box.
+*
+* Reference: PDF 1.7 spec, Section 12.5.5 (Appearance Streams).
+*/
+/** Format a number for content stream operators. */
+function n(value) {
+	if (Number.isInteger(value)) return value.toString();
+	const s = value.toFixed(4).replace(/\.?0+$/, "");
+	return s === "-0" ? "0" : s;
+}
+/** Bezier curve constant for approximating a quarter circle. */
+const KAPPA = .5522847498;
+/**
+* Build a Form XObject (appearance stream) from content operators.
+*
+* @param content   The content stream operators.
+* @param bbox      The bounding box [x1, y1, x2, y2].
+* @param resources Optional resources dictionary.
+* @returns         A PdfStream configured as a Form XObject.
+*/
+function buildAppearanceStream(content, bbox, resources) {
+	const dict = new PdfDict();
+	dict.set("/Type", PdfName.of("XObject"));
+	dict.set("/Subtype", PdfName.of("Form"));
+	dict.set("/BBox", PdfArray.fromNumbers(bbox));
+	if (resources) dict.set("/Resources", resources);
+	return PdfStream.fromString(content, dict);
+}
+/**
+* Generate appearance stream for a Square annotation.
+*/
+function generateSquareAppearance(annot) {
+	const [x1, y1, x2, y2] = annot.getRect();
+	const w = x2 - x1;
+	const h = y2 - y1;
+	const color = annot.getColor();
+	const opacity = annot.getOpacity();
+	const dict = annot.getDict();
+	const icObj = dict.get("/IC");
+	let interiorColor;
+	if (icObj && icObj.kind === "array" && icObj.items.length >= 3) interiorColor = {
+		r: icObj.items[0]?.value ?? 0,
+		g: icObj.items[1]?.value ?? 0,
+		b: icObj.items[2]?.value ?? 0
+	};
+	let borderWidth = 1;
+	const bsObj = dict.get("/BS");
+	if (bsObj && bsObj.kind === "dict") {
+		const wObj = bsObj.get("/W");
+		if (wObj && wObj.kind === "number") borderWidth = wObj.value;
+	}
+	let ops = "";
+	if (opacity < 1) ops += `${n(opacity)} ca ${n(opacity)} CA\n`;
+	if (interiorColor) {
+		ops += `${n(interiorColor.r)} ${n(interiorColor.g)} ${n(interiorColor.b)} rg\n`;
+		ops += `${n(borderWidth / 2)} ${n(borderWidth / 2)} ${n(w - borderWidth)} ${n(h - borderWidth)} re\n`;
+		ops += "f\n";
+	}
+	if (color) ops += `${n(color.r)} ${n(color.g)} ${n(color.b)} RG\n`;
+	else ops += "0 0 0 RG\n";
+	ops += `${n(borderWidth)} w\n`;
+	ops += `${n(borderWidth / 2)} ${n(borderWidth / 2)} ${n(w - borderWidth)} ${n(h - borderWidth)} re\n`;
+	ops += "S\n";
+	return buildAppearanceStream(ops, [
+		0,
+		0,
+		w,
+		h
+	]);
+}
+/**
+* Generate appearance stream for a Circle annotation.
+*/
+function generateCircleAppearance(annot) {
+	const [x1, y1, x2, y2] = annot.getRect();
+	const w = x2 - x1;
+	const h = y2 - y1;
+	const cx = w / 2;
+	const cy = h / 2;
+	const rx = w / 2;
+	const ry = h / 2;
+	const color = annot.getColor();
+	const opacity = annot.getOpacity();
+	const dict = annot.getDict();
+	const icObj = dict.get("/IC");
+	let interiorColor;
+	if (icObj && icObj.kind === "array" && icObj.items.length >= 3) interiorColor = {
+		r: icObj.items[0]?.value ?? 0,
+		g: icObj.items[1]?.value ?? 0,
+		b: icObj.items[2]?.value ?? 0
+	};
+	let borderWidth = 1;
+	const bsObj = dict.get("/BS");
+	if (bsObj && bsObj.kind === "dict") {
+		const wObj = bsObj.get("/W");
+		if (wObj && wObj.kind === "number") borderWidth = wObj.value;
+	}
+	const adjRx = rx - borderWidth / 2;
+	const adjRy = ry - borderWidth / 2;
+	const kx = KAPPA * adjRx;
+	const ky = KAPPA * adjRy;
+	let ops = "";
+	if (opacity < 1) ops += `${n(opacity)} ca ${n(opacity)} CA\n`;
+	const ellipsePath = `${n(cx)} ${n(cy + adjRy)} m\n${n(cx + kx)} ${n(cy + adjRy)} ${n(cx + adjRx)} ${n(cy + ky)} ${n(cx + adjRx)} ${n(cy)} c\n${n(cx + adjRx)} ${n(cy - ky)} ${n(cx + kx)} ${n(cy - adjRy)} ${n(cx)} ${n(cy - adjRy)} c\n${n(cx - kx)} ${n(cy - adjRy)} ${n(cx - adjRx)} ${n(cy - ky)} ${n(cx - adjRx)} ${n(cy)} c\n${n(cx - adjRx)} ${n(cy + ky)} ${n(cx - kx)} ${n(cy + adjRy)} ${n(cx)} ${n(cy + adjRy)} c\n`;
+	if (interiorColor) {
+		ops += `${n(interiorColor.r)} ${n(interiorColor.g)} ${n(interiorColor.b)} rg\n`;
+		if (color) ops += `${n(color.r)} ${n(color.g)} ${n(color.b)} RG\n`;
+		else ops += "0 0 0 RG\n";
+		ops += `${n(borderWidth)} w\n`;
+		ops += ellipsePath;
+		ops += "B\n";
+	} else {
+		if (color) ops += `${n(color.r)} ${n(color.g)} ${n(color.b)} RG\n`;
+		else ops += "0 0 0 RG\n";
+		ops += `${n(borderWidth)} w\n`;
+		ops += ellipsePath;
+		ops += "S\n";
+	}
+	return buildAppearanceStream(ops, [
+		0,
+		0,
+		w,
+		h
+	]);
+}
+/**
+* Generate appearance stream for a Line annotation.
+*/
+function generateLineAppearance(annot) {
+	const [rx1, ry1, rx2, ry2] = annot.getRect();
+	const w = rx2 - rx1;
+	const h = ry2 - ry1;
+	const color = annot.getColor();
+	const opacity = annot.getOpacity();
+	const dict = annot.getDict();
+	const lObj = dict.get("/L");
+	let lx1 = 0, ly1 = 0, lx2 = w, ly2 = h;
+	if (lObj && lObj.kind === "array" && lObj.items.length >= 4) {
+		lx1 = lObj.items[0]?.value ?? 0;
+		ly1 = lObj.items[1]?.value ?? 0;
+		lx2 = lObj.items[2]?.value ?? 0;
+		ly2 = lObj.items[3]?.value ?? 0;
+		lx1 -= rx1;
+		ly1 -= ry1;
+		lx2 -= rx1;
+		ly2 -= ry1;
+	}
+	let borderWidth = 1;
+	const bsObj = dict.get("/BS");
+	if (bsObj && bsObj.kind === "dict") {
+		const wObj = bsObj.get("/W");
+		if (wObj && wObj.kind === "number") borderWidth = wObj.value;
+	}
+	let ops = "";
+	if (opacity < 1) ops += `${n(opacity)} ca ${n(opacity)} CA\n`;
+	if (color) ops += `${n(color.r)} ${n(color.g)} ${n(color.b)} RG\n`;
+	else ops += "0 0 0 RG\n";
+	ops += `${n(borderWidth)} w\n`;
+	ops += `${n(lx1)} ${n(ly1)} m\n`;
+	ops += `${n(lx2)} ${n(ly2)} l\n`;
+	ops += "S\n";
+	return buildAppearanceStream(ops, [
+		0,
+		0,
+		w,
+		h
+	]);
+}
+/**
+* Generate appearance stream for a Highlight annotation.
+*/
+function generateHighlightAppearance(annot) {
+	const [x1, y1, x2, y2] = annot.getRect();
+	const w = x2 - x1;
+	const h = y2 - y1;
+	const color = annot.getColor() ?? {
+		r: 1,
+		g: 1,
+		b: 0
+	};
+	const opacity = annot.getOpacity();
+	let ops = "";
+	if (opacity < 1) ops += `${n(opacity)} ca\n`;
+	ops += `${n(color.r)} ${n(color.g)} ${n(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);
+		for (let i = 0; i + 7 < points.length; i += 8) {
+			const qx1 = points[i] - x1;
+			const qy1 = points[i + 1] - y1;
+			const qx2 = points[i + 2] - x1;
+			const qy2 = points[i + 3] - y1;
+			const qx3 = points[i + 4] - x1;
+			const qy3 = points[i + 5] - y1;
+			const qx4 = points[i + 6] - x1;
+			const qy4 = points[i + 7] - y1;
+			ops += `${n(qx1)} ${n(qy1)} m\n`;
+			ops += `${n(qx2)} ${n(qy2)} l\n`;
+			ops += `${n(qx4)} ${n(qy4)} l\n`;
+			ops += `${n(qx3)} ${n(qy3)} l\n`;
+			ops += "f\n";
+		}
+	} else {
+		ops += `0 0 ${n(w)} ${n(h)} re\n`;
+		ops += "f\n";
+	}
+	return buildAppearanceStream(ops, [
+		0,
+		0,
+		w,
+		h
+	]);
+}
+/**
+* Generate appearance stream for an Underline annotation.
+*/
+function generateUnderlineAppearance(annot) {
+	const [x1, y1, x2, y2] = annot.getRect();
+	const w = x2 - x1;
+	const h = y2 - y1;
+	const color = annot.getColor() ?? {
+		r: 0,
+		g: 0,
+		b: 1
+	};
+	let ops = "";
+	ops += `${n(color.r)} ${n(color.g)} ${n(color.b)} RG\n`;
+	ops += "1 w\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);
+		for (let i = 0; i + 7 < points.length; i += 8) {
+			const bx1 = points[i + 4] - x1;
+			const by1 = points[i + 5] - y1;
+			const bx2 = points[i + 6] - x1;
+			const by2 = points[i + 7] - y1;
+			ops += `${n(bx1)} ${n(by1)} m\n`;
+			ops += `${n(bx2)} ${n(by2)} l\n`;
+			ops += "S\n";
+		}
+	} else {
+		ops += `0 0 m\n`;
+		ops += `${n(w)} 0 l\n`;
+		ops += "S\n";
+	}
+	return buildAppearanceStream(ops, [
+		0,
+		0,
+		w,
+		h
+	]);
+}
+/**
+* Generate appearance stream for a Squiggly annotation.
+*/
+function generateSquigglyAppearance(annot) {
+	const [x1, y1, x2, y2] = annot.getRect();
+	const w = x2 - x1;
+	const h = y2 - y1;
+	const color = annot.getColor() ?? {
+		r: 0,
+		g: .5,
+		b: 0
+	};
+	let ops = "";
+	ops += `${n(color.r)} ${n(color.g)} ${n(color.b)} RG\n`;
+	ops += "0.5 w\n";
+	const amplitude = 2;
+	const period = 4;
+	ops += `0 ${n(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(x1p)} ${n(y1p)} l\n`;
+		if (x2p <= w) ops += `${n(x2p)} ${n(y2p)} l\n`;
+	}
+	ops += "S\n";
+	return buildAppearanceStream(ops, [
+		0,
+		0,
+		w,
+		h
+	]);
+}
+/**
+* Generate appearance stream for a StrikeOut annotation.
+*/
+function generateStrikeOutAppearance(annot) {
+	const [x1, y1, x2, y2] = annot.getRect();
+	const w = x2 - x1;
+	const h = y2 - y1;
+	const color = annot.getColor() ?? {
+		r: 1,
+		g: 0,
+		b: 0
+	};
+	let ops = "";
+	ops += `${n(color.r)} ${n(color.g)} ${n(color.b)} RG\n`;
+	ops += "1 w\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);
+		for (let i = 0; i + 7 < points.length; i += 8) {
+			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(leftX)} ${n(midY)} m\n`;
+			ops += `${n(rightX)} ${n(midY)} l\n`;
+			ops += "S\n";
+		}
+	} else {
+		const midY = h / 2;
+		ops += `0 ${n(midY)} m\n`;
+		ops += `${n(w)} ${n(midY)} l\n`;
+		ops += "S\n";
+	}
+	return buildAppearanceStream(ops, [
+		0,
+		0,
+		w,
+		h
+	]);
+}
+/**
+* Generate appearance stream for an Ink annotation.
+*/
+function generateInkAppearance(annot) {
+	const [x1, y1, x2, y2] = annot.getRect();
+	const w = x2 - x1;
+	const h = y2 - y1;
+	const color = annot.getColor() ?? {
+		r: 0,
+		g: 0,
+		b: 0
+	};
+	const opacity = annot.getOpacity();
+	let ops = "";
+	if (opacity < 1) ops += `${n(opacity)} ca ${n(opacity)} CA\n`;
+	ops += `${n(color.r)} ${n(color.g)} ${n(color.b)} RG\n`;
+	ops += "1 w\n";
+	ops += "1 J\n";
+	const inkListObj = annot.getDict().get("/InkList");
+	if (inkListObj && inkListObj.kind === "array") for (const pathObj of inkListObj.items) {
+		if (pathObj.kind !== "array") continue;
+		const points = pathObj.items.filter((item) => item.kind === "number").map((item) => item.value);
+		if (points.length >= 2) {
+			ops += `${n(points[0] - x1)} ${n(points[1] - y1)} m\n`;
+			for (let i = 2; i + 1 < points.length; i += 2) ops += `${n(points[i] - x1)} ${n(points[i + 1] - y1)} l\n`;
+			ops += "S\n";
+		}
+	}
+	return buildAppearanceStream(ops, [
+		0,
+		0,
+		w,
+		h
+	]);
+}
+/**
+* Generate appearance stream for a FreeText annotation.
+*
+* This requires access to the annotation's text, default appearance
+* string, and alignment.  We accept the annotation object directly
+* to access these properties.
+*/
+function generateFreeTextAppearance(annot) {
+	const [x1, y1, x2, y2] = annot.getRect();
+	const w = x2 - x1;
+	const h = y2 - y1;
+	const text = annot.getContents() ?? "";
+	const dict = annot.getDict();
+	let da = "0 0 0 rg /Helv 12 Tf";
+	const daObj = dict.get("/DA");
+	if (daObj && daObj.kind === "string") da = daObj.value;
+	let align = 0;
+	const qObj = dict.get("/Q");
+	if (qObj && qObj.kind === "number") align = qObj.value;
+	let fontSize = 12;
+	const fsMatch = /\/\w+\s+([\d.]+)\s+Tf/.exec(da);
+	if (fsMatch?.[1]) fontSize = parseFloat(fsMatch[1]);
+	let ops = "";
+	ops += `${da}\n`;
+	ops += "BT\n";
+	const margin = 2;
+	const textY = h - fontSize - margin;
+	if (align === 1) ops += `${n(w / 2)} ${n(textY)} Td\n`;
+	else if (align === 2) ops += `${n(w - margin)} ${n(textY)} Td\n`;
+	else ops += `${n(margin)} ${n(textY)} Td\n`;
+	const escapedText = text.replace(/\\/g, "\\\\").replace(/\(/g, "\\(").replace(/\)/g, "\\)");
+	ops += `(${escapedText}) Tj\n`;
+	ops += "ET\n";
+	const resources = new PdfDict();
+	const fontDict = new PdfDict();
+	const helvetica = new PdfDict();
+	helvetica.set("/Type", PdfName.of("Font"));
+	helvetica.set("/Subtype", PdfName.of("Type1"));
+	helvetica.set("/BaseFont", PdfName.of("Helvetica"));
+	fontDict.set("/Helv", helvetica);
+	resources.set("/Font", fontDict);
+	return buildAppearanceStream(ops, [
+		0,
+		0,
+		w,
+		h
+	], resources);
+}
+
+//#endregion
+//#region src/annotation/types/freeTextAnnotation.ts
+/**
+* @module annotation/types/freeTextAnnotation
+*
+* FreeText annotation — displays text directly on the page without
+* requiring the user to click an icon.
+*
+* Reference: PDF 1.7 spec, Section 12.5.6.6 (Free Text Annotations).
+*/
+const ALIGNMENT_MAP = {
+	left: 0,
+	center: 1,
+	right: 2
+};
+const ALIGNMENT_REVERSE = {
+	0: "left",
+	1: "center",
+	2: "right"
+};
+/**
+* A free text annotation (subtype /FreeText).
+*
+* Displays text directly on the page as if it were part of the page
+* content.  Does not require opening a popup.
+*/
+var PdfFreeTextAnnotation = class PdfFreeTextAnnotation extends PdfAnnotation {
+	constructor(dict) {
+		super("FreeText", dict);
+	}
+	/**
+	* Create a new free text annotation.
+	*/
+	static create(options) {
+		const annot = new PdfFreeTextAnnotation(buildAnnotationDict("FreeText", options));
+		const fontSize = options.fontSize ?? 12;
+		const da = options.defaultAppearance ?? `0 0 0 rg /Helv ${fontSize} Tf`;
+		annot.setDefaultAppearance(da);
+		if (options.text !== void 0) annot.setText(options.text);
+		if (options.alignment !== void 0) annot.setAlignment(options.alignment);
+		return annot;
+	}
+	/**
+	* Create from an existing dictionary.
+	*/
+	static fromDict(dict, resolver) {
+		return new PdfFreeTextAnnotation(dict);
+	}
+	/** Get the displayed text. */
+	getText() {
+		return this.getContents() ?? "";
+	}
+	/** Set the displayed text. */
+	setText(text) {
+		this.setContents(text);
+	}
+	/** Get the font size from the default appearance string. */
+	getFontSize() {
+		const da = this.getDefaultAppearance();
+		const match = /\/\w+\s+([\d.]+)\s+Tf/.exec(da);
+		if (match?.[1]) return parseFloat(match[1]);
+		return 12;
+	}
+	/** Set the font size (rebuilds the default appearance string). */
+	setFontSize(size) {
+		let da = this.getDefaultAppearance();
+		const replaced = da.replace(/(\/\w+)\s+[\d.]+\s+Tf/, `$1 ${size} Tf`);
+		if (replaced !== da) this.setDefaultAppearance(replaced);
+		else this.setDefaultAppearance(`${da} /Helv ${size} Tf`);
+	}
+	/** Get the text alignment. Defaults to 'left'. */
+	getAlignment() {
+		const obj = this.dict.get("/Q");
+		if (obj && obj.kind === "number") return ALIGNMENT_REVERSE[obj.value] ?? "left";
+		return "left";
+	}
+	/** Set the text alignment. */
+	setAlignment(align) {
+		this.dict.set("/Q", PdfNumber.of(ALIGNMENT_MAP[align]));
+	}
+	/** Get the default appearance string (/DA). */
+	getDefaultAppearance() {
+		const obj = this.dict.get("/DA");
+		if (obj && obj.kind === "string") return obj.value;
+		return "0 0 0 rg /Helv 12 Tf";
+	}
+	/** Set the default appearance string. */
+	setDefaultAppearance(da) {
+		this.dict.set("/DA", PdfString.literal(da));
+	}
+	/** Generate the appearance stream for this free text annotation. */
+	generateAppearance() {
+		return generateFreeTextAppearance(this);
+	}
+};
+
+//#endregion
+//#region src/annotation/types/markupAnnotations.ts
+/**
+* @module annotation/types/markupAnnotations
+*
+* Text markup annotations: Highlight, Underline, Squiggly, StrikeOut.
+*
+* These annotations use QuadPoints to define the regions of text they
+* mark.  Each quad is 8 numbers: the four corners of a quadrilateral
+* covering the text.
+*
+* Reference: PDF 1.7 spec, Section 12.5.6.10 (Text Markup Annotations).
+*/
+/** Extract QuadPoints from a dictionary. */
+function getQuadPointsFromDict(dict) {
+	const obj = dict.get("/QuadPoints");
+	if (obj && obj.kind === "array") return obj.items.filter((item) => item.kind === "number").map((item) => item.value);
+	return [];
+}
+/** Set QuadPoints on a dictionary. */
+function setQuadPointsOnDict(dict, points) {
+	dict.set("/QuadPoints", PdfArray.fromNumbers(points));
+}
+/** Create quad points from a rectangle (for convenience). */
+function rectToQuadPoints(rect) {
+	const [x1, y1, x2, y2] = rect;
+	return [
+		x1,
+		y2,
+		x2,
+		y2,
+		x1,
+		y1,
+		x2,
+		y1
+	];
+}
+/**
+* Highlight annotation (subtype /Highlight).
+*
+* Highlights text with a translucent colour overlay.
+*/
+var PdfHighlightAnnotation = class PdfHighlightAnnotation extends PdfAnnotation {
+	constructor(dict) {
+		super("Highlight", dict);
+	}
+	/** Create a new highlight annotation. */
+	static create(options) {
+		const annot = new PdfHighlightAnnotation(buildAnnotationDict("Highlight", options));
+		const qp = options.quadPoints ?? rectToQuadPoints(options.rect);
+		annot.setQuadPoints(qp);
+		return annot;
+	}
+	/**
+	* Convenience: create a highlight for a rectangle region.
+	*/
+	static createForRect(rect, color) {
+		return PdfHighlightAnnotation.create({
+			rect,
+			color: color ?? {
+				r: 1,
+				g: 1,
+				b: 0
+			}
+		});
+	}
+	static fromDict(dict, resolver) {
+		return new PdfHighlightAnnotation(dict);
+	}
+	/** Get the quad points array. */
+	getQuadPoints() {
+		return getQuadPointsFromDict(this.dict);
+	}
+	/** Set the quad points array. */
+	setQuadPoints(points) {
+		setQuadPointsOnDict(this.dict, points);
+	}
+	generateAppearance() {
+		return generateHighlightAppearance(this);
+	}
+};
+/**
+* Underline annotation (subtype /Underline).
+*/
+var PdfUnderlineAnnotation = class PdfUnderlineAnnotation extends PdfAnnotation {
+	constructor(dict) {
+		super("Underline", dict);
+	}
+	static create(options) {
+		const annot = new PdfUnderlineAnnotation(buildAnnotationDict("Underline", options));
+		const qp = options.quadPoints ?? rectToQuadPoints(options.rect);
+		annot.setQuadPoints(qp);
+		return annot;
+	}
+	static fromDict(dict, resolver) {
+		return new PdfUnderlineAnnotation(dict);
+	}
+	/** Get the quad points array. */
+	getQuadPoints() {
+		return getQuadPointsFromDict(this.dict);
+	}
+	/** Set the quad points array. */
+	setQuadPoints(points) {
+		setQuadPointsOnDict(this.dict, points);
+	}
+	generateAppearance() {
+		return generateUnderlineAppearance(this);
+	}
+};
+/**
+* Squiggly underline annotation (subtype /Squiggly).
+*/
+var PdfSquigglyAnnotation = class PdfSquigglyAnnotation extends PdfAnnotation {
+	constructor(dict) {
+		super("Squiggly", dict);
+	}
+	static create(options) {
+		const annot = new PdfSquigglyAnnotation(buildAnnotationDict("Squiggly", options));
+		const qp = options.quadPoints ?? rectToQuadPoints(options.rect);
+		annot.setQuadPoints(qp);
+		return annot;
+	}
+	static fromDict(dict, resolver) {
+		return new PdfSquigglyAnnotation(dict);
+	}
+	/** Get the quad points array. */
+	getQuadPoints() {
+		return getQuadPointsFromDict(this.dict);
+	}
+	/** Set the quad points array. */
+	setQuadPoints(points) {
+		setQuadPointsOnDict(this.dict, points);
+	}
+	generateAppearance() {
+		return generateSquigglyAppearance(this);
+	}
+};
+/**
+* Strike-out annotation (subtype /StrikeOut).
+*/
+var PdfStrikeOutAnnotation = class PdfStrikeOutAnnotation extends PdfAnnotation {
+	constructor(dict) {
+		super("StrikeOut", dict);
+	}
+	static create(options) {
+		const annot = new PdfStrikeOutAnnotation(buildAnnotationDict("StrikeOut", options));
+		const qp = options.quadPoints ?? rectToQuadPoints(options.rect);
+		annot.setQuadPoints(qp);
+		return annot;
+	}
+	static fromDict(dict, resolver) {
+		return new PdfStrikeOutAnnotation(dict);
+	}
+	/** Get the quad points array. */
+	getQuadPoints() {
+		return getQuadPointsFromDict(this.dict);
+	}
+	/** Set the quad points array. */
+	setQuadPoints(points) {
+		setQuadPointsOnDict(this.dict, points);
+	}
+	generateAppearance() {
+		return generateStrikeOutAppearance(this);
+	}
+};
+
+//#endregion
+//#region src/annotation/types/shapeAnnotations.ts
+/**
+* @module annotation/types/shapeAnnotations
+*
+* Geometric shape annotations: Line, Square, Circle, Polygon, PolyLine.
+*
+* Reference: PDF 1.7 spec, Sections 12.5.6.7-12.5.6.9.
+*/
+function getInteriorColor(dict) {
+	const obj = dict.get("/IC");
+	if (obj && obj.kind === "array" && obj.items.length >= 3) return {
+		r: obj.items[0]?.value ?? 0,
+		g: obj.items[1]?.value ?? 0,
+		b: obj.items[2]?.value ?? 0
+	};
+}
+function setInteriorColor(dict, color) {
+	dict.set("/IC", PdfArray.fromNumbers([
+		color.r,
+		color.g,
+		color.b
+	]));
+}
+/**
+* Line annotation (subtype /Line).
+*
+* Draws a straight line between two points on the page.
+*/
+var PdfLineAnnotation = class PdfLineAnnotation extends PdfAnnotation {
+	constructor(dict) {
+		super("Line", dict);
+	}
+	/**
+	* Create a new line annotation.
+	*/
+	static create(options) {
+		const annot = new PdfLineAnnotation(buildAnnotationDict("Line", options));
+		if (options.linePoints !== void 0) annot.setLinePoints(options.linePoints);
+		if (options.lineEndingStart !== void 0 || options.lineEndingEnd !== void 0) annot.setLineEndingStyles(options.lineEndingStart ?? "None", options.lineEndingEnd ?? "None");
+		return annot;
+	}
+	static fromDict(dict, resolver) {
+		return new PdfLineAnnotation(dict);
+	}
+	/** Get the line endpoints [x1, y1, x2, y2]. */
+	getLinePoints() {
+		const obj = this.dict.get("/L");
+		if (obj && obj.kind === "array" && obj.items.length >= 4) return [
+			obj.items[0]?.value ?? 0,
+			obj.items[1]?.value ?? 0,
+			obj.items[2]?.value ?? 0,
+			obj.items[3]?.value ?? 0
+		];
+		return [
+			0,
+			0,
+			0,
+			0
+		];
+	}
+	/** Set the line endpoints. */
+	setLinePoints(points) {
+		this.dict.set("/L", PdfArray.fromNumbers(points));
+	}
+	/** Get the line ending styles [start, end]. */
+	getLineEndingStyles() {
+		const obj = this.dict.get("/LE");
+		if (obj && obj.kind === "array" && obj.items.length >= 2) {
+			const start = obj.items[0];
+			const end = obj.items[1];
+			return [start && start.kind === "name" ? start.value.startsWith("/") ? start.value.slice(1) : start.value : "None", end && end.kind === "name" ? end.value.startsWith("/") ? end.value.slice(1) : end.value : "None"];
+		}
+		return ["None", "None"];
+	}
+	/** Set the line ending styles. */
+	setLineEndingStyles(start, end) {
+		this.dict.set("/LE", PdfArray.of([PdfName.of(start), PdfName.of(end)]));
+	}
+	generateAppearance() {
+		return generateLineAppearance(this);
+	}
+};
+/**
+* Square annotation (subtype /Square).
+*
+* Draws a rectangle on the page.
+*/
+var PdfSquareAnnotation = class PdfSquareAnnotation extends PdfAnnotation {
+	constructor(dict) {
+		super("Square", dict);
+	}
+	static create(options) {
+		const annot = new PdfSquareAnnotation(buildAnnotationDict("Square", options));
+		if (options.interiorColor !== void 0) annot.setInteriorColor(options.interiorColor);
+		return annot;
+	}
+	static fromDict(dict, resolver) {
+		return new PdfSquareAnnotation(dict);
+	}
+	/** Get the interior (fill) color. */
+	getInteriorColor() {
+		return getInteriorColor(this.dict);
+	}
+	/** Set the interior (fill) color. */
+	setInteriorColor(color) {
+		setInteriorColor(this.dict, color);
+	}
+	generateAppearance() {
+		return generateSquareAppearance(this);
+	}
+};
+/**
+* Circle annotation (subtype /Circle).
+*
+* Draws an ellipse inscribed within the annotation rectangle.
+*/
+var PdfCircleAnnotation = class PdfCircleAnnotation extends PdfAnnotation {
+	constructor(dict) {
+		super("Circle", dict);
+	}
+	static create(options) {
+		const annot = new PdfCircleAnnotation(buildAnnotationDict("Circle", options));
+		if (options.interiorColor !== void 0) annot.setInteriorColor(options.interiorColor);
+		return annot;
+	}
+	static fromDict(dict, resolver) {
+		return new PdfCircleAnnotation(dict);
+	}
+	/** Get the interior (fill) color. */
+	getInteriorColor() {
+		return getInteriorColor(this.dict);
+	}
+	/** Set the interior (fill) color. */
+	setInteriorColor(color) {
+		setInteriorColor(this.dict, color);
+	}
+	generateAppearance() {
+		return generateCircleAppearance(this);
+	}
+};
+/**
+* Polygon annotation (subtype /Polygon).
+*
+* Draws a closed polygon on the page.
+*/
+var PdfPolygonAnnotation = class PdfPolygonAnnotation extends PdfAnnotation {
+	constructor(dict) {
+		super("Polygon", dict);
+	}
+	static create(options) {
+		const annot = new PdfPolygonAnnotation(buildAnnotationDict("Polygon", options));
+		if (options.vertices !== void 0) annot.setVertices(options.vertices);
+		if (options.interiorColor !== void 0) annot.setInteriorColor(options.interiorColor);
+		return annot;
+	}
+	static fromDict(dict, resolver) {
+		return new PdfPolygonAnnotation(dict);
+	}
+	/** Get the polygon vertices as a flat array [x1,y1,x2,y2,...]. */
+	getVertices() {
+		const obj = this.dict.get("/Vertices");
+		if (obj && obj.kind === "array") return obj.items.filter((item) => item.kind === "number").map((item) => item.value);
+		return [];
+	}
+	/** Set the polygon vertices. */
+	setVertices(vertices) {
+		this.dict.set("/Vertices", PdfArray.fromNumbers(vertices));
+	}
+	/** Get the interior (fill) color. */
+	getInteriorColor() {
+		return getInteriorColor(this.dict);
+	}
+	/** Set the interior (fill) color. */
+	setInteriorColor(color) {
+		setInteriorColor(this.dict, color);
+	}
+};
+/**
+* PolyLine annotation (subtype /PolyLine).
+*
+* Draws an open polyline (series of connected line segments).
+*/
+var PdfPolyLineAnnotation = class PdfPolyLineAnnotation extends PdfAnnotation {
+	constructor(dict) {
+		super("PolyLine", dict);
+	}
+	static create(options) {
+		const annot = new PdfPolyLineAnnotation(buildAnnotationDict("PolyLine", options));
+		if (options.vertices !== void 0) annot.setVertices(options.vertices);
+		return annot;
+	}
+	static fromDict(dict, resolver) {
+		return new PdfPolyLineAnnotation(dict);
+	}
+	/** Get the polyline vertices as a flat array [x1,y1,x2,y2,...]. */
+	getVertices() {
+		const obj = this.dict.get("/Vertices");
+		if (obj && obj.kind === "array") return obj.items.filter((item) => item.kind === "number").map((item) => item.value);
+		return [];
+	}
+	/** Set the polyline vertices. */
+	setVertices(vertices) {
+		this.dict.set("/Vertices", PdfArray.fromNumbers(vertices));
+	}
+};
+
+//#endregion
+//#region src/annotation/types/stampAnnotation.ts
+/**
+* @module annotation/types/stampAnnotation
+*
+* Stamp annotation — displays a predefined or custom rubber stamp
+* on the page (e.g. "Approved", "Draft", "Confidential").
+*
+* Reference: PDF 1.7 spec, Section 12.5.6.12 (Rubber Stamp Annotations).
+*/
+/**
+* A stamp annotation (subtype /Stamp).
+*
+* Displays a graphical stamp on the page, similar to a rubber stamp
+* applied to a physical document.
+*/
+var PdfStampAnnotation = class PdfStampAnnotation extends PdfAnnotation {
+	constructor(dict) {
+		super("Stamp", dict);
+	}
+	/**
+	* Create a new stamp annotation.
+	*/
+	static create(options) {
+		const annot = new PdfStampAnnotation(buildAnnotationDict("Stamp", options));
+		annot.setStampName(options.stampName ?? "Draft");
+		return annot;
+	}
+	static fromDict(dict, resolver) {
+		return new PdfStampAnnotation(dict);
+	}
+	/** Get the stamp name (e.g. 'Approved', 'Draft'). */
+	getStampName() {
+		const obj = this.dict.get("/Name");
+		if (obj && obj.kind === "name") return obj.value.startsWith("/") ? obj.value.slice(1) : obj.value;
+		return "Draft";
+	}
+	/** Set the stamp name. */
+	setStampName(name) {
+		this.dict.set("/Name", PdfName.of(name));
+	}
+};
+
+//#endregion
+//#region src/annotation/types/inkAnnotation.ts
+/**
+* @module annotation/types/inkAnnotation
+*
+* Ink annotation — represents freehand "scribble" composed of one
+* or more disjoint paths (ink lists).
+*
+* Reference: PDF 1.7 spec, Section 12.5.6.13 (Ink Annotations).
+*/
+/**
+* An ink annotation (subtype /Ink).
+*
+* Contains one or more ink paths, each being an array of coordinate
+* pairs [x1,y1,x2,y2,...] representing a freehand stroke.
+*/
+var PdfInkAnnotation = class PdfInkAnnotation extends PdfAnnotation {
+	constructor(dict) {
+		super("Ink", dict);
+	}
+	/**
+	* Create a new ink annotation.
+	*/
+	static create(options) {
+		const annot = new PdfInkAnnotation(buildAnnotationDict("Ink", options));
+		if (options.inkLists !== void 0) for (const list of options.inkLists) annot.addInkList(list);
+		return annot;
+	}
+	static fromDict(dict, resolver) {
+		return new PdfInkAnnotation(dict);
+	}
+	/**
+	* Get all ink lists.
+	*
+	* Each ink list is an array of numbers [x1,y1,x2,y2,...] representing
+	* a single stroke path.
+	*/
+	getInkLists() {
+		const obj = this.dict.get("/InkList");
+		if (!obj || obj.kind !== "array") return [];
+		const lists = [];
+		for (const item of obj.items) if (item.kind === "array") {
+			const points = item.items.filter((p) => p.kind === "number").map((p) => p.value);
+			lists.push(points);
+		}
+		return lists;
+	}
+	/**
+	* Add a new ink stroke path.
+	*
+	* @param points Array of coordinate pairs [x1,y1,x2,y2,...].
+	*/
+	addInkList(points) {
+		let inkListArr = this.dict.get("/InkList");
+		if (!inkListArr || inkListArr.kind !== "array") {
+			inkListArr = new PdfArray();
+			this.dict.set("/InkList", inkListArr);
+		}
+		inkListArr.push(PdfArray.fromNumbers(points));
+	}
+	/** Remove all ink stroke paths. */
+	clearInkLists() {
+		this.dict.set("/InkList", new PdfArray());
+	}
+	generateAppearance() {
+		return generateInkAppearance(this);
+	}
+};
+
+//#endregion
+//#region src/annotation/types/redactAnnotation.ts
+/**
+* @module annotation/types/redactAnnotation
+*
+* Redact annotation — marks a region of the page for redaction.
+* When applied, the redacted content is permanently removed and
+* the area is covered with an overlay.
+*
+* Reference: PDF 1.7 spec, Section 12.5.6.23 (Redaction Annotations).
+*/
+/**
+* A redaction annotation (subtype /Redact).
+*
+* Marks content for redaction.  The annotation itself is a marker;
+* the actual redaction (content removal) must be applied separately.
+*/
+var PdfRedactAnnotation = class PdfRedactAnnotation extends PdfAnnotation {
+	constructor(dict) {
+		super("Redact", dict);
+	}
+	/**
+	* Create a new redact annotation.
+	*/
+	static create(options) {
+		const annot = new PdfRedactAnnotation(buildAnnotationDict("Redact", options));
+		if (options.overlayText !== void 0) annot.setOverlayText(options.overlayText);
+		if (options.interiorColor !== void 0) annot.setInteriorColor(options.interiorColor);
+		if (options.quadPoints !== void 0) annot.setQuadPoints(options.quadPoints);
+		return annot;
+	}
+	static fromDict(dict, resolver) {
+		return new PdfRedactAnnotation(dict);
+	}
+	/** Get the overlay text displayed after redaction is applied. */
+	getOverlayText() {
+		const obj = this.dict.get("/OverlayText");
+		if (obj && obj.kind === "string") return obj.value;
+	}
+	/** Set the overlay text. */
+	setOverlayText(text) {
+		this.dict.set("/OverlayText", PdfString.literal(text));
+	}
+	/** Get the interior (fill) color used after redaction. */
+	getInteriorColor() {
+		const obj = this.dict.get("/IC");
+		if (obj && obj.kind === "array" && obj.items.length >= 3) return {
+			r: obj.items[0]?.value ?? 0,
+			g: obj.items[1]?.value ?? 0,
+			b: obj.items[2]?.value ?? 0
+		};
+	}
+	/** Set the interior color. */
+	setInteriorColor(color) {
+		this.dict.set("/IC", PdfArray.fromNumbers([
+			color.r,
+			color.g,
+			color.b
+		]));
+	}
+	/** Get the quad points (regions to redact). */
+	getQuadPoints() {
+		const obj = this.dict.get("/QuadPoints");
+		if (obj && obj.kind === "array") return obj.items.filter((item) => item.kind === "number").map((item) => item.value);
+	}
+	/** Set the quad points. */
+	setQuadPoints(points) {
+		this.dict.set("/QuadPoints", PdfArray.fromNumbers(points));
+	}
+};
+
+//#endregion
+//#region src/parser/textExtractor.ts
+/**
+* @module parser/textExtractor
+*
+* Extract text content from parsed PDF content streams.  Supports both
+* simple text extraction (concatenated strings) and position-aware
+* extraction that tracks the text matrix to compute x/y coordinates.
+*
+* Handles:
+* - All PDF text-showing operators: `Tj`, `TJ`, `'`, `"`
+* - Text-positioning operators: `Td`, `TD`, `Tm`, `T*`
+* - Font selection: `Tf`
+* - Graphics state: `q`/`Q`, `cm`
+* - WinAnsiEncoding (standard single-byte)
+* - Identity-H CID fonts with ToUnicode CMap
+*
+* Reference: PDF 1.7 spec, §9 (Text).
+*
+* @packageDocumentation
+*/
+/**
+* Extract plain text from a sequence of parsed content-stream operators.
+*
+* This function concatenates all text-showing operator strings, inserting
+* spaces between text objects (BT/ET blocks) and newlines at line breaks
+* (`T*`, `Td`, `TD`).
+*
+* @param operators - Parsed content-stream operators.
+* @param resources - Optional page `/Resources` dictionary (used to look
+*                    up font encodings and ToUnicode CMaps).
+* @param options   - Extraction options.
+* @returns The extracted text as a single string.
+*/
+function extractText(operators, resources, options) {
+	if (options?.withPositions) return extractTextWithPositions(operators, resources).map((item) => item.text).join(" ");
+	const state = new TextState(resources);
+	const parts = [];
+	let lineHasContent = false;
+	for (const op of operators) switch (op.operator) {
+		case "BT":
+			state.resetTextMatrix();
+			if (parts.length > 0 && lineHasContent) parts.push(" ");
+			lineHasContent = false;
+			break;
+		case "ET": break;
+		case "Tf":
+			state.setFont(operandAsString(op.operands[0]), operandAsNumber(op.operands[1]));
+			break;
+		case "Tc":
+			state.charSpacing = operandAsNumber(op.operands[0]);
+			break;
+		case "Tw":
+			state.wordSpacing = operandAsNumber(op.operands[0]);
+			break;
+		case "TL":
+			state.leading = operandAsNumber(op.operands[0]);
+			break;
+		case "Tz":
+			state.horizontalScaling = operandAsNumber(op.operands[0]);
+			break;
+		case "Ts":
+			state.rise = operandAsNumber(op.operands[0]);
+			break;
+		case "Td": {
+			const tx = operandAsNumber(op.operands[0]);
+			const ty = operandAsNumber(op.operands[1]);
+			state.moveText(tx, ty);
+			if (Math.abs(ty) > .5 && lineHasContent) {
+				parts.push("\n");
+				lineHasContent = false;
+			} else if (Math.abs(tx) > state.fontSize * .3 && lineHasContent) parts.push(" ");
+			break;
+		}
+		case "TD": {
+			const tx = operandAsNumber(op.operands[0]);
+			const ty = operandAsNumber(op.operands[1]);
+			state.leading = -ty;
+			state.moveText(tx, ty);
+			if (Math.abs(ty) > .5 && lineHasContent) {
+				parts.push("\n");
+				lineHasContent = false;
+			}
+			break;
+		}
+		case "Tm":
+			state.setTextMatrix(operandAsNumber(op.operands[0]), operandAsNumber(op.operands[1]), operandAsNumber(op.operands[2]), operandAsNumber(op.operands[3]), operandAsNumber(op.operands[4]), operandAsNumber(op.operands[5]));
+			break;
+		case "T*":
+			state.nextLine();
+			if (lineHasContent) {
+				parts.push("\n");
+				lineHasContent = false;
+			}
+			break;
+		case "Tj": {
+			const text = state.decodeString(op.operands[0]);
+			if (text.length > 0) {
+				parts.push(text);
+				lineHasContent = true;
+			}
+			break;
+		}
+		case "TJ": {
+			const text = state.decodeTJArray(op.operands[0]);
+			if (text.length > 0) {
+				parts.push(text);
+				lineHasContent = true;
+			}
+			break;
+		}
+		case "'": {
+			state.nextLine();
+			if (lineHasContent) {
+				parts.push("\n");
+				lineHasContent = false;
+			}
+			const text = state.decodeString(op.operands[0]);
+			if (text.length > 0) {
+				parts.push(text);
+				lineHasContent = true;
+			}
+			break;
+		}
+		case "\"": {
+			state.wordSpacing = operandAsNumber(op.operands[0]);
+			state.charSpacing = operandAsNumber(op.operands[1]);
+			state.nextLine();
+			if (lineHasContent) {
+				parts.push("\n");
+				lineHasContent = false;
+			}
+			const text = state.decodeString(op.operands[2]);
+			if (text.length > 0) {
+				parts.push(text);
+				lineHasContent = true;
+			}
+			break;
+		}
+		case "q":
+			state.save();
+			break;
+		case "Q":
+			state.restore();
+			break;
+		case "cm":
+			state.concatCTM(operandAsNumber(op.operands[0]), operandAsNumber(op.operands[1]), operandAsNumber(op.operands[2]), operandAsNumber(op.operands[3]), operandAsNumber(op.operands[4]), operandAsNumber(op.operands[5]));
+			break;
+		default: break;
+	}
+	return parts.join("");
+}
+/**
+* Extract text with position information from a parsed content stream.
+*
+* Each returned {@link TextItem} includes the text string, its position
+* (x, y), dimensions (width, height), font size, and font name.
+*
+* @param operators - Parsed content-stream operators.
+* @param resources - Optional page `/Resources` dictionary.
+* @returns An array of positioned text items.
+*/
+function extractTextWithPositions(operators, resources) {
+	const state = new TextState(resources);
+	const items = [];
+	for (const op of operators) switch (op.operator) {
+		case "BT":
+			state.resetTextMatrix();
+			break;
+		case "ET": break;
+		case "Tf":
+			state.setFont(operandAsString(op.operands[0]), operandAsNumber(op.operands[1]));
+			break;
+		case "Tc":
+			state.charSpacing = operandAsNumber(op.operands[0]);
+			break;
+		case "Tw":
+			state.wordSpacing = operandAsNumber(op.operands[0]);
+			break;
+		case "TL":
+			state.leading = operandAsNumber(op.operands[0]);
+			break;
+		case "Tz":
+			state.horizontalScaling = operandAsNumber(op.operands[0]);
+			break;
+		case "Ts":
+			state.rise = operandAsNumber(op.operands[0]);
+			break;
+		case "Td":
+			state.moveText(operandAsNumber(op.operands[0]), operandAsNumber(op.operands[1]));
+			break;
+		case "TD": {
+			const tx = operandAsNumber(op.operands[0]);
+			const ty = operandAsNumber(op.operands[1]);
+			state.leading = -ty;
+			state.moveText(tx, ty);
+			break;
+		}
+		case "Tm":
+			state.setTextMatrix(operandAsNumber(op.operands[0]), operandAsNumber(op.operands[1]), operandAsNumber(op.operands[2]), operandAsNumber(op.operands[3]), operandAsNumber(op.operands[4]), operandAsNumber(op.operands[5]));
+			break;
+		case "T*":
+			state.nextLine();
+			break;
+		case "Tj": {
+			const text = state.decodeString(op.operands[0]);
+			if (text.length > 0) {
+				const pos = state.getTextPosition();
+				items.push({
+					text,
+					x: pos.x,
+					y: pos.y,
+					width: state.estimateWidth(text),
+					height: state.fontSize,
+					fontSize: state.fontSize,
+					fontName: state.fontName
+				});
+				state.advanceByText(text);
+			}
+			break;
+		}
+		case "TJ": {
+			const operand = op.operands[0];
+			if (Array.isArray(operand)) for (const elem of operand) if (typeof elem === "number") state.advanceByDisplacement(-elem);
+			else {
+				const text = state.decodeString(elem);
+				if (text.length > 0) {
+					const pos = state.getTextPosition();
+					items.push({
+						text,
+						x: pos.x,
+						y: pos.y,
+						width: state.estimateWidth(text),
+						height: state.fontSize,
+						fontSize: state.fontSize,
+						fontName: state.fontName
+					});
+					state.advanceByText(text);
+				}
+			}
+			break;
+		}
+		case "'":
+			state.nextLine();
+			{
+				const text = state.decodeString(op.operands[0]);
+				if (text.length > 0) {
+					const pos = state.getTextPosition();
+					items.push({
+						text,
+						x: pos.x,
+						y: pos.y,
+						width: state.estimateWidth(text),
+						height: state.fontSize,
+						fontSize: state.fontSize,
+						fontName: state.fontName
+					});
+					state.advanceByText(text);
+				}
+			}
+			break;
+		case "\"":
+			state.wordSpacing = operandAsNumber(op.operands[0]);
+			state.charSpacing = operandAsNumber(op.operands[1]);
+			state.nextLine();
+			{
+				const text = state.decodeString(op.operands[2]);
+				if (text.length > 0) {
+					const pos = state.getTextPosition();
+					items.push({
+						text,
+						x: pos.x,
+						y: pos.y,
+						width: state.estimateWidth(text),
+						height: state.fontSize,
+						fontSize: state.fontSize,
+						fontName: state.fontName
+					});
+					state.advanceByText(text);
+				}
+			}
+			break;
+		case "q":
+			state.save();
+			break;
+		case "Q":
+			state.restore();
+			break;
+		case "cm":
+			state.concatCTM(operandAsNumber(op.operands[0]), operandAsNumber(op.operands[1]), operandAsNumber(op.operands[2]), operandAsNumber(op.operands[3]), operandAsNumber(op.operands[4]), operandAsNumber(op.operands[5]));
+			break;
+		default: break;
+	}
+	return items;
+}
+/**
+* Parse a ToUnicode CMap stream into a lookup map.
+*
+* Handles the two standard mapping constructs:
+* - `beginbfchar` / `endbfchar` — single code-to-Unicode mappings
+* - `beginbfrange` / `endbfrange` — range-based mappings
+*
+* @param data - The raw CMap stream bytes (already decompressed).
+* @returns A parsed CMap.
+*/
+function parseToUnicodeCMap(data) {
+	const text = decodeText(data);
+	const map = /* @__PURE__ */ new Map();
+	parseBfCharSections(text, map);
+	parseBfRangeSections(text, map);
+	return { map };
+}
+/**
+* Parse all `beginbfchar`/`endbfchar` sections in a CMap.
+*/
+function parseBfCharSections(text, map) {
+	const regex = /beginbfchar\s*([\s\S]*?)\s*endbfchar/g;
+	let match;
+	while ((match = regex.exec(text)) !== null) {
+		const body = match[1];
+		const lineRegex = /<([0-9a-fA-F]+)>\s*<([0-9a-fA-F]+)>/g;
+		let lineMatch;
+		while ((lineMatch = lineRegex.exec(body)) !== null) {
+			const srcCode = parseInt(lineMatch[1], 16);
+			const dstString = hexToUnicode(lineMatch[2]);
+			map.set(srcCode, dstString);
+		}
+	}
+}
+/**
+* Parse all `beginbfrange`/`endbfrange` sections in a CMap.
+*/
+function parseBfRangeSections(text, map) {
+	const regex = /beginbfrange\s*([\s\S]*?)\s*endbfrange/g;
+	let match;
+	while ((match = regex.exec(text)) !== null) {
+		const body = match[1];
+		const lineRegex = /<([0-9a-fA-F]+)>\s*<([0-9a-fA-F]+)>\s*(?:<([0-9a-fA-F]+)>|\[([\s\S]*?)\])/g;
+		let lineMatch;
+		while ((lineMatch = lineRegex.exec(body)) !== null) {
+			const srcLow = parseInt(lineMatch[1], 16);
+			const srcHigh = parseInt(lineMatch[2], 16);
+			if (lineMatch[3]) {
+				let dstCode = parseInt(lineMatch[3], 16);
+				for (let code = srcLow; code <= srcHigh; code++) {
+					map.set(code, codePointToString(dstCode));
+					dstCode++;
+				}
+			} else if (lineMatch[4]) {
+				const arrRegex = /<([0-9a-fA-F]+)>/g;
+				let arrMatch;
+				let code = srcLow;
+				while ((arrMatch = arrRegex.exec(lineMatch[4])) !== null && code <= srcHigh) {
+					map.set(code, hexToUnicode(arrMatch[1]));
+					code++;
+				}
+			}
+		}
+	}
+}
+/**
+* Convert a hex string (2 or 4 hex chars per code point) to a Unicode
+* string.
+*/
+function hexToUnicode(hex) {
+	let result = "";
+	const step = hex.length <= 4 ? hex.length : 4;
+	for (let i = 0; i < hex.length; i += step) {
+		const chunk = hex.substring(i, i + step);
+		const code = parseInt(chunk, 16);
+		if (!isNaN(code)) result += String.fromCodePoint(code);
+	}
+	return result;
+}
+/**
+* Convert a numeric code point to a string.
+*/
+function codePointToString(code) {
+	return String.fromCodePoint(code);
+}
+/**
+* WinAnsiEncoding table for bytes 0x80-0x9F that differ from Latin-1.
+* Bytes 0x00-0x7F and 0xA0-0xFF map directly to their Unicode code points.
+*/
+const WIN_ANSI_SPECIAL = {
+	128: 8364,
+	130: 8218,
+	131: 402,
+	132: 8222,
+	133: 8230,
+	134: 8224,
+	135: 8225,
+	136: 710,
+	137: 8240,
+	138: 352,
+	139: 8249,
+	140: 338,
+	142: 381,
+	145: 8216,
+	146: 8217,
+	147: 8220,
+	148: 8221,
+	149: 8226,
+	150: 8211,
+	151: 8212,
+	152: 732,
+	153: 8482,
+	154: 353,
+	155: 8250,
+	156: 339,
+	158: 382,
+	159: 376
+};
+/**
+* Decode a single byte using WinAnsiEncoding.
+*/
+function winAnsiDecode(byte) {
+	if (Object.hasOwn(WIN_ANSI_SPECIAL, byte)) return String.fromCodePoint(WIN_ANSI_SPECIAL[byte]);
+	return String.fromCharCode(byte);
+}
+/** Identity matrix. */
+function identityMatrix() {
+	return [
+		1,
+		0,
+		0,
+		1,
+		0,
+		0
+	];
+}
+/**
+* Multiply two 3x3 matrices (stored as 6-element arrays).
+* Result = A * B
+*/
+function multiplyMatrices(a, b) {
+	return [
+		a[0] * b[0] + a[1] * b[2],
+		a[0] * b[1] + a[1] * b[3],
+		a[2] * b[0] + a[3] * b[2],
+		a[2] * b[1] + a[3] * b[3],
+		a[4] * b[0] + a[5] * b[2] + b[4],
+		a[4] * b[1] + a[5] * b[3] + b[5]
+	];
+}
+/**
+* Tracks the graphics/text state needed for text extraction.
+*/
+var TextState = class {
+	/** Current transformation matrix (CTM). */
+	ctm = identityMatrix();
+	/** Text matrix — set by Tm, updated by Td/TD/T*. */
+	textMatrix = identityMatrix();
+	/** Text line matrix — the matrix at the start of the current line. */
+	textLineMatrix = identityMatrix();
+	/** Current font resource name. */
+	fontName = "";
+	/** Current font size. */
+	fontSize = 12;
+	/** Character spacing (Tc). */
+	charSpacing = 0;
+	/** Word spacing (Tw). */
+	wordSpacing = 0;
+	/** Horizontal scaling (Tz) as a percentage (100 = normal). */
+	horizontalScaling = 100;
+	/** Text leading (TL). */
+	leading = 0;
+	/** Text rise (Ts). */
+	rise = 0;
+	/** Graphics state stack for q/Q. */
+	stateStack = [];
+	/** Page resources dictionary. */
+	resources;
+	/** Cache of parsed ToUnicode CMaps per font name. */
+	cmapCache = /* @__PURE__ */ new Map();
+	/** Cache of font encoding type per font name. */
+	fontEncodingCache = /* @__PURE__ */ new Map();
+	/** Cache of whether a font is a CID (2-byte) font. */
+	cidFontCache = /* @__PURE__ */ new Map();
+	constructor(resources) {
+		this.resources = resources;
+		if (resources) this.analyzeFonts(resources);
+	}
+	/**
+	* Pre-analyze fonts from the resources dictionary to determine encoding
+	* types and cache ToUnicode CMaps.
+	*/
+	analyzeFonts(resources) {
+		const fonts = resources.get("/Font");
+		if (!(fonts instanceof PdfDict)) return;
+		for (const [name, fontObj] of fonts) {
+			if (!(fontObj instanceof PdfDict)) continue;
+			const subtype = fontObj.get("/Subtype");
+			const isCid = subtype instanceof PdfName && (subtype.value === "/Type0" || subtype.value === "/CIDFontType0" || subtype.value === "/CIDFontType2");
+			this.cidFontCache.set(name, isCid);
+			const encoding = fontObj.get("/Encoding");
+			if (encoding instanceof PdfName) this.fontEncodingCache.set(name, encoding.value.replace(/^\//, ""));
+			const toUnicode = fontObj.get("/ToUnicode");
+			if (toUnicode instanceof PdfStream) try {
+				const cmap = parseToUnicodeCMap(toUnicode.data);
+				this.cmapCache.set(name, cmap);
+			} catch {
+				this.cmapCache.set(name, null);
+			}
+		}
+	}
+	/**
+	* Save the current graphics state (q).
+	*/
+	save() {
+		this.stateStack.push({
+			ctm: [...this.ctm],
+			fontName: this.fontName,
+			fontSize: this.fontSize,
+			charSpacing: this.charSpacing,
+			wordSpacing: this.wordSpacing,
+			horizontalScaling: this.horizontalScaling,
+			leading: this.leading,
+			rise: this.rise
+		});
+	}
+	/**
+	* Restore the previously saved graphics state (Q).
+	*/
+	restore() {
+		const saved = this.stateStack.pop();
+		if (saved) {
+			this.ctm = saved.ctm;
+			this.fontName = saved.fontName;
+			this.fontSize = saved.fontSize;
+			this.charSpacing = saved.charSpacing;
+			this.wordSpacing = saved.wordSpacing;
+			this.horizontalScaling = saved.horizontalScaling;
+			this.leading = saved.leading;
+			this.rise = saved.rise;
+		}
+	}
+	/**
+	* Concatenate a matrix with the CTM (cm).
+	*/
+	concatCTM(a, b, c, d, e, f) {
+		this.ctm = multiplyMatrices([
+			a,
+			b,
+			c,
+			d,
+			e,
+			f
+		], this.ctm);
+	}
+	/**
+	* Reset the text matrix to identity (called at BT).
+	*/
+	resetTextMatrix() {
+		this.textMatrix = identityMatrix();
+		this.textLineMatrix = identityMatrix();
+	}
+	/**
+	* Set the font and size (Tf).
+	*/
+	setFont(name, size) {
+		this.fontName = name.startsWith("/") ? name : `/${name}`;
+		this.fontSize = size;
+	}
+	/**
+	* Move text position (Td).
+	*/
+	moveText(tx, ty) {
+		this.textLineMatrix = multiplyMatrices([
+			1,
+			0,
+			0,
+			1,
+			tx,
+			ty
+		], this.textLineMatrix);
+		this.textMatrix = [...this.textLineMatrix];
+	}
+	/**
+	* Set the text matrix directly (Tm).
+	*/
+	setTextMatrix(a, b, c, d, e, f) {
+		this.textMatrix = [
+			a,
+			b,
+			c,
+			d,
+			e,
+			f
+		];
+		this.textLineMatrix = [
+			a,
+			b,
+			c,
+			d,
+			e,
+			f
+		];
+	}
+	/**
+	* Move to the start of the next line (T*).
+	* Equivalent to: 0 -TL Td
+	*/
+	nextLine() {
+		this.moveText(0, -this.leading);
+	}
+	/**
+	* Get the current text position in user-space coordinates.
+	*/
+	getTextPosition() {
+		const combined = multiplyMatrices(this.textMatrix, this.ctm);
+		return {
+			x: combined[4],
+			y: combined[5]
+		};
+	}
+	/**
+	* Estimate the width of a text string in user-space units.
+	*
+	* Uses a rough heuristic: 0.5 * fontSize per character for standard
+	* fonts.  A production implementation would use font metrics.
+	*/
+	estimateWidth(text) {
+		const avgCharWidth = .5;
+		const hScale = this.horizontalScaling / 100;
+		return text.length * this.fontSize * avgCharWidth * hScale;
+	}
+	/**
+	* Advance the text matrix by the width of the given text.
+	*/
+	advanceByText(text) {
+		this.textMatrix = multiplyMatrices([
+			1,
+			0,
+			0,
+			1,
+			this.estimateWidth(text),
+			0
+		], this.textMatrix);
+	}
+	/**
+	* Advance the text matrix by a TJ displacement value.
+	*
+	* The displacement is in thousandths of a unit of text space.
+	*/
+	advanceByDisplacement(displacement) {
+		this.textMatrix = multiplyMatrices([
+			1,
+			0,
+			0,
+			1,
+			displacement / 1e3 * this.fontSize * (this.horizontalScaling / 100),
+			0
+		], this.textMatrix);
+	}
+	/**
+	* Decode an operand (string or hex string) into a readable text string.
+	*
+	* Uses the current font's ToUnicode CMap if available, otherwise falls
+	* back to WinAnsiEncoding or direct code-point mapping.
+	*/
+	decodeString(operand) {
+		if (operand == null) return "";
+		if (typeof operand === "number") return "";
+		const raw = typeof operand === "string" ? operand : String(operand);
+		const cmap = this.cmapCache.get(this.fontName);
+		const isCid = this.cidFontCache.get(this.fontName) ?? false;
+		if (cmap) return this.decodeWithCMap(raw, cmap, isCid);
+		if (isCid) return this.decodeCIDString(raw);
+		return this.decodeWinAnsi(raw);
+	}
+	/**
+	* Decode a TJ array operand (array of strings + numbers).
+	*/
+	decodeTJArray(operand) {
+		if (!Array.isArray(operand)) return this.decodeString(operand);
+		const parts = [];
+		for (const elem of operand) if (typeof elem === "number") {
+			if (elem <= -100) parts.push(" ");
+		} else {
+			const decoded = this.decodeString(elem);
+			if (decoded.length > 0) parts.push(decoded);
+		}
+		return parts.join("");
+	}
+	/**
+	* Decode a string using a ToUnicode CMap.
+	*/
+	decodeWithCMap(raw, cmap, isCid) {
+		let result = "";
+		if (isCid) for (let i = 0; i + 1 < raw.length; i += 2) {
+			const code = raw.charCodeAt(i) << 8 | raw.charCodeAt(i + 1);
+			const mapped = cmap.map.get(code);
+			if (mapped !== void 0) result += mapped;
+			else if (code >= 32 && code <= 65535) result += String.fromCharCode(code);
+		}
+		else for (let i = 0; i < raw.length; i++) {
+			const code = raw.charCodeAt(i);
+			const mapped = cmap.map.get(code);
+			if (mapped !== void 0) result += mapped;
+			else result += winAnsiDecode(code);
+		}
+		return result;
+	}
+	/**
+	* Decode a CID (Identity-H) encoded string without a ToUnicode CMap.
+	*/
+	decodeCIDString(raw) {
+		let result = "";
+		for (let i = 0; i + 1 < raw.length; i += 2) {
+			const code = raw.charCodeAt(i) << 8 | raw.charCodeAt(i + 1);
+			if (code >= 32 && code <= 65535) result += String.fromCharCode(code);
+		}
+		return result;
+	}
+	/**
+	* Decode a string using WinAnsiEncoding.
+	*/
+	decodeWinAnsi(raw) {
+		let result = "";
+		for (let i = 0; i < raw.length; i++) {
+			const code = raw.charCodeAt(i);
+			result += winAnsiDecode(code);
+		}
+		return result;
+	}
+};
+/**
+* Extract a numeric value from an operand, defaulting to 0.
+*/
+function operandAsNumber(operand) {
+	if (typeof operand === "number") return operand;
+	if (operand instanceof PdfNumber) return operand.value;
+	if (typeof operand === "string") {
+		const n = parseFloat(operand);
+		return isNaN(n) ? 0 : n;
+	}
+	return 0;
+}
+/**
+* Extract a string value from an operand.
+*/
+function operandAsString(operand) {
+	if (typeof operand === "string") return operand;
+	if (operand instanceof PdfName) return operand.value;
+	if (typeof operand === "number") return String(operand);
+	return "";
+}
+/**
+* Decode raw bytes to a string (ASCII/Latin-1 — sufficient for CMap
+* parsing which is ASCII-based).
+*/
+function decodeText(data) {
+	return new TextDecoder("latin1").decode(data);
+}
+
+//#endregion
+//#region src/parser/contentStreamParser.ts
+/**
+* @module parser/contentStreamParser
+*
+* Parse PDF content streams (the operator/operand sequences that describe
+* page appearance) into a structured AST.
+*
+* A PDF content stream consists of a flat sequence of *operands* followed
+* by an *operator*.  Operands are PDF objects (numbers, strings, names,
+* booleans, arrays, `null`); operators are unquoted letter sequences.
+*
+* Special handling is required for inline images (`BI … ID data EI`).
+*
+* Reference: PDF 1.7 spec, §7.8.2 (Content Streams).
+*
+* @packageDocumentation
+*/
+/**
+* Parse a PDF content stream into an ordered list of operators.
+*
+* @param data - The raw content-stream bytes (already decompressed).
+* @returns An array of operators in document order.
+*/
+function parseContentStream(data) {
+	return new ContentStreamLexer(data).parse();
+}
+var TokenType = /* @__PURE__ */ function(TokenType) {
+	TokenType[TokenType["Number"] = 0] = "Number";
+	TokenType[TokenType["String"] = 1] = "String";
+	TokenType[TokenType["HexString"] = 2] = "HexString";
+	TokenType[TokenType["Name"] = 3] = "Name";
+	TokenType[TokenType["Bool"] = 4] = "Bool";
+	TokenType[TokenType["Null"] = 5] = "Null";
+	TokenType[TokenType["ArrayStart"] = 6] = "ArrayStart";
+	TokenType[TokenType["ArrayEnd"] = 7] = "ArrayEnd";
+	TokenType[TokenType["Operator"] = 8] = "Operator";
+	TokenType[TokenType["InlineImage"] = 9] = "InlineImage";
+	TokenType[TokenType["EOF"] = 10] = "EOF";
+	return TokenType;
+}(TokenType || {});
+/**
+* Combined lexer + parser for PDF content streams.
+*
+* Content streams are simpler than full PDF object syntax — there are no
+* dictionaries (except inside inline images), no indirect references, and
+* no comments outside of string literals.
+*/
+var ContentStreamLexer = class {
+	data;
+	pos = 0;
+	constructor(data) {
+		this.data = data;
+	}
+	/**
+	* Parse the entire stream and return all operators.
+	*/
+	parse() {
+		const result = [];
+		const operandStack = [];
+		while (true) {
+			const token = this.nextToken();
+			if (token.type === TokenType.EOF) break;
+			switch (token.type) {
+				case TokenType.Number:
+				case TokenType.String:
+				case TokenType.HexString:
+				case TokenType.Bool:
+				case TokenType.Null:
+				case TokenType.Name:
+					operandStack.push(token.value);
+					break;
+				case TokenType.ArrayStart: {
+					const arr = this.parseArray();
+					operandStack.push(arr);
+					break;
+				}
+				case TokenType.ArrayEnd: break;
+				case TokenType.Operator: {
+					const op = token.value;
+					if (op === "BI") {
+						const inlineImg = this.parseInlineImage();
+						result.push({
+							operator: "BI",
+							operands: [inlineImg]
+						});
+					} else result.push({
+						operator: op,
+						operands: operandStack.splice(0, operandStack.length)
+					});
+					break;
+				}
+				case TokenType.InlineImage: break;
+			}
+		}
+		return result;
+	}
+	/**
+	* Parse a PDF array `[…]`.  Called after the `[` token has been consumed.
+	*/
+	parseArray() {
+		const items = [];
+		while (true) {
+			const token = this.nextToken();
+			if (token.type === TokenType.EOF) break;
+			if (token.type === TokenType.ArrayEnd) break;
+			switch (token.type) {
+				case TokenType.Number:
+				case TokenType.String:
+				case TokenType.HexString:
+				case TokenType.Bool:
+				case TokenType.Null:
+				case TokenType.Name:
+					items.push(token.value);
+					break;
+				case TokenType.ArrayStart:
+					items.push(this.parseArray());
+					break;
+				default: break;
+			}
+		}
+		return items;
+	}
+	/**
+	* Parse an inline image.
+	*
+	* After `BI` has been read, we expect key-value pairs (name + value)
+	* until `ID`, then raw binary data until we find `EI` preceded by
+	* whitespace.
+	*/
+	parseInlineImage() {
+		const dict = {};
+		while (true) {
+			this.skipWhitespace();
+			if (this.pos >= this.data.length) break;
+			if (this.peekKeyword("ID")) {
+				this.pos += 2;
+				break;
+			}
+			const keyToken = this.nextToken();
+			if (keyToken.type === TokenType.Operator) {
+				const kw = keyToken.value;
+				if (kw === "ID") break;
+				dict[kw] = this.nextToken().value;
+				continue;
+			}
+			if (keyToken.type === TokenType.Name) {
+				const name = keyToken.value.value;
+				dict[name] = this.nextToken().value;
+			} else if (keyToken.type === TokenType.EOF) break;
+		}
+		if (this.pos < this.data.length) {
+			const ch = this.data[this.pos];
+			if (ch === 32 || ch === 10 || ch === 13 || ch === 9) {
+				this.pos++;
+				if (ch === 13 && this.pos < this.data.length && this.data[this.pos] === 10) this.pos++;
+			}
+		}
+		const dataStart = this.pos;
+		let dataEnd = this.pos;
+		while (this.pos < this.data.length) {
+			if (this.isWhitespace(this.data[this.pos])) {
+				const wsPos = this.pos;
+				let probe = wsPos + 1;
+				if (probe + 1 < this.data.length && this.data[probe] === 69 && this.data[probe + 1] === 73) {
+					const afterEI = probe + 2;
+					if (afterEI >= this.data.length || this.isWhitespace(this.data[afterEI])) {
+						dataEnd = wsPos;
+						this.pos = afterEI;
+						break;
+					}
+				}
+			}
+			this.pos++;
+		}
+		return {
+			dict,
+			data: this.data.slice(dataStart, dataEnd)
+		};
+	}
+	/**
+	* Peek ahead to see if the next characters form a given keyword
+	* followed by whitespace.
+	*/
+	peekKeyword(keyword) {
+		for (let i = 0; i < keyword.length; i++) {
+			if (this.pos + i >= this.data.length) return false;
+			if (this.data[this.pos + i] !== keyword.charCodeAt(i)) return false;
+		}
+		const afterPos = this.pos + keyword.length;
+		if (afterPos >= this.data.length) return true;
+		const after = this.data[afterPos];
+		return this.isWhitespace(after) || this.isDelimiter(after);
+	}
+	/**
+	* Read and return the next token from the stream.
+	*/
+	nextToken() {
+		this.skipWhitespaceAndComments();
+		if (this.pos >= this.data.length) return {
+			type: TokenType.EOF,
+			value: null
+		};
+		const ch = this.data[this.pos];
+		if (ch === 40) return this.readLiteralString();
+		if (ch === 60) {
+			if (this.pos + 1 < this.data.length && this.data[this.pos + 1] === 60) {
+				this.pos += 2;
+				return this.nextToken();
+			}
+			return this.readHexString();
+		}
+		if (ch === 62 && this.pos + 1 < this.data.length && this.data[this.pos + 1] === 62) {
+			this.pos += 2;
+			return this.nextToken();
+		}
+		if (ch === 91) {
+			this.pos++;
+			return {
+				type: TokenType.ArrayStart,
+				value: null
+			};
+		}
+		if (ch === 93) {
+			this.pos++;
+			return {
+				type: TokenType.ArrayEnd,
+				value: null
+			};
+		}
+		if (ch === 47) return this.readName();
+		if (this.isNumberStart(ch)) return this.readNumber();
+		if (this.isRegularChar(ch)) return this.readKeyword();
+		this.pos++;
+		return this.nextToken();
+	}
+	/**
+	* Read a literal string `(…)`, handling nested parentheses and escapes.
+	*/
+	readLiteralString() {
+		this.pos++;
+		let result = "";
+		let depth = 1;
+		while (this.pos < this.data.length && depth > 0) {
+			const ch = this.data[this.pos];
+			if (ch === 92) {
+				this.pos++;
+				if (this.pos >= this.data.length) break;
+				const esc = this.data[this.pos];
+				switch (esc) {
+					case 110:
+						result += "\n";
+						this.pos++;
+						break;
+					case 114:
+						result += "\r";
+						this.pos++;
+						break;
+					case 116:
+						result += "	";
+						this.pos++;
+						break;
+					case 98:
+						result += "\b";
+						this.pos++;
+						break;
+					case 102:
+						result += "\f";
+						this.pos++;
+						break;
+					case 40:
+						result += "(";
+						this.pos++;
+						break;
+					case 41:
+						result += ")";
+						this.pos++;
+						break;
+					case 92:
+						result += "\\";
+						this.pos++;
+						break;
+					case 10:
+						this.pos++;
+						break;
+					case 13:
+						this.pos++;
+						if (this.pos < this.data.length && this.data[this.pos] === 10) this.pos++;
+						break;
+					default:
+						if (esc >= 48 && esc <= 55) {
+							let octal = esc - 48;
+							this.pos++;
+							if (this.pos < this.data.length) {
+								const d2 = this.data[this.pos];
+								if (d2 >= 48 && d2 <= 55) {
+									octal = octal * 8 + (d2 - 48);
+									this.pos++;
+									if (this.pos < this.data.length) {
+										const d3 = this.data[this.pos];
+										if (d3 >= 48 && d3 <= 55) {
+											octal = octal * 8 + (d3 - 48);
+											this.pos++;
+										}
+									}
+								}
+							}
+							result += String.fromCharCode(octal & 255);
+						} else {
+							result += String.fromCharCode(esc);
+							this.pos++;
+						}
+						break;
+				}
+			} else if (ch === 40) {
+				depth++;
+				result += "(";
+				this.pos++;
+			} else if (ch === 41) {
+				depth--;
+				if (depth > 0) result += ")";
+				this.pos++;
+			} else {
+				result += String.fromCharCode(ch);
+				this.pos++;
+			}
+		}
+		return {
+			type: TokenType.String,
+			value: result
+		};
+	}
+	/**
+	* Read a hex string `<…>`.
+	*/
+	readHexString() {
+		this.pos++;
+		let hex = "";
+		while (this.pos < this.data.length) {
+			const ch = this.data[this.pos];
+			if (ch === 62) {
+				this.pos++;
+				break;
+			}
+			if (this.isWhitespace(ch)) {
+				this.pos++;
+				continue;
+			}
+			hex += String.fromCharCode(ch);
+			this.pos++;
+		}
+		if (hex.length % 2 !== 0) hex += "0";
+		let result = "";
+		for (let i = 0; i < hex.length; i += 2) {
+			const byte = parseInt(hex.substring(i, i + 2), 16);
+			if (!isNaN(byte)) result += String.fromCharCode(byte);
+		}
+		return {
+			type: TokenType.HexString,
+			value: result
+		};
+	}
+	/**
+	* Read a PDF name `/…`.
+	*/
+	readName() {
+		this.pos++;
+		let name = "/";
+		while (this.pos < this.data.length) {
+			const ch = this.data[this.pos];
+			if (this.isWhitespace(ch) || this.isDelimiter(ch)) break;
+			if (ch === 35 && this.pos + 2 < this.data.length) {
+				const hi = this.data[this.pos + 1];
+				const lo = this.data[this.pos + 2];
+				const hex = String.fromCharCode(hi) + String.fromCharCode(lo);
+				const code = parseInt(hex, 16);
+				if (!isNaN(code)) {
+					name += String.fromCharCode(code);
+					this.pos += 3;
+					continue;
+				}
+			}
+			name += String.fromCharCode(ch);
+			this.pos++;
+		}
+		return {
+			type: TokenType.Name,
+			value: PdfName.of(name)
+		};
+	}
+	/**
+	* Read a numeric value (integer or real).
+	*/
+	readNumber() {
+		const start = this.pos;
+		let hasDecimal = false;
+		if (this.data[this.pos] === 43 || this.data[this.pos] === 45) this.pos++;
+		while (this.pos < this.data.length) {
+			const ch = this.data[this.pos];
+			if (ch === 46) {
+				if (hasDecimal) break;
+				hasDecimal = true;
+				this.pos++;
+			} else if (ch >= 48 && ch <= 57) this.pos++;
+			else break;
+		}
+		const str = this.decodeAscii(start, this.pos);
+		const value = parseFloat(str);
+		return {
+			type: TokenType.Number,
+			value: isNaN(value) ? 0 : value
+		};
+	}
+	/**
+	* Read a keyword — an operator name or one of the special keywords
+	* `true`, `false`, `null`.
+	*/
+	readKeyword() {
+		const start = this.pos;
+		while (this.pos < this.data.length) {
+			const ch = this.data[this.pos];
+			if (this.isWhitespace(ch) || this.isDelimiter(ch)) break;
+			this.pos++;
+		}
+		const word = this.decodeAscii(start, this.pos);
+		if (word === "true") return {
+			type: TokenType.Bool,
+			value: true
+		};
+		if (word === "false") return {
+			type: TokenType.Bool,
+			value: false
+		};
+		if (word === "null") return {
+			type: TokenType.Null,
+			value: null
+		};
+		return {
+			type: TokenType.Operator,
+			value: word
+		};
+	}
+	/** PDF whitespace characters. */
+	isWhitespace(ch) {
+		return ch === 0 || ch === 9 || ch === 10 || ch === 12 || ch === 13 || ch === 32;
+	}
+	/** PDF delimiter characters. */
+	isDelimiter(ch) {
+		return ch === 40 || ch === 41 || ch === 60 || ch === 62 || ch === 91 || ch === 93 || ch === 123 || ch === 125 || ch === 47 || ch === 37;
+	}
+	/** Whether a character can begin a number. */
+	isNumberStart(ch) {
+		return ch >= 48 && ch <= 57 || ch === 43 || ch === 45 || ch === 46;
+	}
+	/** Whether a character is a regular (non-whitespace, non-delimiter) character. */
+	isRegularChar(ch) {
+		return !this.isWhitespace(ch) && !this.isDelimiter(ch);
+	}
+	/** Skip whitespace. */
+	skipWhitespace() {
+		while (this.pos < this.data.length && this.isWhitespace(this.data[this.pos])) this.pos++;
+	}
+	/** Skip whitespace and `%` comments. */
+	skipWhitespaceAndComments() {
+		while (this.pos < this.data.length) {
+			const ch = this.data[this.pos];
+			if (this.isWhitespace(ch)) this.pos++;
+			else if (ch === 37) {
+				this.pos++;
+				while (this.pos < this.data.length) {
+					const c = this.data[this.pos];
+					if (c === 10 || c === 13) break;
+					this.pos++;
+				}
+			} else break;
+		}
+	}
+	/**
+	* Decode a slice of the data as ASCII text.
+	*/
+	decodeAscii(start, end) {
+		let s = "";
+		for (let i = start; i < end; i++) s += String.fromCharCode(this.data[i]);
+		return s;
+	}
+};
+
+//#endregion
+//#region src/signature/timestamp.ts
+/**
+* @module signature/timestamp
+*
+* RFC 3161 Timestamp Authority (TSA) client for timestamped signatures.
+*
+* Timestamps provide proof that a document was signed at a specific time,
+* independent of the signer's system clock.  A TSA is a trusted third
+* party that cryptographically binds a hash to a specific moment in time.
+*
+* This module builds TimeStampReq messages, sends them to a TSA via
+* HTTP POST (using `fetch()`), and parses TimeStampResp messages.
+*
+* References:
+* - RFC 3161 (Internet X.509 PKI Time-Stamp Protocol)
+* - RFC 5816 (ESSCertIDv2 Update for RFC 3161)
+*
+* @packageDocumentation
+*/
+const HASH_OID_MAP = {
+	"SHA-256": "2.16.840.1.101.3.4.2.1",
+	"SHA-384": "2.16.840.1.101.3.4.2.2",
+	"SHA-512": "2.16.840.1.101.3.4.2.3"
+};
+/**
+* Encode a BOOLEAN TRUE value in DER.
+*/
+function encodeBooleanTrue() {
+	return new Uint8Array([
+		1,
+		1,
+		255
+	]);
+}
+/**
+* Encode an INTEGER value in DER.
+*/
+function encodeIntegerValue(value) {
+	if (value < 128) return new Uint8Array([
+		2,
+		1,
+		value
+	]);
+	if (value < 32768) return new Uint8Array([
+		2,
+		2,
+		value >> 8 & 255,
+		value & 255
+	]);
+	return new Uint8Array([
+		2,
+		3,
+		value >> 16 & 255,
+		value >> 8 & 255,
+		value & 255
+	]);
+}
+/**
+* Parse a GeneralizedTime string (YYYYMMDDHHmmSS[.fff]Z) to a Date.
+*/
+function parseGeneralizedTime(timeStr) {
+	const clean = timeStr.replace("Z", "").replace(/\..*$/, "");
+	const year = parseInt(clean.substring(0, 4), 10);
+	const month = parseInt(clean.substring(4, 6), 10) - 1;
+	const day = parseInt(clean.substring(6, 8), 10);
+	const hours = parseInt(clean.substring(8, 10), 10);
+	const minutes = parseInt(clean.substring(10, 12), 10);
+	const seconds = parseInt(clean.substring(12, 14), 10) || 0;
+	return new Date(Date.UTC(year, month, day, hours, minutes, seconds));
+}
+/**
+* Parse a UTCTime string (YYMMDDHHmmSSZ) to a Date.
+*/
+function parseUtcTime(timeStr) {
+	const clean = timeStr.replace("Z", "");
+	const year = parseInt(clean.substring(0, 2), 10);
+	const month = parseInt(clean.substring(2, 4), 10) - 1;
+	const day = parseInt(clean.substring(4, 6), 10);
+	const hours = parseInt(clean.substring(6, 8), 10);
+	const minutes = parseInt(clean.substring(8, 10), 10);
+	const seconds = parseInt(clean.substring(10, 12), 10) || 0;
+	const fullYear = year < 50 ? 2e3 + year : 1900 + year;
+	return new Date(Date.UTC(fullYear, month, day, hours, minutes, seconds));
+}
+/**
+* Build a DER-encoded TimeStampReq (RFC 3161 SS2.4.1).
+*
+* ```
+* TimeStampReq ::= SEQUENCE {
+*   version         INTEGER { v1(1) },
+*   messageImprint  MessageImprint,
+*   reqPolicy       TSAPolicyId OPTIONAL,
+*   nonce           INTEGER OPTIONAL,
+*   certReq         BOOLEAN DEFAULT FALSE,
+*   extensions      [0] IMPLICIT Extensions OPTIONAL
+* }
+*
+* MessageImprint ::= SEQUENCE {
+*   hashAlgorithm   AlgorithmIdentifier,
+*   hashedMessage    OCTET STRING
+* }
+* ```
+*
+* @param dataHash       The hash of the data to timestamp.
+* @param hashAlgorithm  The hash algorithm used.
+* @returns              DER-encoded TimeStampReq.
+*/
+function buildTimestampRequest(dataHash, hashAlgorithm) {
+	const hashOid = HASH_OID_MAP[hashAlgorithm];
+	if (!hashOid) throw new Error(`Unsupported hash algorithm for timestamp: ${hashAlgorithm}`);
+	const version = encodeIntegerValue(1);
+	const messageImprint = encodeSequence([encodeSequence([encodeOID(hashOid), new Uint8Array([5, 0])]), encodeOctetString(dataHash)]);
+	const nonceBytes = new Uint8Array(8);
+	globalThis.crypto.getRandomValues(nonceBytes);
+	nonceBytes[0] = nonceBytes[0] & 127;
+	const nonce = new Uint8Array(2 + nonceBytes.length);
+	nonce[0] = 2;
+	nonce[1] = nonceBytes.length;
+	nonce.set(nonceBytes, 2);
+	return encodeSequence([
+		version,
+		messageImprint,
+		nonce,
+		encodeBooleanTrue()
+	]);
+}
+/**
+* Parse a DER-encoded TimeStampResp (RFC 3161 SS2.4.2).
+*
+* ```
+* TimeStampResp ::= SEQUENCE {
+*   status          PKIStatusInfo,
+*   timeStampToken  ContentInfo OPTIONAL
+* }
+*
+* PKIStatusInfo ::= SEQUENCE {
+*   status        PKIStatus (INTEGER),
+*   statusString  PKIFreeText OPTIONAL,
+*   failInfo      PKIFailureInfo OPTIONAL
+* }
+* ```
+*
+* @param response  DER-encoded TimeStampResp.
+* @returns         The parsed timestamp result.
+* @throws          Error if the TSA reported an error status.
+*/
+function parseTimestampResponse(response) {
+	const resp = parseDerTlv(response, 0);
+	if (resp.children.length < 1) throw new Error("Invalid TimeStampResp: empty SEQUENCE");
+	const statusInfo = resp.children[0];
+	const status = statusInfo.children[0].data[0];
+	if (status !== 0 && status !== 1) {
+		let errorMsg = `TSA returned error status ${status}`;
+		if (statusInfo.children.length > 1) {
+			const statusString = statusInfo.children[1];
+			try {
+				const textDecoder = new TextDecoder("utf-8");
+				errorMsg += `: ${textDecoder.decode(statusString.data)}`;
+			} catch {}
+		}
+		throw new Error(errorMsg);
+	}
+	if (resp.children.length < 2) throw new Error("TimeStampResp contains no TimeStampToken");
+	const tokenNode = resp.children[1];
+	const tokenStart = tokenNode.offset;
+	return {
+		timestampToken: response.subarray(tokenStart, tokenStart + tokenNode.totalLength),
+		signingTime: extractTstInfoTime(tokenNode)
+	};
+}
+/**
+* Extract the genTime from a TimeStampToken's TSTInfo.
+*
+* The token is a ContentInfo containing SignedData, which in turn
+* contains the TSTInfo as the encapsulated content.
+*/
+function extractTstInfoTime(contentInfo) {
+	try {
+		const signedData = contentInfo.children[1].children[0];
+		for (const child of signedData.children) if (child.tag === 48 && child.children.length >= 1) {
+			const oidNode = child.children[0];
+			if (oidNode.tag === 6) {
+				if (decodeOidBytes(oidNode.data) === "1.2.840.113549.1.9.16.1.4" && child.children.length >= 2) {
+					const eContent = child.children[1].children[0];
+					const tstInfo = parseDerTlv(eContent.data, 0);
+					if (tstInfo.children.length >= 5) {
+						const genTimeNode = tstInfo.children[4];
+						const timeStr = new TextDecoder("ascii").decode(genTimeNode.data);
+						if (genTimeNode.tag === 24) return parseGeneralizedTime(timeStr);
+						return parseUtcTime(timeStr);
+					}
+				}
+			}
+		}
+	} catch {}
+	return /* @__PURE__ */ new Date();
+}
+/**
+* Request a timestamp from an RFC 3161 TSA.
+*
+* Sends a TimeStampReq via HTTP POST and parses the TimeStampResp.
+* Uses `fetch()` for universal runtime compatibility (Node.js 18+,
+* browsers, Deno, Bun, Cloudflare Workers).
+*
+* @param dataHash       The hash of the data to timestamp.
+* @param tsaUrl         The URL of the TSA service.
+* @param hashAlgorithm  The hash algorithm. Default 'SHA-256'.
+* @returns              The timestamp result.
+* @throws               Error if the request fails or the TSA returns
+*                       an error status.
+*
+* @example
+* ```ts
+* const hash = await computeSignatureHash(pdfBytes, byteRange);
+* const timestamp = await requestTimestamp(
+*   hash,
+*   'http://timestamp.digicert.com',
+* );
+* ```
+*/
+async function requestTimestamp(dataHash, tsaUrl, hashAlgorithm = "SHA-256") {
+	const tsReq = buildTimestampRequest(dataHash, hashAlgorithm);
+	const bodyBuffer = tsReq.buffer.slice(tsReq.byteOffset, tsReq.byteOffset + tsReq.byteLength);
+	const response = await fetch(tsaUrl, {
+		method: "POST",
+		headers: { "Content-Type": "application/timestamp-query" },
+		body: bodyBuffer
+	});
+	if (!response.ok) throw new Error(`TSA request failed: HTTP ${response.status} ${response.statusText}`);
+	const contentType = response.headers.get("Content-Type");
+	if (contentType && !contentType.includes("timestamp-reply")) {}
+	return parseTimestampResponse(new Uint8Array(await response.arrayBuffer()));
+}
+
+//#endregion
+//#region src/core/linearization.ts
+const encoder$1 = new TextEncoder();
+const decoder$1 = new TextDecoder();
+/**
+* Check if a PDF is linearized.
+*
+* A linearized PDF has a linearization parameter dictionary as the
+* very first indirect object after the header.  This dictionary
+* contains `/Linearized` as a key.
+*
+* @param pdfBytes  The raw PDF bytes.
+* @returns         `true` if the PDF appears to be linearized.
+*/
+function isLinearized(pdfBytes) {
+	const searchWindow = Math.min(pdfBytes.length, 1024);
+	const header = decoder$1.decode(pdfBytes.subarray(0, searchWindow));
+	return /\/Linearized\s+[\d.]+/.test(header);
+}
+/** Find a string in the byte array, starting from `start`. */
+function findString(data, str, start = 0) {
+	const bytes = encoder$1.encode(str);
+	outer: for (let i = start; i <= data.length - bytes.length; i++) {
+		for (let j = 0; j < bytes.length; j++) if (data[i + j] !== bytes[j]) continue outer;
+		return i;
+	}
+	return -1;
+}
+/** Read an ASCII line starting at offset (until \n or \r\n). */
+function readLine(data, offset) {
+	let end = offset;
+	while (end < data.length && data[end] !== 10 && data[end] !== 13) end++;
+	const line = decoder$1.decode(data.subarray(offset, end));
+	let next = end;
+	if (next < data.length && data[next] === 13) next++;
+	if (next < data.length && data[next] === 10) next++;
+	return {
+		line,
+		nextOffset: next
+	};
+}
+/** Parse the startxref offset from the end of the file. */
+function findStartXref(data) {
+	const tail = decoder$1.decode(data.subarray(Math.max(0, data.length - 256)));
+	const idx = tail.lastIndexOf("startxref");
+	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;
+}
+function parseXrefTable(data, xrefOffset) {
+	const entries = /* @__PURE__ */ new Map();
+	let pos = xrefOffset;
+	pos = readLine(data, pos).nextOffset;
+	while (pos < data.length) {
+		const line = readLine(data, pos);
+		if (line.line.startsWith("trailer")) break;
+		const parts = line.line.trim().split(/\s+/);
+		if (parts.length === 2) {
+			const startObj = parseInt(parts[0], 10);
+			const count = parseInt(parts[1], 10);
+			pos = line.nextOffset;
+			for (let i = 0; i < count; i++) {
+				const entryLine = readLine(data, pos);
+				pos = entryLine.nextOffset;
+				const ep = entryLine.line.trim().split(/\s+/);
+				if (ep.length >= 3) entries.set(startObj + i, {
+					offset: parseInt(ep[0], 10),
+					generation: parseInt(ep[1], 10),
+					inUse: ep[2] === "n"
+				});
+			}
+		} else pos = line.nextOffset;
+	}
+	const trailerStart = findString(data, "trailer", xrefOffset);
+	const trailerEnd = findString(data, ">>", trailerStart) + 2;
+	const trailerStr = decoder$1.decode(data.subarray(trailerStart, trailerEnd));
+	const sizeMatch = /\/Size\s+(\d+)/.exec(trailerStr);
+	const rootMatch = /\/Root\s+(\d+)\s+(\d+)\s+R/.exec(trailerStr);
+	const infoMatch = /\/Info\s+(\d+)\s+(\d+)\s+R/.exec(trailerStr);
+	return {
+		entries,
+		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
+		}
+	};
+}
+/** Extract the raw bytes of an indirect object from the PDF. */
+function extractObject(data, offset) {
+	const endIdx = findString(data, "endobj", offset);
+	if (endIdx < 0) return data.subarray(offset);
+	return data.subarray(offset, endIdx + 6);
+}
+/**
+* Linearize a PDF document for fast web viewing.
+*
+* This reorganizes the PDF so that:
+* 1. A linearization parameter dictionary appears first
+* 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.
+*
+* @param pdfBytes  The raw PDF bytes.
+* @param options   Linearization options.
+* @returns         The linearized PDF bytes.
+*/
+async function linearizePdf(pdfBytes, options) {
+	const _firstPage = options?.firstPage ?? 0;
+	if (isLinearized(pdfBytes)) return pdfBytes;
+	const startXref = findStartXref(pdfBytes);
+	if (startXref < 0) throw new Error("Cannot linearize: no startxref found");
+	let xrefResult;
+	try {
+		xrefResult = parseXrefTable(pdfBytes, startXref);
+	} catch {
+		throw new Error("Cannot linearize: failed to parse xref table");
+	}
+	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);
+	const catalogBytes = objects.get(rootObjNum);
+	let pagesObjNum = 0;
+	if (catalogBytes) {
+		const catalogStr = decoder$1.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$1.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$1.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$1.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);
+	const chunks = [];
+	const newOffsets = /* @__PURE__ */ new Map();
+	let currentOffset = 0;
+	function writeStr(s) {
+		const bytes = encoder$1.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 linObjNum = trailer.size;
+	const linDictOffset = currentOffset;
+	const linDictPlaceholder = currentOffset;
+	const pageCount = pagesBytes ? decoder$1.decode(pagesBytes).match(/\/Count\s+(\d+)/)?.[1] ?? "1" : "1";
+	writeStr(`${linObjNum} 0 obj\n`);
+	writeStr(`<< /Linearized 1.0\n`);
+	writeStr(`   /L 0000000000\n`);
+	writeStr(`   /O ${firstPageObjNum}\n`);
+	writeStr(`   /E 0000000000\n`);
+	writeStr(`   /N ${pageCount}\n`);
+	writeStr(`   /T 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) {
+		const objBytes = objects.get(objNum);
+		if (objBytes) {
+			newOffsets.set(objNum, currentOffset);
+			writeBytes(objBytes);
+			writeStr("\n");
+		}
+	}
+	const endOfFirstPage = currentOffset;
+	for (const objNum of remainingObjects) {
+		const objBytes = objects.get(objNum);
+		if (objBytes) {
+			newOffsets.set(objNum, currentOffset);
+			writeBytes(objBytes);
+			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;
+	writeStr("xref\n");
+	writeStr(`0 ${totalSize}\n`);
+	writeStr("0000000000 65535 f \n");
+	for (let i = 1; i < totalSize; 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(`/Root ${trailer.rootRef}\n`);
+	if (trailer.infoRef) writeStr(`/Info ${trailer.infoRef}\n`);
+	writeStr(">>\n");
+	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, 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.concat(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$1.encode(prefix);
+	const searchEnd = Math.min(searchStart + 500, data.length);
+	outer: for (let i = searchStart; i < searchEnd - prefixBytes.length; i++) {
+		for (let j = 0; j < prefixBytes.length; j++) if (data[i + j] !== prefixBytes[j]) continue outer;
+		const numStr = value.toString().padStart(10, "0");
+		const numBytes = encoder$1.encode(numStr);
+		for (let k = 0; k < 10 && i + prefixBytes.length + k < data.length; k++) data[i + prefixBytes.length + k] = numBytes[k];
+		return;
+	}
+}
+
+//#endregion
+//#region src/utils/binary.ts
+/**
+* Concatenate one or more `Uint8Array` buffers into a single contiguous
+* array.
+*
+* @param arrays  The arrays to concatenate (in order).
+* @returns       A new `Uint8Array` containing all bytes.
+*/
+function concatBytes(...arrays) {
+	if (arrays.length === 0) return new Uint8Array(0);
+	if (arrays.length === 1) return arrays[0];
+	let totalLength = 0;
+	for (const arr of arrays) totalLength += arr.length;
+	const result = new Uint8Array(totalLength);
+	let offset = 0;
+	for (const arr of arrays) {
+		result.set(arr, offset);
+		offset += arr.length;
+	}
+	return result;
+}
+
+//#endregion
+//#region src/compliance/pdfA.ts
+/**
+* @module compliance/pdfA
+*
+* PDF/A compliance validation and enforcement.
+*
+* PDF/A is an ISO standard for long-term archival of electronic documents.
+* It restricts certain PDF features (e.g. encryption, JavaScript,
+* transparency) and mandates others (e.g. embedded fonts, XMP metadata).
+*
+* Supported conformance levels:
+* - **1b**: PDF/A-1b (based on PDF 1.4) — basic visual preservation
+* - **1a**: PDF/A-1a — adds logical structure and tagged PDF
+* - **2b**: PDF/A-2b (based on PDF 1.7) — allows JPEG2000, transparency
+* - **2a**: PDF/A-2a — adds logical structure
+* - **2u**: PDF/A-2u — adds Unicode mapping
+* - **3b**: PDF/A-3b — allows embedded files of any type
+* - **3a**: PDF/A-3a — adds logical structure
+* - **3u**: PDF/A-3u — adds Unicode mapping
+*
+* Reference: ISO 19005-1:2005, ISO 19005-2:2011, ISO 19005-3:2012.
+*/
+const decoder = new TextDecoder();
+const encoder = new TextEncoder();
+/** Search for a pattern in the PDF bytes. */
+function findPattern(data, pattern, start = 0) {
+	const bytes = encoder.encode(pattern);
+	outer: for (let i = start; i <= data.length - bytes.length; i++) {
+		for (let j = 0; j < bytes.length; j++) if (data[i + j] !== bytes[j]) continue outer;
+		return i;
+	}
+	return -1;
+}
+/** Check if a pattern exists anywhere in the PDF. */
+function containsPattern(data, pattern) {
+	return findPattern(data, pattern) >= 0;
+}
+/** Extract text between two markers. */
+function extractBetween(data, start, end) {
+	const startIdx = findPattern(data, start);
+	if (startIdx < 0) return void 0;
+	const endIdx = findPattern(data, end, startIdx + start.length);
+	if (endIdx < 0) return void 0;
+	return decoder.decode(data.subarray(startIdx + start.length, endIdx));
+}
+/**
+* Validate a PDF against a specific PDF/A conformance level.
+*
+* This performs structural checks on the raw PDF bytes. It does NOT
+* fully render or deeply parse the PDF — it checks for the presence
+* or absence of features that PDF/A requires or forbids.
+*
+* @param pdfBytes  The raw PDF bytes.
+* @param level     The target PDF/A conformance level.
+* @returns         A validation result with any issues found.
+*/
+function validatePdfA(pdfBytes, level) {
+	const issues = [];
+	const part = parseInt(level[0], 10);
+	const conformance = level[1];
+	if (!containsPattern(pdfBytes, "/Metadata")) issues.push({
+		code: "PDFA-001",
+		message: "XMP metadata stream is required but not found in the catalog.",
+		severity: "error"
+	});
+	else {
+		const xmpContent = extractBetween(pdfBytes, "<x:xmpmeta", "</x:xmpmeta>");
+		if (xmpContent) {
+			if (!xmpContent.includes("pdfaid:part") && !xmpContent.includes("pdfaSchema")) issues.push({
+				code: "PDFA-002",
+				message: "XMP metadata does not contain PDF/A identification (pdfaid:part).",
+				severity: "error"
+			});
+		}
+	}
+	if (containsPattern(pdfBytes, "/Encrypt")) issues.push({
+		code: "PDFA-003",
+		message: "PDF/A documents must not be encrypted.",
+		severity: "error"
+	});
+	if (containsPattern(pdfBytes, "/JavaScript") || containsPattern(pdfBytes, "/JS")) issues.push({
+		code: "PDFA-004",
+		message: "PDF/A documents must not contain JavaScript.",
+		severity: "error"
+	});
+	const trailerIdx = findPattern(pdfBytes, "trailer");
+	if (trailerIdx >= 0) {
+		const trailerEnd = findPattern(pdfBytes, ">>", trailerIdx);
+		if (trailerEnd >= 0) {
+			if (!decoder.decode(pdfBytes.subarray(trailerIdx, trailerEnd + 2)).includes("/ID")) issues.push({
+				code: "PDFA-005",
+				message: "PDF/A requires a file identifier (/ID) in the trailer.",
+				severity: "error"
+			});
+		}
+	}
+	checkFontEmbedding(pdfBytes, issues);
+	if (part === 1) {
+		if (containsPattern(pdfBytes, "/SMask") || containsPattern(pdfBytes, "/CA ") || containsPattern(pdfBytes, "/ca ")) {
+			if (checkTransparency(pdfBytes)) issues.push({
+				code: "PDFA-006",
+				message: "PDF/A-1 does not allow transparency (SMask, non-1.0 CA/ca values).",
+				severity: "error"
+			});
+		}
+	}
+	if (conformance === "a") {
+		if (!containsPattern(pdfBytes, "/StructTreeRoot")) issues.push({
+			code: "PDFA-007",
+			message: `PDF/A-${part}a requires a document structure tree (/StructTreeRoot).`,
+			severity: "error"
+		});
+		if (!containsPattern(pdfBytes, "/MarkInfo")) issues.push({
+			code: "PDFA-008",
+			message: `PDF/A-${part}a requires the document to be marked (/MarkInfo with /Marked true).`,
+			severity: "error"
+		});
+	}
+	if ((conformance === "u" || conformance === "a") && part >= 2) {
+		if (!containsPattern(pdfBytes, "/ToUnicode")) issues.push({
+			code: "PDFA-009",
+			message: `PDF/A-${part}${conformance} requires ToUnicode CMaps for all fonts.`,
+			severity: "warning"
+		});
+	}
+	if (part < 3) {
+		if (containsPattern(pdfBytes, "/EmbeddedFiles") || containsPattern(pdfBytes, "/AF ")) issues.push({
+			code: "PDFA-010",
+			message: `PDF/A-${part} does not allow embedded file attachments.`,
+			severity: "error"
+		});
+	}
+	if (!containsPattern(pdfBytes, "/Lang")) issues.push({
+		code: "PDFA-011",
+		message: "PDF/A recommends setting the document language (/Lang in the catalog).",
+		severity: "warning"
+	});
+	if (containsPattern(pdfBytes, "/DeviceRGB") || containsPattern(pdfBytes, "/DeviceCMYK")) {
+		if (!containsPattern(pdfBytes, "/OutputIntents")) issues.push({
+			code: "PDFA-012",
+			message: "PDF/A requires /OutputIntents when using device-dependent color spaces.",
+			severity: "warning"
+		});
+	}
+	return {
+		valid: issues.filter((i) => i.severity === "error").length === 0,
+		level,
+		issues
+	};
+}
+/** Check if fonts are properly embedded. */
+function checkFontEmbedding(data, issues) {
+	const fontMatches = decoder.decode(data).matchAll(/\/Subtype\s*\/Type1[\s\S]*?\/BaseFont\s*\/([\w-]+)/g);
+	const standardFonts = 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"
+	]);
+	for (const m of fontMatches) {
+		const fontName = m[1];
+		if (standardFonts.has(fontName)) issues.push({
+			code: "PDFA-013",
+			message: `Font "${fontName}" must be embedded for PDF/A compliance (standard 14 fonts are not exempt).`,
+			severity: "error"
+		});
+	}
+}
+/** Check if the PDF uses transparency features. */
+function checkTransparency(data) {
+	const str = decoder.decode(data);
+	if (/\/SMask\s+(?!\/None)/.test(str)) return true;
+	const caMatch = /\/[Cc][Aa]\s+([\d.]+)/g;
+	let m;
+	while ((m = caMatch.exec(str)) !== null) if (parseFloat(m[1]) < 1) return true;
+	return false;
+}
+/**
+* Attempt to make a PDF conform to PDF/A.
+*
+* This adds or corrects:
+* - XMP metadata with PDF/A identification
+* - File identifier (/ID) in the trailer
+* - Document language (if missing, defaults to "en")
+*
+* **Limitations:**
+* - Cannot embed fonts that are not already embedded
+* - Cannot remove encryption or JavaScript (throws an error)
+* - Cannot add structure tree for 'a' conformance
+* - For full PDF/A conversion, use a dedicated tool
+*
+* @param pdfBytes  The raw PDF bytes.
+* @param level     The target PDF/A conformance level.
+* @returns         The modified PDF bytes.
+*/
+async function enforcePdfA(pdfBytes, level) {
+	const validation = validatePdfA(pdfBytes, level);
+	for (const issue of validation.issues) {
+		if (issue.code === "PDFA-003") throw new Error("Cannot enforce PDF/A: document is encrypted. Remove encryption first.");
+		if (issue.code === "PDFA-004") throw new Error("Cannot enforce PDF/A: document contains JavaScript. Remove it first.");
+	}
+	if (validation.valid) return pdfBytes;
+	const part = parseInt(level[0], 10);
+	const conformance = level[1];
+	let result = pdfBytes;
+	if (!validation.issues.every((i) => i.code !== "PDFA-001" && i.code !== "PDFA-002")) result = addPdfAXmpMetadata(result, part, conformance);
+	if (validation.issues.some((i) => i.code === "PDFA-005")) result = addTrailerId(result);
+	return result;
+}
+/** Generate XMP metadata with PDF/A identification and inject it. */
+function addPdfAXmpMetadata(data, part, conformance) {
+	const conformanceUpper = conformance.toUpperCase();
+	const xmp = [
+		"<?xpacket begin=\"\" id=\"W5M0MpCehiHzreSzNTczkc9d\"?>",
+		"<x:xmpmeta xmlns:x=\"adobe:ns:meta/\">",
+		"  <rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">",
+		"    <rdf:Description rdf:about=\"\"",
+		"      xmlns:pdfaid=\"http://www.aiim.org/pdfa/ns/id/\"",
+		"      xmlns:dc=\"http://purl.org/dc/elements/1.1/\"",
+		"      xmlns:xmp=\"http://ns.adobe.com/xap/1.0/\">",
+		`      <pdfaid:part>${part}</pdfaid:part>`,
+		`      <pdfaid:conformance>${conformanceUpper}</pdfaid:conformance>`,
+		"      <xmp:CreatorTool>modern-pdf</xmp:CreatorTool>",
+		"    </rdf:Description>",
+		"  </rdf:RDF>",
+		"</x:xmpmeta>",
+		"<?xpacket end=\"w\"?>"
+	].join("\n");
+	const xmpBytes = encoder.encode(xmp);
+	const objMatches = decoder.decode(data).matchAll(/(\d+)\s+0\s+obj/g);
+	let maxObj = 0;
+	for (const m of objMatches) {
+		const num = parseInt(m[1], 10);
+		if (num > maxObj) maxObj = num;
+	}
+	const metadataObjNum = maxObj + 1;
+	const metaObj = [
+		`${metadataObjNum} 0 obj`,
+		`<< /Type /Metadata /Subtype /XML /Length ${xmpBytes.length} >>`,
+		"stream"
+	].join("\n");
+	const metaObjEnd = "\nendstream\nendobj\n";
+	const catalogIdx = findPattern(data, "/Type /Catalog");
+	if (catalogIdx < 0) return data;
+	const catalogEnd = findPattern(data, ">>", catalogIdx);
+	if (catalogEnd < 0) return data;
+	const metaRef = `\n/Metadata ${metadataObjNum} 0 R\n`;
+	const parts = [];
+	parts.push(data.subarray(0, catalogEnd));
+	parts.push(encoder.encode(metaRef));
+	parts.push(data.subarray(catalogEnd));
+	parts.push(encoder.encode("\n"));
+	parts.push(encoder.encode(metaObj + "\n"));
+	parts.push(xmpBytes);
+	parts.push(encoder.encode(metaObjEnd));
+	return concatBytes(...parts);
+}
+/** Add a file identifier (/ID) to the trailer. */
+function addTrailerId(data) {
+	const trailerIdx = findPattern(data, "trailer");
+	if (trailerIdx < 0) return data;
+	const trailerEnd = findPattern(data, ">>", trailerIdx);
+	if (trailerEnd < 0) return data;
+	const idEntry = `\n/ID [<${crypto.getRandomValues(new Uint8Array(16)).toHex()}> <${crypto.getRandomValues(new Uint8Array(16)).toHex()}>]\n`;
+	const parts = [];
+	parts.push(data.subarray(0, trailerEnd));
+	parts.push(encoder.encode(idEntry));
+	parts.push(data.subarray(trailerEnd));
+	return concatBytes(...parts);
+}
+
+//#endregion
+//#region src/errors.ts
+/**
+* @module errors
+*
+* Typed error classes for common failure modes in the modern-pdf library.
+* Each error class extends the native `Error` and carries a descriptive
+* `name` so callers can use `instanceof` checks or `error.name` comparisons.
+*
+* All constructors accept an optional `ErrorOptions` parameter to support
+* error chaining via the standard `{ cause }` option (ES2022+).
+*
+* These match the pdf-lib error hierarchy for API compatibility.
+*/
+/**
+* Thrown when attempting to load or manipulate an encrypted PDF without
+* providing the correct password.
+*/
+var EncryptedPdfError = class extends Error {
+	name = "EncryptedPdfError";
+	constructor(message = "The PDF is encrypted. Please provide a password.", options) {
+		super(message, options);
+	}
+};
+/**
+* Thrown when a font operation requires an embedded font but none has been
+* registered or the font reference is invalid.
+*/
+var FontNotEmbeddedError = class extends Error {
+	name = "FontNotEmbeddedError";
+	constructor(fontName, options) {
+		super(fontName ? `The font "${fontName}" has not been embedded in this document.` : "No font has been embedded. Call doc.embedFont() first.", options);
+	}
+};
+/**
+* Thrown when attempting to use a page from a different document without
+* first copying it.
+*/
+var ForeignPageError = class extends Error {
+	name = "ForeignPageError";
+	constructor(options) {
+		super("The page belongs to a different document. Use doc.copyPages() to import pages from another document before adding them.", options);
+	}
+};
+/**
+* Thrown when attempting to remove a page from a document that has no pages.
+*/
+var RemovePageFromEmptyDocumentError = class extends Error {
+	name = "RemovePageFromEmptyDocumentError";
+	constructor(options) {
+		super("Cannot remove a page from a document with no pages.", options);
+	}
+};
+/**
+* Thrown when looking up a form field by name that does not exist.
+*/
+var NoSuchFieldError = class extends Error {
+	name = "NoSuchFieldError";
+	constructor(fieldName, options) {
+		super(`No form field named "${fieldName}" exists in this document.`, options);
+	}
+};
+/**
+* Thrown when a form field is accessed via the wrong typed getter
+* (e.g. calling `getTextField()` on a checkbox field).
+*/
+var UnexpectedFieldTypeError = class extends Error {
+	name = "UnexpectedFieldTypeError";
+	constructor(fieldName, expected, actual, options) {
+		super(`Expected field "${fieldName}" to be of type "${expected}", but it is of type "${actual}".`, options);
+	}
+};
+/**
+* Thrown when a checkbox or radio button is checked but no "on" value
+* can be determined from its appearance dictionary.
+*/
+var MissingOnValueCheckError = class extends Error {
+	name = "MissingOnValueCheckError";
+	constructor(fieldName, options) {
+		super(`Cannot determine the "on" value for checkbox/radio "${fieldName}". The field is missing an /AP /N appearance dictionary with a non-/Off key.`, options);
+	}
+};
+/**
+* Thrown when creating a form field with a name that is already in use.
+*/
+var FieldAlreadyExistsError = class extends Error {
+	name = "FieldAlreadyExistsError";
+	constructor(fieldName, options) {
+		super(`A form field named "${fieldName}" already exists.`, options);
+	}
+};
+/**
+* Thrown when a field name part (between dots in a qualified name) is
+* empty or contains invalid characters.
+*/
+var InvalidFieldNamePartError = class extends Error {
+	name = "InvalidFieldNamePartError";
+	constructor(namePart, options) {
+		super(`Invalid field name part: "${namePart}".`, options);
+	}
+};
+/**
+* Thrown when attempting to create a terminal field but a non-terminal
+* node (a field with /Kids but no /FT) already uses the same name.
+*/
+var FieldExistsAsNonTerminalError = class extends Error {
+	name = "FieldExistsAsNonTerminalError";
+	constructor(fieldName, options) {
+		super(`A non-terminal field node named "${fieldName}" already exists. Cannot create a terminal field with the same name.`, options);
+	}
+};
+/**
+* Thrown when attempting to read the rich text value (/RV) of a field
+* that does not support it or whose rich text is malformed.
+*/
+var RichTextFieldReadError = class extends Error {
+	name = "RichTextFieldReadError";
+	constructor(fieldName, options) {
+		super(`Cannot read the rich text value of field "${fieldName}". Rich text reading is not currently supported.`, options);
+	}
+};
+/**
+* Thrown when a combed text field receives more characters than its
+* maximum length allows.
+*/
+var CombedTextLayoutError = class extends Error {
+	name = "CombedTextLayoutError";
+	constructor(textLength, maxLength, options) {
+		super(`Combed text has ${textLength} characters but the field only allows a maximum of ${maxLength}.`, options);
+	}
+};
+/**
+* Thrown when a text field value exceeds the field's declared
+* maximum length (/MaxLen).
+*/
+var ExceededMaxLengthError = class extends Error {
+	name = "ExceededMaxLengthError";
+	constructor(textLength, maxLength, fieldName, options) {
+		super(`The value for field "${fieldName}" is ${textLength} characters long, but the maximum length is ${maxLength}.`, options);
+	}
+};
+
+//#endregion
+//#region src/index.ts
+/** Whether initWasm has already completed successfully. */
+let wasmInitialized = false;
+/**
+* Initialize the optional WASM acceleration modules.
+*
+* Call this once before `save()` if you want WASM-accelerated
+* compression, PNG decoding, or font subsetting.  It is safe to call
+* multiple times -- subsequent calls are no-ops.
+*
+* If not called, the library falls back to pure-JS implementations
+* (fflate for compression, JS for PNG decoding).
+*
+* @param options  Configuration for which WASM modules to load,
+*                 and optionally pre-loaded WASM binary bytes.
+*                 When a string or URL is passed, it is treated as
+*                 a legacy `wasmUrl` parameter (ignored for backward
+*                 compatibility).
+* @returns        A promise that resolves when all requested modules
+*                 are ready.
+*/
+async function initWasm(options) {
+	if (options === void 0 || typeof options === "string" || options instanceof URL) return;
+	if (wasmInitialized) return;
+	const inits = [];
+	if (options.deflate || options.deflateWasm) inits.push(import("./libdeflateWasm-QVHmuzw-.mjs").then((n) => n.r).then(async ({ initDeflateWasm }) => {
+		await initDeflateWasm(options.deflateWasm);
+	}));
+	if (options.png || options.pngWasm) inits.push(import("./pngEmbed-DgeNWlbS.mjs").then((n) => n.n).then(async ({ initPngWasm }) => {
+		await initPngWasm(options.pngWasm);
+	}));
+	if (options.fonts || options.fontWasm) inits.push(import("./fontSubset-BOGts8y9.mjs").then((n) => n.r).then(async ({ initSubsetWasm }) => {
+		await initSubsetWasm(options.fontWasm);
+	}));
+	await Promise.all(inits);
+	wasmInitialized = true;
+}
+
+//#endregion
+export { AnnotationFlags, BlendMode, ChangeTracker, CombedTextLayoutError, EmbeddedFont, EncryptedPdfError, ExceededMaxLengthError, FieldAlreadyExistsError, FieldExistsAsNonTerminalError, FieldFlags, FontNotEmbeddedError, ForeignPageError, ImageAlignment, InvalidFieldNamePartError, LineCapStyle, LineJoinStyle, MissingOnValueCheckError, NoSuchFieldError, PDFOperator, PageSizes, ParseSpeeds, PdfAnnotation, PdfArray, PdfBool, PdfButtonField, PdfCheckboxField, PdfCircleAnnotation, PdfDict, PdfDocument, PdfDropdownField, PdfEncryptionHandler, PdfField, PdfForm, PdfFreeTextAnnotation, PdfHighlightAnnotation, PdfInkAnnotation, PdfLayer, PdfLayerManager, PdfLineAnnotation, PdfLinkAnnotation, PdfListboxField, PdfName, PdfNull, PdfNumber, PdfObjectRegistry, PdfOutlineItem, PdfOutlineTree, PdfPage, PdfPolyLineAnnotation, PdfPolygonAnnotation, PdfRadioGroup, PdfRedactAnnotation, PdfRef, PdfSignatureField, PdfSquareAnnotation, PdfSquigglyAnnotation, PdfStampAnnotation, PdfStream, PdfStreamWriter, PdfStrikeOutAnnotation, PdfString, PdfStructureElement, PdfStructureTree, PdfTextAnnotation, PdfTextField, PdfUnderlineAnnotation, PdfViewerPreferences, PdfWriter, RemovePageFromEmptyDocumentError, RichTextFieldReadError, StandardFonts, TextAlignment, TextRenderingMode, UnexpectedFieldTypeError, addWatermark, addWatermarkToPage, aesDecryptCBC, aesEncryptCBC, annotationFromDict, applyFillColor, applyRedactions, applyStrokeColor, asNumber, asPDFName, asPDFNumber, attachFile, base64Decode, base64Encode, beginArtifact, beginArtifactWithType, beginLayerContent, beginMarkedContent, beginMarkedContentSequence, beginMarkedContentWithProperties, beginText, buildAnnotationDict, buildCatalog, buildDocumentStructure, buildEmbeddedFilesNameTree, buildInfoDict, buildPageTree, buildPkcs7Signature, buildTimestampRequest, buildViewerPreferencesDict, buildXmpMetadata, checkAccessibility, circlePath, clipEvenOdd, clip as clipOp, closeAndStroke, closeFillAndStroke, closeFillEvenOddAndStroke, closePath as closePathOp, cmyk, colorToComponents, componentsToColor, computeFileEncryptionKey, computeFontSize, computeSignatureHash, concatMatrix, concatMatrix as concatTransformationMatrix, copyPages, createAnnotation, createMarkedContentScope, createPdf, createXmpStream, cropPage, curveToFinal, curveToInitial, curveTo as curveToOp, decodePermissions, decodeStream, degrees, degreesToRadians, drawImageWithMatrix, drawImageXObject, drawXObject as drawObject, drawXObject, drawSvgOnPage, ellipsePath, embedPageAsFormXObject, embedSignature, encodeContextTag, encodeInteger, encodeLength, encodeOID, encodeOctetString, encodePermissions, encodePrintableString, encodeSequence, encodeSet, encodeUTCTime, encodeUtf8String, endArtifact, endLayerContent, endMarkedContent, endPath as endPathOp, endText, enforcePdfA, extractMetrics, extractText, extractTextWithPositions, fillAndStroke as fillAndStrokeOp, fillEvenOdd, fillEvenOddAndStroke, fill as fillOp, findSignatures, formatPdfDate, generateButtonAppearance, generateCheckboxAppearance, generateCircleAppearance, generateDropdownAppearance, generateFreeTextAppearance, generateHighlightAppearance, generateInkAppearance, generateLineAppearance, generateListboxAppearance, generateRadioAppearance, generateSignatureAppearance, generateSquareAppearance, generateSquigglyAppearance, generateStrikeOutAppearance, generateTextAppearance, generateUnderlineAppearance, getAttachments, getPageSize, getRedactionMarks, getSignatures, grayscale, initWasm, insertPage, isAccessible, isLinearized, isOpenTypeCFF, isTrueType, layoutCombedText, layoutMultilineText, layoutSinglelineText, lineTo as lineToOp, linearizePdf, loadPdf, markForRedaction, md5, mergePdfs, movePage, moveText as moveTextOp, moveTextSetLeading, moveTo as moveToOp, nextLine as nextLineOp, parseContentStream, parseSvg, parseSvgColor, parseSvgPath, parseSvgTransform, parseTimestampResponse, parseViewerPreferences, parseXmpMetadata, restoreState as popGraphicsState, restoreState, prepareForSigning, saveState as pushGraphicsState, saveState, radians, radiansToDegrees, rc4, rectangle as rectangleOp, removePage, removePages, requestTimestamp, resizePage, reversePages, rgb, rotateAllPages, rotate as rotateOp, rotatePage, rotationMatrix, saveDocumentIncremental, saveIncremental, scale as scaleOp, serializePdf, setCharacterSpacing as setCharacterSpacingOp, setCharacterSpacing as setCharacterSqueeze, setColorSpace, setDashPattern as setDashPatternOp, setFillColor, setFillColorCmyk, setFillColorGray, setFillColorRgb, setFillingColor, setFlatness, setFont as setFontAndSize, setFont as setFontOp, setFontSize as setFontSizeOp, setGraphicsState as setGraphicsStateOp, setLeading as setLeadingOp, setLeading as setLineHeight, setLineCap as setLineCapOp, setLineJoin as setLineJoinOp, setLineWidth as setLineWidthOp, setMiterLimit, setStrokeColor, setStrokeColorCmyk, setStrokeColorGray, setStrokeColorRgb, setStrokeColorSpace, setStrokingColor, setTextMatrix as setTextMatrixOp, setTextRenderingMode as setTextRenderingModeOp, setTextRise as setTextRiseOp, setWordSpacing as setWordSpacingOp, sha256, sha384, sha512, showTextArray, showTextHex, showTextNextLine, showText as showTextOp, showTextWithSpacing, signPdf, skew as skewOp, splitPdf, stroke as strokeOp, summarizeIssues, svgToPdfOperators, translate as translateOp, validatePdfA, verifyOwnerPassword, verifySignature, verifySignatures, verifyUserPassword, wrapInMarkedContent };
+//# sourceMappingURL=index.mjs.map