modern-pdf-lib 0.15.0 → 0.19.9

package/dist/compressionAnalysis-Bw2alOxt.mjs

@@ -0,0 +1,1490 @@
+import { i as PdfName, l as PdfStream, o as PdfNumber, r as PdfDict } from "./pdfObjects-uEsWlfzU.mjs";
+import { a as isJpegWasmReady, r as encodeJpegWasm } from "./bridge-DTH5LMAK.mjs";
+import { n as extractImages, t as decodeImageStream } from "./imageExtract-B6OvUEp-.mjs";
+import { n as isGrayscaleImage } from "./grayscaleDetect-C6kFF3dk.mjs";
+
+//#region src/parser/textExtractor.ts
+/**
+* @module parser/textExtractor
+*
+* Extract text content from parsed PDF content streams.  Supports both
+* simple text extraction (concatenated strings) and position-aware
+* extraction that tracks the text matrix to compute x/y coordinates.
+*
+* Handles:
+* - All PDF text-showing operators: `Tj`, `TJ`, `'`, `"`
+* - Text-positioning operators: `Td`, `TD`, `Tm`, `T*`
+* - Font selection: `Tf`
+* - Graphics state: `q`/`Q`, `cm`
+* - WinAnsiEncoding (standard single-byte)
+* - Identity-H CID fonts with ToUnicode CMap
+*
+* Reference: PDF 1.7 spec, §9 (Text).
+*
+* @packageDocumentation
+*/
+/**
+* Extract plain text from a sequence of parsed content-stream operators.
+*
+* This function concatenates all text-showing operator strings, inserting
+* spaces between text objects (BT/ET blocks) and newlines at line breaks
+* (`T*`, `Td`, `TD`).
+*
+* @param operators - Parsed content-stream operators.
+* @param resources - Optional page `/Resources` dictionary (used to look
+*                    up font encodings and ToUnicode CMaps).
+* @param options   - Extraction options.
+* @returns The extracted text as a single string.
+*/
+function extractText(operators, resources, options) {
+	if (options?.withPositions) return extractTextWithPositions(operators, resources).map((item) => item.text).join(" ");
+	const state = new TextState(resources);
+	const parts = [];
+	let lineHasContent = false;
+	for (const op of operators) switch (op.operator) {
+		case "BT":
+			state.resetTextMatrix();
+			if (parts.length > 0 && lineHasContent) parts.push(" ");
+			lineHasContent = false;
+			break;
+		case "ET": break;
+		case "Tf":
+			state.setFont(operandAsString(op.operands[0]), operandAsNumber(op.operands[1]));
+			break;
+		case "Tc":
+			state.charSpacing = operandAsNumber(op.operands[0]);
+			break;
+		case "Tw":
+			state.wordSpacing = operandAsNumber(op.operands[0]);
+			break;
+		case "TL":
+			state.leading = operandAsNumber(op.operands[0]);
+			break;
+		case "Tz":
+			state.horizontalScaling = operandAsNumber(op.operands[0]);
+			break;
+		case "Ts":
+			state.rise = operandAsNumber(op.operands[0]);
+			break;
+		case "Td": {
+			const tx = operandAsNumber(op.operands[0]);
+			const ty = operandAsNumber(op.operands[1]);
+			state.moveText(tx, ty);
+			if (Math.abs(ty) > .5 && lineHasContent) {
+				parts.push("\n");
+				lineHasContent = false;
+			} else if (Math.abs(tx) > state.fontSize * .3 && lineHasContent) parts.push(" ");
+			break;
+		}
+		case "TD": {
+			const tx = operandAsNumber(op.operands[0]);
+			const ty = operandAsNumber(op.operands[1]);
+			state.leading = -ty;
+			state.moveText(tx, ty);
+			if (Math.abs(ty) > .5 && lineHasContent) {
+				parts.push("\n");
+				lineHasContent = false;
+			}
+			break;
+		}
+		case "Tm":
+			state.setTextMatrix(operandAsNumber(op.operands[0]), operandAsNumber(op.operands[1]), operandAsNumber(op.operands[2]), operandAsNumber(op.operands[3]), operandAsNumber(op.operands[4]), operandAsNumber(op.operands[5]));
+			break;
+		case "T*":
+			state.nextLine();
+			if (lineHasContent) {
+				parts.push("\n");
+				lineHasContent = false;
+			}
+			break;
+		case "Tj": {
+			const text = state.decodeString(op.operands[0]);
+			if (text.length > 0) {
+				parts.push(text);
+				lineHasContent = true;
+			}
+			break;
+		}
+		case "TJ": {
+			const text = state.decodeTJArray(op.operands[0]);
+			if (text.length > 0) {
+				parts.push(text);
+				lineHasContent = true;
+			}
+			break;
+		}
+		case "'": {
+			state.nextLine();
+			if (lineHasContent) {
+				parts.push("\n");
+				lineHasContent = false;
+			}
+			const text = state.decodeString(op.operands[0]);
+			if (text.length > 0) {
+				parts.push(text);
+				lineHasContent = true;
+			}
+			break;
+		}
+		case "\"": {
+			state.wordSpacing = operandAsNumber(op.operands[0]);
+			state.charSpacing = operandAsNumber(op.operands[1]);
+			state.nextLine();
+			if (lineHasContent) {
+				parts.push("\n");
+				lineHasContent = false;
+			}
+			const text = state.decodeString(op.operands[2]);
+			if (text.length > 0) {
+				parts.push(text);
+				lineHasContent = true;
+			}
+			break;
+		}
+		case "q":
+			state.save();
+			break;
+		case "Q":
+			state.restore();
+			break;
+		case "cm":
+			state.concatCTM(operandAsNumber(op.operands[0]), operandAsNumber(op.operands[1]), operandAsNumber(op.operands[2]), operandAsNumber(op.operands[3]), operandAsNumber(op.operands[4]), operandAsNumber(op.operands[5]));
+			break;
+		default: break;
+	}
+	return parts.join("");
+}
+/**
+* Extract text with position information from a parsed content stream.
+*
+* Each returned {@link TextItem} includes the text string, its position
+* (x, y), dimensions (width, height), font size, and font name.
+*
+* @param operators - Parsed content-stream operators.
+* @param resources - Optional page `/Resources` dictionary.
+* @returns An array of positioned text items.
+*/
+function extractTextWithPositions(operators, resources) {
+	const state = new TextState(resources);
+	const items = [];
+	for (const op of operators) switch (op.operator) {
+		case "BT":
+			state.resetTextMatrix();
+			break;
+		case "ET": break;
+		case "Tf":
+			state.setFont(operandAsString(op.operands[0]), operandAsNumber(op.operands[1]));
+			break;
+		case "Tc":
+			state.charSpacing = operandAsNumber(op.operands[0]);
+			break;
+		case "Tw":
+			state.wordSpacing = operandAsNumber(op.operands[0]);
+			break;
+		case "TL":
+			state.leading = operandAsNumber(op.operands[0]);
+			break;
+		case "Tz":
+			state.horizontalScaling = operandAsNumber(op.operands[0]);
+			break;
+		case "Ts":
+			state.rise = operandAsNumber(op.operands[0]);
+			break;
+		case "Td":
+			state.moveText(operandAsNumber(op.operands[0]), operandAsNumber(op.operands[1]));
+			break;
+		case "TD": {
+			const tx = operandAsNumber(op.operands[0]);
+			const ty = operandAsNumber(op.operands[1]);
+			state.leading = -ty;
+			state.moveText(tx, ty);
+			break;
+		}
+		case "Tm":
+			state.setTextMatrix(operandAsNumber(op.operands[0]), operandAsNumber(op.operands[1]), operandAsNumber(op.operands[2]), operandAsNumber(op.operands[3]), operandAsNumber(op.operands[4]), operandAsNumber(op.operands[5]));
+			break;
+		case "T*":
+			state.nextLine();
+			break;
+		case "Tj": {
+			const text = state.decodeString(op.operands[0]);
+			if (text.length > 0) {
+				const pos = state.getTextPosition();
+				items.push({
+					text,
+					x: pos.x,
+					y: pos.y,
+					width: state.estimateWidth(text),
+					height: state.fontSize,
+					fontSize: state.fontSize,
+					fontName: state.fontName
+				});
+				state.advanceByText(text);
+			}
+			break;
+		}
+		case "TJ": {
+			const operand = op.operands[0];
+			if (Array.isArray(operand)) for (const elem of operand) if (typeof elem === "number") state.advanceByDisplacement(-elem);
+			else {
+				const text = state.decodeString(elem);
+				if (text.length > 0) {
+					const pos = state.getTextPosition();
+					items.push({
+						text,
+						x: pos.x,
+						y: pos.y,
+						width: state.estimateWidth(text),
+						height: state.fontSize,
+						fontSize: state.fontSize,
+						fontName: state.fontName
+					});
+					state.advanceByText(text);
+				}
+			}
+			break;
+		}
+		case "'":
+			state.nextLine();
+			{
+				const text = state.decodeString(op.operands[0]);
+				if (text.length > 0) {
+					const pos = state.getTextPosition();
+					items.push({
+						text,
+						x: pos.x,
+						y: pos.y,
+						width: state.estimateWidth(text),
+						height: state.fontSize,
+						fontSize: state.fontSize,
+						fontName: state.fontName
+					});
+					state.advanceByText(text);
+				}
+			}
+			break;
+		case "\"":
+			state.wordSpacing = operandAsNumber(op.operands[0]);
+			state.charSpacing = operandAsNumber(op.operands[1]);
+			state.nextLine();
+			{
+				const text = state.decodeString(op.operands[2]);
+				if (text.length > 0) {
+					const pos = state.getTextPosition();
+					items.push({
+						text,
+						x: pos.x,
+						y: pos.y,
+						width: state.estimateWidth(text),
+						height: state.fontSize,
+						fontSize: state.fontSize,
+						fontName: state.fontName
+					});
+					state.advanceByText(text);
+				}
+			}
+			break;
+		case "q":
+			state.save();
+			break;
+		case "Q":
+			state.restore();
+			break;
+		case "cm":
+			state.concatCTM(operandAsNumber(op.operands[0]), operandAsNumber(op.operands[1]), operandAsNumber(op.operands[2]), operandAsNumber(op.operands[3]), operandAsNumber(op.operands[4]), operandAsNumber(op.operands[5]));
+			break;
+		default: break;
+	}
+	return items;
+}
+/**
+* Parse a ToUnicode CMap stream into a lookup map.
+*
+* Handles the two standard mapping constructs:
+* - `beginbfchar` / `endbfchar` — single code-to-Unicode mappings
+* - `beginbfrange` / `endbfrange` — range-based mappings
+*
+* @param data - The raw CMap stream bytes (already decompressed).
+* @returns A parsed CMap.
+*/
+function parseToUnicodeCMap(data) {
+	const text = decodeText(data);
+	const map = /* @__PURE__ */ new Map();
+	parseBfCharSections(text, map);
+	parseBfRangeSections(text, map);
+	return { map };
+}
+/**
+* Parse all `beginbfchar`/`endbfchar` sections in a CMap.
+*/
+function parseBfCharSections(text, map) {
+	const regex = /beginbfchar\s*([\s\S]*?)\s*endbfchar/g;
+	let match;
+	while ((match = regex.exec(text)) !== null) {
+		const body = match[1];
+		const lineRegex = /<([0-9a-fA-F]+)>\s*<([0-9a-fA-F]+)>/g;
+		let lineMatch;
+		while ((lineMatch = lineRegex.exec(body)) !== null) {
+			const srcCode = parseInt(lineMatch[1], 16);
+			const dstString = hexToUnicode(lineMatch[2]);
+			map.set(srcCode, dstString);
+		}
+	}
+}
+/**
+* Parse all `beginbfrange`/`endbfrange` sections in a CMap.
+*/
+function parseBfRangeSections(text, map) {
+	const regex = /beginbfrange\s*([\s\S]*?)\s*endbfrange/g;
+	let match;
+	while ((match = regex.exec(text)) !== null) {
+		const body = match[1];
+		const lineRegex = /<([0-9a-fA-F]+)>\s*<([0-9a-fA-F]+)>\s*(?:<([0-9a-fA-F]+)>|\[([\s\S]*?)\])/g;
+		let lineMatch;
+		while ((lineMatch = lineRegex.exec(body)) !== null) {
+			const srcLow = parseInt(lineMatch[1], 16);
+			const srcHigh = parseInt(lineMatch[2], 16);
+			if (lineMatch[3]) {
+				let dstCode = parseInt(lineMatch[3], 16);
+				for (let code = srcLow; code <= srcHigh; code++) {
+					map.set(code, codePointToString(dstCode));
+					dstCode++;
+				}
+			} else if (lineMatch[4]) {
+				const arrRegex = /<([0-9a-fA-F]+)>/g;
+				let arrMatch;
+				let code = srcLow;
+				while ((arrMatch = arrRegex.exec(lineMatch[4])) !== null && code <= srcHigh) {
+					map.set(code, hexToUnicode(arrMatch[1]));
+					code++;
+				}
+			}
+		}
+	}
+}
+/**
+* Convert a hex string (2 or 4 hex chars per code point) to a Unicode
+* string.
+*/
+function hexToUnicode(hex) {
+	const parts = [];
+	const step = hex.length <= 4 ? hex.length : 4;
+	for (let i = 0; i < hex.length; i += step) {
+		const chunk = hex.slice(i, i + step);
+		const code = parseInt(chunk, 16);
+		if (!isNaN(code)) parts.push(String.fromCodePoint(code));
+	}
+	return parts.join("");
+}
+/**
+* Convert a numeric code point to a string.
+*/
+function codePointToString(code) {
+	return String.fromCodePoint(code);
+}
+/**
+* WinAnsiEncoding table for bytes 0x80-0x9F that differ from Latin-1.
+* Bytes 0x00-0x7F and 0xA0-0xFF map directly to their Unicode code points.
+*/
+const WIN_ANSI_SPECIAL = {
+	128: 8364,
+	130: 8218,
+	131: 402,
+	132: 8222,
+	133: 8230,
+	134: 8224,
+	135: 8225,
+	136: 710,
+	137: 8240,
+	138: 352,
+	139: 8249,
+	140: 338,
+	142: 381,
+	145: 8216,
+	146: 8217,
+	147: 8220,
+	148: 8221,
+	149: 8226,
+	150: 8211,
+	151: 8212,
+	152: 732,
+	153: 8482,
+	154: 353,
+	155: 8250,
+	156: 339,
+	158: 382,
+	159: 376
+};
+/**
+* Decode a single byte using WinAnsiEncoding.
+*/
+function winAnsiDecode(byte) {
+	if (Object.hasOwn(WIN_ANSI_SPECIAL, byte)) return String.fromCodePoint(WIN_ANSI_SPECIAL[byte]);
+	return String.fromCharCode(byte);
+}
+/** Identity matrix. */
+function identityMatrix() {
+	return [
+		1,
+		0,
+		0,
+		1,
+		0,
+		0
+	];
+}
+/**
+* Multiply two 3x3 matrices (stored as 6-element arrays).
+* Result = A * B
+*/
+function multiplyMatrices(a, b) {
+	return [
+		a[0] * b[0] + a[1] * b[2],
+		a[0] * b[1] + a[1] * b[3],
+		a[2] * b[0] + a[3] * b[2],
+		a[2] * b[1] + a[3] * b[3],
+		a[4] * b[0] + a[5] * b[2] + b[4],
+		a[4] * b[1] + a[5] * b[3] + b[5]
+	];
+}
+/**
+* Tracks the graphics/text state needed for text extraction.
+*/
+var TextState = class {
+	/** Current transformation matrix (CTM). */
+	ctm = identityMatrix();
+	/** Text matrix — set by Tm, updated by Td/TD/T*. */
+	textMatrix = identityMatrix();
+	/** Text line matrix — the matrix at the start of the current line. */
+	textLineMatrix = identityMatrix();
+	/** Current font resource name. */
+	fontName = "";
+	/** Current font size. */
+	fontSize = 12;
+	/** Character spacing (Tc). */
+	charSpacing = 0;
+	/** Word spacing (Tw). */
+	wordSpacing = 0;
+	/** Horizontal scaling (Tz) as a percentage (100 = normal). */
+	horizontalScaling = 100;
+	/** Text leading (TL). */
+	leading = 0;
+	/** Text rise (Ts). */
+	rise = 0;
+	/** Graphics state stack for q/Q. */
+	stateStack = [];
+	/** Page resources dictionary. */
+	resources;
+	/** Cache of parsed ToUnicode CMaps per font name. */
+	cmapCache = /* @__PURE__ */ new Map();
+	/** Cache of font encoding type per font name. */
+	fontEncodingCache = /* @__PURE__ */ new Map();
+	/** Cache of whether a font is a CID (2-byte) font. */
+	cidFontCache = /* @__PURE__ */ new Map();
+	constructor(resources) {
+		this.resources = resources;
+		if (resources) this.analyzeFonts(resources);
+	}
+	/**
+	* Pre-analyze fonts from the resources dictionary to determine encoding
+	* types and cache ToUnicode CMaps.
+	*/
+	analyzeFonts(resources) {
+		const fonts = resources.get("/Font");
+		if (!(fonts instanceof PdfDict)) return;
+		for (const [name, fontObj] of fonts) {
+			if (!(fontObj instanceof PdfDict)) continue;
+			const subtype = fontObj.get("/Subtype");
+			const isCid = subtype instanceof PdfName && (subtype.value === "/Type0" || subtype.value === "/CIDFontType0" || subtype.value === "/CIDFontType2");
+			this.cidFontCache.set(name, isCid);
+			const encoding = fontObj.get("/Encoding");
+			if (encoding instanceof PdfName) this.fontEncodingCache.set(name, encoding.value.replace(/^\//, ""));
+			const toUnicode = fontObj.get("/ToUnicode");
+			if (toUnicode instanceof PdfStream) try {
+				const cmap = parseToUnicodeCMap(toUnicode.data);
+				this.cmapCache.set(name, cmap);
+			} catch {
+				this.cmapCache.set(name, null);
+			}
+		}
+	}
+	/**
+	* Save the current graphics state (q).
+	*/
+	save() {
+		this.stateStack.push({
+			ctm: [...this.ctm],
+			fontName: this.fontName,
+			fontSize: this.fontSize,
+			charSpacing: this.charSpacing,
+			wordSpacing: this.wordSpacing,
+			horizontalScaling: this.horizontalScaling,
+			leading: this.leading,
+			rise: this.rise
+		});
+	}
+	/**
+	* Restore the previously saved graphics state (Q).
+	*/
+	restore() {
+		const saved = this.stateStack.pop();
+		if (saved) {
+			this.ctm = saved.ctm;
+			this.fontName = saved.fontName;
+			this.fontSize = saved.fontSize;
+			this.charSpacing = saved.charSpacing;
+			this.wordSpacing = saved.wordSpacing;
+			this.horizontalScaling = saved.horizontalScaling;
+			this.leading = saved.leading;
+			this.rise = saved.rise;
+		}
+	}
+	/**
+	* Concatenate a matrix with the CTM (cm).
+	*/
+	concatCTM(a, b, c, d, e, f) {
+		this.ctm = multiplyMatrices([
+			a,
+			b,
+			c,
+			d,
+			e,
+			f
+		], this.ctm);
+	}
+	/**
+	* Reset the text matrix to identity (called at BT).
+	*/
+	resetTextMatrix() {
+		this.textMatrix = identityMatrix();
+		this.textLineMatrix = identityMatrix();
+	}
+	/**
+	* Set the font and size (Tf).
+	*/
+	setFont(name, size) {
+		this.fontName = name.startsWith("/") ? name : `/${name}`;
+		this.fontSize = size;
+	}
+	/**
+	* Move text position (Td).
+	*/
+	moveText(tx, ty) {
+		this.textLineMatrix = multiplyMatrices([
+			1,
+			0,
+			0,
+			1,
+			tx,
+			ty
+		], this.textLineMatrix);
+		this.textMatrix = [...this.textLineMatrix];
+	}
+	/**
+	* Set the text matrix directly (Tm).
+	*/
+	setTextMatrix(a, b, c, d, e, f) {
+		this.textMatrix = [
+			a,
+			b,
+			c,
+			d,
+			e,
+			f
+		];
+		this.textLineMatrix = [
+			a,
+			b,
+			c,
+			d,
+			e,
+			f
+		];
+	}
+	/**
+	* Move to the start of the next line (T*).
+	* Equivalent to: 0 -TL Td
+	*/
+	nextLine() {
+		this.moveText(0, -this.leading);
+	}
+	/**
+	* Get the current text position in user-space coordinates.
+	*/
+	getTextPosition() {
+		const combined = multiplyMatrices(this.textMatrix, this.ctm);
+		return {
+			x: combined[4],
+			y: combined[5]
+		};
+	}
+	/**
+	* Estimate the width of a text string in user-space units.
+	*
+	* Uses a rough heuristic: 0.5 * fontSize per character for standard
+	* fonts.  A production implementation would use font metrics.
+	*/
+	estimateWidth(text) {
+		const avgCharWidth = .5;
+		const hScale = this.horizontalScaling / 100;
+		return text.length * this.fontSize * avgCharWidth * hScale;
+	}
+	/**
+	* Advance the text matrix by the width of the given text.
+	*/
+	advanceByText(text) {
+		this.textMatrix = multiplyMatrices([
+			1,
+			0,
+			0,
+			1,
+			this.estimateWidth(text),
+			0
+		], this.textMatrix);
+	}
+	/**
+	* Advance the text matrix by a TJ displacement value.
+	*
+	* The displacement is in thousandths of a unit of text space.
+	*/
+	advanceByDisplacement(displacement) {
+		this.textMatrix = multiplyMatrices([
+			1,
+			0,
+			0,
+			1,
+			displacement / 1e3 * this.fontSize * (this.horizontalScaling / 100),
+			0
+		], this.textMatrix);
+	}
+	/**
+	* Decode an operand (string or hex string) into a readable text string.
+	*
+	* Uses the current font's ToUnicode CMap if available, otherwise falls
+	* back to WinAnsiEncoding or direct code-point mapping.
+	*/
+	decodeString(operand) {
+		if (operand == null) return "";
+		if (typeof operand === "number") return "";
+		const raw = typeof operand === "string" ? operand : String(operand);
+		const cmap = this.cmapCache.get(this.fontName);
+		const isCid = this.cidFontCache.get(this.fontName) ?? false;
+		if (cmap) return this.decodeWithCMap(raw, cmap, isCid);
+		if (isCid) return this.decodeCIDString(raw);
+		return this.decodeWinAnsi(raw);
+	}
+	/**
+	* Decode a TJ array operand (array of strings + numbers).
+	*/
+	decodeTJArray(operand) {
+		if (!Array.isArray(operand)) return this.decodeString(operand);
+		const parts = [];
+		for (const elem of operand) if (typeof elem === "number") {
+			if (elem <= -100) parts.push(" ");
+		} else {
+			const decoded = this.decodeString(elem);
+			if (decoded.length > 0) parts.push(decoded);
+		}
+		return parts.join("");
+	}
+	/**
+	* Decode a string using a ToUnicode CMap.
+	*/
+	decodeWithCMap(raw, cmap, isCid) {
+		let result = "";
+		if (isCid) for (let i = 0; i + 1 < raw.length; i += 2) {
+			const code = raw.charCodeAt(i) << 8 | raw.charCodeAt(i + 1);
+			const mapped = cmap.map.get(code);
+			if (mapped !== void 0) result += mapped;
+			else if (code >= 32 && code <= 65535) result += String.fromCharCode(code);
+		}
+		else for (let i = 0; i < raw.length; i++) {
+			const code = raw.charCodeAt(i);
+			const mapped = cmap.map.get(code);
+			if (mapped !== void 0) result += mapped;
+			else result += winAnsiDecode(code);
+		}
+		return result;
+	}
+	/**
+	* Decode a CID (Identity-H) encoded string without a ToUnicode CMap.
+	*/
+	decodeCIDString(raw) {
+		let result = "";
+		for (let i = 0; i + 1 < raw.length; i += 2) {
+			const code = raw.charCodeAt(i) << 8 | raw.charCodeAt(i + 1);
+			if (code >= 32 && code <= 65535) result += String.fromCharCode(code);
+		}
+		return result;
+	}
+	/**
+	* Decode a string using WinAnsiEncoding.
+	*/
+	decodeWinAnsi(raw) {
+		let result = "";
+		for (let i = 0; i < raw.length; i++) {
+			const code = raw.charCodeAt(i);
+			result += winAnsiDecode(code);
+		}
+		return result;
+	}
+};
+/**
+* Extract a numeric value from an operand, defaulting to 0.
+*/
+function operandAsNumber(operand) {
+	if (typeof operand === "number") return operand;
+	if (operand instanceof PdfNumber) return operand.value;
+	if (typeof operand === "string") {
+		const n = parseFloat(operand);
+		return isNaN(n) ? 0 : n;
+	}
+	return 0;
+}
+/**
+* Extract a string value from an operand.
+*/
+function operandAsString(operand) {
+	if (typeof operand === "string") return operand;
+	if (operand instanceof PdfName) return operand.value;
+	if (typeof operand === "number") return String(operand);
+	return "";
+}
+/**
+* Decode raw bytes to a string (ASCII/Latin-1 — sufficient for CMap
+* parsing which is ASCII-based).
+*/
+function decodeText(data) {
+	return new TextDecoder("latin1").decode(data);
+}
+
+//#endregion
+//#region src/parser/contentStreamParser.ts
+/**
+* @module parser/contentStreamParser
+*
+* Parse PDF content streams (the operator/operand sequences that describe
+* page appearance) into a structured AST.
+*
+* A PDF content stream consists of a flat sequence of *operands* followed
+* by an *operator*.  Operands are PDF objects (numbers, strings, names,
+* booleans, arrays, `null`); operators are unquoted letter sequences.
+*
+* Special handling is required for inline images (`BI … ID data EI`).
+*
+* Reference: PDF 1.7 spec, §7.8.2 (Content Streams).
+*
+* @packageDocumentation
+*/
+/**
+* Parse a PDF content stream into an ordered list of operators.
+*
+* @param data - The raw content-stream bytes (already decompressed).
+* @returns An array of operators in document order.
+*/
+function parseContentStream(data) {
+	return new ContentStreamLexer(data).parse();
+}
+var TokenType = /* @__PURE__ */ function(TokenType) {
+	TokenType[TokenType["Number"] = 0] = "Number";
+	TokenType[TokenType["String"] = 1] = "String";
+	TokenType[TokenType["HexString"] = 2] = "HexString";
+	TokenType[TokenType["Name"] = 3] = "Name";
+	TokenType[TokenType["Bool"] = 4] = "Bool";
+	TokenType[TokenType["Null"] = 5] = "Null";
+	TokenType[TokenType["ArrayStart"] = 6] = "ArrayStart";
+	TokenType[TokenType["ArrayEnd"] = 7] = "ArrayEnd";
+	TokenType[TokenType["Operator"] = 8] = "Operator";
+	TokenType[TokenType["InlineImage"] = 9] = "InlineImage";
+	TokenType[TokenType["EOF"] = 10] = "EOF";
+	return TokenType;
+}(TokenType || {});
+/**
+* `hexVal[b]` is the numeric value (0-15) of a hex character, or -1 if
+* the byte is not a valid hex digit.
+*/
+const hexVal = /* @__PURE__ */ (() => {
+	const t = new Int8Array(256).fill(-1);
+	for (let i = 0; i <= 9; i++) t[48 + i] = i;
+	for (let i = 0; i < 6; i++) {
+		t[65 + i] = 10 + i;
+		t[97 + i] = 10 + i;
+	}
+	return t;
+})();
+/**
+* Combined lexer + parser for PDF content streams.
+*
+* Content streams are simpler than full PDF object syntax — there are no
+* dictionaries (except inside inline images), no indirect references, and
+* no comments outside of string literals.
+*/
+var ContentStreamLexer = class {
+	data;
+	pos = 0;
+	constructor(data) {
+		this.data = data;
+	}
+	/**
+	* Parse the entire stream and return all operators.
+	*/
+	parse() {
+		const result = [];
+		const operandStack = [];
+		while (true) {
+			const token = this.nextToken();
+			if (token.type === TokenType.EOF) break;
+			switch (token.type) {
+				case TokenType.Number:
+				case TokenType.String:
+				case TokenType.HexString:
+				case TokenType.Bool:
+				case TokenType.Null:
+				case TokenType.Name:
+					operandStack.push(token.value);
+					break;
+				case TokenType.ArrayStart: {
+					const arr = this.parseArray();
+					operandStack.push(arr);
+					break;
+				}
+				case TokenType.ArrayEnd: break;
+				case TokenType.Operator: {
+					const op = token.value;
+					if (op === "BI") {
+						const inlineImg = this.parseInlineImage();
+						result.push({
+							operator: "BI",
+							operands: [inlineImg]
+						});
+					} else result.push({
+						operator: op,
+						operands: operandStack.splice(0, operandStack.length)
+					});
+					break;
+				}
+				case TokenType.InlineImage: break;
+			}
+		}
+		return result;
+	}
+	/**
+	* Parse a PDF array `[…]`.  Called after the `[` token has been consumed.
+	*/
+	parseArray() {
+		const items = [];
+		while (true) {
+			const token = this.nextToken();
+			if (token.type === TokenType.EOF) break;
+			if (token.type === TokenType.ArrayEnd) break;
+			switch (token.type) {
+				case TokenType.Number:
+				case TokenType.String:
+				case TokenType.HexString:
+				case TokenType.Bool:
+				case TokenType.Null:
+				case TokenType.Name:
+					items.push(token.value);
+					break;
+				case TokenType.ArrayStart:
+					items.push(this.parseArray());
+					break;
+				default: break;
+			}
+		}
+		return items;
+	}
+	/**
+	* Parse an inline image.
+	*
+	* After `BI` has been read, we expect key-value pairs (name + value)
+	* until `ID`, then raw binary data until we find `EI` preceded by
+	* whitespace.
+	*/
+	parseInlineImage() {
+		const dict = {};
+		while (true) {
+			this.skipWhitespace();
+			if (this.pos >= this.data.length) break;
+			if (this.peekKeyword("ID")) {
+				this.pos += 2;
+				break;
+			}
+			const keyToken = this.nextToken();
+			if (keyToken.type === TokenType.Operator) {
+				const kw = keyToken.value;
+				if (kw === "ID") break;
+				dict[kw] = this.nextToken().value;
+				continue;
+			}
+			if (keyToken.type === TokenType.Name) {
+				const name = keyToken.value.value;
+				dict[name] = this.nextToken().value;
+			} else if (keyToken.type === TokenType.EOF) break;
+		}
+		if (this.pos < this.data.length) {
+			const ch = this.data[this.pos];
+			if (ch === 32 || ch === 10 || ch === 13 || ch === 9) {
+				this.pos++;
+				if (ch === 13 && this.pos < this.data.length && this.data[this.pos] === 10) this.pos++;
+			}
+		}
+		const dataStart = this.pos;
+		let dataEnd = this.pos;
+		let searchFrom = this.pos;
+		while (searchFrom < this.data.length) {
+			const eIdx = this.data.indexOf(69, searchFrom);
+			if (eIdx === -1 || eIdx + 1 >= this.data.length) {
+				this.pos = this.data.length;
+				break;
+			}
+			if (eIdx > dataStart && this.isWhitespace(this.data[eIdx - 1]) && this.data[eIdx + 1] === 73) {
+				const afterEI = eIdx + 2;
+				if (afterEI >= this.data.length || this.isWhitespace(this.data[afterEI])) {
+					dataEnd = eIdx - 1;
+					this.pos = afterEI;
+					break;
+				}
+			}
+			searchFrom = eIdx + 1;
+		}
+		return {
+			dict,
+			data: this.data.slice(dataStart, dataEnd)
+		};
+	}
+	/**
+	* Peek ahead to see if the next characters form a given keyword
+	* followed by whitespace.
+	*/
+	peekKeyword(keyword) {
+		for (let i = 0; i < keyword.length; i++) {
+			if (this.pos + i >= this.data.length) return false;
+			if (this.data[this.pos + i] !== keyword.charCodeAt(i)) return false;
+		}
+		const afterPos = this.pos + keyword.length;
+		if (afterPos >= this.data.length) return true;
+		const after = this.data[afterPos];
+		return this.isWhitespace(after) || this.isDelimiter(after);
+	}
+	/**
+	* Read and return the next token from the stream.
+	*/
+	nextToken() {
+		this.skipWhitespaceAndComments();
+		if (this.pos >= this.data.length) return {
+			type: TokenType.EOF,
+			value: null
+		};
+		const ch = this.data[this.pos];
+		if (ch === 40) return this.readLiteralString();
+		if (ch === 60) {
+			if (this.pos + 1 < this.data.length && this.data[this.pos + 1] === 60) {
+				this.pos += 2;
+				return this.nextToken();
+			}
+			return this.readHexString();
+		}
+		if (ch === 62 && this.pos + 1 < this.data.length && this.data[this.pos + 1] === 62) {
+			this.pos += 2;
+			return this.nextToken();
+		}
+		if (ch === 91) {
+			this.pos++;
+			return {
+				type: TokenType.ArrayStart,
+				value: null
+			};
+		}
+		if (ch === 93) {
+			this.pos++;
+			return {
+				type: TokenType.ArrayEnd,
+				value: null
+			};
+		}
+		if (ch === 47) return this.readName();
+		if (this.isNumberStart(ch)) return this.readNumber();
+		if (this.isRegularChar(ch)) return this.readKeyword();
+		this.pos++;
+		return this.nextToken();
+	}
+	/**
+	* Read a literal string `(…)`, handling nested parentheses and escapes.
+	*/
+	readLiteralString() {
+		this.pos++;
+		const parts = [];
+		let depth = 1;
+		while (this.pos < this.data.length && depth > 0) {
+			const ch = this.data[this.pos];
+			if (ch === 92) {
+				this.pos++;
+				if (this.pos >= this.data.length) break;
+				const esc = this.data[this.pos];
+				switch (esc) {
+					case 110:
+						parts.push("\n");
+						this.pos++;
+						break;
+					case 114:
+						parts.push("\r");
+						this.pos++;
+						break;
+					case 116:
+						parts.push("	");
+						this.pos++;
+						break;
+					case 98:
+						parts.push("\b");
+						this.pos++;
+						break;
+					case 102:
+						parts.push("\f");
+						this.pos++;
+						break;
+					case 40:
+						parts.push("(");
+						this.pos++;
+						break;
+					case 41:
+						parts.push(")");
+						this.pos++;
+						break;
+					case 92:
+						parts.push("\\");
+						this.pos++;
+						break;
+					case 10:
+						this.pos++;
+						break;
+					case 13:
+						this.pos++;
+						if (this.pos < this.data.length && this.data[this.pos] === 10) this.pos++;
+						break;
+					default:
+						if (esc >= 48 && esc <= 55) {
+							let octal = esc - 48;
+							this.pos++;
+							if (this.pos < this.data.length) {
+								const d2 = this.data[this.pos];
+								if (d2 >= 48 && d2 <= 55) {
+									octal = octal * 8 + (d2 - 48);
+									this.pos++;
+									if (this.pos < this.data.length) {
+										const d3 = this.data[this.pos];
+										if (d3 >= 48 && d3 <= 55) {
+											octal = octal * 8 + (d3 - 48);
+											this.pos++;
+										}
+									}
+								}
+							}
+							parts.push(String.fromCharCode(octal & 255));
+						} else {
+							parts.push(String.fromCharCode(esc));
+							this.pos++;
+						}
+						break;
+				}
+			} else if (ch === 40) {
+				depth++;
+				parts.push("(");
+				this.pos++;
+			} else if (ch === 41) {
+				depth--;
+				if (depth > 0) parts.push(")");
+				this.pos++;
+			} else {
+				parts.push(String.fromCharCode(ch));
+				this.pos++;
+			}
+		}
+		return {
+			type: TokenType.String,
+			value: parts.join("")
+		};
+	}
+	/**
+	* Read a hex string `<…>`.
+	*/
+	readHexString() {
+		this.pos++;
+		const bytes = [];
+		let hi = -1;
+		while (this.pos < this.data.length) {
+			const ch = this.data[this.pos];
+			if (ch === 62) {
+				this.pos++;
+				break;
+			}
+			if (this.isWhitespace(ch)) {
+				this.pos++;
+				continue;
+			}
+			const v = hexVal[ch];
+			if (v === -1) {
+				this.pos++;
+				continue;
+			}
+			if (hi === -1) hi = v;
+			else {
+				bytes.push(hi << 4 | v);
+				hi = -1;
+			}
+			this.pos++;
+		}
+		if (hi !== -1) bytes.push(hi << 4);
+		return {
+			type: TokenType.HexString,
+			value: String.fromCharCode.apply(null, bytes)
+		};
+	}
+	/**
+	* Read a PDF name `/…`.
+	*/
+	readName() {
+		this.pos++;
+		const parts = ["/"];
+		while (this.pos < this.data.length) {
+			const ch = this.data[this.pos];
+			if (this.isWhitespace(ch) || this.isDelimiter(ch)) break;
+			if (ch === 35 && this.pos + 2 < this.data.length) {
+				const hi = hexVal[this.data[this.pos + 1]];
+				const lo = hexVal[this.data[this.pos + 2]];
+				if (hi !== -1 && lo !== -1) {
+					parts.push(String.fromCharCode(hi << 4 | lo));
+					this.pos += 3;
+					continue;
+				}
+			}
+			parts.push(String.fromCharCode(ch));
+			this.pos++;
+		}
+		return {
+			type: TokenType.Name,
+			value: PdfName.of(parts.join(""))
+		};
+	}
+	/**
+	* Read a numeric value (integer or real).
+	*/
+	readNumber() {
+		const start = this.pos;
+		let hasDecimal = false;
+		if (this.data[this.pos] === 43 || this.data[this.pos] === 45) this.pos++;
+		while (this.pos < this.data.length) {
+			const ch = this.data[this.pos];
+			if (ch === 46) {
+				if (hasDecimal) break;
+				hasDecimal = true;
+				this.pos++;
+			} else if (ch >= 48 && ch <= 57) this.pos++;
+			else break;
+		}
+		const str = this.decodeAscii(start, this.pos);
+		const value = parseFloat(str);
+		return {
+			type: TokenType.Number,
+			value: isNaN(value) ? 0 : value
+		};
+	}
+	/**
+	* Read a keyword — an operator name or one of the special keywords
+	* `true`, `false`, `null`.
+	*/
+	readKeyword() {
+		const start = this.pos;
+		while (this.pos < this.data.length) {
+			const ch = this.data[this.pos];
+			if (this.isWhitespace(ch) || this.isDelimiter(ch)) break;
+			this.pos++;
+		}
+		const word = this.decodeAscii(start, this.pos);
+		if (word === "true") return {
+			type: TokenType.Bool,
+			value: true
+		};
+		if (word === "false") return {
+			type: TokenType.Bool,
+			value: false
+		};
+		if (word === "null") return {
+			type: TokenType.Null,
+			value: null
+		};
+		return {
+			type: TokenType.Operator,
+			value: word
+		};
+	}
+	/** PDF whitespace characters. */
+	isWhitespace(ch) {
+		return ch === 0 || ch === 9 || ch === 10 || ch === 12 || ch === 13 || ch === 32;
+	}
+	/** PDF delimiter characters. */
+	isDelimiter(ch) {
+		return ch === 40 || ch === 41 || ch === 60 || ch === 62 || ch === 91 || ch === 93 || ch === 123 || ch === 125 || ch === 47 || ch === 37;
+	}
+	/** Whether a character can begin a number. */
+	isNumberStart(ch) {
+		return ch >= 48 && ch <= 57 || ch === 43 || ch === 45 || ch === 46;
+	}
+	/** Whether a character is a regular (non-whitespace, non-delimiter) character. */
+	isRegularChar(ch) {
+		return !this.isWhitespace(ch) && !this.isDelimiter(ch);
+	}
+	/** Skip whitespace. */
+	skipWhitespace() {
+		while (this.pos < this.data.length && this.isWhitespace(this.data[this.pos])) this.pos++;
+	}
+	/** Skip whitespace and `%` comments. */
+	skipWhitespaceAndComments() {
+		while (this.pos < this.data.length) {
+			const ch = this.data[this.pos];
+			if (this.isWhitespace(ch)) this.pos++;
+			else if (ch === 37) {
+				this.pos++;
+				while (this.pos < this.data.length) {
+					const c = this.data[this.pos];
+					if (c === 10 || c === 13) break;
+					this.pos++;
+				}
+			} else break;
+		}
+	}
+	/**
+	* Decode a slice of the data as ASCII text.
+	*/
+	decodeAscii(start, end) {
+		return String.fromCharCode.apply(null, this.data.subarray(start, end));
+	}
+};
+
+//#endregion
+//#region src/assets/image/dpiAnalyze.ts
+/**
+* Compute the effective DPI of an image given its pixel dimensions
+* and display dimensions in points.
+*
+* PDF uses 72 points per inch, so:
+* ```
+* DPI = imagePixels / (displayPoints / 72)
+* ```
+*
+* @param imageWidth    - Image width in pixels.
+* @param imageHeight   - Image height in pixels.
+* @param displayWidth  - Display width in PDF points (1/72 inch).
+* @param displayHeight - Display height in PDF points (1/72 inch).
+* @returns DPI information.
+*
+* @example
+* ```ts
+* import { computeImageDpi } from 'modern-pdf-lib';
+*
+* // A 3000×2000 image displayed at 4.17×2.78 inches (300×200 points)
+* const dpi = computeImageDpi(3000, 2000, 300, 200);
+* console.log(dpi.effectiveDpi); // 720
+* ```
+*/
+function computeImageDpi(imageWidth, imageHeight, displayWidth, displayHeight) {
+	const xDpi = displayWidth > 0 ? imageWidth / displayWidth * 72 : Infinity;
+	const yDpi = displayHeight > 0 ? imageHeight / displayHeight * 72 : Infinity;
+	return {
+		xDpi,
+		yDpi,
+		effectiveDpi: Math.min(xDpi, yDpi)
+	};
+}
+/**
+* Compute the target pixel dimensions for downscaling an image
+* to a maximum DPI at a given display size.
+*
+* @param imageWidth    - Current image width in pixels.
+* @param imageHeight   - Current image height in pixels.
+* @param displayWidth  - Display width in PDF points.
+* @param displayHeight - Display height in PDF points.
+* @param maxDpi        - Maximum allowed DPI.
+* @returns Target dimensions, or the original dimensions if no
+*          downscaling is needed.
+*/
+function computeTargetDimensions(imageWidth, imageHeight, displayWidth, displayHeight, maxDpi) {
+	const dpi = computeImageDpi(imageWidth, imageHeight, displayWidth, displayHeight);
+	if (dpi.effectiveDpi <= maxDpi || !isFinite(dpi.effectiveDpi)) return {
+		width: imageWidth,
+		height: imageHeight,
+		downscaled: false
+	};
+	const scale = maxDpi / dpi.effectiveDpi;
+	return {
+		width: Math.max(1, Math.round(imageWidth * scale)),
+		height: Math.max(1, Math.round(imageHeight * scale)),
+		downscaled: true
+	};
+}
+
+//#endregion
+//#region src/assets/image/compressionAnalysis.ts
+/**
+* Determine the human-readable format name from filter names.
+* @internal
+*/
+function formatFromFilters(filters) {
+	if (filters.length === 0) return "Raw";
+	for (const f of filters) {
+		if (f === "DCTDecode") return "JPEG";
+		if (f === "JPXDecode") return "JPEG2000";
+		if (f === "CCITTFaxDecode") return "CCITT";
+		if (f === "JBIG2Decode") return "JBIG2";
+		if (f === "FlateDecode") return "FlateDecode";
+		if (f === "LZWDecode") return "LZW";
+		if (f === "RunLengthDecode") return "RunLength";
+		if (f === "ASCIIHexDecode") return "ASCIIHex";
+		if (f === "ASCII85Decode") return "ASCII85";
+	}
+	return filters[0] ?? "Unknown";
+}
+/**
+* Estimate JPEG size using a heuristic when WASM is not available.
+*
+* At quality 80, JPEG is typically 10–15% of raw pixel data size for
+* photographic content.  We use 12.5% as a reasonable middle estimate
+* and scale linearly with quality.
+*
+* @internal
+*/
+function estimateJpegSizeHeuristic(width, height, channels, quality) {
+	const rawSize = width * height * channels;
+	const baseRatio = .125;
+	const qualityFactor = quality / 80;
+	const estimated = Math.round(rawSize * baseRatio * qualityFactor);
+	return Math.max(200, estimated);
+}
+/**
+* Determine the recommendation for an image.
+* @internal
+*/
+function determineRecommendation(savingsPercent, isGrayscale, colorSpace, effectiveDpi, maxDpi) {
+	if (isGrayscale && colorSpace !== "DeviceGray" && colorSpace !== "CalGray") return "grayscale";
+	if (effectiveDpi !== void 0 && isFinite(effectiveDpi) && effectiveDpi > maxDpi) return "downscale";
+	if (savingsPercent > 10) return "recompress";
+	return "keep";
+}
+/**
+* Analyze all images in a PDF and report potential savings without
+* modifying the document.
+*
+* For each image XObject with `bitsPerComponent === 8` and 1–4 channels,
+* the function estimates the JPEG-encoded size — using the WASM encoder
+* when available, or a heuristic fallback otherwise.
+*
+* @param doc     - A parsed `PdfDocument`.
+* @param options - Optional quality and maxDpi settings.
+* @returns An `AnalysisReport` with per-image and aggregate statistics.
+*
+* @example
+* ```ts
+* import { loadPdf, analyzeImages } from 'modern-pdf-lib';
+*
+* const doc = await loadPdf(pdfBytes);
+* const report = analyzeImages(doc, { quality: 75, maxDpi: 150 });
+*
+* console.log(`Total savings: ${report.totalSavingsPercent.toFixed(1)}%`);
+* for (const img of report.images) {
+*   console.log(`  ${img.name}: ${img.recommendation} (${img.savingsPercent.toFixed(1)}%)`);
+* }
+* ```
+*/
+function analyzeImages(doc, options) {
+	const quality = options?.quality ?? 80;
+	const maxDpi = options?.maxDpi ?? 150;
+	const allImages = extractImages(doc);
+	const analyses = [];
+	const wasmReady = isJpegWasmReady();
+	for (const info of allImages) {
+		const currentSize = info.compressedSize;
+		const currentFormat = formatFromFilters(info.filters);
+		if (info.bitsPerComponent !== 8 || info.channels < 1 || info.channels > 4) {
+			analyses.push({
+				name: info.name,
+				pageIndex: info.pageIndex,
+				width: info.width,
+				height: info.height,
+				currentSize,
+				currentFormat,
+				colorSpace: info.colorSpace,
+				estimatedJpegSize: currentSize,
+				estimatedSavings: 0,
+				savingsPercent: 0,
+				isGrayscale: false,
+				effectiveDpi: void 0,
+				recommendation: "keep"
+			});
+			continue;
+		}
+		let pixels;
+		try {
+			pixels = decodeImageStream(info);
+		} catch {
+			analyses.push({
+				name: info.name,
+				pageIndex: info.pageIndex,
+				width: info.width,
+				height: info.height,
+				currentSize,
+				currentFormat,
+				colorSpace: info.colorSpace,
+				estimatedJpegSize: currentSize,
+				estimatedSavings: 0,
+				savingsPercent: 0,
+				isGrayscale: false,
+				effectiveDpi: void 0,
+				recommendation: "keep"
+			});
+			continue;
+		}
+		let grayscale = false;
+		if ((info.channels === 3 || info.channels === 4) && pixels.length >= info.width * info.height * info.channels) grayscale = isGrayscaleImage(pixels, info.width, info.height, info.channels);
+		else if (info.channels === 1) grayscale = true;
+		let estimatedJpegSize;
+		if (wasmReady && pixels.length >= info.width * info.height * info.channels) {
+			const channels = info.channels <= 4 ? info.channels : 3;
+			const encoded = encodeJpegWasm(pixels, info.width, info.height, channels, quality);
+			if (encoded) estimatedJpegSize = encoded.length;
+			else estimatedJpegSize = estimateJpegSizeHeuristic(info.width, info.height, info.channels, quality);
+		} else estimatedJpegSize = estimateJpegSizeHeuristic(info.width, info.height, info.channels, quality);
+		const estimatedSavings = Math.max(0, currentSize - estimatedJpegSize);
+		const savingsPercent = currentSize > 0 ? estimatedSavings / currentSize * 100 : 0;
+		const effectiveDpi = computeImageDpi(info.width, info.height, info.width, info.height).effectiveDpi;
+		const recommendation = determineRecommendation(savingsPercent, grayscale, info.colorSpace, effectiveDpi, maxDpi);
+		analyses.push({
+			name: info.name,
+			pageIndex: info.pageIndex,
+			width: info.width,
+			height: info.height,
+			currentSize,
+			currentFormat,
+			colorSpace: info.colorSpace,
+			estimatedJpegSize,
+			estimatedSavings,
+			savingsPercent,
+			isGrayscale: grayscale,
+			effectiveDpi,
+			recommendation
+		});
+	}
+	const totalCurrentSize = analyses.reduce((sum, a) => sum + a.currentSize, 0);
+	const totalEstimatedSize = analyses.reduce((sum, a) => sum + a.estimatedJpegSize, 0);
+	const totalSavings = Math.max(0, totalCurrentSize - totalEstimatedSize);
+	return {
+		images: analyses,
+		totalCurrentSize,
+		totalEstimatedSize,
+		totalSavings,
+		totalSavingsPercent: totalCurrentSize > 0 ? totalSavings / totalCurrentSize * 100 : 0
+	};
+}
+
+//#endregion
+export { extractText as a, parseContentStream as i, computeImageDpi as n, extractTextWithPositions as o, computeTargetDimensions as r, analyzeImages as t };
+//# sourceMappingURL=compressionAnalysis-Bw2alOxt.mjs.map