modern-pdf-lib 0.28.1 → 0.29.0

package/dist/{src-vNbsqoIy.cjs → src-DQ63jYIR.cjs}

@@ -1,6 +1,9 @@
 const require_pdfDocument = require("./pdfDocument-BaQlOkYr.cjs");
 const require_pdfObjects = require("./pdfObjects-BcPlSI0a.cjs");
+const require_streamDecode = require("./streamDecode-kQ-REV7v.cjs");
 const require_pdfForm = require("./pdfForm-BVS_do95.cjs");
+const require_compressionAnalysis = require("./compressionAnalysis-DwxVCe4E.cjs");
+const require_bridge = require("./bridge-ByvzPu5h.cjs");
 const require_loader = require("./loader-DR7H0XOf.cjs");
 let fflate = require("fflate");
 //#region src/core/incrementalWriter.ts
@@ -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,
@@ -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 require_pdfObjects.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] = require_pdfDocument.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 require_pdfObjects.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, require_compressionAnalysis.parseContentStream(require_streamDecode.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(require_compressionAnalysis.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 require_pdfObjects.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 } = require_streamDecode.getStreamFilters(stream.dict);
+	const isJpeg = filters.includes("DCTDecode");
+	let base;
+	if (isJpeg) base = decodeJpegBase(stream, width, height);
+	else base = interpretSamples(require_streamDecode.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 = require_bridge.decodeJpegWasm(require_streamDecode.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] = require_pdfDocument.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 } = require_streamDecode.getStreamFilters(smask.dict);
+	if (filters.includes("DCTDecode")) {
+		const decoded = require_bridge.decodeJpegWasm(require_streamDecode.decodeStreamData(smask));
+		if (!decoded) return void 0;
+		maskData = decoded.pixels;
+	} else {
+		const raw = require_streamDecode.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 require_pdfObjects.PdfName) return nameToColorSpace(resolved.value);
+	if (resolved instanceof require_pdfObjects.PdfArray) {
+		const first = deref(resolved.items[0], registry);
+		if (first instanceof require_pdfObjects.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 require_pdfObjects.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 require_pdfObjects.PdfStream) return require_streamDecode.decodeStreamData(lookup);
+}
+/** Resolve a value to its target object, following one indirect reference. @internal */
+function deref(obj, registry) {
+	if (obj instanceof require_pdfObjects.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 require_pdfObjects.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 require_pdfObjects.PdfStream ? resolved : void 0;
+}
+/** Read an integer from a PDF object, or fall back. @internal */
+function readInt(obj, fallback) {
+	return obj instanceof require_pdfObjects.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: require_streamDecode.decodeStreamData(fontFile)
+	};
+	const fontFile2 = resolveStream(descriptor, "/FontFile2", registry);
+	if (fontFile2) return {
+		format: "truetype",
+		data: require_streamDecode.decodeStreamData(fontFile2)
+	};
+	const fontFile3 = resolveStream(descriptor, "/FontFile3", registry);
+	if (fontFile3) return {
+		format: nameValue(fontFile3.dict.get("/Subtype"), registry) === "OpenType" ? "opentype" : "cff",
+		data: require_streamDecode.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 require_pdfObjects.PdfDict();
+	fontDict.set("/Type", require_pdfObjects.PdfName.of("Font"));
+	fontDict.set("/Subtype", require_pdfObjects.PdfName.of("Type1"));
+	fontDict.set("/BaseFont", require_pdfObjects.PdfName.of("Helvetica"));
+	fontDict.set("/Encoding", require_pdfObjects.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 require_pdfObjects.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(require_compressionAnalysis.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;
@@ -28159,6 +30267,12 @@ Object.defineProperty(exports, "RemovePageFromEmptyDocumentError", {
 		return RemovePageFromEmptyDocumentError;
 	}
 });
+Object.defineProperty(exports, "RenderCache", {
+	enumerable: true,
+	get: function() {
+		return RenderCache;
+	}
+});
 Object.defineProperty(exports, "RichTextFieldReadError", {
 	enumerable: true,
 	get: function() {
@@ -28261,6 +30375,12 @@ Object.defineProperty(exports, "applyHeaderFooterToPage", {
 		return applyHeaderFooterToPage;
 	}
 });
+Object.defineProperty(exports, "applyOcr", {
+	enumerable: true,
+	get: function() {
+		return applyOcr;
+	}
+});
 Object.defineProperty(exports, "applyOverflow", {
 	enumerable: true,
 	get: function() {
@@ -28549,6 +30669,18 @@ Object.defineProperty(exports, "code39ToOperators", {
 		return code39ToOperators;
 	}
 });
+Object.defineProperty(exports, "compareImages", {
+	enumerable: true,
+	get: function() {
+		return compareImages;
+	}
+});
+Object.defineProperty(exports, "comparePages", {
+	enumerable: true,
+	get: function() {
+		return comparePages;
+	}
+});
 Object.defineProperty(exports, "computeCode39CheckDigit", {
 	enumerable: true,
 	get: function() {
@@ -28561,6 +30693,12 @@ Object.defineProperty(exports, "computeObjectHash", {
 		return computeObjectHash;
 	}
 });
+Object.defineProperty(exports, "computeTileGrid", {
+	enumerable: true,
+	get: function() {
+		return computeTileGrid;
+	}
+});
 Object.defineProperty(exports, "convertTiffCmykToRgb", {
 	enumerable: true,
 	get: function() {
@@ -28825,6 +30963,18 @@ Object.defineProperty(exports, "extractEmbeddedRevocationData", {
 		return extractEmbeddedRevocationData;
 	}
 });
+Object.defineProperty(exports, "extractFonts", {
+	enumerable: true,
+	get: function() {
+		return extractFonts;
+	}
+});
+Object.defineProperty(exports, "extractImages", {
+	enumerable: true,
+	get: function() {
+		return extractImages;
+	}
+});
 Object.defineProperty(exports, "extractJpegMetadata", {
 	enumerable: true,
 	get: function() {
@@ -28906,7 +31056,7 @@ Object.defineProperty(exports, "formatDate$1", {
 Object.defineProperty(exports, "formatNumber", {
 	enumerable: true,
 	get: function() {
-		return formatNumber;
+		return formatNumber$1;
 	}
 });
 Object.defineProperty(exports, "generateCiiXml", {
@@ -28993,6 +31143,12 @@ Object.defineProperty(exports, "generateSymbolToUnicodeCmap", {
 		return generateSymbolToUnicodeCmap;
 	}
 });
+Object.defineProperty(exports, "generateThumbnail", {
+	enumerable: true,
+	get: function() {
+		return generateThumbnail;
+	}
+});
 Object.defineProperty(exports, "generateUnderlineAppearance", {
 	enumerable: true,
 	get: function() {
@@ -29113,6 +31269,18 @@ Object.defineProperty(exports, "injectJpegMetadata", {
 		return injectJpegMetadata;
 	}
 });
+Object.defineProperty(exports, "interpretContentStream", {
+	enumerable: true,
+	get: function() {
+		return interpretContentStream;
+	}
+});
+Object.defineProperty(exports, "interpretPage", {
+	enumerable: true,
+	get: function() {
+		return interpretPage;
+	}
+});
 Object.defineProperty(exports, "isCertificateRevoked", {
 	enumerable: true,
 	get: function() {
@@ -29299,6 +31467,12 @@ Object.defineProperty(exports, "professionalPreset", {
 		return professionalPreset;
 	}
 });
+Object.defineProperty(exports, "rasterize", {
+	enumerable: true,
+	get: function() {
+		return rasterize;
+	}
+});
 Object.defineProperty(exports, "readBarcode", {
 	enumerable: true,
 	get: function() {
@@ -29359,6 +31533,12 @@ Object.defineProperty(exports, "reconstructParagraphs", {
 		return reconstructParagraphs;
 	}
 });
+Object.defineProperty(exports, "redactRegions", {
+	enumerable: true,
+	get: function() {
+		return redactRegions;
+	}
+});
 Object.defineProperty(exports, "removeAllBookmarks", {
 	enumerable: true,
 	get: function() {
@@ -29377,6 +31557,30 @@ Object.defineProperty(exports, "renderCodeFrame", {
 		return renderCodeFrame;
 	}
 });
+Object.defineProperty(exports, "renderDisplayListToCanvas", {
+	enumerable: true,
+	get: function() {
+		return renderDisplayListToCanvas;
+	}
+});
+Object.defineProperty(exports, "renderPageTile", {
+	enumerable: true,
+	get: function() {
+		return renderPageTile;
+	}
+});
+Object.defineProperty(exports, "renderPageToCanvas", {
+	enumerable: true,
+	get: function() {
+		return renderPageToCanvas;
+	}
+});
+Object.defineProperty(exports, "renderPageToImage", {
+	enumerable: true,
+	get: function() {
+		return renderPageToImage;
+	}
+});
 Object.defineProperty(exports, "renderStyledBarcode", {
 	enumerable: true,
 	get: function() {
@@ -29666,4 +31870,4 @@ Object.defineProperty(exports, "wrapText", {
 	}
 });
 
-//# sourceMappingURL=src-vNbsqoIy.cjs.map
+//# sourceMappingURL=src-DQ63jYIR.cjs.map