modern-pdf-lib 0.28.1 → 0.29.0

package/dist/{src-BOzRFaEE.mjs → src-Ci9ZjqhP.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-B6czyaVI.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
@@ -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,2111 @@ 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/index.ts
 /** Whether initWasm has already completed successfully. */
 let wasmInitialized = false;
@@ -27883,6 +29991,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 { setFieldValue as $, appendIncrementalUpdate as $i, formatDate$1 as $n, extractJpegMetadata as $r, buildLab as $t, buildPdfXOutputIntent as A, generateSquigglyAppearance as Aa, validatePdfA as Ai, flattenField as An, ean13ToOperators as Ar, levenshtein as At, decodeTile as B, buildSeparationColorSpace as Ba, hasLtvData as Bi, ForeignPageError as Bn, encodeCode128 as Br, buildType1Halftone as Bt, validateKeyUsage as C, PdfFreeTextAnnotation as Ca, getToUnicodeCmap as Ci, batchFlatten as Cn, pdf417ToOperators as Cr, generateOrderX as Ct, layoutColumns as D, generateInkAppearance as Da, detectTransparency as Di, getBookmarks as Dn, encodeUpcA as Dr, buildFunctionShading as Dt, findHyphenationPoints as E, generateHighlightAppearance as Ea, generateSrgbIccProfile as Ei, addBookmark as En, calculateUpcCheckDigit as Er, pdfA4Rules as Et, normalizeComponentDepth as F, buildXmpMetadata as Fa, computeObjectHash as Fi, EncryptedPdfError as Fn, itfToOperators as Fr, buildPdfX6OutputIntent as Ft, downloadCrl as G, buildFieldLockDict as Gi, NoSuchFieldError as Gn, embedTiffDirect as Gr, markdownToPdf as Gt, parseTileInfo as H, saveDocumentIncremental as Ha, getCounterSignatures as Hi, InvalidFieldNamePartError as Hn, valuesToModules as Hr, identityTransferFunction as Ht, offsetSignedToUnsigned as I, createXmpStream as Ia, findChangedObjects as Ii, ExceededMaxLengthError as In, code39ToOperators as Ir, validateBoxGeometry as It, checkCertificateStatus as J, MdpPermission as Ji, RichTextFieldReadError as Jn, webpToJpeg as Jr, reconstructParagraphs as Jt, extractCrlUrls as K, getFieldLocks as Ki, PluginError as Kn, encodePngFromPixels as Kr, buildCollection as Kt, summarizeBitDepth as L, parseXmpMetadata$1 as La, optimizeIncrementalSave as Li, FieldAlreadyExistsError as Ln, computeCode39CheckDigit as Lr, STANDARD_SPOT_FUNCTIONS as Lt, validatePdfX as M, generateUnderlineAppearance as Ma, getLinearizationInfo as Mi, flattenForm as Mn, encodeEan13 as Mr, generateCiiXml as Mt, downscale16To8 as N, PdfLinkAnnotation as Na, isLinearized as Ni, BatchProcessingError as Nn, encodeEan8 as Nr, buildBoxDict as Nt, layoutParagraph as O, generateLineAppearance as Oa, flattenTransparency as Oi, removeAllBookmarks as On, upcAToOperators as Or, sampleShadingColor as Ot, getComponentDepths as P, PdfTextAnnotation as Pa, linearizePdf as Pi, CombedTextLayoutError as Pn, encodeItf as Pr, buildGtsPdfxVersion as Pt, resolveFieldReference as Q, validateSignatureChain as Qi, applyHeaderFooterToPage as Qn, isCmykTiff as Qr, buildCalRGB as Qt, upscale8To16 as R, PDFOperator as Ra, buildDssDictionary as Ri, FieldExistsAsNonTerminalError as Rn, encodeCode39 as Rr, buildSampledTransferFunction as Rt, validateExtendedKeyUsage as S, PdfUnderlineAnnotation as Sa, generateZapfDingbatsToUnicodeCmap as Si, validatePdfUa as Sn, encodePdf417 as Sr, splitByScript as St, validateCertificateChain as T, generateFreeTextAppearance as Ta, SRGB_ICC_PROFILE as Ti, processBatch as Tn, encodeDataMatrix as Tr, buildPdfA4Xmp as Tt, verifySignatureDetailed as U, saveIncremental as Ua, diffSignedContent as Ui, InvalidPageSizeError as Un, PdfWorker as Ur, nameHalftone as Ut, decodeTileRegion as V, ChangeTracker as Va, addCounterSignature as Vi, InvalidColorError as Vn, encodeCode128Values as Vr, buildType5Halftone as Vt, TrustStore as W, addFieldLock as Wi, MissingOnValueCheckError as Wn, canDirectEmbed as Wr, evaluateFunction as Wt, createSandbox as X, getCertificationLevel as Xi, UnexpectedFieldTypeError as Xn, convertTiffCmykToRgb as Xr, buildDocTimeStampDict as Xt, extractOcspUrl as Y, buildDocMdpReference as Yi, StreamingParseError as Yn, webpToPng as Yr, DEFAULT_DOC_TIMESTAMP_CONTENTS_SIZE as Yt, getFieldValue as Z, setCertificationLevel as Zi, applyHeaderFooter as Zn, embedTiffCmyk as Zr, buildCalGray as Zt, interpretPage as _, PdfPolygonAnnotation as _a, getProfile as _i, metadataPlugin as _n, readCode39 as _r, gtsPdfVtVersion as _t, redactRegions as a, parseTimestampResponse as aa, recompressImage as ai, MATHML_NAMESPACE as an, estimateTextWidth as ar, formatDate as at, EKU_OIDS as b, PdfSquigglyAnnotation as ba, generateSymbolToUnicodeCmap as bi, PdfDocumentBuilder as bn, calculateBarcodeDimensions as br, createRangeFetcher as bt, comparePages as c, PdfFileAttachmentAnnotation as ca, generatePdfAXmp as ci, buildNamespacesArray as cn, wrapText$2 as cr, formatNumber$1 as ct, generateThumbnail as d, PdfRedactAnnotation as da, stripProhibitedFeatures as di, buildRequirements as dn, borderedPreset as dr, isWoff2 as dt, findExistingSignatures as ea, injectJpegMetadata as ei, labToRgb as en, replaceTemplateVariables as er, addVisibilityAction as et, renderDisplayListToCanvas as f, PdfInkAnnotation as fa, buildAfArray as fi, buildDPartRoot as fn, minimalPreset as fr, readWoffHeader as ft, interpretContentStream as g, PdfPolyLineAnnotation as ga, validateXmpMetadata as gi, accessibilityPlugin as gn, readCode128 as gr, buildVtDpm as gt, renderPageToImage as h, PdfLineAnnotation as ha, parseXmpMetadata as hi, tableToJson as hn, readBarcode as hr, buildPdfVtDParts as ht, renderPageTile as i, buildTimestampRequest as ia, optimizeImage as ii, toSarif as in, ellipsisText as ir, AFDate_FormatEx as it, enforcePdfX as j, generateStrikeOutAppearance as ja, delinearizePdf as ji, flattenFields as jn, ean8ToOperators as jr, renderCodeFrame as jt, layoutTextFlow as k, generateSquareAppearance as ka, enforcePdfA as ki, removeBookmark as kn, calculateEanCheckDigit as kr, didYouMean as kt, extractFonts as l, PdfCaretAnnotation as la, generatePdfAXmpBytes as li, buildPieceInfo as ln, applyPreset as lr, decodeWoff as lt, rasterize as m, PdfCircleAnnotation as ma, extractXmpMetadata as mi, tableToCsv as mn, stripedPreset as mr, createWorkerPool as mt, RenderCache as n, saveIncrementalWithSignaturePreservation as na, downscaleImage as ni, SARIF_SCHEMA_URI as nn, toRoman as nr, validateFieldValue as nt, applyOcr as o, requestTimestamp as oa, applyRedaction as oi, PDF2_NAMESPACE as on, shrinkFontSize as or, parseAcrobatDate as ot, renderPageToCanvas as p, PdfStampAnnotation as pa, createAssociatedFile as pi, extractTables as pn, professionalPreset as pr, signDeferred as pt, isCertificateRevoked as q, detectModifications as qi, RemovePageFromEmptyDocumentError as qn, recompressWebP as qr, reconstructLines as qt, computeTileGrid as r, validateByteRangeIntegrity as ra, estimateJpegQuality as ri, toJsonReport as rn, applyOverflow as rr, AFSpecial_Format as rt, compareImages as s, searchTextItems as sa, enforcePdfAFull as si, buildNamespace as sn, truncateText as sr, AFNumber_Format as st, initWasm as t, parseExistingTrailer as ta, analyzeJpegMarkers as ti, DEFAULT_SARIF_TOOL_NAME as tn, toAlpha as tr, setFieldVisibility as tt, extractImages as u, PdfPopupAnnotation as ua, countOccurrences as ui, buildRequirement as un, applyTablePreset as ur, isWoff as ut, extractEmbeddedRevocationData as v, PdfSquareAnnotation as va, getSupportedLevels as vi, timestampPlugin as vn, readEan13 as vr, h as vt, buildCertificateChain as w, generateCircleAppearance as wa, buildOutputIntent as wi, batchMerge as wn, dataMatrixToOperators as wr, generateXRechnungCii as wt, validateCertificatePolicy as x, PdfStrikeOutAnnotation as xa, generateWinAnsiToUnicodeCmap as xi, enforcePdfUa as xn, renderStyledBarcode as xr, resolveFallback as xt, verifyOfflineRevocation as y, PdfHighlightAnnotation as ya, isValidLevel as yi, StreamingPdfParser as yn, readEan8 as yr, renderToPdf as yt, assembleTiles as z, buildDeviceNColorSpace as za, embedLtvData as zi, FontNotEmbeddedError as zn, code128ToOperators as zr, buildThresholdHalftone as zt };
 
-//# sourceMappingURL=src-BOzRFaEE.mjs.map
+//# sourceMappingURL=src-Ci9ZjqhP.mjs.map