modern-pdf-lib 0.14.1 → 0.15.0

package/dist/index.cjs

@@ -1,10 +1,11 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_pdfPage = require('./pdfPage-DBfdinTR.cjs');
 const require_pdfCatalog = require('./pdfCatalog-COKoYQ8C.cjs');
-const require_libdeflateWasm = require('./libdeflateWasm-OkNoqBnO.cjs');
+const require_libdeflateWasm = require('./libdeflateWasm-Enus0G1k.cjs');
 const require_fontSubset = require('./fontSubset-pFc8Dueu.cjs');
-const require_pngEmbed = require('./pngEmbed-OYyOe_W0.cjs');
+const require_pngEmbed = require('./pngEmbed-10m4CfBU.cjs');
 const require_fflateAdapter = require('./fflateAdapter-AHC_S3cb.cjs');
+const require_bridge = require('./bridge-DUcJFVsk.cjs');
 let fflate = require("fflate");
 
 //#region src/core/pdfWriter.ts
@@ -4827,10 +4828,10 @@ async function tryLoadLibdeflate() {
 	if (libdeflateAttempted) return libdeflateEngine;
 	libdeflateAttempted = true;
 	try {
-		const { LibdeflateWasm: LibdeflateCtor, initDeflateWasm } = await Promise.resolve().then(() => require("./libdeflateWasm-OkNoqBnO.cjs")).then((n) => n.libdeflateWasm_exports);
+		const { LibdeflateWasm: LibdeflateCtor, initDeflateWasm } = await Promise.resolve().then(() => require("./libdeflateWasm-Enus0G1k.cjs")).then((n) => n.libdeflateWasm_exports);
 		let customBytes;
 		try {
-			const { getWasmLoaderConfig } = await Promise.resolve().then(() => require("./loader-_fqS-TmT.cjs"));
+			const { getWasmLoaderConfig } = await Promise.resolve().then(() => require("./loader-CKlBOHma.cjs"));
 			customBytes = getWasmLoaderConfig().moduleBytes?.["libdeflate"];
 		} catch {}
 		await initDeflateWasm(customBytes);
@@ -9991,7 +9992,7 @@ function isAccessible(issues) {
 * @param data  The bytes to hash.
 * @returns     A hex string hash.
 */
-function hashBytes(data) {
+function hashBytes$1(data) {
 	let hash = 2166136261;
 	for (let i = 0; i < data.length; i++) {
 		hash ^= data[i];
@@ -10083,7 +10084,7 @@ function remapRef$1(sourceRef, context) {
 	}
 	let streamHash;
 	if (sourceObj.kind === "stream") {
-		streamHash = hashBytes(sourceObj.data);
+		streamHash = hashBytes$1(sourceObj.data);
 		const dedup = context.hashMap.get(streamHash);
 		if (dedup) {
 			context.refMap.set(sourceRef.objectNumber, dedup);
@@ -24367,7 +24368,7 @@ function addTrailerId(data) {
 * ```
 */
 function downscaleImage(image, options = {}) {
-	const target = computeTargetDimensions(image.width, image.height, options);
+	const target = computeTargetDimensions$1(image.width, image.height, options);
 	if (target.width >= image.width && target.height >= image.height) return image;
 	switch (options.algorithm ?? "bilinear") {
 		case "nearest": return resampleNearest(image, target.width, target.height);
@@ -24394,7 +24395,7 @@ function downscaleImage(image, options = {}) {
 async function recompressImage(image, options = {}) {
 	switch (options.format ?? "deflate") {
 		case "deflate": return recompressDeflate(image, options.compressionLevel ?? 6);
-		case "jpeg": return recompressJpeg(image, options.quality ?? 85);
+		case "jpeg": return recompressJpeg(image, options.quality ?? 85, options.progressive ?? false, options.chromaSubsampling ?? "4:2:0");
 		default: return {
 			data: image.pixels,
 			width: image.width,
@@ -24424,10 +24425,163 @@ async function optimizeImage(image, options = {}) {
 	return recompressImage(downscaleImage(image, options), options);
 }
 /**
+* Standard JPEG luminance quantization table (Table K.1 from JPEG spec)
+* at quality 50, scaled to quality 100 = all-ones.
+* @internal
+*/
+const STANDARD_LUMINANCE_QT = [
+	16,
+	11,
+	10,
+	16,
+	24,
+	40,
+	51,
+	61,
+	12,
+	12,
+	14,
+	19,
+	26,
+	58,
+	60,
+	55,
+	14,
+	13,
+	16,
+	24,
+	40,
+	57,
+	69,
+	56,
+	14,
+	17,
+	22,
+	29,
+	51,
+	87,
+	80,
+	62,
+	18,
+	22,
+	37,
+	56,
+	68,
+	109,
+	103,
+	77,
+	24,
+	35,
+	55,
+	64,
+	81,
+	104,
+	113,
+	92,
+	49,
+	64,
+	78,
+	87,
+	103,
+	121,
+	120,
+	101,
+	72,
+	92,
+	95,
+	98,
+	112,
+	100,
+	103,
+	99
+];
+/**
+* Estimate the JPEG quality level (1–100) from the quantization tables
+* embedded in a JPEG file.
+*
+* Parses the DQT (Define Quantization Table, marker 0xFFDB) segments
+* from the raw JPEG bytes and compares the table values against the
+* standard JPEG luminance quantization table to estimate the quality
+* factor that was used during encoding.
+*
+* If no DQT marker is found, returns `undefined`.
+*
+* @param jpegBytes - Raw JPEG file bytes.
+* @returns Estimated quality 1–100, or `undefined` if no DQT is found.
+*
+* @example
+* ```ts
+* import { estimateJpegQuality } from 'modern-pdf-lib';
+*
+* const quality = estimateJpegQuality(jpegBytes);
+* if (quality !== undefined) {
+*   console.log(`Estimated JPEG quality: ${quality}`);
+* }
+* ```
+*/
+function estimateJpegQuality(jpegBytes) {
+	if (jpegBytes.length < 2 || jpegBytes[0] !== 255 || jpegBytes[1] !== 216) return;
+	let offset = 2;
+	let bestTable;
+	while (offset < jpegBytes.length - 1) {
+		if (jpegBytes[offset] !== 255) {
+			offset++;
+			continue;
+		}
+		const marker = jpegBytes[offset + 1];
+		if (marker === 255) {
+			offset++;
+			continue;
+		}
+		if (marker === 0 || marker === 1 || marker >= 208 && marker <= 217) {
+			offset += 2;
+			continue;
+		}
+		if (marker === 218) break;
+		if (offset + 3 >= jpegBytes.length) break;
+		const segLen = jpegBytes[offset + 2] << 8 | jpegBytes[offset + 3];
+		if (marker === 219) {
+			let pos = offset + 4;
+			const segEnd = offset + 2 + segLen;
+			while (pos < segEnd && pos + 1 < jpegBytes.length) {
+				const pqTq = jpegBytes[pos];
+				const precision = pqTq >> 4 & 15;
+				const tableId = pqTq & 15;
+				pos++;
+				const tableSize = 64 * (precision === 0 ? 1 : 2);
+				if (pos + tableSize > jpegBytes.length) break;
+				const table = [];
+				for (let i = 0; i < 64; i++) if (precision === 0) table.push(jpegBytes[pos + i]);
+				else table.push(jpegBytes[pos + i * 2] << 8 | jpegBytes[pos + i * 2 + 1]);
+				pos += tableSize;
+				if (tableId === 0 || !bestTable) bestTable = table;
+			}
+		}
+		offset += 2 + segLen;
+	}
+	if (!bestTable) return void 0;
+	let totalRatio = 0;
+	let count = 0;
+	for (let i = 0; i < 64; i++) {
+		const std = STANDARD_LUMINANCE_QT[i];
+		const actual = bestTable[i];
+		if (std === 0 || actual === 0) continue;
+		const scaleFactor = actual * 100 / std;
+		totalRatio += scaleFactor;
+		count++;
+	}
+	if (count === 0) return void 0;
+	const avgScale = totalRatio / count;
+	let quality;
+	if (avgScale < 100) quality = (200 - avgScale) / 2;
+	else quality = 5e3 / avgScale;
+	return Math.max(1, Math.min(100, Math.round(quality)));
+}
+/**
 * Compute target dimensions from options, preserving aspect ratio.
 * @internal
 */
-function computeTargetDimensions(srcWidth, srcHeight, options) {
+function computeTargetDimensions$1(srcWidth, srcHeight, options) {
 	let targetWidth = srcWidth;
 	let targetHeight = srcHeight;
 	if (options.targetDpi && options.printWidth && options.printHeight) {
@@ -24644,30 +24798,37 @@ async function recompressDeflate(image, level) {
 }
 /**
 * Recompress image data as JPEG.
-* @internal
-*/
-/**
-* Recompress image data as JPEG.
-*
-* JPEG encoding in pure JS is complex (DCT, Huffman coding, quantization).
-* A full implementation requires either:
-*
-* 1. **WASM-based encoder** (preferred) -- compile libjpeg-turbo or mozjpeg
-*    to WASM, feed raw pixels, get JPEG bytes back.
-* 2. **Canvas API** (browser-only fallback) -- use `OffscreenCanvas` with
-*    `convertToBlob({ type: 'image/jpeg', quality })`.
-* 3. **Pure JS encoder** (last resort) -- very slow but works everywhere.
 *
-* Until a WASM encoder module is bundled, this function returns the input
-* data unchanged. The caller receives `format: 'raw'` and
-* `wasOptimized: false` to indicate that JPEG encoding was not applied.
+* Uses the JPEG WASM encoder when available (initialized via
+* `initJpegWasm()` or `initWasm({ jpeg: true })`).  When WASM is not
+* loaded, returns the input data unchanged with `wasOptimized: false`.
 *
 * @param image   - The raw image pixel data.
-* @param quality - JPEG quality 1-100 (reserved for future use).
-* @returns         The input data as-is, marked as un-optimized.
+* @param quality - JPEG quality 1–100.
+* @param progressive - Encode as progressive JPEG (default: false).
+* @param chromaSubsampling - Chroma subsampling mode (default: '4:2:0').
+* @returns The JPEG-encoded result, or raw data if WASM is unavailable.
 * @internal
 */
-async function recompressJpeg(image, quality) {
+async function recompressJpeg(image, quality, progressive = false, chromaSubsampling = "4:2:0") {
+	const { encodeJpegWasm, isJpegWasmReady } = await Promise.resolve().then(() => require("./bridge-DUcJFVsk.cjs")).then((n) => n.bridge_exports);
+	if (isJpegWasmReady()) {
+		let pixels = image.pixels;
+		let channels = image.channels;
+		if (image.channels === 4 && image.colorSpace === "cmyk") {
+			pixels = convertCmykToRgb(image.pixels, image.width, image.height);
+			channels = 3;
+		}
+		const jpegBytes = encodeJpegWasm(pixels, image.width, image.height, channels, quality, progressive, chromaSubsampling);
+		if (jpegBytes) return {
+			data: jpegBytes,
+			width: image.width,
+			height: image.height,
+			channels,
+			format: "jpeg",
+			wasOptimized: true
+		};
+	}
 	return {
 		data: image.pixels,
 		width: image.width,
@@ -24677,6 +24838,644 @@ async function recompressJpeg(image, quality) {
 		wasOptimized: false
 	};
 }
+/**
+* Convert CMYK pixel data to RGB.
+*
+* Uses the standard CMYK→RGB formula (inverted CMYK, Adobe convention):
+* ```
+* R = 255 × (1 − C/255) × (1 − K/255)
+* G = 255 × (1 − M/255) × (1 − K/255)
+* B = 255 × (1 − Y/255) × (1 − K/255)
+* ```
+*
+* @param pixels  - CMYK pixel data (4 bytes per pixel, row-major).
+* @param width   - Image width.
+* @param height  - Image height.
+* @returns RGB pixel data (3 bytes per pixel).
+* @internal
+*/
+function convertCmykToRgb(pixels, width, height) {
+	const pixelCount = width * height;
+	const rgb = new Uint8Array(pixelCount * 3);
+	for (let i = 0; i < pixelCount; i++) {
+		const c = pixels[i * 4] / 255;
+		const m = pixels[i * 4 + 1] / 255;
+		const y = pixels[i * 4 + 2] / 255;
+		const k = pixels[i * 4 + 3] / 255;
+		rgb[i * 3] = Math.round(255 * (1 - c) * (1 - k));
+		rgb[i * 3 + 1] = Math.round(255 * (1 - m) * (1 - k));
+		rgb[i * 3 + 2] = Math.round(255 * (1 - y) * (1 - k));
+	}
+	return rgb;
+}
+
+//#endregion
+//#region src/assets/image/imageExtract.ts
+/**
+* Resolve the color space name from a `/ColorSpace` entry.
+* Handles both simple names (`/DeviceRGB`) and array forms
+* (`[/ICCBased ...]`, `[/Indexed /DeviceRGB ...]`).
+* @internal
+*/
+function resolveColorSpace(csEntry, registry) {
+	if (!csEntry) return "DeviceRGB";
+	if (csEntry.kind === "ref") {
+		const resolved = registry.resolve(csEntry);
+		if (!resolved) return "DeviceRGB";
+		return resolveColorSpace(resolved, registry);
+	}
+	if (csEntry.kind === "name") return csEntry.value.replace(/^\//, "");
+	if (csEntry.kind === "array") {
+		const arr = csEntry;
+		const first = arr.items[0];
+		if (first && first.kind === "name") {
+			const csName = first.value.replace(/^\//, "");
+			if (csName === "ICCBased") {
+				const profileRef = arr.items[1];
+				if (profileRef && profileRef.kind === "ref") {
+					const profile = registry.resolve(profileRef);
+					if (profile && profile.kind === "stream") {
+						const n = profile.dict.get("/N");
+						if (n && n.kind === "number") {
+							const channels = n.value;
+							if (channels === 1) return "DeviceGray";
+							if (channels === 3) return "DeviceRGB";
+							if (channels === 4) return "DeviceCMYK";
+						}
+					}
+				}
+				return "DeviceRGB";
+			}
+			if (csName === "Indexed") return "Indexed";
+			return csName;
+		}
+	}
+	return "DeviceRGB";
+}
+/**
+* Determine the number of channels from a color space name.
+* @internal
+*/
+function channelsFromColorSpace(colorSpace) {
+	switch (colorSpace) {
+		case "DeviceGray":
+		case "CalGray": return 1;
+		case "DeviceCMYK": return 4;
+		case "Indexed": return 1;
+		default: return 3;
+	}
+}
+/**
+* Extract all image XObjects from a PDF document.
+*
+* Walks every page's `/Resources /XObject` dictionary and collects
+* metadata for each image XObject found.
+*
+* @param doc - A parsed `PdfDocument`.
+* @returns An array of `ImageInfo` objects, one per image XObject.
+*
+* @example
+* ```ts
+* import { loadPdf, extractImages } from 'modern-pdf-lib';
+*
+* const doc = await loadPdf(pdfBytes);
+* const images = extractImages(doc);
+*
+* for (const img of images) {
+*   console.log(`${img.name}: ${img.width}x${img.height} ${img.colorSpace} (${img.compressedSize} bytes)`);
+* }
+* ```
+*/
+function extractImages(doc) {
+	const images = [];
+	const seenRefs = /* @__PURE__ */ new Set();
+	const pages = doc.getPages();
+	for (let pageIndex = 0; pageIndex < pages.length; pageIndex++) {
+		const page = pages[pageIndex];
+		const resources = page.getOriginalResources();
+		if (!resources) continue;
+		let xObjDict;
+		const xObjEntry = resources.get("/XObject");
+		if (!xObjEntry) continue;
+		if (xObjEntry.kind === "dict") xObjDict = xObjEntry;
+		else if (xObjEntry.kind === "ref") {
+			const resolved = page.getRegistry().resolve(xObjEntry);
+			if (resolved && resolved.kind === "dict") xObjDict = resolved;
+		}
+		if (!xObjDict) continue;
+		const registry = page.getRegistry();
+		for (const [name, value] of xObjDict) {
+			let ref;
+			let stream;
+			if (value.kind === "ref") {
+				ref = value;
+				if (seenRefs.has(ref.objectNumber)) continue;
+				const resolved = registry.resolve(ref);
+				if (resolved && resolved.kind === "stream") stream = resolved;
+			} else if (value.kind === "stream") stream = value;
+			if (!stream || !ref) continue;
+			const subtype = stream.dict.get("/Subtype");
+			if (!subtype || subtype.kind !== "name") continue;
+			if (subtype.value !== "/Image") continue;
+			const widthObj = stream.dict.get("/Width");
+			const heightObj = stream.dict.get("/Height");
+			const bpcObj = stream.dict.get("/BitsPerComponent");
+			const width = widthObj && widthObj.kind === "number" ? widthObj.value : 0;
+			const height = heightObj && heightObj.kind === "number" ? heightObj.value : 0;
+			const bitsPerComponent = bpcObj && bpcObj.kind === "number" ? bpcObj.value : 8;
+			const colorSpace = resolveColorSpace(stream.dict.get("/ColorSpace"), registry);
+			const channels = channelsFromColorSpace(colorSpace);
+			const { filters } = getStreamFilters(stream.dict);
+			seenRefs.add(ref.objectNumber);
+			images.push({
+				stream,
+				ref,
+				name,
+				pageIndex,
+				width,
+				height,
+				bitsPerComponent,
+				colorSpace,
+				channels,
+				filters,
+				compressedSize: stream.data.length
+			});
+		}
+	}
+	return images;
+}
+/**
+* Decode image stream data into raw pixels.
+*
+* For DCTDecode (JPEG) streams, returns the raw JPEG bytes (not decoded
+* to pixels) since JPEG decoding requires the WASM module.
+*
+* For FlateDecode and other filters, fully decodes the stream.
+*
+* @param imageInfo - An `ImageInfo` from `extractImages()`.
+* @returns The decoded stream data.
+*/
+function decodeImageStream(imageInfo) {
+	if (imageInfo.filters.length === 0) return imageInfo.stream.data;
+	return decodeStream(imageInfo.stream.data, imageInfo.filters, null);
+}
+
+//#endregion
+//#region src/assets/image/grayscaleDetect.ts
+/**
+* @module assets/image/grayscaleDetect
+*
+* Grayscale detection and conversion for image optimization.
+*
+* Detects RGB images where all pixels are effectively grayscale
+* (R ≈ G ≈ B) and converts them to single-channel grayscale,
+* reducing data size by ~66%.
+*
+* No Buffer — uses Uint8Array exclusively.
+*/
+/**
+* Check whether an RGB/RGBA image is effectively grayscale.
+*
+* Scans all pixels and checks if R, G, and B channels are within
+* `tolerance` of each other. If ≥99% of pixels pass, the image
+* is considered grayscale.
+*
+* @param pixels    - Raw pixel data (row-major, channel-interleaved).
+* @param width     - Image width in pixels.
+* @param height    - Image height in pixels.
+* @param channels  - Number of channels: 3 (RGB) or 4 (RGBA).
+* @param tolerance - Maximum allowed difference between R, G, and B
+*                    values for a pixel to be considered gray.
+*                    Default: `2`.
+* @returns `true` if the image is effectively grayscale.
+*
+* @example
+* ```ts
+* import { isGrayscaleImage, convertToGrayscale } from 'modern-pdf-lib';
+*
+* if (isGrayscaleImage(pixels, width, height, 3)) {
+*   const grayPixels = convertToGrayscale(pixels, width, height, 3);
+*   // grayPixels has 1 byte per pixel instead of 3
+* }
+* ```
+*/
+function isGrayscaleImage(pixels, width, height, channels, tolerance = 2) {
+	const pixelCount = width * height;
+	const maxNonGray = Math.floor(pixelCount * .01);
+	let nonGrayCount = 0;
+	for (let i = 0; i < pixelCount; i++) {
+		const r = pixels[i * channels];
+		const g = pixels[i * channels + 1];
+		const b = pixels[i * channels + 2];
+		if (Math.max(r, g, b) - Math.min(r, g, b) > tolerance) {
+			nonGrayCount++;
+			if (nonGrayCount > maxNonGray) return false;
+		}
+	}
+	return true;
+}
+/**
+* Convert an RGB/RGBA image to single-channel grayscale.
+*
+* Uses the ITU-R BT.601 luma formula:
+* ```
+* gray = 0.299 × R + 0.587 × G + 0.114 × B
+* ```
+*
+* The alpha channel (if present) is discarded.
+*
+* @param pixels   - Raw pixel data (row-major, channel-interleaved).
+* @param width    - Image width in pixels.
+* @param height   - Image height in pixels.
+* @param channels - Number of channels: 3 (RGB) or 4 (RGBA).
+* @returns Grayscale pixel data (1 byte per pixel).
+*/
+function convertToGrayscale(pixels, width, height, channels) {
+	const pixelCount = width * height;
+	const gray = new Uint8Array(pixelCount);
+	for (let i = 0; i < pixelCount; i++) {
+		const r = pixels[i * channels];
+		const g = pixels[i * channels + 1];
+		const b = pixels[i * channels + 2];
+		gray[i] = Math.round(.299 * r + .587 * g + .114 * b);
+	}
+	return gray;
+}
+
+//#endregion
+//#region src/assets/image/batchOptimize.ts
+/** Minimum image size to bother optimizing (10 KB). */
+const SMALL_IMAGE_THRESHOLD = 10240;
+/**
+* Optimize all images in a PDF document by recompressing them as JPEG.
+*
+* Walks every image XObject in the document, decodes its pixel data,
+* recompresses it as JPEG using the WASM encoder (if available), and
+* replaces the stream data in-place when the result is smaller.
+*
+* **Requires the JPEG WASM module to be initialized** via
+* `initJpegWasm()` or `initWasm({ jpeg: true })`.  Without it,
+* no images will be optimized (all will be skipped).
+*
+* @param doc     - A parsed `PdfDocument` (from `loadPdf()`).
+* @param options - Optimization settings.
+* @returns A report summarizing the optimization results.
+*
+* @example
+* ```ts
+* import { loadPdf, initWasm, optimizeAllImages } from 'modern-pdf-lib';
+*
+* await initWasm({ jpeg: true });
+*
+* const doc = await loadPdf(pdfBytes);
+* const report = await optimizeAllImages(doc);
+*
+* console.log(`Optimized ${report.optimizedImages} of ${report.totalImages} images`);
+* console.log(`Savings: ${report.savings.toFixed(1)}%`);
+*
+* const optimizedBytes = await doc.save();
+* ```
+*/
+async function optimizeAllImages(doc, options = {}) {
+	const quality = options.quality ?? 80;
+	const minSavingsPercent = options.minSavingsPercent ?? 10;
+	const skipSmall = options.skipSmallImages ?? false;
+	const progressive = options.progressive ?? false;
+	const chromaSubsampling = options.chromaSubsampling ?? "4:2:0";
+	const { encodeJpegWasm, isJpegWasmReady } = await Promise.resolve().then(() => require("./bridge-DUcJFVsk.cjs")).then((n) => n.bridge_exports);
+	const { decodeJpegWasm } = await Promise.resolve().then(() => require("./bridge-DUcJFVsk.cjs")).then((n) => n.bridge_exports);
+	const images = extractImages(doc);
+	const perImage = [];
+	let totalOriginal = 0;
+	let totalNew = 0;
+	let optimizedCount = 0;
+	for (const img of images) {
+		totalOriginal += img.compressedSize;
+		if (!isJpegWasmReady()) {
+			perImage.push({
+				name: img.name,
+				pageIndex: img.pageIndex,
+				originalSize: img.compressedSize,
+				newSize: img.compressedSize,
+				skipped: true,
+				reason: "JPEG WASM encoder not initialized"
+			});
+			totalNew += img.compressedSize;
+			continue;
+		}
+		if (skipSmall && img.compressedSize < SMALL_IMAGE_THRESHOLD) {
+			perImage.push({
+				name: img.name,
+				pageIndex: img.pageIndex,
+				originalSize: img.compressedSize,
+				newSize: img.compressedSize,
+				skipped: true,
+				reason: `Below size threshold (${SMALL_IMAGE_THRESHOLD} bytes)`
+			});
+			totalNew += img.compressedSize;
+			continue;
+		}
+		if (img.bitsPerComponent !== 8) {
+			perImage.push({
+				name: img.name,
+				pageIndex: img.pageIndex,
+				originalSize: img.compressedSize,
+				newSize: img.compressedSize,
+				skipped: true,
+				reason: `Unsupported bits per component: ${img.bitsPerComponent}`
+			});
+			totalNew += img.compressedSize;
+			continue;
+		}
+		if (img.colorSpace === "Indexed") {
+			perImage.push({
+				name: img.name,
+				pageIndex: img.pageIndex,
+				originalSize: img.compressedSize,
+				newSize: img.compressedSize,
+				skipped: true,
+				reason: "Indexed color space not suitable for JPEG"
+			});
+			totalNew += img.compressedSize;
+			continue;
+		}
+		let pixels;
+		let channels = img.channels;
+		try {
+			if (img.filters[0] === "DCTDecode") {
+				const decoded = decodeJpegWasm(img.stream.data);
+				if (!decoded) {
+					perImage.push({
+						name: img.name,
+						pageIndex: img.pageIndex,
+						originalSize: img.compressedSize,
+						newSize: img.compressedSize,
+						skipped: true,
+						reason: "Failed to decode existing JPEG"
+					});
+					totalNew += img.compressedSize;
+					continue;
+				}
+				pixels = decoded.pixels;
+				channels = decoded.channels;
+			} else pixels = decodeImageStream(img);
+		} catch {
+			perImage.push({
+				name: img.name,
+				pageIndex: img.pageIndex,
+				originalSize: img.compressedSize,
+				newSize: img.compressedSize,
+				skipped: true,
+				reason: "Failed to decode image stream"
+			});
+			totalNew += img.compressedSize;
+			continue;
+		}
+		const expectedLen = img.width * img.height * channels;
+		if (pixels.length !== expectedLen) {
+			perImage.push({
+				name: img.name,
+				pageIndex: img.pageIndex,
+				originalSize: img.compressedSize,
+				newSize: img.compressedSize,
+				skipped: true,
+				reason: `Pixel data length mismatch: got ${pixels.length}, expected ${expectedLen}`
+			});
+			totalNew += img.compressedSize;
+			continue;
+		}
+		if (channels === 4 && img.colorSpace === "DeviceCMYK") {
+			const rgb = new Uint8Array(img.width * img.height * 3);
+			for (let i = 0; i < img.width * img.height; i++) {
+				const c = pixels[i * 4] / 255;
+				const m = pixels[i * 4 + 1] / 255;
+				const y = pixels[i * 4 + 2] / 255;
+				const k = pixels[i * 4 + 3] / 255;
+				rgb[i * 3] = Math.round(255 * (1 - c) * (1 - k));
+				rgb[i * 3 + 1] = Math.round(255 * (1 - m) * (1 - k));
+				rgb[i * 3 + 2] = Math.round(255 * (1 - y) * (1 - k));
+			}
+			pixels = rgb;
+			channels = 3;
+		}
+		if (options.autoGrayscale && (channels === 3 || channels === 4)) {
+			if (isGrayscaleImage(pixels, img.width, img.height, channels)) {
+				pixels = convertToGrayscale(pixels, img.width, img.height, channels);
+				channels = 1;
+			}
+		}
+		const jpegBytes = encodeJpegWasm(pixels, img.width, img.height, channels, quality, progressive, chromaSubsampling);
+		if (!jpegBytes) {
+			perImage.push({
+				name: img.name,
+				pageIndex: img.pageIndex,
+				originalSize: img.compressedSize,
+				newSize: img.compressedSize,
+				skipped: true,
+				reason: "JPEG encoding failed"
+			});
+			totalNew += img.compressedSize;
+			continue;
+		}
+		const savingsPercent = (img.compressedSize - jpegBytes.length) / img.compressedSize * 100;
+		if (savingsPercent < minSavingsPercent) {
+			perImage.push({
+				name: img.name,
+				pageIndex: img.pageIndex,
+				originalSize: img.compressedSize,
+				newSize: img.compressedSize,
+				skipped: true,
+				reason: `Savings ${savingsPercent.toFixed(1)}% below threshold ${minSavingsPercent}%`
+			});
+			totalNew += img.compressedSize;
+			continue;
+		}
+		img.stream.data = jpegBytes;
+		img.stream.syncLength();
+		const dict = img.stream.dict;
+		dict.set("/Filter", require_pdfCatalog.PdfName.of("/DCTDecode"));
+		if (img.colorSpace === "DeviceCMYK" && channels === 3) dict.set("/ColorSpace", require_pdfCatalog.PdfName.of("/DeviceRGB"));
+		if (channels === 1) dict.set("/ColorSpace", require_pdfCatalog.PdfName.of("/DeviceGray"));
+		dict.delete("/DecodeParms");
+		if (img.colorSpace === "DeviceCMYK") dict.delete("/Decode");
+		optimizedCount++;
+		perImage.push({
+			name: img.name,
+			pageIndex: img.pageIndex,
+			originalSize: img.compressedSize,
+			newSize: jpegBytes.length,
+			skipped: false
+		});
+		totalNew += jpegBytes.length;
+	}
+	const overallSavings = totalOriginal > 0 ? (totalOriginal - totalNew) / totalOriginal * 100 : 0;
+	return {
+		totalImages: images.length,
+		optimizedImages: optimizedCount,
+		originalTotalBytes: totalOriginal,
+		optimizedTotalBytes: totalNew,
+		savings: overallSavings,
+		perImage
+	};
+}
+
+//#endregion
+//#region src/assets/image/deduplicateImages.ts
+/**
+* Compute a fast FNV-1a hash of a byte array.
+*
+* This is used instead of SHA-256 because:
+* 1. It's synchronous (no need for crypto.subtle)
+* 2. It's fast for large buffers
+* 3. We only need collision resistance within a single document
+*
+* Returns a 64-char hex string (two 32-bit hashes concatenated).
+* @internal
+*/
+function hashBytes(data) {
+	let h1 = 2166136261;
+	for (let i = 0; i < data.length; i++) {
+		h1 ^= data[i];
+		h1 = Math.imul(h1, 16777619);
+	}
+	let h2 = 16777619;
+	for (let i = data.length - 1; i >= 0; i--) {
+		h2 ^= data[i];
+		h2 = Math.imul(h2, 2166136261);
+	}
+	const h3 = data.length * 2654435769 | 0;
+	return (h1 >>> 0).toString(16).padStart(8, "0") + (h2 >>> 0).toString(16).padStart(8, "0") + (h3 >>> 0).toString(16).padStart(8, "0");
+}
+/**
+* Deduplicate identical images in a PDF document.
+*
+* Scans all image XObjects, hashes their compressed stream data (plus
+* dimensions and filter), and replaces duplicate references in page
+* resource dictionaries with the canonical (first-seen) copy.
+*
+* This operation modifies the document in-place. Duplicate streams
+* are not removed from the object registry (they become unreferenced
+* and will be omitted on save if the writer supports garbage collection).
+*
+* @param doc - A parsed `PdfDocument` (from `loadPdf()`).
+* @returns A report summarizing deduplication results.
+*
+* @example
+* ```ts
+* import { loadPdf, deduplicateImages } from 'modern-pdf-lib';
+*
+* const doc = await loadPdf(pdfBytes);
+* const report = await deduplicateImages(doc);
+*
+* console.log(`Removed ${report.duplicatesRemoved} duplicate images`);
+* console.log(`Saved ~${(report.bytesSaved / 1024).toFixed(0)} KB`);
+*
+* const optimizedBytes = await doc.save();
+* ```
+*/
+function deduplicateImages(doc) {
+	const images = extractImages(doc);
+	const hashToCanonical = /* @__PURE__ */ new Map();
+	const duplicates = [];
+	for (const img of images) {
+		const key = `${img.width}x${img.height}:${img.filters.join(",")}:` + hashBytes(img.stream.data);
+		const existing = hashToCanonical.get(key);
+		if (existing) duplicates.push({
+			image: img,
+			canonicalRef: existing.ref
+		});
+		else hashToCanonical.set(key, {
+			ref: img.ref,
+			size: img.compressedSize
+		});
+	}
+	let bytesSaved = 0;
+	for (const { image, canonicalRef } of duplicates) {
+		const page = doc.getPages()[image.pageIndex];
+		if (!page) continue;
+		const resources = page.getOriginalResources();
+		if (!resources) continue;
+		const xObjEntry = resources.get("/XObject");
+		if (!xObjEntry) continue;
+		let xObjDict;
+		if (xObjEntry.kind === "dict") xObjDict = xObjEntry;
+		else if (xObjEntry.kind === "ref") {
+			const resolved = page.getRegistry().resolve(xObjEntry);
+			if (resolved && resolved.kind === "dict") xObjDict = resolved;
+		}
+		if (!xObjDict) continue;
+		xObjDict.set(image.name, canonicalRef);
+		bytesSaved += image.compressedSize;
+	}
+	return {
+		totalImages: images.length,
+		uniqueImages: hashToCanonical.size,
+		duplicatesRemoved: duplicates.length,
+		bytesSaved
+	};
+}
+
+//#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/errors.ts
@@ -24846,15 +25645,18 @@ async function initWasm(options) {
 	if (options === void 0 || typeof options === "string" || options instanceof URL) return;
 	if (wasmInitialized) return;
 	const inits = [];
-	if (options.deflate || options.deflateWasm) inits.push(Promise.resolve().then(() => require("./libdeflateWasm-OkNoqBnO.cjs")).then((n) => n.libdeflateWasm_exports).then(async ({ initDeflateWasm }) => {
+	if (options.deflate || options.deflateWasm) inits.push(Promise.resolve().then(() => require("./libdeflateWasm-Enus0G1k.cjs")).then((n) => n.libdeflateWasm_exports).then(async ({ initDeflateWasm }) => {
 		await initDeflateWasm(options.deflateWasm);
 	}));
-	if (options.png || options.pngWasm) inits.push(Promise.resolve().then(() => require("./pngEmbed-OYyOe_W0.cjs")).then((n) => n.pngEmbed_exports).then(async ({ initPngWasm }) => {
+	if (options.png || options.pngWasm) inits.push(Promise.resolve().then(() => require("./pngEmbed-10m4CfBU.cjs")).then((n) => n.pngEmbed_exports).then(async ({ initPngWasm }) => {
 		await initPngWasm(options.pngWasm);
 	}));
 	if (options.fonts || options.fontWasm) inits.push(Promise.resolve().then(() => require("./fontSubset-pFc8Dueu.cjs")).then((n) => n.fontSubset_exports).then(async ({ initSubsetWasm }) => {
 		await initSubsetWasm(options.fontWasm);
 	}));
+	if (options.jpeg || options.jpegWasm) inits.push(Promise.resolve().then(() => require("./bridge-DUcJFVsk.cjs")).then((n) => n.bridge_exports).then(async ({ initJpegWasm }) => {
+		await initJpegWasm(options.jpegWasm);
+	}));
 	await Promise.all(inits);
 	wasmInitialized = true;
 }
@@ -24984,9 +25786,12 @@ exports.colorToComponents = require_pdfPage.colorToComponents;
 exports.componentsToColor = require_pdfPage.componentsToColor;
 exports.computeFileEncryptionKey = computeFileEncryptionKey;
 exports.computeFontSize = computeFontSize;
+exports.computeImageDpi = computeImageDpi;
 exports.computeSignatureHash = computeSignatureHash;
+exports.computeTargetDimensions = computeTargetDimensions;
 exports.concatMatrix = require_pdfPage.concatMatrix;
 exports.concatTransformationMatrix = require_pdfPage.concatMatrix;
+exports.convertToGrayscale = convertToGrayscale;
 exports.copyPages = copyPages;
 exports.createAnnotation = require_pdfPage.createAnnotation;
 exports.createMarkedContentScope = require_pdfPage.createMarkedContentScope;
@@ -24996,8 +25801,11 @@ exports.cropPage = cropPage;
 exports.curveToFinal = require_pdfPage.curveToFinal;
 exports.curveToInitial = require_pdfPage.curveToInitial;
 exports.curveToOp = require_pdfPage.curveTo;
+exports.decodeImageStream = decodeImageStream;
+exports.decodeJpegWasm = require_bridge.decodeJpegWasm;
 exports.decodePermissions = decodePermissions;
 exports.decodeStream = decodeStream;
+exports.deduplicateImages = deduplicateImages;
 exports.degrees = require_pdfPage.degrees;
 exports.degreesToRadians = require_pdfPage.degreesToRadians;
 exports.downscaleImage = downscaleImage;
@@ -25011,6 +25819,7 @@ exports.embedPageAsFormXObject = embedPageAsFormXObject;
 exports.embedSignature = embedSignature;
 exports.encodeContextTag = encodeContextTag;
 exports.encodeInteger = encodeInteger;
+exports.encodeJpegWasm = require_bridge.encodeJpegWasm;
 exports.encodeLength = encodeLength;
 exports.encodeOID = encodeOID;
 exports.encodeOctetString = encodeOctetString;
@@ -25026,6 +25835,8 @@ exports.endMarkedContent = require_pdfPage.endMarkedContent;
 exports.endPathOp = require_pdfPage.endPath;
 exports.endText = require_pdfPage.endText;
 exports.enforcePdfA = enforcePdfA;
+exports.estimateJpegQuality = estimateJpegQuality;
+exports.extractImages = extractImages;
 exports.extractMetrics = extractMetrics;
 exports.extractText = extractText;
 exports.extractTextWithPositions = extractTextWithPositions;
@@ -25057,9 +25868,12 @@ exports.getPageSize = getPageSize;
 exports.getRedactionMarks = require_pdfPage.getRedactionMarks;
 exports.getSignatures = getSignatures;
 exports.grayscale = require_pdfPage.grayscale;
+exports.initJpegWasm = require_bridge.initJpegWasm;
 exports.initWasm = initWasm;
 exports.insertPage = insertPage;
 exports.isAccessible = isAccessible;
+exports.isGrayscaleImage = isGrayscaleImage;
+exports.isJpegWasmReady = require_bridge.isJpegWasmReady;
 exports.isLinearized = isLinearized;
 exports.isOpenTypeCFF = isOpenTypeCFF;
 exports.isTrueType = isTrueType;
@@ -25078,6 +25892,7 @@ exports.moveTextOp = require_pdfPage.moveText;
 exports.moveTextSetLeading = require_pdfPage.moveTextSetLeading;
 exports.moveToOp = require_pdfPage.moveTo;
 exports.nextLineOp = require_pdfPage.nextLine;
+exports.optimizeAllImages = optimizeAllImages;
 exports.optimizeImage = optimizeImage;
 exports.parseContentStream = parseContentStream;
 exports.parseSvg = require_pdfPage.parseSvg;