modern-pdf-lib 0.28.1 → 0.30.0

package/dist/{src-BOzRFaEE.mjs → src-s9zNsZAT.mjs}

@@ -1,6 +1,9 @@
-import { A as encodeUTCTime, Br as rectangle, Bt as PageSizes, C as encodeInteger, E as encodeOctetString, F as parseDerTlv, Gr as setLineWidth, H as mergePdfs, I as toBuffer, Jr as beginText, Kn as applyFillColor, L as computeSignatureHash, M as extractIssuerAndSerial, N as extractSubjectPublicKeyInfo, O as encodeSequence, P as getSubtle, Pr as fill, Rn as restoreState, Rr as lineTo, S as encodeContextTag, Sn as formatPdfDate, T as encodeOID, Vn as saveState, Vr as setDashPattern, Xr as moveText, Yr as endText, at as sha256, b as detectKeyAlgorithm, ei as setFont, gn as buildAnnotationDict, gt as PdfParseError, k as encodeSet, mn as PdfAnnotation, n as StandardFonts, oi as setWordSpacing, qn as applyStrokeColor, qr as stroke, r as createPdf, s as setPageLabels, si as showText, t as PdfDocument, x as detectNamedCurve, y as decodeOidBytes, z as findSignatures, zr as moveTo } from "./pdfDocument-B6czyaVI.mjs";
-import { i as PdfName, l as PdfStream, n as PdfBool, o as PdfNumber, r as PdfDict, t as PdfArray, u as PdfString } from "./pdfObjects-CB7TEdbW.mjs";
+import { A as encodeUTCTime, Br as rectangle, Bt as PageSizes, C as encodeInteger, E as encodeOctetString, F as parseDerTlv, Gr as setLineWidth, H as mergePdfs, I as toBuffer, Jr as beginText, Kn as applyFillColor, L as computeSignatureHash, M as extractIssuerAndSerial, N as extractSubjectPublicKeyInfo, O as encodeSequence, P as getSubtle, Pr as fill, Rn as restoreState, Rr as lineTo, S as encodeContextTag, Sn as formatPdfDate, T as encodeOID, Vn as saveState, Vr as setDashPattern, Xr as moveText, Yn as cmykToRgb, Yr as endText, at as sha256, b as detectKeyAlgorithm, ei as setFont, gn as buildAnnotationDict, gt as PdfParseError, k as encodeSet, mn as PdfAnnotation, n as StandardFonts, oi as setWordSpacing, qn as applyStrokeColor, qr as stroke, r as createPdf, s as setPageLabels, si as showText$1, t as PdfDocument, x as detectNamedCurve, y as decodeOidBytes, z as findSignatures, zr as moveTo } from "./pdfDocument-Cgkkk8F8.mjs";
+import { c as PdfRef, i as PdfName, l as PdfStream, n as PdfBool, o as PdfNumber, r as PdfDict, t as PdfArray, u as PdfString } from "./pdfObjects-CB7TEdbW.mjs";
+import { n as decodeStreamData, r as getStreamFilters } from "./streamDecode-DCpgTocN.mjs";
 import { g as FieldFlags, v as numVal } from "./pdfForm-CfLnlsj-.mjs";
+import { i as parseContentStream } from "./compressionAnalysis-BEd_745I.mjs";
+import { n as decodeJpegWasm } from "./bridge-7dhURZj7.mjs";
 import { r as detectRuntime } from "./loader-DkrXz-h4.mjs";
 import { deflateSync, inflateSync, unzlibSync } from "fflate";
 //#region src/core/incrementalWriter.ts
@@ -274,7 +277,7 @@ function compressStream(stream, level) {
 * @returns              The incremental save result.
 */
 async function saveDocumentIncremental(originalBytes, doc, options) {
-	const { buildDocumentStructure } = await import("./pdfDocument-B6czyaVI.mjs").then((n) => n.Cn);
+	const { buildDocumentStructure } = await import("./pdfDocument-Cgkkk8F8.mjs").then((n) => n.Cn);
 	const registry = doc.getRegistry();
 	const structure = buildDocumentStructure(doc.getInternalPages().map((p) => p.finalize()), {
 		producer: doc.getProducer(),
@@ -13324,7 +13327,7 @@ function renderStyledBarcode(matrix, x, y, text, options) {
 		ops += setFont(fontName, fontSize);
 		ops += applyFillColor(textColor);
 		ops += moveText(textX, textY);
-		ops += showText(text);
+		ops += showText$1(text);
 		ops += endText();
 	}
 	ops += restoreState();
@@ -17923,7 +17926,7 @@ function skipWS(data, pos) {
 * Read a decimal integer from `data` starting at `pos`.
 * Returns `{ value, nextPos }`.
 */
-function readInt(data, pos) {
+function readInt$1(data, pos) {
 	let value = 0;
 	let started = false;
 	while (pos < data.length) {
@@ -18472,10 +18475,10 @@ var StreamingPdfParser = class StreamingPdfParser {
 		pos = skipWS(data, pos);
 		while (pos < data.length) {
 			if (pos + 7 <= data.length && data[pos] === 116 && data[pos + 1] === 114 && data[pos + 2] === 97 && data[pos + 3] === 105 && data[pos + 4] === 108 && data[pos + 5] === 101 && data[pos + 6] === 114) break;
-			const firstObjResult = readInt(data, pos);
+			const firstObjResult = readInt$1(data, pos);
 			if (firstObjResult.value === -1) break;
 			pos = skipWS(data, firstObjResult.nextPos);
-			const countResult = readInt(data, pos);
+			const countResult = readInt$1(data, pos);
 			if (countResult.value === -1) break;
 			pos = skipWS(data, countResult.nextPos);
 			const firstObjNum = firstObjResult.value;
@@ -18554,8 +18557,8 @@ var StreamingPdfParser = class StreamingPdfParser {
 	}
 	parseXrefStream(data, offset) {
 		let pos = skipWS(data, offset);
-		pos = skipWS(data, readInt(data, pos).nextPos);
-		pos = skipWS(data, readInt(data, pos).nextPos);
+		pos = skipWS(data, readInt$1(data, pos).nextPos);
+		pos = skipWS(data, readInt$1(data, pos).nextPos);
 		if (pos + 3 <= data.length && data[pos] === 111 && data[pos + 1] === 98 && data[pos + 2] === 106) pos += 3;
 		pos = skipWS(data, pos);
 		const dictResult = parseLightDict(data, pos);
@@ -18642,10 +18645,10 @@ var StreamingPdfParser = class StreamingPdfParser {
 	*/
 	parseObjectDict(data, offset) {
 		let pos = skipWS(data, offset);
-		const objNumResult = readInt(data, pos);
+		const objNumResult = readInt$1(data, pos);
 		if (objNumResult.value === -1) return void 0;
 		pos = skipWS(data, objNumResult.nextPos);
-		const genResult = readInt(data, pos);
+		const genResult = readInt$1(data, pos);
 		if (genResult.value === -1) return void 0;
 		pos = skipWS(data, genResult.nextPos);
 		if (pos + 3 <= data.length && data[pos] === 111 && data[pos + 1] === 98 && data[pos + 2] === 106) pos += 3;
@@ -18741,10 +18744,10 @@ var StreamingPdfParser = class StreamingPdfParser {
 		while (pos < data.length) {
 			pos = skipWS(data, pos);
 			if (pos >= data.length || data[pos] === 93) break;
-			const objResult = readInt(data, pos);
+			const objResult = readInt$1(data, pos);
 			if (objResult.value === -1) break;
 			pos = skipWS(data, objResult.nextPos);
-			const genResult = readInt(data, pos);
+			const genResult = readInt$1(data, pos);
 			if (genResult.value === -1) break;
 			pos = skipWS(data, genResult.nextPos);
 			if (pos < data.length && data[pos] === 82) {
@@ -22590,7 +22593,7 @@ function parseFormattedNumber(text) {
 * @param options  Formatting options.
 * @returns        The formatted string.
 */
-function formatNumber(value, options = {}) {
+function formatNumber$1(value, options = {}) {
 	const { decimals = 2, thousandsSep = ",", decimalSep = ".", negativeStyle = "minus", currency = "", currencyPrepend = true } = options;
 	const isNeg = value < 0;
 	const fixed = Math.abs(value).toFixed(decimals);
@@ -22625,7 +22628,7 @@ function AFNumber_Format(nDec, sepStyle, negStyle, currStyle, strCurrency, bCurr
 	return (value) => {
 		const num = parseFormattedNumber(value);
 		if (Number.isNaN(num)) return value;
-		return formatNumber(num, {
+		return formatNumber$1(num, {
 			decimals: nDec,
 			thousandsSep: seps.thousands,
 			decimalSep: seps.decimal,
@@ -26385,7 +26388,7 @@ function renderLine(line, x, y, availableWidth, alignment, measure, defaultFontN
 			ops += moveText(spaceWidth, 0);
 			currentX += spaceWidth;
 		}
-		ops += showText(word.text);
+		ops += showText$1(word.text);
 		currentX += word.width;
 		if (word.underline) {
 			ops += endText();
@@ -27838,6 +27841,2581 @@ function extractNodeBytesFromParent(fullBuffer, parent, child) {
 	return fullBuffer.subarray(start, start + child.totalLength);
 }
 //#endregion
+//#region src/render/matrix.ts
+/** The identity transform. */
+function identity() {
+	return [
+		1,
+		0,
+		0,
+		1,
+		0,
+		0
+	];
+}
+/**
+* Concatenate two transforms: the result applies `m` **first**, then `n`
+* (i.e. `point · m · n`). This matches the PDF `cm` operator, where the new
+* CTM is `cmMatrix × CTM`.
+*/
+function multiply(m, n) {
+	return [
+		m[0] * n[0] + m[1] * n[2],
+		m[0] * n[1] + m[1] * n[3],
+		m[2] * n[0] + m[3] * n[2],
+		m[2] * n[1] + m[3] * n[3],
+		m[4] * n[0] + m[5] * n[2] + n[4],
+		m[4] * n[1] + m[5] * n[3] + n[5]
+	];
+}
+/** Apply a transform to a point, returning the transformed `[x, y]`. */
+function applyToPoint(m, x, y) {
+	return [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];
+}
+/** A pure translation transform. */
+function translation(tx, ty) {
+	return [
+		1,
+		0,
+		0,
+		1,
+		tx,
+		ty
+	];
+}
+/**
+* The magnitude by which `m` scales lengths — the geometric mean of the
+* x- and y-axis scale factors (`sqrt(|det|)`). Used to map a user-space line
+* width to device space.
+*/
+function meanScale(m) {
+	const det = m[0] * m[3] - m[1] * m[2];
+	return Math.sqrt(Math.abs(det));
+}
+//#endregion
+//#region src/render/interpreter.ts
+/**
+* @module render/interpreter
+*
+* Executes a parsed PDF content stream through a graphics-state machine,
+* producing a resolution-independent {@link DisplayList} (page space, y-up).
+* This is the foundation the rasterizer and Canvas adapter render from.
+*
+* Supported operators: graphics state (`q`/`Q`/`cm`/`w`/`J`/`j`/`gs`), path
+* construction (`m`/`l`/`c`/`v`/`y`/`re`/`h`), path painting
+* (`f`/`F`/`f*`/`S`/`s`/`B`/`B*`/`b`/`b*`/`n`), clipping (`W`/`W*`), color
+* (`rg`/`RG`/`g`/`G`/`k`/`K`/`cs`/`CS`/`sc`/`scn`/`SC`/`SCN`), text
+* (`BT`/`ET`/`Tf`/`Td`/`TD`/`Tm`/`T*`/`Tc`/`Tw`/`Tz`/`TL`/`Ts`/`Tr`/`Tj`/`TJ`/`'`/`"`),
+* and XObjects (`Do`, recursing into form XObjects). Bézier curves are
+* flattened to polylines.
+*
+* @packageDocumentation
+*/
+function initialState$1() {
+	return {
+		ctm: identity(),
+		fill: [
+			0,
+			0,
+			0,
+			255
+		],
+		stroke: [
+			0,
+			0,
+			0,
+			255
+		],
+		lineWidth: 1,
+		lineCap: 0,
+		lineJoin: 0,
+		fillAlpha: 1,
+		strokeAlpha: 1,
+		clip: void 0,
+		font: void 0,
+		fontSize: 0,
+		charSpace: 0,
+		wordSpace: 0,
+		hScale: 1,
+		leading: 0,
+		rise: 0,
+		renderMode: 0
+	};
+}
+function cloneState(s) {
+	return { ...s };
+}
+function num$2(op) {
+	return typeof op === "number" ? op : 0;
+}
+function nameOf(op) {
+	if (op instanceof PdfName) return op.value.replace(/^\//, "");
+	if (typeof op === "string") return op.replace(/^\//, "");
+}
+function clamp255(v) {
+	return Math.max(0, Math.min(255, Math.round(v * 255)));
+}
+function grayRgba(g) {
+	const v = clamp255(g);
+	return [
+		v,
+		v,
+		v,
+		255
+	];
+}
+function rgbRgba(r, g, b) {
+	return [
+		clamp255(r),
+		clamp255(g),
+		clamp255(b),
+		255
+	];
+}
+function cmykRgba(c, m, y, k) {
+	const [r, g, b] = cmykToRgb(c, m, y, k);
+	return [
+		clamp255(r),
+		clamp255(g),
+		clamp255(b),
+		255
+	];
+}
+/** Interpret `sc`/`scn` numeric components by arity → RGBA. */
+function componentsToRgba(comps) {
+	if (comps.length === 1) return grayRgba(comps[0]);
+	if (comps.length === 3) return rgbRgba(comps[0], comps[1], comps[2]);
+	if (comps.length === 4) return cmykRgba(comps[0], comps[1], comps[2], comps[3]);
+}
+const BEZIER_STEPS = 16;
+function flattenCubic(out, p0, p1, p2, p3) {
+	for (let i = 1; i <= BEZIER_STEPS; i++) {
+		const t = i / BEZIER_STEPS;
+		const mt = 1 - t;
+		const a = mt * mt * mt;
+		const b = 3 * mt * mt * t;
+		const c = 3 * mt * t * t;
+		const d = t * t * t;
+		out.push(a * p0[0] + b * p1[0] + c * p2[0] + d * p3[0], a * p0[1] + b * p1[1] + c * p2[1] + d * p3[1]);
+	}
+}
+/**
+* Execute a parsed content stream into a {@link DisplayList}.
+*
+* @param operators - Output of {@link parseContentStream}.
+* @param options   - Page dimensions and (optional) resources/registry.
+*/
+function interpretContentStream(operators, options) {
+	const items = [];
+	const origin = options.origin ?? [0, 0];
+	interpretInto(items, operators, initialState$1(), options, 0);
+	return {
+		items,
+		width: options.width,
+		height: options.height,
+		origin
+	};
+}
+const MAX_FORM_DEPTH = 12;
+function interpretInto(items, operators, startState, options, depth) {
+	const stack = [];
+	let gs = startState;
+	let path = [];
+	let cur = null;
+	let curUser = [0, 0];
+	let curPage = [0, 0];
+	let pendingClip = null;
+	let tm = identity();
+	let tlm = identity();
+	const startSub = (x, y) => {
+		if (cur && cur.length >= 4) path.push({
+			points: cur,
+			closed: false
+		});
+		curUser = [x, y];
+		curPage = applyToPoint(gs.ctm, x, y);
+		cur = [curPage[0], curPage[1]];
+	};
+	const lineTo = (x, y) => {
+		if (!cur) startSub(x, y);
+		curUser = [x, y];
+		curPage = applyToPoint(gs.ctm, x, y);
+		cur.push(curPage[0], curPage[1]);
+	};
+	const finishPath = () => {
+		if (cur && cur.length >= 4) path.push({
+			points: cur,
+			closed: false
+		});
+		const result = path;
+		path = [];
+		cur = null;
+		return result;
+	};
+	const applyClipIfPending = (subs) => {
+		if (pendingClip) {
+			gs = {
+				...gs,
+				clip: subs.map((s) => ({
+					points: s.points.slice(),
+					closed: true
+				}))
+			};
+			pendingClip = null;
+		}
+	};
+	const pushOpen = (closed) => {
+		if (cur && cur.length >= 4) path.push({
+			points: cur,
+			closed
+		});
+		cur = null;
+	};
+	for (const { operator, operands } of operators) switch (operator) {
+		case "q":
+			stack.push(cloneState(gs));
+			break;
+		case "Q":
+			if (stack.length) gs = stack.pop();
+			break;
+		case "cm":
+			gs = {
+				...gs,
+				ctm: multiply([
+					num$2(operands[0]),
+					num$2(operands[1]),
+					num$2(operands[2]),
+					num$2(operands[3]),
+					num$2(operands[4]),
+					num$2(operands[5])
+				], gs.ctm)
+			};
+			break;
+		case "w":
+			gs = {
+				...gs,
+				lineWidth: num$2(operands[0])
+			};
+			break;
+		case "J":
+			gs = {
+				...gs,
+				lineCap: num$2(operands[0]) | 0
+			};
+			break;
+		case "j":
+			gs = {
+				...gs,
+				lineJoin: num$2(operands[0]) | 0
+			};
+			break;
+		case "gs":
+			gs = applyExtGState(gs, nameOf(operands[0]), options);
+			break;
+		case "rg":
+			gs = {
+				...gs,
+				fill: rgbRgba(num$2(operands[0]), num$2(operands[1]), num$2(operands[2]))
+			};
+			break;
+		case "RG":
+			gs = {
+				...gs,
+				stroke: rgbRgba(num$2(operands[0]), num$2(operands[1]), num$2(operands[2]))
+			};
+			break;
+		case "g":
+			gs = {
+				...gs,
+				fill: grayRgba(num$2(operands[0]))
+			};
+			break;
+		case "G":
+			gs = {
+				...gs,
+				stroke: grayRgba(num$2(operands[0]))
+			};
+			break;
+		case "k":
+			gs = {
+				...gs,
+				fill: cmykRgba(num$2(operands[0]), num$2(operands[1]), num$2(operands[2]), num$2(operands[3]))
+			};
+			break;
+		case "K":
+			gs = {
+				...gs,
+				stroke: cmykRgba(num$2(operands[0]), num$2(operands[1]), num$2(operands[2]), num$2(operands[3]))
+			};
+			break;
+		case "sc":
+		case "scn": {
+			const rgba = componentsToRgba(operands.filter((o) => typeof o === "number"));
+			if (rgba) gs = {
+				...gs,
+				fill: rgba
+			};
+			break;
+		}
+		case "SC":
+		case "SCN": {
+			const rgba = componentsToRgba(operands.filter((o) => typeof o === "number"));
+			if (rgba) gs = {
+				...gs,
+				stroke: rgba
+			};
+			break;
+		}
+		case "m":
+			startSub(num$2(operands[0]), num$2(operands[1]));
+			break;
+		case "l":
+			lineTo(num$2(operands[0]), num$2(operands[1]));
+			break;
+		case "c": {
+			if (!cur) startSub(curUser[0], curUser[1]);
+			const p1 = applyToPoint(gs.ctm, num$2(operands[0]), num$2(operands[1]));
+			const p2 = applyToPoint(gs.ctm, num$2(operands[2]), num$2(operands[3]));
+			const p3 = applyToPoint(gs.ctm, num$2(operands[4]), num$2(operands[5]));
+			flattenCubic(cur, curPage, p1, p2, p3);
+			curUser = [num$2(operands[4]), num$2(operands[5])];
+			curPage = p3;
+			break;
+		}
+		case "v": {
+			if (!cur) startSub(curUser[0], curUser[1]);
+			const p2 = applyToPoint(gs.ctm, num$2(operands[0]), num$2(operands[1]));
+			const p3 = applyToPoint(gs.ctm, num$2(operands[2]), num$2(operands[3]));
+			flattenCubic(cur, curPage, curPage, p2, p3);
+			curUser = [num$2(operands[2]), num$2(operands[3])];
+			curPage = p3;
+			break;
+		}
+		case "y": {
+			if (!cur) startSub(curUser[0], curUser[1]);
+			const p1 = applyToPoint(gs.ctm, num$2(operands[0]), num$2(operands[1]));
+			const p3 = applyToPoint(gs.ctm, num$2(operands[2]), num$2(operands[3]));
+			flattenCubic(cur, curPage, p1, p3, p3);
+			curUser = [num$2(operands[2]), num$2(operands[3])];
+			curPage = p3;
+			break;
+		}
+		case "re": {
+			const x = num$2(operands[0]);
+			const y = num$2(operands[1]);
+			const w = num$2(operands[2]);
+			const h = num$2(operands[3]);
+			pushOpen(false);
+			const corners = [
+				applyToPoint(gs.ctm, x, y),
+				applyToPoint(gs.ctm, x + w, y),
+				applyToPoint(gs.ctm, x + w, y + h),
+				applyToPoint(gs.ctm, x, y + h)
+			];
+			path.push({
+				points: corners.flat(),
+				closed: true
+			});
+			cur = null;
+			curUser = [x, y];
+			curPage = corners[0];
+			break;
+		}
+		case "h":
+			pushOpen(true);
+			break;
+		case "f":
+		case "F":
+		case "f*": {
+			const subs = finishPath();
+			emitFill(items, subs, operator === "f*" ? "evenodd" : "nonzero", gs);
+			applyClipIfPending(subs);
+			break;
+		}
+		case "S":
+		case "s": {
+			if (operator === "s") pushOpen(true);
+			const subs = finishPath();
+			emitStroke(items, subs, gs);
+			applyClipIfPending(subs);
+			break;
+		}
+		case "B":
+		case "B*":
+		case "b":
+		case "b*": {
+			if (operator === "b" || operator === "b*") pushOpen(true);
+			const subs = finishPath();
+			emitFill(items, subs, operator === "B*" || operator === "b*" ? "evenodd" : "nonzero", gs);
+			emitStroke(items, subs, gs);
+			applyClipIfPending(subs);
+			break;
+		}
+		case "n":
+			applyClipIfPending(finishPath());
+			break;
+		case "W":
+			pendingClip = "nonzero";
+			break;
+		case "W*":
+			pendingClip = "evenodd";
+			break;
+		case "BT":
+			tm = identity();
+			tlm = identity();
+			break;
+		case "ET": break;
+		case "Tf":
+			gs = {
+				...gs,
+				font: nameOf(operands[0]),
+				fontSize: num$2(operands[1])
+			};
+			break;
+		case "Tc":
+			gs = {
+				...gs,
+				charSpace: num$2(operands[0])
+			};
+			break;
+		case "Tw":
+			gs = {
+				...gs,
+				wordSpace: num$2(operands[0])
+			};
+			break;
+		case "Tz":
+			gs = {
+				...gs,
+				hScale: num$2(operands[0]) / 100
+			};
+			break;
+		case "TL":
+			gs = {
+				...gs,
+				leading: num$2(operands[0])
+			};
+			break;
+		case "Ts":
+			gs = {
+				...gs,
+				rise: num$2(operands[0])
+			};
+			break;
+		case "Tr":
+			gs = {
+				...gs,
+				renderMode: num$2(operands[0]) | 0
+			};
+			break;
+		case "Td":
+			tlm = multiply(translation(num$2(operands[0]), num$2(operands[1])), tlm);
+			tm = tlm;
+			break;
+		case "TD":
+			gs = {
+				...gs,
+				leading: -num$2(operands[1])
+			};
+			tlm = multiply(translation(num$2(operands[0]), num$2(operands[1])), tlm);
+			tm = tlm;
+			break;
+		case "Tm":
+			tm = [
+				num$2(operands[0]),
+				num$2(operands[1]),
+				num$2(operands[2]),
+				num$2(operands[3]),
+				num$2(operands[4]),
+				num$2(operands[5])
+			];
+			tlm = tm;
+			break;
+		case "T*":
+			tlm = multiply(translation(0, -gs.leading), tlm);
+			tm = tlm;
+			break;
+		case "Tj":
+			tm = showText(items, textString(operands[0]), tm, gs);
+			break;
+		case "TJ": {
+			const arr = Array.isArray(operands[0]) ? operands[0] : [];
+			let combined = "";
+			for (const el of arr) if (typeof el === "number") tm = multiply(translation(-el / 1e3 * gs.fontSize * gs.hScale, 0), tm);
+			else {
+				combined += textString(el);
+				tm = showText(items, textString(el), tm, gs);
+			}
+			break;
+		}
+		case "'":
+			tlm = multiply(translation(0, -gs.leading), tlm);
+			tm = tlm;
+			tm = showText(items, textString(operands[0]), tm, gs);
+			break;
+		case "\"":
+			gs = {
+				...gs,
+				wordSpace: num$2(operands[0]),
+				charSpace: num$2(operands[1])
+			};
+			tlm = multiply(translation(0, -gs.leading), tlm);
+			tm = tlm;
+			tm = showText(items, textString(operands[2]), tm, gs);
+			break;
+		case "Do":
+			doXObject(items, nameOf(operands[0]), gs, options, depth);
+			break;
+		default: break;
+	}
+}
+function freeze(subs) {
+	return subs.map((s) => ({
+		points: s.points,
+		closed: s.closed
+	}));
+}
+function emitFill(items, subs, rule, gs) {
+	if (!subs.length) return;
+	items.push({
+		type: "fill",
+		subpaths: freeze(subs),
+		rule,
+		color: gs.fill,
+		alpha: gs.fillAlpha,
+		clip: gs.clip
+	});
+}
+function emitStroke(items, subs, gs) {
+	if (!subs.length) return;
+	items.push({
+		type: "stroke",
+		subpaths: freeze(subs),
+		color: gs.stroke,
+		alpha: gs.strokeAlpha,
+		lineWidth: Math.max(gs.lineWidth * meanScale(gs.ctm), .1),
+		lineCap: gs.lineCap,
+		lineJoin: gs.lineJoin,
+		clip: gs.clip
+	});
+}
+/** Decode a content-stream string operand to text (best-effort latin-1/WinAnsi). */
+function textString(op) {
+	return typeof op === "string" ? op : "";
+}
+/** Emit a text run and advance the text matrix by an approximate width. */
+function showText(items, text, tm, gs) {
+	if (text.length) items.push({
+		type: "text",
+		text,
+		font: gs.font,
+		fontSize: gs.fontSize,
+		transform: multiply(multiply([
+			gs.fontSize * gs.hScale,
+			0,
+			0,
+			gs.fontSize,
+			0,
+			gs.rise
+		], tm), gs.ctm),
+		color: gs.fill,
+		alpha: gs.fillAlpha,
+		renderMode: gs.renderMode,
+		clip: gs.clip
+	});
+	let w = 0;
+	for (const ch of text) w += .5 * gs.fontSize + gs.charSpace + (ch === " " ? gs.wordSpace : 0);
+	return multiply(translation(w * gs.hScale, 0), tm);
+}
+function resolve$1(obj, options) {
+	if (obj && obj.kind === "ref" && options.registry) return options.registry.resolve(obj);
+	return obj;
+}
+function subDict(resources, key, options) {
+	if (!resources) return void 0;
+	const d = resolve$1(resources.get(key), options);
+	return d && d.kind === "dict" ? d : void 0;
+}
+function applyExtGState(gs, name, options) {
+	if (!name) return gs;
+	const egs = subDict(options.resources, "/ExtGState", options);
+	const dict = egs ? resolve$1(egs.get("/" + name), options) : void 0;
+	if (!dict || dict.kind !== "dict") return gs;
+	const d = dict;
+	const ca = resolve$1(d.get("/ca"), options);
+	const CA = resolve$1(d.get("/CA"), options);
+	const LW = resolve$1(d.get("/LW"), options);
+	const next = { ...gs };
+	if (ca && ca.kind === "number") next.fillAlpha = ca.value;
+	if (CA && CA.kind === "number") next.strokeAlpha = CA.value;
+	if (LW && LW.kind === "number") next.lineWidth = LW.value;
+	return next;
+}
+function doXObject(items, name, gs, options, depth) {
+	if (!name) return;
+	const xobjects = subDict(options.resources, "/XObject", options);
+	const xobj = xobjects ? resolve$1(xobjects.get("/" + name), options) : void 0;
+	if (!xobj || xobj.kind !== "stream") {
+		items.push({
+			type: "image",
+			name,
+			transform: gs.ctm,
+			alpha: gs.fillAlpha,
+			clip: gs.clip
+		});
+		return;
+	}
+	const stream = xobj;
+	const subtype = stream.dict.get("/Subtype");
+	if ((subtype instanceof PdfName ? subtype.value.replace(/^\//, "") : "") === "Form" && depth < MAX_FORM_DEPTH) {
+		const matrixObj = resolve$1(stream.dict.get("/Matrix"), options);
+		let formCtm = gs.ctm;
+		if (matrixObj && matrixObj.kind === "array") {
+			const m = matrixObj.items.map((o) => o && o.kind === "number" ? o.value : 0);
+			if (m.length === 6) formCtm = multiply(m, gs.ctm);
+		}
+		const formResources = subDict(stream.dict, "/Resources", options) ?? options.resources;
+		try {
+			interpretInto(items, parseContentStream(decodeStreamData(stream)), {
+				...gs,
+				ctm: formCtm
+			}, {
+				...options,
+				resources: formResources
+			}, depth + 1);
+		} catch {}
+		return;
+	}
+	items.push({
+		type: "image",
+		name,
+		transform: gs.ctm,
+		alpha: gs.fillAlpha,
+		clip: gs.clip
+	});
+}
+/**
+* Interpret a {@link PdfPage}'s content into a {@link DisplayList}, using its
+* crop/media box for dimensions and its resources/registry for `Do`/`gs`/`Tf`
+* resolution. The entry point for {@link renderPageToImage} et al.
+*/
+function interpretPage(page) {
+	const box = page.getCropBox() ?? page.getMediaBox();
+	return interpretContentStream(parseContentStream(page.getContentStream()), {
+		width: box.width,
+		height: box.height,
+		origin: [box.x, box.y],
+		resources: page.getOriginalResources(),
+		registry: page.getRegistry()
+	});
+}
+//#endregion
+//#region src/render/rasterizer.ts
+function resolveScale(opts) {
+	if (typeof opts.scale === "number") return opts.scale;
+	if (typeof opts.dpi === "number") return opts.dpi / 72;
+	return 1;
+}
+/** Rasterize a display list to an RGBA8888 buffer. */
+function rasterize(dl, opts = {}) {
+	const scale = resolveScale(opts);
+	const fullH = Math.max(1, Math.ceil(dl.height * scale));
+	const region = opts.region ?? {
+		x: 0,
+		y: 0,
+		width: Math.max(1, Math.ceil(dl.width * scale)),
+		height: fullH
+	};
+	const W = Math.max(1, region.width);
+	const H = Math.max(1, region.height);
+	const data = new Uint8Array(W * H * 4);
+	const bg = opts.background ?? [
+		255,
+		255,
+		255,
+		255
+	];
+	if (bg !== "transparent") for (let i = 0; i < data.length; i += 4) {
+		data[i] = bg[0];
+		data[i + 1] = bg[1];
+		data[i + 2] = bg[2];
+		data[i + 3] = bg[3];
+	}
+	const [ox, oy] = dl.origin;
+	/** page space → region-local pixel space (with y-flip + tile offset). */
+	const toPx = (x, y) => [(x - ox) * scale - region.x, fullH - (y - oy) * scale - region.y];
+	const renderText = opts.renderText ?? true;
+	for (const item of dl.items) {
+		const clip = item.clip ? toPixelSubpaths(item.clip, toPx) : void 0;
+		if (item.type === "fill") fillSubpaths(data, W, H, toPixelSubpaths(item.subpaths, toPx), item.rule, item.color, item.alpha, clip);
+		else if (item.type === "stroke") strokeSubpaths(data, W, H, item.subpaths, toPx, item.lineWidth * scale, item.color, item.alpha, clip);
+		else if (item.type === "text" && renderText && item.renderMode !== 3 && item.renderMode !== 7) fillTextBoxes(data, W, H, item, toPx, clip);
+	}
+	return {
+		data,
+		width: W,
+		height: H
+	};
+}
+/**
+* Render a {@link PdfPage} to a PNG image.
+* @returns The PNG bytes plus pixel dimensions.
+*/
+async function renderPageToImage(page, opts = {}) {
+	const img = rasterize(interpretPage(page), opts);
+	return {
+		data: encodePngFromPixels(img.data, img.width, img.height, 4),
+		width: img.width,
+		height: img.height
+	};
+}
+function toPixelSubpaths(subpaths, toPx) {
+	return subpaths.map((s) => {
+		const out = [];
+		for (let i = 0; i + 1 < s.points.length; i += 2) {
+			const [px, py] = toPx(s.points[i], s.points[i + 1]);
+			out.push(px, py);
+		}
+		return out;
+	});
+}
+function buildEdges(subpaths) {
+	const edges = [];
+	for (const pts of subpaths) {
+		const n = pts.length / 2;
+		if (n < 2) continue;
+		for (let i = 0; i < n; i++) {
+			const x0 = pts[i * 2];
+			const y0 = pts[i * 2 + 1];
+			const j = (i + 1) % n;
+			const x1 = pts[j * 2];
+			const y1 = pts[j * 2 + 1];
+			if (y0 === y1) continue;
+			if (y0 < y1) edges.push({
+				ymin: y0,
+				ymax: y1,
+				xAtYmin: x0,
+				dxdy: (x1 - x0) / (y1 - y0),
+				dir: 1
+			});
+			else edges.push({
+				ymin: y1,
+				ymax: y0,
+				xAtYmin: x1,
+				dxdy: (x0 - x1) / (y0 - y1),
+				dir: -1
+			});
+		}
+	}
+	return edges;
+}
+const SUBSAMPLES = 4;
+function fillSubpaths(data, W, H, subpaths, rule, color, alpha, clip) {
+	const edges = buildEdges(subpaths);
+	if (!edges.length) return;
+	const clipEdges = clip ? buildEdges(clip) : void 0;
+	let yTop = H;
+	let yBot = 0;
+	for (const e of edges) {
+		yTop = Math.min(yTop, e.ymin);
+		yBot = Math.max(yBot, e.ymax);
+	}
+	const rowStart = Math.max(0, Math.floor(yTop));
+	const rowEnd = Math.min(H, Math.ceil(yBot));
+	const coverage = new Float32Array(W);
+	const inc = 1 / SUBSAMPLES;
+	for (let y = rowStart; y < rowEnd; y++) {
+		coverage.fill(0);
+		for (let s = 0; s < SUBSAMPLES; s++) accumulateSpans(coverage, W, edges, y + (s + .5) / SUBSAMPLES, rule, inc, clipEdges);
+		const r = color[0];
+		const g = color[1];
+		const b = color[2];
+		const ca = color[3] / 255 * alpha;
+		const base = y * W * 4;
+		for (let x = 0; x < W; x++) {
+			const cov = coverage[x];
+			if (cov <= 0) continue;
+			blend(data, base + x * 4, r, g, b, Math.min(1, cov) * ca);
+		}
+	}
+}
+/** Build winding spans at sub-scanline `sy`, adding fractional coverage. */
+function accumulateSpans(coverage, W, edges, sy, rule, weight, clipEdges) {
+	const xs = crossings(edges, sy);
+	if (xs.length < 2) return;
+	const clipSpans = clipEdges ? rowSpans(crossings(clipEdges, sy), "nonzero") : void 0;
+	const spans = rowSpans(xs, rule);
+	for (const [x0, x1] of spans) if (clipSpans) for (const [c0, c1] of clipSpans) addSpan(coverage, W, Math.max(x0, c0), Math.min(x1, c1), weight);
+	else addSpan(coverage, W, x0, x1, weight);
+}
+function crossings(edges, sy) {
+	const xs = [];
+	for (const e of edges) if (sy >= e.ymin && sy < e.ymax) xs.push({
+		x: e.xAtYmin + (sy - e.ymin) * e.dxdy,
+		dir: e.dir
+	});
+	xs.sort((a, b) => a.x - b.x);
+	return xs;
+}
+function rowSpans(xs, rule) {
+	const spans = [];
+	let winding = 0;
+	for (let i = 0; i + 1 < xs.length; i++) {
+		winding += xs[i].dir;
+		if (rule === "evenodd" ? (i + 1) % 2 === 1 : winding !== 0) spans.push([xs[i].x, xs[i + 1].x]);
+	}
+	return spans;
+}
+/** Add `weight` coverage over `[x0, x1)` with fractional pixel ends. */
+function addSpan(coverage, W, x0, x1, weight) {
+	if (x1 <= x0) return;
+	const a = Math.max(0, x0);
+	const b = Math.min(W, x1);
+	if (b <= a) return;
+	const ia = Math.floor(a);
+	const ib = Math.floor(b - 1e-9);
+	if (ia === ib) {
+		coverage[ia] += (b - a) * weight;
+		return;
+	}
+	coverage[ia] += (ia + 1 - a) * weight;
+	for (let x = ia + 1; x < ib; x++) coverage[x] += weight;
+	coverage[ib] += (b - ib) * weight;
+}
+function blend(data, idx, r, g, b, a) {
+	if (a <= 0) return;
+	const ia = 1 - a;
+	data[idx] = Math.round(r * a + data[idx] * ia);
+	data[idx + 1] = Math.round(g * a + data[idx + 1] * ia);
+	data[idx + 2] = Math.round(b * a + data[idx + 2] * ia);
+	data[idx + 3] = Math.round(255 * a + data[idx + 3] * ia);
+}
+function strokeSubpaths(data, W, H, subpaths, toPx, widthPx, color, alpha, clip) {
+	const hw = Math.max(widthPx / 2, .35);
+	for (const sp of subpaths) {
+		const pts = sp.points;
+		const n = pts.length / 2;
+		const segCount = sp.closed ? n : n - 1;
+		for (let i = 0; i < segCount; i++) {
+			const a = toPx(pts[i * 2], pts[i * 2 + 1]);
+			const j = (i + 1) % n;
+			const b = toPx(pts[j * 2], pts[j * 2 + 1]);
+			const dx = b[0] - a[0];
+			const dy = b[1] - a[1];
+			const len = Math.hypot(dx, dy);
+			if (len < 1e-6) continue;
+			const nx = -dy / len * hw;
+			const ny = dx / len * hw;
+			fillSubpaths(data, W, H, [[
+				a[0] + nx,
+				a[1] + ny,
+				b[0] + nx,
+				b[1] + ny,
+				b[0] - nx,
+				b[1] - ny,
+				a[0] - nx,
+				a[1] - ny
+			]], "nonzero", color, alpha, clip);
+		}
+	}
+}
+function fillTextBoxes(data, W, H, item, toPx, clip) {
+	const m = item.transform;
+	const boxes = [];
+	let i = 0;
+	for (const ch of item.text) {
+		if (ch !== " ") {
+			const x0 = i * .5 + .05;
+			const x1 = i * .5 + .45;
+			const src = [
+				[x0, 0],
+				[x1, 0],
+				[x1, .62],
+				[x0, .62]
+			];
+			const flat = [];
+			for (const [tx, ty] of src) {
+				const [ux, uy] = applyToPoint(m, tx, ty);
+				const [px, py] = toPx(ux, uy);
+				flat.push(px, py);
+			}
+			boxes.push(flat);
+		}
+		i++;
+	}
+	if (boxes.length) fillSubpaths(data, W, H, boxes, "nonzero", item.color, item.alpha * .85, clip);
+}
+//#endregion
+//#region src/render/canvas.ts
+function effectiveScale(opts) {
+	return (typeof opts.scale === "number" ? opts.scale : typeof opts.dpi === "number" ? opts.dpi / 72 : 1) * (opts.pixelRatio ?? 1);
+}
+function rgbaStr(c, alpha) {
+	const a = c[3] / 255 * alpha;
+	return `rgba(${c[0]}, ${c[1]}, ${c[2]}, ${Number(a.toFixed(3))})`;
+}
+/** Replay a display list onto a 2D context. */
+function renderDisplayListToCanvas(dl, ctx, opts = {}) {
+	const scale = effectiveScale(opts);
+	const H = dl.height * scale;
+	const [ox, oy] = dl.origin;
+	const toPx = (x, y) => [(x - ox) * scale, H - (y - oy) * scale];
+	const family = opts.fontFamily ?? "sans-serif";
+	for (const item of dl.items) if (item.type === "fill") {
+		ctx.fillStyle = rgbaStr(item.color, item.alpha);
+		ctx.beginPath();
+		tracePath(ctx, item.subpaths, toPx);
+		ctx.fill(item.rule);
+	} else if (item.type === "stroke") {
+		ctx.strokeStyle = rgbaStr(item.color, item.alpha);
+		ctx.lineWidth = Math.max(item.lineWidth * scale, .5);
+		ctx.beginPath();
+		tracePath(ctx, item.subpaths, toPx);
+		ctx.stroke();
+	} else if (item.type === "text" && item.renderMode !== 3 && item.renderMode !== 7) {
+		const m = item.transform;
+		const [px, py] = toPx(...applyToPoint(m, 0, 0));
+		const sizePx = Math.hypot(m[2], m[3]) * scale;
+		if (sizePx >= .5 && item.text.length) {
+			ctx.fillStyle = rgbaStr(item.color, item.alpha);
+			ctx.font = `${Number(sizePx.toFixed(2))}px ${family}`;
+			ctx.fillText(item.text, px, py);
+		}
+	}
+}
+function tracePath(ctx, subpaths, toPx) {
+	for (const sp of subpaths) {
+		const pts = sp.points;
+		if (pts.length < 4) continue;
+		const [x0, y0] = toPx(pts[0], pts[1]);
+		ctx.moveTo(x0, y0);
+		for (let i = 2; i + 1 < pts.length; i += 2) {
+			const [x, y] = toPx(pts[i], pts[i + 1]);
+			ctx.lineTo(x, y);
+		}
+		if (sp.closed) ctx.closePath();
+	}
+}
+/**
+* Render a {@link PdfPage} onto a 2D context. The context's canvas should be
+* sized to `page.width × scale` by `page.height × scale`.
+*/
+function renderPageToCanvas(page, ctx, opts = {}) {
+	renderDisplayListToCanvas(interpretPage(page), ctx, opts);
+}
+//#endregion
+//#region src/render/thumbnail.ts
+/**
+* @module render/thumbnail
+*
+* Generate a small preview PNG of a page by rasterizing it at a scale that fits
+* the longest side to a target size. (Persisting a `/Thumb` image XObject on the
+* page — ISO 32000-2 §12.3.4 — requires page-dictionary write access not yet on
+* the public {@link PdfPage} API; tracked for a later patch.)
+*
+* @packageDocumentation
+*/
+/**
+* Render `page` to a thumbnail PNG whose longest side is `maxSize` pixels,
+* preserving aspect ratio.
+*/
+async function generateThumbnail(page, opts = {}) {
+	const maxSize = opts.maxSize ?? 256;
+	const dl = interpretPage(page);
+	const img = rasterize(dl, {
+		scale: maxSize / (Math.max(dl.width, dl.height) || 1),
+		background: opts.background,
+		renderText: opts.renderText ?? true
+	});
+	return {
+		data: encodePngFromPixels(img.data, img.width, img.height, 4),
+		width: img.width,
+		height: img.height
+	};
+}
+//#endregion
+//#region src/render/imageExtract.ts
+/**
+* Extract and decode all image XObjects referenced by a page.
+*
+* @param page - The page whose `/Resources /XObject` images are extracted.
+* @returns One {@link ExtractedImage} per successfully decoded image XObject.
+*          Images that cannot be decoded (unsupported filters/colour spaces,
+*          missing WASM, malformed data) are skipped silently.
+*
+* @example
+* ```ts
+* import { loadPdf } from 'modern-pdf-lib';
+* import { extractImages } from 'modern-pdf-lib/render';
+*
+* const doc = await loadPdf(bytes);
+* for (const img of extractImages(doc.getPage(0))) {
+*   console.log(img.name, img.width, img.height, img.channels, img.hasAlpha);
+* }
+* ```
+*/
+function extractImages(page) {
+	const out = [];
+	const resources = page.getOriginalResources();
+	if (!resources) return out;
+	const registry = page.getRegistry();
+	const xObjDict = resolveDict$1(resources.get("/XObject"), registry);
+	if (!xObjDict) return out;
+	for (const [name, value] of xObjDict) {
+		const stream = resolveStream$1(value, registry);
+		if (!stream) continue;
+		const subtype = stream.dict.get("/Subtype");
+		if (!(subtype instanceof PdfName) || subtype.value !== "/Image") continue;
+		try {
+			const extracted = decodeImage(name, stream, registry);
+			if (extracted) out.push(extracted);
+		} catch {
+			continue;
+		}
+	}
+	return out;
+}
+/**
+* Decode a single image XObject stream to interleaved 8-bit pixels and
+* composite any soft mask.  Returns `undefined` when the image cannot be
+* decoded (e.g. JPEG WASM unavailable, unsupported colour space).
+* @internal
+*/
+function decodeImage(name, stream, registry) {
+	const width = readInt(stream.dict.get("/Width"), 0);
+	const height = readInt(stream.dict.get("/Height"), 0);
+	if (width <= 0 || height <= 0) return void 0;
+	const bitsPerComponent = readInt(stream.dict.get("/BitsPerComponent"), 8);
+	const cs = resolveColorSpace(stream.dict.get("/ColorSpace"), registry);
+	const { filters } = getStreamFilters(stream.dict);
+	const isJpeg = filters.includes("DCTDecode");
+	let base;
+	if (isJpeg) base = decodeJpegBase(stream, width, height);
+	else base = interpretSamples(decodeStreamData(stream), width, height, bitsPerComponent, cs);
+	if (!base) return void 0;
+	const alpha = extractSoftMask(stream, registry, width, height);
+	if (alpha) {
+		const pixels = compositeAlpha(base.pixels, base.channels, width, height, alpha);
+		return {
+			name: stripSlash(name),
+			width,
+			height,
+			channels: 4,
+			pixels,
+			colorSpace: cs.name,
+			bitsPerComponent,
+			hasAlpha: true
+		};
+	}
+	return {
+		name: stripSlash(name),
+		width,
+		height,
+		channels: base.channels,
+		pixels: base.pixels,
+		colorSpace: cs.name,
+		bitsPerComponent,
+		hasAlpha: false
+	};
+}
+/**
+* Decode a DCTDecode (JPEG) image XObject to interleaved 8-bit pixels.
+*
+* `decodeStreamData` passes DCTDecode through unchanged (decoding any outer
+* filters such as an ASCII85 wrapper first), so the result is the raw JPEG
+* byte stream handed to the WASM decoder.
+* @internal
+*/
+function decodeJpegBase(stream, width, height) {
+	const decoded = decodeJpegWasm(decodeStreamData(stream));
+	if (!decoded) return void 0;
+	const w = decoded.width || width;
+	const h = decoded.height || height;
+	const channels = decoded.channels;
+	if (w <= 0 || h <= 0 || channels <= 0) return void 0;
+	if (decoded.pixels.length < w * h * channels) return void 0;
+	return {
+		pixels: decoded.pixels,
+		channels
+	};
+}
+/**
+* Interpret decoded sample bytes as interleaved 8-bit RGB / grayscale
+* pixels according to the colour space and bits-per-component.
+* @internal
+*/
+function interpretSamples(data, width, height, bpc, cs) {
+	const pixelCount = width * height;
+	if (cs.name === "Indexed" && cs.palette) return expandIndexed(data, width, height, bpc, cs.palette);
+	const components = cs.components;
+	const samples = readComponentSamples(data, pixelCount * components, bpc);
+	if (!samples) return void 0;
+	if (cs.name === "DeviceGray" || cs.name === "CalGray") {
+		const pixels = new Uint8Array(pixelCount);
+		for (let i = 0; i < pixelCount; i++) pixels[i] = samples[i] ?? 0;
+		return {
+			pixels,
+			channels: 1
+		};
+	}
+	if (cs.name === "DeviceCMYK") {
+		const pixels = new Uint8Array(pixelCount * 3);
+		for (let p = 0; p < pixelCount; p++) {
+			const si = p * 4;
+			const [r, g, b] = cmykToRgb((samples[si] ?? 0) / 255, (samples[si + 1] ?? 0) / 255, (samples[si + 2] ?? 0) / 255, (samples[si + 3] ?? 0) / 255);
+			const di = p * 3;
+			pixels[di] = Math.round(r * 255);
+			pixels[di + 1] = Math.round(g * 255);
+			pixels[di + 2] = Math.round(b * 255);
+		}
+		return {
+			pixels,
+			channels: 3
+		};
+	}
+	const pixels = new Uint8Array(pixelCount * 3);
+	for (let i = 0; i < pixelCount * 3; i++) pixels[i] = samples[i] ?? 0;
+	return {
+		pixels,
+		channels: 3
+	};
+}
+/**
+* Expand an indexed (palette) image to interleaved RGB pixels.
+* @internal
+*/
+function expandIndexed(data, width, height, bpc, palette) {
+	const pixelCount = width * height;
+	const pixels = new Uint8Array(pixelCount * 3);
+	const maxIndex = Math.floor(palette.length / 3) - 1;
+	const indices = readPackedRows(data, width, height, 1, bpc);
+	for (let p = 0; p < pixelCount; p++) {
+		let idx = indices[p] ?? 0;
+		if (idx > maxIndex) idx = maxIndex < 0 ? 0 : maxIndex;
+		const pi = idx * 3;
+		const di = p * 3;
+		pixels[di] = palette[pi] ?? 0;
+		pixels[di + 1] = palette[pi + 1] ?? 0;
+		pixels[di + 2] = palette[pi + 2] ?? 0;
+	}
+	return {
+		pixels,
+		channels: 3
+	};
+}
+/**
+* Read `count` component samples, normalizing sub-byte / 16-bit components
+* to 8-bit values.  Returns `undefined` when the buffer is too small.
+* @internal
+*/
+function readComponentSamples(data, count, bpc) {
+	if (bpc === 8) {
+		if (data.length < count) return void 0;
+		return data.subarray(0, count);
+	}
+	if (bpc === 16) {
+		if (data.length < count * 2) return void 0;
+		const out = new Uint8Array(count);
+		for (let i = 0; i < count; i++) out[i] = data[i * 2] ?? 0;
+		return out;
+	}
+	if (bpc === 1 || bpc === 2 || bpc === 4) {
+		const out = new Uint8Array(count);
+		const max = (1 << bpc) - 1;
+		let bitPos = 0;
+		for (let i = 0; i < count; i++) {
+			const byteIdx = bitPos >>> 3;
+			if (byteIdx >= data.length) return void 0;
+			const shift = 8 - (bitPos & 7) - bpc;
+			const val = data[byteIdx] >> shift & max;
+			out[i] = Math.round(val / max * 255);
+			bitPos += bpc;
+		}
+		return out;
+	}
+}
+/**
+* Read packed single-component rows (e.g. indexed indices) honouring PDF
+* row-byte alignment (each scanline starts on a byte boundary).
+* @internal
+*/
+function readPackedRows(data, width, height, components, bpc) {
+	const out = new Uint8Array(width * height * components);
+	const rowBits = width * components * bpc;
+	const rowBytes = Math.ceil(rowBits / 8);
+	const max = (1 << bpc) - 1;
+	for (let row = 0; row < height; row++) {
+		const rowStart = row * rowBytes;
+		let bitPos = 0;
+		for (let col = 0; col < width * components; col++) {
+			const byteIdx = rowStart + (bitPos >>> 3);
+			let val = 0;
+			if (byteIdx < data.length) if (bpc === 8) val = data[byteIdx];
+			else if (bpc === 16) val = data[byteIdx];
+			else {
+				const shift = 8 - (bitPos & 7) - bpc;
+				val = data[byteIdx] >> shift & max;
+			}
+			out[row * width * components + col] = val;
+			bitPos += bpc;
+		}
+	}
+	return out;
+}
+/**
+* Resolve and decode the `/SMask` of an image to a per-pixel 8-bit alpha
+* buffer sized `width * height`, nearest-sampling when the mask resolution
+* differs from the base image.  Returns `undefined` when no usable mask is
+* present.
+* @internal
+*/
+function extractSoftMask(stream, registry, width, height) {
+	const smask = resolveStream$1(stream.dict.get("/SMask"), registry);
+	if (!smask) return void 0;
+	const mw = readInt(smask.dict.get("/Width"), 0);
+	const mh = readInt(smask.dict.get("/Height"), 0);
+	if (mw <= 0 || mh <= 0) return void 0;
+	const mbpc = readInt(smask.dict.get("/BitsPerComponent"), 8);
+	let maskData;
+	const { filters } = getStreamFilters(smask.dict);
+	if (filters.includes("DCTDecode")) {
+		const decoded = decodeJpegWasm(decodeStreamData(smask));
+		if (!decoded) return void 0;
+		maskData = decoded.pixels;
+	} else {
+		const raw = decodeStreamData(smask);
+		const samples = readComponentSamples(raw, mw * mh, mbpc);
+		if (!samples) maskData = readPackedRows(raw, mw, mh, 1, mbpc);
+		else maskData = samples;
+	}
+	if (maskData.length < mw * mh) return void 0;
+	if (mw === width && mh === height) return maskData.subarray(0, width * height);
+	const alpha = new Uint8Array(width * height);
+	for (let y = 0; y < height; y++) {
+		const sy = Math.min(mh - 1, Math.floor(y * mh / height));
+		for (let x = 0; x < width; x++) {
+			const sx = Math.min(mw - 1, Math.floor(x * mw / width));
+			alpha[y * width + x] = maskData[sy * mw + sx] ?? 255;
+		}
+	}
+	return alpha;
+}
+/**
+* Composite a base colour buffer with an alpha channel into interleaved
+* RGBA pixels.  A grayscale base is promoted to RGB first.
+* @internal
+*/
+function compositeAlpha(base, channels, width, height, alpha) {
+	const pixelCount = width * height;
+	const out = new Uint8Array(pixelCount * 4);
+	for (let p = 0; p < pixelCount; p++) {
+		const di = p * 4;
+		if (channels === 1) {
+			const g = base[p] ?? 0;
+			out[di] = g;
+			out[di + 1] = g;
+			out[di + 2] = g;
+		} else {
+			const si = p * channels;
+			out[di] = base[si] ?? 0;
+			out[di + 1] = base[si + 1] ?? 0;
+			out[di + 2] = base[si + 2] ?? 0;
+		}
+		out[di + 3] = alpha[p] ?? 255;
+	}
+	return out;
+}
+/**
+* Resolve a `/ColorSpace` entry into a canonical name, component count, and
+* (for indexed spaces) the palette bytes.
+* @internal
+*/
+function resolveColorSpace(entry, registry) {
+	const resolved = deref(entry, registry);
+	if (resolved instanceof PdfName) return nameToColorSpace(resolved.value);
+	if (resolved instanceof PdfArray) {
+		const first = deref(resolved.items[0], registry);
+		if (first instanceof PdfName) {
+			const head = stripSlash(first.value);
+			if (head === "ICCBased") {
+				const profile = resolveStream$1(resolved.items[1], registry);
+				const n = profile ? readInt(profile.dict.get("/N"), 3) : 3;
+				if (n === 1) return {
+					name: "DeviceGray",
+					components: 1
+				};
+				if (n === 4) return {
+					name: "DeviceCMYK",
+					components: 4
+				};
+				return {
+					name: "DeviceRGB",
+					components: 3
+				};
+			}
+			if (head === "Indexed" || head === "I") return {
+				name: "Indexed",
+				components: 1,
+				palette: readIndexedPalette(resolved, registry)
+			};
+			if (head === "CalRGB" || head === "Lab") return {
+				name: head,
+				components: 3
+			};
+			if (head === "CalGray") return {
+				name: "CalGray",
+				components: 1
+			};
+			return nameToColorSpace(first.value);
+		}
+	}
+	return {
+		name: "DeviceRGB",
+		components: 3
+	};
+}
+/** Map a colour-space name to its canonical form + component count. @internal */
+function nameToColorSpace(rawName) {
+	switch (stripSlash(rawName)) {
+		case "DeviceGray":
+		case "G":
+		case "CalGray": return {
+			name: "DeviceGray",
+			components: 1
+		};
+		case "DeviceCMYK":
+		case "CMYK": return {
+			name: "DeviceCMYK",
+			components: 4
+		};
+		case "DeviceRGB":
+		case "RGB":
+		case "CalRGB": return {
+			name: "DeviceRGB",
+			components: 3
+		};
+		default: return {
+			name: "DeviceRGB",
+			components: 3
+		};
+	}
+}
+/**
+* Read the lookup table (palette) from an `[/Indexed base hival lookup]`
+* colour-space array.  The lookup table may be a hex/literal string or a
+* stream.
+* @internal
+*/
+function readIndexedPalette(arr, registry) {
+	const lookup = deref(arr.items[3], registry);
+	if (lookup instanceof PdfString) {
+		const value = lookup.value;
+		const bytes = new Uint8Array(value.length);
+		for (let i = 0; i < value.length; i++) bytes[i] = value.charCodeAt(i) & 255;
+		return bytes;
+	}
+	if (lookup instanceof PdfStream) return decodeStreamData(lookup);
+}
+/** Resolve a value to its target object, following one indirect reference. @internal */
+function deref(obj, registry) {
+	if (obj instanceof PdfRef) return registry.resolve(obj);
+	return obj;
+}
+/** Resolve a value (possibly a ref) to a `PdfDict`, or `undefined`. @internal */
+function resolveDict$1(obj, registry) {
+	const resolved = deref(obj, registry);
+	return resolved instanceof PdfDict ? resolved : void 0;
+}
+/** Resolve a value (possibly a ref) to a `PdfStream`, or `undefined`. @internal */
+function resolveStream$1(obj, registry) {
+	const resolved = deref(obj, registry);
+	return resolved instanceof PdfStream ? resolved : void 0;
+}
+/** Read an integer from a PDF object, or fall back. @internal */
+function readInt(obj, fallback) {
+	return obj instanceof PdfNumber ? Math.round(obj.value) : fallback;
+}
+/** Strip a single leading slash from a PDF name string. @internal */
+function stripSlash(s) {
+	return s.startsWith("/") ? s.slice(1) : s;
+}
+//#endregion
+//#region src/render/fontExtract.ts
+/**
+* Resolve an object through the registry if it is an indirect reference,
+* otherwise return it unchanged.
+*/
+function resolve(obj, registry) {
+	if (obj && obj.kind === "ref") return registry.resolve(obj);
+	return obj;
+}
+/** Resolve `dict[key]` and return it only if it is a dictionary. */
+function resolveDict(dict, key, registry) {
+	const v = resolve(dict.get(key), registry);
+	return v && v.kind === "dict" ? v : void 0;
+}
+/** Resolve `dict[key]` and return it only if it is a stream. */
+function resolveStream(dict, key, registry) {
+	const v = resolve(dict.get(key), registry);
+	return v && v.kind === "stream" ? v : void 0;
+}
+/** Read a `/Name` value with the leading slash stripped, if present. */
+function nameValue(obj, registry) {
+	const v = resolve(obj, registry);
+	if (v && v.kind === "name") {
+		const raw = v.value;
+		return raw.startsWith("/") ? raw.slice(1) : raw;
+	}
+}
+/**
+* Locate the `/FontDescriptor` for a font dictionary.
+*
+* For simple fonts the descriptor is a direct child.  For composite
+* (Type0) fonts it lives on the first `/DescendantFonts` entry.
+*/
+function findFontDescriptor(fontDict, registry) {
+	const direct = resolveDict(fontDict, "/FontDescriptor", registry);
+	if (direct) return direct;
+	if (nameValue(fontDict.get("/Subtype"), registry) === "Type0") {
+		const descendants = resolve(fontDict.get("/DescendantFonts"), registry);
+		if (descendants && descendants.kind === "array") {
+			const first = descendants.items[0];
+			const cidFont = resolve(first, registry);
+			if (cidFont && cidFont.kind === "dict") return resolveDict(cidFont, "/FontDescriptor", registry);
+		}
+	}
+}
+/**
+* Pull the embedded font program (if any) out of a `/FontDescriptor`.
+*
+* Returns the decoded bytes and the detected format, or `undefined` when
+* the descriptor carries no embedded file (e.g. a standard font).
+*/
+function extractFromDescriptor(descriptor, registry) {
+	const fontFile = resolveStream(descriptor, "/FontFile", registry);
+	if (fontFile) return {
+		format: "type1",
+		data: decodeStreamData(fontFile)
+	};
+	const fontFile2 = resolveStream(descriptor, "/FontFile2", registry);
+	if (fontFile2) return {
+		format: "truetype",
+		data: decodeStreamData(fontFile2)
+	};
+	const fontFile3 = resolveStream(descriptor, "/FontFile3", registry);
+	if (fontFile3) return {
+		format: nameValue(fontFile3.dict.get("/Subtype"), registry) === "OpenType" ? "opentype" : "cff",
+		data: decodeStreamData(fontFile3)
+	};
+}
+/**
+* Determine whether a base-font name carries a subset tag.
+*
+* A subset tag is exactly six uppercase ASCII letters followed by `+`,
+* e.g. `ABCDEF+Helvetica`.
+*/
+function hasSubsetTag(baseFont) {
+	if (baseFont.length < 7 || baseFont[6] !== "+") return false;
+	for (let i = 0; i < 6; i++) {
+		const code = baseFont.charCodeAt(i);
+		if (code < 65 || code > 90) return false;
+	}
+	return true;
+}
+/**
+* Extract every embedded font program referenced by a page.
+*
+* Walks the page's original `/Resources` → `/Font` dictionary.  For each
+* font that carries an embedded file (`/FontFile`, `/FontFile2`, or
+* `/FontFile3`) — directly or via a Type0 descendant — the standalone,
+* filter-decoded font bytes are returned.  Standard-14 fonts with no
+* embedded file are omitted, and malformed entries are skipped silently.
+*
+* @param page  The page to scan (typically from a loaded PDF).
+* @returns     One {@link ExtractedFont} per embedded font program.
+*
+* @example
+* ```ts
+* const loaded = await PdfDocument.load(bytes);
+* const fonts = extractFonts(loaded.getPage(0));
+* for (const f of fonts) {
+*   console.log(f.resourceName, f.baseFont, f.format, f.data.length, f.subset);
+* }
+* ```
+*/
+function extractFonts(page) {
+	const resources = page.getOriginalResources();
+	if (!resources) return [];
+	const registry = page.getRegistry();
+	const fontDict = resolveDict(resources, "/Font", registry);
+	if (!fontDict) return [];
+	const result = [];
+	for (const [key, value] of fontDict) {
+		const dict = resolve(value, registry);
+		if (!dict || dict.kind !== "dict") continue;
+		const descriptor = findFontDescriptor(dict, registry);
+		if (!descriptor) continue;
+		let extracted;
+		try {
+			extracted = extractFromDescriptor(descriptor, registry);
+		} catch {
+			continue;
+		}
+		if (!extracted) continue;
+		const baseFont = nameValue(dict.get("/BaseFont"), registry) ?? "";
+		const resourceName = key.startsWith("/") ? key.slice(1) : key;
+		result.push({
+			resourceName,
+			baseFont,
+			format: extracted.format,
+			data: extracted.data,
+			subset: hasSubsetTag(baseFont)
+		});
+	}
+	return result;
+}
+//#endregion
+//#region src/render/diff.ts
+/**
+* @module render/diff
+*
+* Visual regression for PDFs: rasterize two pages (or compare two raster
+* images) and report a per-pixel difference count, a difference heatmap, and a
+* structural-similarity (SSIM) score over 8×8 luminance blocks.
+*
+* @packageDocumentation
+*/
+const C1 = (.01 * 255) ** 2;
+const C2 = (.03 * 255) ** 2;
+function luma(data, i) {
+	return .299 * data[i] + .587 * data[i + 1] + .114 * data[i + 2];
+}
+/** Compare two equally-sized raster images. */
+function compareImages(a, b, opts = {}) {
+	if (a.width !== b.width || a.height !== b.height) throw new Error(`compareImages: size mismatch (${a.width}×${a.height} vs ${b.width}×${b.height}); render both at the same scale`);
+	const W = a.width;
+	const H = a.height;
+	const threshold = opts.threshold ?? 16;
+	const heatmap = new Uint8Array(W * H * 4);
+	let changed = 0;
+	for (let p = 0; p < W * H; p++) {
+		const i = p * 4;
+		const dr = Math.abs(a.data[i] - b.data[i]);
+		const dg = Math.abs(a.data[i + 1] - b.data[i + 1]);
+		const db = Math.abs(a.data[i + 2] - b.data[i + 2]);
+		if (Math.max(dr, dg, db) > threshold) {
+			changed++;
+			heatmap[i] = 255;
+			heatmap[i + 1] = 40;
+			heatmap[i + 2] = 40;
+			heatmap[i + 3] = 255;
+		} else {
+			const g = Math.round(luma(a.data, i) * .4 + 153);
+			heatmap[i] = g;
+			heatmap[i + 1] = g;
+			heatmap[i + 2] = g;
+			heatmap[i + 3] = 255;
+		}
+	}
+	return {
+		width: W,
+		height: H,
+		changedPixels: changed,
+		changedRatio: changed / (W * H),
+		ssim: meanSsim(a, b, W, H),
+		heatmap
+	};
+}
+/** Mean SSIM over non-overlapping 8×8 luminance blocks. */
+function meanSsim(a, b, W, H) {
+	const block = 8;
+	let total = 0;
+	let count = 0;
+	for (let by = 0; by < H; by += block) for (let bx = 0; bx < W; bx += block) {
+		const bw = Math.min(block, W - bx);
+		const bh = Math.min(block, H - by);
+		const n = bw * bh;
+		let sa = 0;
+		let sb = 0;
+		let saa = 0;
+		let sbb = 0;
+		let sab = 0;
+		for (let y = 0; y < bh; y++) for (let x = 0; x < bw; x++) {
+			const i = ((by + y) * W + (bx + x)) * 4;
+			const la = luma(a.data, i);
+			const lb = luma(b.data, i);
+			sa += la;
+			sb += lb;
+			saa += la * la;
+			sbb += lb * lb;
+			sab += la * lb;
+		}
+		const ma = sa / n;
+		const mb = sb / n;
+		const va = saa / n - ma * ma;
+		const vb = sbb / n - mb * mb;
+		const cov = sab / n - ma * mb;
+		const ssim = (2 * ma * mb + C1) * (2 * cov + C2) / ((ma * ma + mb * mb + C1) * (va + vb + C2));
+		total += ssim;
+		count++;
+	}
+	return count ? total / count : 1;
+}
+/** Rasterize two pages at the same scale and compare them. */
+async function comparePages(pageA, pageB, opts = {}) {
+	return compareImages(rasterize(interpretPage(pageA), opts), rasterize(interpretPage(pageB), opts), opts);
+}
+//#endregion
+//#region src/render/ocr.ts
+/**
+* Escape a string for use inside a PDF literal string `(…)`.
+* Backslash and both parentheses must be escaped so the content stream
+* remains well-formed.
+*/
+function escapePdfLiteral(text) {
+	return text.replaceAll("\\", "\\\\").replaceAll("(", "\\(").replaceAll(")", "\\)");
+}
+/**
+* Format a number for PDF output: at most 4 decimal places, trailing zeros
+* stripped, never `-0`.
+*/
+function num$1(value) {
+	if (!Number.isFinite(value)) return "0";
+	if (Number.isInteger(value)) return value.toString();
+	const s = value.toFixed(4).replace(/\.?0+$/, "");
+	return s === "-0" ? "0" : s;
+}
+/**
+* Build a standard Helvetica (Type 1) font dictionary, register it in the
+* page's object registry, and attach it to the page under `resourceName`.
+*
+* This lets {@link applyOcr} guarantee a usable font resource exists for the
+* invisible overlay without needing a reference to the owning document.
+*/
+function ensureOverlayFont(page, resourceName) {
+	const registry = page.getRegistry();
+	const fontDict = new PdfDict();
+	fontDict.set("/Type", PdfName.of("Font"));
+	fontDict.set("/Subtype", PdfName.of("Type1"));
+	fontDict.set("/BaseFont", PdfName.of("Helvetica"));
+	fontDict.set("/Encoding", PdfName.of("WinAnsiEncoding"));
+	const ref = registry.register(fontDict);
+	page.registerFont(resourceName, ref);
+}
+/**
+* Run OCR on a page and append the recognized text as an invisible,
+* selectable/searchable overlay.
+*
+* The page is rasterized to RGBA at `opts.dpi`, passed to `engine.recognize`,
+* and each returned word is written back as a content-stream fragment:
+*
+* ```text
+* BT 3 Tr /<font> <size> Tf <x> <y> Td (<escaped text>) Tj ET
+* ```
+*
+* where `<size> ≈ word.height` and `<x> <y>` is the word's lower-left corner
+* in page space.  Render mode `3` makes the text invisible (no fill, no
+* stroke) while keeping it part of the document's text content.
+*
+* @param page    The page to OCR and annotate.
+* @param engine  The OCR backend.
+* @param opts    Optional DPI and font-resource overrides.
+* @returns       The words returned by the engine (unmodified).
+*/
+async function applyOcr(page, engine, opts) {
+	const dpi = opts?.dpi ?? 150;
+	const fontName = opts?.fontResourceName ?? "OCRFont";
+	const raster = rasterize(interpretPage(page), { dpi });
+	const words = await engine.recognize(raster.data, raster.width, raster.height);
+	if (words.length === 0) return words;
+	ensureOverlayFont(page, fontName);
+	let fragment = "";
+	for (const word of words) {
+		const size = word.height > 0 ? word.height : 1;
+		const escaped = escapePdfLiteral(word.text);
+		fragment += `BT 3 Tr /${fontName} ${num$1(size)} Tf ${num$1(word.x)} ${num$1(word.y)} Td (${escaped}) Tj ET\n`;
+	}
+	page.pushOperators(fragment);
+	return words;
+}
+//#endregion
+//#region src/render/redactContent.ts
+/** Build a {@link BBox} from a set of page-space corner points. */
+function bboxOfPoints(points) {
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX = -Infinity;
+	let maxY = -Infinity;
+	for (const [x, y] of points) {
+		if (x < minX) minX = x;
+		if (y < minY) minY = y;
+		if (x > maxX) maxX = x;
+		if (y > maxY) maxY = y;
+	}
+	return {
+		minX,
+		minY,
+		maxX,
+		maxY
+	};
+}
+/** Whether a page-space bounding box intersects a redaction rect. */
+function intersects(box, rect) {
+	const rMinX = rect.x;
+	const rMinY = rect.y;
+	const rMaxX = rect.x + rect.width;
+	const rMaxY = rect.y + rect.height;
+	return box.minX <= rMaxX && box.maxX >= rMinX && box.minY <= rMaxY && box.maxY >= rMinY;
+}
+/** Whether a bounding box intersects *any* of the redaction rects. */
+function intersectsAny(box, rects) {
+	for (const rect of rects) {
+		if (rect.width <= 0 || rect.height <= 0) continue;
+		if (intersects(box, rect)) return true;
+	}
+	return false;
+}
+function num(op) {
+	return typeof op === "number" ? op : 0;
+}
+/** Length of the visible characters a text-show operand contributes. */
+function operandTextLength(op) {
+	if (typeof op === "string") return op.length;
+	if (Array.isArray(op)) {
+		let total = 0;
+		for (const el of op) if (typeof el === "string") total += el.length;
+		return total;
+	}
+	return 0;
+}
+const AVG_GLYPH_WIDTH_EM = .5;
+const ASCENT_EM = .85;
+const DESCENT_EM = -.2;
+/**
+* Compute the page-space bounding box of a text run shown at the current
+* text-rendering matrix.  The run is approximated as a rectangle spanning
+* `[0, advance]` horizontally and `[descent, ascent]` vertically in text
+* space (em units, before the font-size scale baked into `trm`).
+*/
+function textRunBBox(trm, glyphCount) {
+	const advance = Math.max(glyphCount, 1) * AVG_GLYPH_WIDTH_EM;
+	return bboxOfPoints([
+		applyToPoint(trm, 0, DESCENT_EM),
+		applyToPoint(trm, advance, DESCENT_EM),
+		applyToPoint(trm, advance, ASCENT_EM),
+		applyToPoint(trm, 0, ASCENT_EM)
+	]);
+}
+/**
+* Compute the page-space bounding box of an image placed by `Do`.  An image
+* XObject is painted into the unit square `[0,1]×[0,1]` transformed by the
+* current CTM.
+*/
+function imageBBox(ctm) {
+	return bboxOfPoints([
+		applyToPoint(ctm, 0, 0),
+		applyToPoint(ctm, 1, 0),
+		applyToPoint(ctm, 1, 1),
+		applyToPoint(ctm, 0, 1)
+	]);
+}
+/**
+* Serialize a string operand as a PDF hex string `<…>`.
+*
+* Hex strings are byte-exact and contain only ASCII, so they survive the
+* UTF-8 encoding applied when the content stream is written.  The parser
+* decodes both `(…)` and `<…>` strings to a JS string of latin-1 char codes,
+* so re-emitting as hex preserves the original bytes regardless of the
+* original literal form (important for multi-byte / CID-encoded text).
+*/
+function serializeString(s) {
+	let out = "<";
+	for (let i = 0; i < s.length; i++) {
+		const byte = s.charCodeAt(i) & 255;
+		out += byte.toString(16).padStart(2, "0");
+	}
+	return out + ">";
+}
+/** Format a number the way PDF content streams expect (no trailing zeros). */
+function formatNumber(value) {
+	if (Number.isInteger(value)) return value.toString();
+	const s = value.toFixed(6).replace(/\.?0+$/, "");
+	return s === "-0" ? "0" : s;
+}
+/** Serialize a single operand to its content-stream textual form. */
+function serializeOperand(op) {
+	if (op === null) return "null";
+	if (typeof op === "boolean") return op ? "true" : "false";
+	if (typeof op === "number") return formatNumber(op);
+	if (typeof op === "string") return serializeString(op);
+	if (op instanceof PdfName) return op.value;
+	if (Array.isArray(op)) return "[" + op.map(serializeOperand).join(" ") + "]";
+	return "";
+}
+/** Serialize one operator (operands followed by the operator keyword). */
+function serializeOperator(op) {
+	if (op.operands.length === 0) return op.operator;
+	return `${op.operands.map(serializeOperand).join(" ")} ${op.operator}`;
+}
+function initialState() {
+	return {
+		ctm: identity(),
+		fontSize: 0,
+		hScale: 1,
+		rise: 0,
+		leading: 0
+	};
+}
+/**
+* Build the text-rendering matrix used to map text-space (em) coordinates to
+* page space, matching the interpreter:
+* `Trm = [fontSize·hScale, 0, 0, fontSize, 0, rise] × Tm × CTM`.
+*/
+function textRenderingMatrix(state, tm) {
+	return multiply(multiply([
+		state.fontSize * state.hScale,
+		0,
+		0,
+		state.fontSize,
+		0,
+		state.rise
+	], tm), state.ctm);
+}
+/**
+* Walk the operators, tracking position, and return both the filtered
+* operator list and the removal counts.
+*/
+function filterOperators(operators, rects) {
+	const kept = [];
+	let removedText = 0;
+	let removedImages = 0;
+	const stack = [];
+	let state = initialState();
+	let tm = identity();
+	let tlm = identity();
+	for (const op of operators) {
+		const { operator, operands } = op;
+		let drop = false;
+		switch (operator) {
+			case "q":
+				stack.push({ ...state });
+				break;
+			case "Q":
+				if (stack.length > 0) state = stack.pop();
+				break;
+			case "cm":
+				state = {
+					...state,
+					ctm: multiply([
+						num(operands[0]),
+						num(operands[1]),
+						num(operands[2]),
+						num(operands[3]),
+						num(operands[4]),
+						num(operands[5])
+					], state.ctm)
+				};
+				break;
+			case "BT":
+				tm = identity();
+				tlm = identity();
+				break;
+			case "ET": break;
+			case "Tf":
+				state = {
+					...state,
+					fontSize: num(operands[1])
+				};
+				break;
+			case "Tz":
+				state = {
+					...state,
+					hScale: num(operands[0]) / 100
+				};
+				break;
+			case "Ts":
+				state = {
+					...state,
+					rise: num(operands[0])
+				};
+				break;
+			case "TL":
+				state = {
+					...state,
+					leading: num(operands[0])
+				};
+				break;
+			case "Td":
+				tlm = multiply(translation(num(operands[0]), num(operands[1])), tlm);
+				tm = tlm;
+				break;
+			case "TD":
+				state = {
+					...state,
+					leading: -num(operands[1])
+				};
+				tlm = multiply(translation(num(operands[0]), num(operands[1])), tlm);
+				tm = tlm;
+				break;
+			case "Tm":
+				tm = [
+					num(operands[0]),
+					num(operands[1]),
+					num(operands[2]),
+					num(operands[3]),
+					num(operands[4]),
+					num(operands[5])
+				];
+				tlm = tm;
+				break;
+			case "T*":
+				tlm = multiply(translation(0, -state.leading), tlm);
+				tm = tlm;
+				break;
+			case "Tj":
+			case "TJ":
+			case "'":
+			case "\"": {
+				if (operator === "'" || operator === "\"") {
+					tlm = multiply(translation(0, -state.leading), tlm);
+					tm = tlm;
+				}
+				if (operator === "\"") state = { ...state };
+				const glyphCount = operandTextLength(operator === "\"" ? operands[2] : operator === "'" ? operands[0] : operands[0]);
+				if (intersectsAny(textRunBBox(textRenderingMatrix(state, tm), glyphCount), rects)) {
+					drop = true;
+					removedText++;
+				}
+				break;
+			}
+			case "Do":
+				if (intersectsAny(imageBBox(state.ctm), rects)) {
+					drop = true;
+					removedImages++;
+				}
+				break;
+			default: break;
+		}
+		if (!drop) kept.push(op);
+	}
+	return {
+		kept,
+		removedText,
+		removedImages
+	};
+}
+/** Replace the page's entire content stream with the given operator string. */
+function replacePageContent(page, content) {
+	const internals = page;
+	internals.ops = content;
+	internals._originalContentRefs = [];
+}
+/**
+* Permanently remove text and image content within the given regions from a
+* page (redaction by removal).
+*
+* The page's content stream is parsed, replayed through a position-tracking
+* graphics-state machine, and re-emitted with every text-showing operator and
+* image placement that falls inside any redaction rect omitted.  All other
+* operators — paths, fills, colors, clips, state changes — are preserved, so
+* the surrounding page layout is left intact.  The filtered content is written
+* back to the page and takes effect on the next `save()`.
+*
+* @param page   The page to redact (modified in place).
+* @param rects  Redaction regions in page space (PDF points, y-up).
+* @returns      Counts of removed text runs and image placements.
+*
+* @example
+* ```ts
+* const result = redactRegions(page, [{ x: 0, y: 90, width: 200, height: 30 }]);
+* console.log(`Removed ${result.removedText} text runs`);
+* const bytes = await doc.save();
+* ```
+*/
+function redactRegions(page, rects) {
+	if (rects.length === 0) return {
+		removedText: 0,
+		removedImages: 0
+	};
+	const { kept, removedText, removedImages } = filterOperators(parseContentStream(page.getContentStream()), rects);
+	replacePageContent(page, kept.map(serializeOperator).join("\n") + (kept.length > 0 ? "\n" : ""));
+	return {
+		removedText,
+		removedImages
+	};
+}
+//#endregion
+//#region src/render/tiles.ts
+/**
+* @module render/tiles
+*
+* Tile-based rendering of large pages plus a small LRU cache. A page is
+* interpreted once into a {@link DisplayList}; each tile rasterizes only its
+* pixel sub-window via the rasterizer's `region` option, so arbitrarily large
+* pages render in bounded memory.
+*
+* @packageDocumentation
+*/
+function scaleOf(opts) {
+	if (typeof opts.scale === "number") return opts.scale;
+	if (typeof opts.dpi === "number") return opts.dpi / 72;
+	return 1;
+}
+function gridFromDisplayList(dl, opts) {
+	const scale = scaleOf(opts);
+	const tileSize = opts.tileSize ?? 512;
+	const fullWidth = Math.max(1, Math.ceil(dl.width * scale));
+	const fullHeight = Math.max(1, Math.ceil(dl.height * scale));
+	return {
+		columns: Math.max(1, Math.ceil(fullWidth / tileSize)),
+		rows: Math.max(1, Math.ceil(fullHeight / tileSize)),
+		tileSize,
+		fullWidth,
+		fullHeight,
+		scale
+	};
+}
+/** Compute the tile grid for a page. */
+function computeTileGrid(page, opts = {}) {
+	return gridFromDisplayList(interpretPage(page), opts);
+}
+/** Render a single tile `(column, row)` of a page to an RGBA image. */
+function renderPageTile(page, column, row, opts = {}) {
+	const dl = interpretPage(page);
+	const grid = gridFromDisplayList(dl, opts);
+	const x = column * grid.tileSize;
+	const y = row * grid.tileSize;
+	const width = Math.min(grid.tileSize, grid.fullWidth - x);
+	const height = Math.min(grid.tileSize, grid.fullHeight - y);
+	return rasterize(dl, {
+		scale: grid.scale,
+		background: opts.background,
+		renderText: opts.renderText ?? true,
+		region: {
+			x,
+			y,
+			width: Math.max(1, width),
+			height: Math.max(1, height)
+		}
+	});
+}
+/**
+* A simple least-recently-used cache (Map-backed). Useful for memoizing
+* interpreted display lists or rasterized tiles across renders.
+*/
+var RenderCache = class {
+	maxEntries;
+	map = /* @__PURE__ */ new Map();
+	constructor(maxEntries = 64) {
+		this.maxEntries = maxEntries;
+	}
+	/** Number of cached entries. */
+	get size() {
+		return this.map.size;
+	}
+	/** Look up a value, marking it most-recently-used. */
+	get(key) {
+		const v = this.map.get(key);
+		if (v !== void 0) {
+			this.map.delete(key);
+			this.map.set(key, v);
+		}
+		return v;
+	}
+	/** Whether a key is present (without affecting recency). */
+	has(key) {
+		return this.map.has(key);
+	}
+	/** Insert/replace a value, evicting the LRU entry when over capacity. */
+	set(key, value) {
+		if (this.map.has(key)) this.map.delete(key);
+		this.map.set(key, value);
+		while (this.map.size > this.maxEntries) {
+			const oldest = this.map.keys().next().value;
+			if (oldest === void 0) break;
+			this.map.delete(oldest);
+		}
+	}
+	/** Remove a key. */
+	delete(key) {
+		return this.map.delete(key);
+	}
+	/** Empty the cache. */
+	clear() {
+		this.map.clear();
+	}
+};
+//#endregion
+//#region src/compliance/afAttach.ts
+/**
+* @module compliance/afAttach
+*
+* Attach embedded / associated files to any PDF object.
+*
+* The Associated Files mechanism (`/AF`) lets a PDF declare that one or more
+* embedded files are *associated* with a given object.  ISO 32000-2 allows the
+* `/AF` key on the document catalog (§7.11.4) as well as on individual objects
+* — page dictionaries, annotation dictionaries, Form/Image XObject stream
+* dictionaries, and structure elements (§14.13).  Because every one of those
+* targets is a plain {@link PdfDict}, the same helper attaches `/AF` uniformly.
+*
+* In addition, a *document-level* associated file must also be reachable
+* through the catalog's embedded-files name tree
+* (`/Names` → `/EmbeddedFiles` → `/Names`).  {@link createAssociatedFile} (in
+* `associatedFiles.ts`) intentionally leaves that wiring to the caller;
+* {@link registerEmbeddedFile} completes it.
+*
+* These are pure builders: they mutate the supplied dictionaries in place and
+* return nothing.  Object numbers / serialization remain the writer's concern.
+*
+* Reference: ISO 32000-2:2020, §7.11.4 (embedded file streams) and §14.13
+* (associated files).
+*/
+/**
+* Attach one or more associated files to any PDF object via its `/AF` key.
+*
+* Works uniformly for the document catalog, a page dictionary, an annotation
+* dictionary, a Form/Image XObject stream's dictionary, or a structure-element
+* dictionary — all of which are plain {@link PdfDict} instances.
+*
+* If `target` has no `/AF` yet, a fresh array (built with
+* {@link buildAfArray}) is set.  If `/AF` is already a {@link PdfArray}, the
+* new refs are appended to it, preserving the existing entries and order.  Any
+* other (malformed) `/AF` value is replaced with a fresh array.
+*
+* @param target        The object dictionary to attach the files to.
+* @param fileSpecRefs  Indirect references to file-specification dictionaries.
+*/
+function attachAssociatedFiles(target, fileSpecRefs) {
+	const existing = target.get("/AF");
+	if (existing instanceof PdfArray) {
+		for (const ref of fileSpecRefs) existing.push(ref);
+		return;
+	}
+	target.set("/AF", buildAfArray([...fileSpecRefs]));
+}
+/**
+* Locate the `/EmbeddedFiles` name-tree `/Names` array on the catalog,
+* creating the intermediate `/Names` and `/EmbeddedFiles` dictionaries (and
+* the leaf `/Names` array) if they do not yet exist.  Existing dictionaries
+* are reused in place rather than replaced.
+*/
+function ensureEmbeddedFilesNames(catalog) {
+	const namesEntry = catalog.get("/Names");
+	const namesDict = namesEntry instanceof PdfDict ? namesEntry : new PdfDict();
+	if (namesDict !== namesEntry) catalog.set("/Names", namesDict);
+	const efEntry = namesDict.get("/EmbeddedFiles");
+	const efDict = efEntry instanceof PdfDict ? efEntry : new PdfDict();
+	if (efDict !== efEntry) namesDict.set("/EmbeddedFiles", efDict);
+	const leafEntry = efDict.get("/Names");
+	const leaf = leafEntry instanceof PdfArray ? leafEntry : new PdfArray();
+	if (leaf !== leafEntry) efDict.set("/Names", leaf);
+	return leaf;
+}
+/**
+* Insert a `[name, fileSpecRef]` pair into an embedded-files name-tree `/Names`
+* array, keeping the array sorted by name.  The array is a flat sequence of
+* alternating key/value entries: `[ name0, ref0, name1, ref1, … ]`.
+*/
+function insertNamePairSorted(leaf, name, fileSpecRef) {
+	const items = leaf.items;
+	let insertAt = items.length;
+	for (let i = 0; i < items.length; i += 2) {
+		const entry = items[i];
+		if ((entry instanceof PdfString ? entry.value : "") > name) {
+			insertAt = i;
+			break;
+		}
+	}
+	items.splice(insertAt, 0, PdfString.literal(name), fileSpecRef);
+}
+/**
+* Complete {@link createAssociatedFile}'s "caller responsibility" by wiring a
+* file-specification reference into the document catalog at the *document
+* level*.
+*
+* Two things happen:
+*  1. The pair `[PdfString.literal(name), fileSpecRef]` is added to the
+*     catalog's `/Names` → `/EmbeddedFiles` → `/Names` array, keeping the
+*     array's name/value pairs sorted by name (as required for a name tree).
+*     The intermediate dictionaries and the leaf array are created on demand
+*     and reused if already present.
+*  2. `fileSpecRef` is added to the catalog's `/AF` array (via
+*     {@link attachAssociatedFiles}).
+*
+* @param catalog      The document catalog dictionary.
+* @param name         The name under which the file is registered in the tree.
+* @param fileSpecRef  Indirect reference to the file-specification dictionary.
+*/
+function registerEmbeddedFile(catalog, name, fileSpecRef) {
+	insertNamePairSorted(ensureEmbeddedFilesNames(catalog), name, fileSpecRef);
+	attachAssociatedFiles(catalog, [fileSpecRef]);
+}
+//#endregion
+//#region src/compliance/pageOutputIntent.ts
+/**
+* @module compliance/pageOutputIntent
+*
+* Per-page and per-stream output intents (ISO 32000-2 §14.11.5).
+*
+* In addition to the document-level `/OutputIntents` array carried on the
+* catalog, PDF 2.0 permits an `/OutputIntents` array on individual *page*
+* dictionaries and on *Form XObject* stream dictionaries.  These narrower
+* intents override the document intent for the colour-managed content of that
+* page or form, which is essential for documents that mix output conditions
+* (for example, a PDF/X job whose individual pages target different print
+* presses).
+*
+* This module provides two pure builders:
+*
+*  - {@link buildPageOutputIntent} constructs a single `/OutputIntent`
+*    dictionary (reusing {@link buildOutputIntent} for the embedded ICC
+*    `/DestOutputProfile`) and registers it as an indirect object.
+*  - {@link attachOutputIntents} sets — or, when one already exists, appends
+*    to — the `/OutputIntents` array on a target dictionary (a page dict for
+*    per-page intents, or a Form XObject stream's dict for per-stream).
+*
+* Reference: ISO 32000-2:2020, §14.11.5 (Output intents).
+*/
+/**
+* Attach output-intent references to a target dictionary's `/OutputIntents`
+* array.
+*
+* If the target has no `/OutputIntents` entry, a fresh {@link PdfArray} is
+* created and populated with `intentRefs`.  If one already exists (and is an
+* array), the references are appended to it in order, preserving the existing
+* array instance.
+*
+* The target may be a page dictionary (for per-page intents) or a Form
+* XObject stream's dictionary (for per-stream intents).
+*
+* @param target      The page or Form XObject dictionary to mutate.
+* @param intentRefs  Indirect references to `/OutputIntent` dictionaries.
+*/
+function attachOutputIntents(target, intentRefs) {
+	const existing = target.get("/OutputIntents");
+	const array = existing instanceof PdfArray ? existing : new PdfArray();
+	for (const ref of intentRefs) array.push(ref);
+	if (!(existing instanceof PdfArray)) target.set("/OutputIntents", array);
+}
+/**
+* Build a per-page / per-stream `/OutputIntent` dictionary and register it.
+*
+* The embedded ICC `/DestOutputProfile` is produced by reusing
+* {@link buildOutputIntent}; this builder then layers the per-page subtype
+* (`/S`), output-condition identifier and optional `/Info` string on top.
+* The resulting dictionary carries `/Type /OutputIntent` and may be attached
+* to a page or Form XObject dictionary via {@link attachOutputIntents}.
+*
+* @param registry  The PDF object registry to register objects into.
+* @param options   Output-intent configuration.
+* @returns         An indirect reference to the `/OutputIntent` dictionary.
+*/
+function buildPageOutputIntent(registry, options = {}) {
+	const intentRef = buildOutputIntent(registry, {
+		subtype: options.subtype ?? "/GTS_PDFA1",
+		...options.iccProfile !== void 0 ? { iccProfile: options.iccProfile } : {},
+		...options.components !== void 0 ? { components: options.components } : {},
+		...options.outputConditionIdentifier !== void 0 ? { outputConditionIdentifier: options.outputConditionIdentifier } : {}
+	});
+	const intentDict = registry.resolve(intentRef);
+	if (intentDict !== void 0 && intentDict.kind === "dict") {
+		intentDict.set("/Type", PdfName.of("OutputIntent"));
+		if (options.outputConditionIdentifier !== void 0) intentDict.set("/OutputConditionIdentifier", PdfString.literal(options.outputConditionIdentifier));
+		if (options.info !== void 0) intentDict.set("/Info", PdfString.literal(options.info));
+	}
+	return intentRef;
+}
+//#endregion
+//#region src/compliance/encryptedPayload.ts
+/**
+* @module compliance/encryptedPayload
+*
+* Unencrypted wrapper documents and encrypted payloads
+* (ISO 32000-2:2020 §7.6.7).
+*
+* A PDF 2.0 *unencrypted wrapper document* is an ordinary, viewable PDF that
+* carries an *encrypted payload* as an embedded file.  The wrapper itself is
+* not encrypted (so any conforming reader can open it and show a cover page),
+* while the sensitive content lives in the embedded payload, which is
+* protected by an external/handler-specific crypto filter.
+*
+* The payload is declared through an *Encrypted Payload* dictionary
+* (`/Type /EncryptedPayload`).  Its `/Subtype` names the crypto filter used to
+* protect the payload (for example `/AESV3`), and an optional `/Version`
+* records the version of that filter.  The Encrypted Payload dictionary is
+* attached to the embedded file's *file specification* dictionary via the
+* `/EP` key, and that file specification is also marked with
+* `/AFRelationship /EncryptedPayload`.
+*
+* This module provides two pure builders:
+*
+*  - {@link buildEncryptedPayload} — build the `/EncryptedPayload` dictionary.
+*  - {@link buildUnencryptedWrapper} — embed the payload bytes as an
+*    associated file and attach the `/EP` dictionary to its file
+*    specification, returning the file-spec reference.
+*
+* The caller attaches the returned file-spec reference to the catalog `/AF`
+* array and to the `/Names /EmbeddedFiles` name tree (for example via
+* `afAttach`).
+*
+* Reference: ISO 32000-2:2020, §7.6.7 (Unencrypted wrapper document).
+*/
+/**
+* Build an `/EncryptedPayload` dictionary (ISO 32000-2 §7.6.7).
+*
+* The returned dictionary has:
+*  - `/Type /EncryptedPayload`
+*  - `/Subtype /<subtype>` — the crypto filter name
+*  - `/Version /<version>` — only when {@link EncryptedPayloadOptions.version}
+*    is supplied
+*
+* @param options - The crypto-filter subtype and optional version.
+* @returns A spec-shaped `/EncryptedPayload` {@link PdfDict}.
+*/
+function buildEncryptedPayload(options) {
+	const dict = new PdfDict();
+	dict.set("/Type", PdfName.of("EncryptedPayload"));
+	dict.set("/Subtype", PdfName.of(options.subtype));
+	if (options.version !== void 0) dict.set("/Version", PdfName.of(options.version));
+	return dict;
+}
+/**
+* Build the embedded encrypted-payload file for an unencrypted wrapper
+* document and return its file-specification reference.
+*
+* The payload bytes are embedded via {@link createAssociatedFile} with an
+* `/AFRelationship` of `/EncryptedPayload` and an `application/octet-stream`
+* MIME type.  The resolved file-specification dictionary then receives an
+* `/EP` entry holding the {@link buildEncryptedPayload} dictionary.
+*
+* The caller is responsible for attaching the returned file-spec reference to
+* the catalog `/AF` array and the `/Names /EmbeddedFiles` name tree.
+*
+* @param registry - The PDF object registry to register objects into.
+* @param options  - The payload bytes, filename, crypto subtype/version, and
+*                   optional description.
+* @returns An indirect reference to the file-specification dictionary.
+*/
+function buildUnencryptedWrapper(registry, options) {
+	const { fileSpecRef } = createAssociatedFile(registry, {
+		data: options.data,
+		filename: options.filename,
+		mimeType: "application/octet-stream",
+		relationship: "EncryptedPayload",
+		description: options.description
+	});
+	const fileSpec = registry.resolve(fileSpecRef);
+	if (fileSpec instanceof PdfDict) {
+		const ep = buildEncryptedPayload({
+			subtype: options.subtype,
+			version: options.version
+		});
+		fileSpec.set("/EP", ep);
+	}
+	return fileSpecRef;
+}
+//#endregion
+//#region src/core/softMask.ts
+/**
+* @module core/softMask
+*
+* Soft-mask groups in graphics state (ISO 32000-1 §11.6.5.2).
+*
+* A *soft mask* defines a per-pixel shape/opacity for subsequent painting
+* operations.  It is carried in an `ExtGState` dictionary under the `/SMask`
+* key.  The mask is derived from a *transparency-group XObject* (a form
+* XObject whose `/Group` dictionary has `/S /Transparency`):
+*
+*  - A **luminosity** mask (`/S /Luminosity`) computes the mask value from the
+*    luminosity of the group's composited result.  An optional `/BC` backdrop
+*    color sets the colour against which the group is composited before the
+*    luminosity is measured.
+*  - An **alpha** mask (`/S /Alpha`) computes the mask value from the group's
+*    accumulated alpha (shape/opacity).  `/BC` is not meaningful and is omitted.
+*
+* An optional `/TR` *transfer function* remaps the computed mask values; it may
+* be an indirect reference to a function object or the name `/Identity`.
+*
+* These are pure builders: they return spec-shaped `ExtGState` dictionaries.
+* Registering the result and naming it in a page's `/Resources /ExtGState`
+* (e.g. via `page.registerExtGState(name, registry.register(extGState))`) is
+* the caller's concern.
+*
+* Reference: ISO 32000-1:2008, §11.6.5.2 (Mask shape and opacity);
+*            ISO 32000-1:2008, §8.4.5 (Graphics state, `/SMask`).
+*/
+/**
+* Build an `ExtGState` dictionary that installs a soft-mask group.
+*
+* The returned dictionary has `/Type /ExtGState` and an `/SMask` mask
+* dictionary:
+*
+*  - `/Type /Mask`
+*  - `/S /Luminosity` or `/S /Alpha` (per {@link SoftMaskGroupOptions.type},
+*    defaulting to `Luminosity`)
+*  - `/G` → the supplied group XObject reference
+*  - `/BC [ … ]` — backdrop colour, **only** for luminosity masks and only
+*    when {@link SoftMaskGroupOptions.backdropColor} is provided
+*  - `/TR` → the transfer function (indirect reference) or the name
+*    `/Identity`, only when {@link SoftMaskGroupOptions.transferFunction} is
+*    provided
+*
+* @param options - The soft-mask group description.
+* @returns A spec-shaped `ExtGState` {@link PdfDict}.
+*/
+function buildSoftMaskGroupExtGState(options) {
+	const subtype = options.type ?? "Luminosity";
+	const smask = new PdfDict();
+	smask.set("/Type", PdfName.of("Mask"));
+	smask.set("/S", PdfName.of(subtype));
+	smask.set("/G", options.groupXObject);
+	if (subtype === "Luminosity" && options.backdropColor !== void 0 && options.backdropColor.length > 0) smask.set("/BC", PdfArray.fromNumbers([...options.backdropColor]));
+	if (options.transferFunction !== void 0) smask.set("/TR", options.transferFunction === "Identity" ? PdfName.of("Identity") : options.transferFunction);
+	const extGState = new PdfDict();
+	extGState.set("/Type", PdfName.of("ExtGState"));
+	extGState.set("/SMask", smask);
+	return extGState;
+}
+/**
+* Build an `ExtGState` dictionary that clears any active soft mask by setting
+* `/SMask /None`.  Apply this after a masked region to restore unmasked
+* painting.
+*
+* @returns An `ExtGState` {@link PdfDict} with `/SMask /None`.
+*/
+function buildSoftMaskNone() {
+	const extGState = new PdfDict();
+	extGState.set("/Type", PdfName.of("ExtGState"));
+	extGState.set("/SMask", PdfName.of("None"));
+	return extGState;
+}
+//#endregion
+//#region src/core/imageMask.ts
+/**
+* @module core/imageMask
+*
+* Image masks and black-point compensation per ISO 32000-2 §8.9.6
+* (Masked images) and §8.6.5.9 (Black-point compensation).
+*
+* PDF supports three ways of masking an image XObject:
+*
+* - **Stencil mask** — a 1-bit-per-component `/ImageMask` image whose sample
+*   values select which areas of the page are painted with the current fill
+*   colour and which are left untouched (§8.9.6.2). The mask data is packed
+*   one bit per sample, each row byte-aligned (`ceil(width / 8)` bytes per
+*   row); the caller supplies the already-packed bytes.
+* - **Colour-key mask** — a `/Mask` array of `[min0 max0 min1 max1 …]`
+*   integer ranges (two per colour component) that makes matching sample
+*   colours transparent (§8.9.6.4).
+* - **Soft mask** — a separate DeviceGray image referenced from a base
+*   image's `/SMask` entry, giving per-pixel opacity (§11.6.5.2).
+*
+* Black-point compensation (§8.6.5.9) is controlled through an ExtGState's
+* `/UseBlackPtComp` entry, which selects whether the conversion between
+* colour spaces maps source black to destination black.
+*
+* These are pure builders: they construct (and, for the stream variants,
+* register) PDF objects but do not wire them into a page or resource
+* dictionary — that is the caller's concern.
+*
+* Reference: ISO 32000-2:2020, §8.9.6 (Masked images), §8.6.5.9
+*            (Black-point compensation).
+*/
+/**
+* Build a stencil mask: a 1-bit `/ImageMask` image XObject (§8.9.6.2).
+*
+* The returned stream has `/Type /XObject`, `/Subtype /Image`,
+* `/ImageMask true`, `/BitsPerComponent 1`, and the supplied `/Width` and
+* `/Height`. When a `decode` pair is given it is emitted as a `/Decode`
+* array, allowing the mask polarity to be inverted (`[1 0]`).
+*
+* The `bits` buffer must already be packed one bit per sample with each row
+* byte-aligned (`ceil(width / 8)` bytes per row); this builder stores it
+* verbatim and does not repack it.
+*
+* @param registry - Registry to register the stream into.
+* @param bits     - Packed, byte-aligned 1-bpc mask data.
+* @param width    - Image width in samples.
+* @param height   - Image height in samples.
+* @param decode   - Optional `[d0, d1]` decode pair.
+* @returns An indirect reference to the registered image XObject stream.
+*/
+function buildStencilMask(registry, bits, width, height, decode) {
+	const dict = new PdfDict();
+	dict.set("/Type", PdfName.of("XObject"));
+	dict.set("/Subtype", PdfName.of("Image"));
+	dict.set("/ImageMask", PdfBool.TRUE);
+	dict.set("/BitsPerComponent", PdfNumber.of(1));
+	dict.set("/Width", PdfNumber.of(width));
+	dict.set("/Height", PdfNumber.of(height));
+	if (decode !== void 0) dict.set("/Decode", PdfArray.fromNumbers([decode[0], decode[1]]));
+	dict.set("/Length", PdfNumber.of(bits.length));
+	return registry.register(new PdfStream(dict, bits));
+}
+/**
+* Build a colour-key masking array (§8.9.6.4).
+*
+* The `ranges` list holds two integers — a minimum and a maximum — per
+* colour component, laid out as `[min0 max0 min1 max1 …]`. Sample colours
+* whose every component falls within its range become transparent. The
+* returned {@link PdfArray} is assigned to a base image's `/Mask` entry.
+*
+* @param ranges - An even-length list of `[min, max]` integer pairs.
+* @returns A `/Mask` {@link PdfArray} of {@link PdfNumber}s.
+* @throws RangeError if `ranges` is empty or has an odd length.
+*/
+function buildColorKeyMask(ranges) {
+	if (ranges.length === 0 || ranges.length % 2 !== 0) throw new RangeError(`colour-key mask requires a non-empty even number of values (min/max pairs); got ${ranges.length}`);
+	return new PdfArray(ranges.map((v) => PdfNumber.of(v)));
+}
+/**
+* Build an image soft mask: a DeviceGray image XObject usable as a base
+* image's `/SMask` (§11.6.5.2).
+*
+* The returned stream has `/Type /XObject`, `/Subtype /Image`,
+* `/ColorSpace /DeviceGray`, the supplied `/Width` and `/Height`, and
+* `/BitsPerComponent` (defaulting to 8). Each grayscale sample provides the
+* opacity of the corresponding base-image pixel.
+*
+* @param registry          - Registry to register the stream into.
+* @param gray              - Grayscale opacity samples.
+* @param width             - Image width in samples.
+* @param height            - Image height in samples.
+* @param bitsPerComponent  - Bits per sample; defaults to 8.
+* @returns An indirect reference to the registered soft-mask image XObject.
+*/
+function buildImageSoftMask(registry, gray, width, height, bitsPerComponent) {
+	const dict = new PdfDict();
+	dict.set("/Type", PdfName.of("XObject"));
+	dict.set("/Subtype", PdfName.of("Image"));
+	dict.set("/Width", PdfNumber.of(width));
+	dict.set("/Height", PdfNumber.of(height));
+	dict.set("/ColorSpace", PdfName.of("DeviceGray"));
+	dict.set("/BitsPerComponent", PdfNumber.of(bitsPerComponent ?? 8));
+	dict.set("/Length", PdfNumber.of(gray.length));
+	return registry.register(new PdfStream(dict, gray));
+}
+/**
+* Build an ExtGState that controls black-point compensation (§8.6.5.9).
+*
+* The returned dictionary has `/Type /ExtGState` and `/UseBlackPtComp` set
+* to the requested mode:
+*
+* - `Default` — leave the choice to the conforming reader.
+* - `ON`      — always apply black-point compensation.
+* - `OFF`     — never apply black-point compensation.
+*
+* @param mode - The `/UseBlackPtComp` mode.
+* @returns An ExtGState {@link PdfDict}.
+*/
+function buildBlackPointCompensationExtGState(mode) {
+	const gs = new PdfDict();
+	gs.set("/Type", PdfName.of("ExtGState"));
+	gs.set("/UseBlackPtComp", PdfName.of(mode));
+	return gs;
+}
+//#endregion
 //#region src/index.ts
 /** Whether initWasm has already completed successfully. */
 let wasmInitialized = false;
@@ -27864,15 +30442,15 @@ async function initWasm(options) {
 	if (wasmInitialized) return;
 	const inits = [];
 	if (options.deflate || options.deflateWasm) inits.push((async () => {
-		const { initDeflateWasm } = await import("./pdfDocument-B6czyaVI.mjs").then((n) => n.zt);
+		const { initDeflateWasm } = await import("./pdfDocument-Cgkkk8F8.mjs").then((n) => n.zt);
 		await initDeflateWasm(options.deflateWasm);
 	})());
 	if (options.png || options.pngWasm) inits.push((async () => {
-		const { initPngWasm } = await import("./pdfDocument-B6czyaVI.mjs").then((n) => n.At);
+		const { initPngWasm } = await import("./pdfDocument-Cgkkk8F8.mjs").then((n) => n.At);
 		await initPngWasm(options.pngWasm);
 	})());
 	if (options.fonts || options.fontWasm) inits.push((async () => {
-		const { initSubsetWasm } = await import("./pdfDocument-B6czyaVI.mjs").then((n) => n.Pt);
+		const { initSubsetWasm } = await import("./pdfDocument-Cgkkk8F8.mjs").then((n) => n.Pt);
 		await initSubsetWasm(options.fontWasm);
 	})());
 	if (options.jpeg || options.jpegWasm) inits.push((async () => {
@@ -27883,6 +30461,6 @@ async function initWasm(options) {
 	wasmInitialized = true;
 }
 //#endregion
-export { buildPdfVtDParts as $, PdfLineAnnotation as $i, readBarcode as $n, parseXmpMetadata as $r, tableToJson as $t, extractCrlUrls as A, getFieldLocks as Ai, PluginError as An, encodePngFromPixels as Ar, buildCollection as At, validateFieldValue as B, saveIncrementalWithSignaturePreservation as Bi, toRoman as Bn, downscaleImage as Br, SARIF_SCHEMA_URI as Bt, assembleTiles as C, buildDeviceNColorSpace as Ca, embedLtvData as Ci, FontNotEmbeddedError as Cn, code128ToOperators as Cr, buildThresholdHalftone as Ct, verifySignatureDetailed as D, saveIncremental as Da, diffSignedContent as Di, InvalidPageSizeError as Dn, PdfWorker as Dr, nameHalftone as Dt, parseTileInfo as E, saveDocumentIncremental as Ea, getCounterSignatures as Ei, InvalidFieldNamePartError as En, valuesToModules as Er, identityTransferFunction as Et, getFieldValue as F, setCertificationLevel as Fi, applyHeaderFooter as Fn, embedTiffCmyk as Fr, buildCalGray as Ft, AFNumber_Format as G, searchTextItems as Gi, truncateText as Gn, enforcePdfAFull as Gr, buildNamespace as Gt, AFDate_FormatEx as H, buildTimestampRequest as Hi, ellipsisText as Hn, optimizeImage as Hr, toSarif as Ht, resolveFieldReference as I, validateSignatureChain as Ii, applyHeaderFooterToPage as In, isCmykTiff as Ir, buildCalRGB as It, isWoff as J, PdfPopupAnnotation as Ji, applyTablePreset as Jn, countOccurrences as Jr, buildRequirement as Jt, formatNumber as K, PdfFileAttachmentAnnotation as Ki, wrapText$2 as Kn, generatePdfAXmp as Kr, buildNamespacesArray as Kt, setFieldValue as L, appendIncrementalUpdate as Li, formatDate$1 as Ln, extractJpegMetadata as Lr, buildLab as Lt, checkCertificateStatus as M, MdpPermission as Mi, RichTextFieldReadError as Mn, webpToJpeg as Mr, reconstructParagraphs as Mt, extractOcspUrl as N, buildDocMdpReference as Ni, StreamingParseError as Nn, webpToPng as Nr, DEFAULT_DOC_TIMESTAMP_CONTENTS_SIZE as Nt, TrustStore as O, addFieldLock as Oi, MissingOnValueCheckError as On, canDirectEmbed as Or, evaluateFunction as Ot, createSandbox as P, getCertificationLevel as Pi, UnexpectedFieldTypeError as Pn, convertTiffCmykToRgb as Pr, buildDocTimeStampDict as Pt, createWorkerPool as Q, PdfCircleAnnotation as Qi, stripedPreset as Qn, extractXmpMetadata as Qr, tableToCsv as Qt, addVisibilityAction as R, findExistingSignatures as Ri, replaceTemplateVariables as Rn, injectJpegMetadata as Rr, labToRgb as Rt, upscale8To16 as S, PDFOperator as Sa, buildDssDictionary as Si, FieldExistsAsNonTerminalError as Sn, encodeCode39 as Sr, buildSampledTransferFunction as St, decodeTileRegion as T, ChangeTracker as Ta, addCounterSignature as Ti, InvalidColorError as Tn, encodeCode128Values as Tr, buildType5Halftone as Tt, formatDate as U, parseTimestampResponse as Ui, estimateTextWidth as Un, recompressImage as Ur, MATHML_NAMESPACE as Ut, AFSpecial_Format as V, validateByteRangeIntegrity as Vi, applyOverflow as Vn, estimateJpegQuality as Vr, toJsonReport as Vt, parseAcrobatDate as W, requestTimestamp as Wi, shrinkFontSize as Wn, applyRedaction as Wr, PDF2_NAMESPACE as Wt, readWoffHeader as X, PdfInkAnnotation as Xi, minimalPreset as Xn, buildAfArray as Xr, buildDPartRoot as Xt, isWoff2 as Y, PdfRedactAnnotation as Yi, borderedPreset as Yn, stripProhibitedFeatures as Yr, buildRequirements as Yt, signDeferred as Z, PdfStampAnnotation as Zi, professionalPreset as Zn, createAssociatedFile as Zr, extractTables as Zt, downscale16To8 as _, PdfLinkAnnotation as _a, isLinearized as _i, BatchProcessingError as _n, encodeEan8 as _r, buildBoxDict as _t, validateCertificatePolicy as a, PdfStrikeOutAnnotation as aa, generateWinAnsiToUnicodeCmap as ai, enforcePdfUa as an, renderStyledBarcode as ar, resolveFallback as at, offsetSignedToUnsigned as b, createXmpStream as ba, findChangedObjects as bi, ExceededMaxLengthError as bn, code39ToOperators as br, validateBoxGeometry as bt, buildCertificateChain as c, generateCircleAppearance as ca, buildOutputIntent as ci, batchMerge as cn, dataMatrixToOperators as cr, generateXRechnungCii as ct, layoutColumns as d, generateInkAppearance as da, detectTransparency as di, getBookmarks as dn, encodeUpcA as dr, buildFunctionShading as dt, PdfPolyLineAnnotation as ea, validateXmpMetadata as ei, accessibilityPlugin as en, readCode128 as er, buildVtDpm as et, layoutParagraph as f, generateLineAppearance as fa, flattenTransparency as fi, removeAllBookmarks as fn, upcAToOperators as fr, sampleShadingColor as ft, validatePdfX as g, generateUnderlineAppearance as ga, getLinearizationInfo as gi, flattenForm as gn, encodeEan13 as gr, generateCiiXml as gt, enforcePdfX as h, generateStrikeOutAppearance as ha, delinearizePdf as hi, flattenFields as hn, ean8ToOperators as hr, renderCodeFrame as ht, EKU_OIDS as i, PdfSquigglyAnnotation as ia, generateSymbolToUnicodeCmap as ii, PdfDocumentBuilder as in, calculateBarcodeDimensions as ir, createRangeFetcher as it, isCertificateRevoked as j, detectModifications as ji, RemovePageFromEmptyDocumentError as jn, recompressWebP as jr, reconstructLines as jt, downloadCrl as k, buildFieldLockDict as ki, NoSuchFieldError as kn, embedTiffDirect as kr, markdownToPdf as kt, validateCertificateChain as l, generateFreeTextAppearance as la, SRGB_ICC_PROFILE as li, processBatch as ln, encodeDataMatrix as lr, buildPdfA4Xmp as lt, buildPdfXOutputIntent as m, generateSquigglyAppearance as ma, validatePdfA as mi, flattenField as mn, ean13ToOperators as mr, levenshtein as mt, extractEmbeddedRevocationData as n, PdfSquareAnnotation as na, getSupportedLevels as ni, timestampPlugin as nn, readEan13 as nr, h as nt, validateExtendedKeyUsage as o, PdfUnderlineAnnotation as oa, generateZapfDingbatsToUnicodeCmap as oi, validatePdfUa as on, encodePdf417 as or, splitByScript as ot, layoutTextFlow as p, generateSquareAppearance as pa, enforcePdfA as pi, removeBookmark as pn, calculateEanCheckDigit as pr, didYouMean as pt, decodeWoff as q, PdfCaretAnnotation as qi, applyPreset as qn, generatePdfAXmpBytes as qr, buildPieceInfo as qt, verifyOfflineRevocation as r, PdfHighlightAnnotation as ra, isValidLevel as ri, StreamingPdfParser as rn, readEan8 as rr, renderToPdf as rt, validateKeyUsage as s, PdfFreeTextAnnotation as sa, getToUnicodeCmap as si, batchFlatten as sn, pdf417ToOperators as sr, generateOrderX as st, initWasm as t, PdfPolygonAnnotation as ta, getProfile as ti, metadataPlugin as tn, readCode39 as tr, gtsPdfVtVersion as tt, findHyphenationPoints as u, generateHighlightAppearance as ua, generateSrgbIccProfile as ui, addBookmark as un, calculateUpcCheckDigit as ur, pdfA4Rules as ut, getComponentDepths as v, PdfTextAnnotation as va, linearizePdf as vi, CombedTextLayoutError as vn, encodeItf as vr, buildGtsPdfxVersion as vt, decodeTile as w, buildSeparationColorSpace as wa, hasLtvData as wi, ForeignPageError as wn, encodeCode128 as wr, buildType1Halftone as wt, summarizeBitDepth as x, parseXmpMetadata$1 as xa, optimizeIncrementalSave as xi, FieldAlreadyExistsError as xn, computeCode39CheckDigit as xr, STANDARD_SPOT_FUNCTIONS as xt, normalizeComponentDepth as y, buildXmpMetadata as ya, computeObjectHash as yi, EncryptedPdfError as yn, itfToOperators as yr, buildPdfX6OutputIntent as yt, setFieldVisibility as z, parseExistingTrailer as zi, toAlpha as zn, analyzeJpegMarkers as zr, DEFAULT_SARIF_TOOL_NAME as zt };
+export { decodeTileRegion as $, ChangeTracker as $a, addCounterSignature as $i, InvalidColorError as $n, encodeCode128Values as $r, buildType5Halftone as $t, extractEmbeddedRevocationData as A, PdfSquareAnnotation as Aa, getSupportedLevels as Ai, timestampPlugin as An, readEan13 as Ar, h as At, layoutParagraph as B, generateLineAppearance as Ba, flattenTransparency as Bi, removeAllBookmarks as Bn, upcAToOperators as Br, sampleShadingColor as Bt, generateThumbnail as C, PdfRedactAnnotation as Ca, stripProhibitedFeatures as Ci, buildRequirements as Cn, borderedPreset as Cr, isWoff2 as Ct, renderPageToImage as D, PdfLineAnnotation as Da, parseXmpMetadata as Di, tableToJson as Dn, readBarcode as Dr, buildPdfVtDParts as Dt, rasterize as E, PdfCircleAnnotation as Ea, extractXmpMetadata as Ei, tableToCsv as En, stripedPreset as Er, createWorkerPool as Et, validateKeyUsage as F, PdfFreeTextAnnotation as Fa, getToUnicodeCmap as Fi, batchFlatten as Fn, pdf417ToOperators as Fr, generateOrderX as Ft, downscale16To8 as G, PdfLinkAnnotation as Ga, isLinearized as Gi, BatchProcessingError as Gn, encodeEan8 as Gr, buildBoxDict as Gt, buildPdfXOutputIntent as H, generateSquigglyAppearance as Ha, validatePdfA as Hi, flattenField as Hn, ean13ToOperators as Hr, levenshtein as Ht, buildCertificateChain as I, generateCircleAppearance as Ia, buildOutputIntent as Ii, batchMerge as In, dataMatrixToOperators as Ir, generateXRechnungCii as It, offsetSignedToUnsigned as J, createXmpStream as Ja, findChangedObjects as Ji, ExceededMaxLengthError as Jn, code39ToOperators as Jr, validateBoxGeometry as Jt, getComponentDepths as K, PdfTextAnnotation as Ka, linearizePdf as Ki, CombedTextLayoutError as Kn, encodeItf as Kr, buildGtsPdfxVersion as Kt, validateCertificateChain as L, generateFreeTextAppearance as La, SRGB_ICC_PROFILE as Li, processBatch as Ln, encodeDataMatrix as Lr, buildPdfA4Xmp as Lt, EKU_OIDS as M, PdfSquigglyAnnotation as Ma, generateSymbolToUnicodeCmap as Mi, PdfDocumentBuilder as Mn, calculateBarcodeDimensions as Mr, createRangeFetcher as Mt, validateCertificatePolicy as N, PdfStrikeOutAnnotation as Na, generateWinAnsiToUnicodeCmap as Ni, enforcePdfUa as Nn, renderStyledBarcode as Nr, resolveFallback as Nt, interpretContentStream as O, PdfPolyLineAnnotation as Oa, validateXmpMetadata as Oi, accessibilityPlugin as On, readCode128 as Or, buildVtDpm as Ot, validateExtendedKeyUsage as P, PdfUnderlineAnnotation as Pa, generateZapfDingbatsToUnicodeCmap as Pi, validatePdfUa as Pn, encodePdf417 as Pr, splitByScript as Pt, decodeTile as Q, buildSeparationColorSpace as Qa, hasLtvData as Qi, ForeignPageError as Qn, encodeCode128 as Qr, buildType1Halftone as Qt, findHyphenationPoints as R, generateHighlightAppearance as Ra, generateSrgbIccProfile as Ri, addBookmark as Rn, calculateUpcCheckDigit as Rr, pdfA4Rules as Rt, extractImages as S, PdfPopupAnnotation as Sa, countOccurrences as Si, buildRequirement as Sn, applyTablePreset as Sr, isWoff as St, renderPageToCanvas as T, PdfStampAnnotation as Ta, createAssociatedFile as Ti, extractTables as Tn, professionalPreset as Tr, signDeferred as Tt, enforcePdfX as U, generateStrikeOutAppearance as Ua, delinearizePdf as Ui, flattenFields as Un, ean8ToOperators as Ur, renderCodeFrame as Ut, layoutTextFlow as V, generateSquareAppearance as Va, enforcePdfA as Vi, removeBookmark as Vn, calculateEanCheckDigit as Vr, didYouMean as Vt, validatePdfX as W, generateUnderlineAppearance as Wa, getLinearizationInfo as Wi, flattenForm as Wn, encodeEan13 as Wr, generateCiiXml as Wt, upscale8To16 as X, PDFOperator as Xa, buildDssDictionary as Xi, FieldExistsAsNonTerminalError as Xn, encodeCode39 as Xr, buildSampledTransferFunction as Xt, summarizeBitDepth as Y, parseXmpMetadata$1 as Ya, optimizeIncrementalSave as Yi, FieldAlreadyExistsError as Yn, computeCode39CheckDigit as Yr, STANDARD_SPOT_FUNCTIONS as Yt, assembleTiles as Z, buildDeviceNColorSpace as Za, embedLtvData as Zi, FontNotEmbeddedError as Zn, code128ToOperators as Zr, buildThresholdHalftone as Zt, redactRegions as _, parseTimestampResponse as _a, recompressImage as _i, MATHML_NAMESPACE as _n, estimateTextWidth as _r, formatDate as _t, buildStencilMask as a, detectModifications as aa, recompressWebP as ai, reconstructLines as an, RemovePageFromEmptyDocumentError as ar, isCertificateRevoked as at, comparePages as b, PdfFileAttachmentAnnotation as ba, generatePdfAXmp as bi, buildNamespacesArray as bn, wrapText$2 as br, formatNumber$1 as bt, buildEncryptedPayload as c, getCertificationLevel as ca, convertTiffCmykToRgb as ci, buildDocTimeStampDict as cn, UnexpectedFieldTypeError as cr, createSandbox as ct, buildPageOutputIntent as d, appendIncrementalUpdate as da, extractJpegMetadata as di, buildLab as dn, formatDate$1 as dr, setFieldValue as dt, getCounterSignatures as ea, valuesToModules as ei, identityTransferFunction as en, saveDocumentIncremental as eo, InvalidFieldNamePartError as er, parseTileInfo as et, attachAssociatedFiles as f, findExistingSignatures as fa, injectJpegMetadata as fi, labToRgb as fn, replaceTemplateVariables as fr, addVisibilityAction as ft, renderPageTile as g, buildTimestampRequest as ga, optimizeImage as gi, toSarif as gn, ellipsisText as gr, AFDate_FormatEx as gt, computeTileGrid as h, validateByteRangeIntegrity as ha, estimateJpegQuality as hi, toJsonReport as hn, applyOverflow as hr, AFSpecial_Format as ht, buildImageSoftMask as i, getFieldLocks as ia, encodePngFromPixels as ii, buildCollection as in, PluginError as ir, extractCrlUrls as it, verifyOfflineRevocation as j, PdfHighlightAnnotation as ja, isValidLevel as ji, StreamingPdfParser as jn, readEan8 as jr, renderToPdf as jt, interpretPage as k, PdfPolygonAnnotation as ka, getProfile as ki, metadataPlugin as kn, readCode39 as kr, gtsPdfVtVersion as kt, buildUnencryptedWrapper as l, setCertificationLevel as la, embedTiffCmyk as li, buildCalGray as ln, applyHeaderFooter as lr, getFieldValue as lt, RenderCache as m, saveIncrementalWithSignaturePreservation as ma, downscaleImage as mi, SARIF_SCHEMA_URI as mn, toRoman as mr, validateFieldValue as mt, buildBlackPointCompensationExtGState as n, addFieldLock as na, canDirectEmbed as ni, evaluateFunction as nn, MissingOnValueCheckError as nr, TrustStore as nt, buildSoftMaskGroupExtGState as o, MdpPermission as oa, webpToJpeg as oi, reconstructParagraphs as on, RichTextFieldReadError as or, checkCertificateStatus as ot, registerEmbeddedFile as p, parseExistingTrailer as pa, analyzeJpegMarkers as pi, DEFAULT_SARIF_TOOL_NAME as pn, toAlpha as pr, setFieldVisibility as pt, normalizeComponentDepth as q, buildXmpMetadata as qa, computeObjectHash as qi, EncryptedPdfError as qn, itfToOperators as qr, buildPdfX6OutputIntent as qt, buildColorKeyMask as r, buildFieldLockDict as ra, embedTiffDirect as ri, markdownToPdf as rn, NoSuchFieldError as rr, downloadCrl as rt, buildSoftMaskNone as s, buildDocMdpReference as sa, webpToPng as si, DEFAULT_DOC_TIMESTAMP_CONTENTS_SIZE as sn, StreamingParseError as sr, extractOcspUrl as st, initWasm as t, diffSignedContent as ta, PdfWorker as ti, nameHalftone as tn, saveIncremental as to, InvalidPageSizeError as tr, verifySignatureDetailed as tt, attachOutputIntents as u, validateSignatureChain as ua, isCmykTiff as ui, buildCalRGB as un, applyHeaderFooterToPage as ur, resolveFieldReference as ut, applyOcr as v, requestTimestamp as va, applyRedaction as vi, PDF2_NAMESPACE as vn, shrinkFontSize as vr, parseAcrobatDate as vt, renderDisplayListToCanvas as w, PdfInkAnnotation as wa, buildAfArray as wi, buildDPartRoot as wn, minimalPreset as wr, readWoffHeader as wt, extractFonts as x, PdfCaretAnnotation as xa, generatePdfAXmpBytes as xi, buildPieceInfo as xn, applyPreset as xr, decodeWoff as xt, compareImages as y, searchTextItems as ya, enforcePdfAFull as yi, buildNamespace as yn, truncateText as yr, AFNumber_Format as yt, layoutColumns as z, generateInkAppearance as za, detectTransparency as zi, getBookmarks as zn, encodeUpcA as zr, buildFunctionShading as zt };
 
-//# sourceMappingURL=src-BOzRFaEE.mjs.map
+//# sourceMappingURL=src-s9zNsZAT.mjs.map