modern-pdf-lib 0.14.1 → 0.15.1

package/dist/batchOptimize-DYQOX1-7.cjs

@@ -0,0 +1,329 @@
+const require_rolldown_runtime = require('./rolldown-runtime-CKhH4XqG.cjs');
+const require_pdfObjects = require('./pdfObjects-BrU4Xd0V.cjs');
+const require_imageExtract = require('./imageExtract-BC7TMY98.cjs');
+
+//#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
+var batchOptimize_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({ optimizeAllImages: () => optimizeAllImages });
+/** 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-DN7BOHRW.cjs")).then((n) => n.bridge_exports);
+	const { decodeJpegWasm } = await Promise.resolve().then(() => require("./bridge-DN7BOHRW.cjs")).then((n) => n.bridge_exports);
+	const images = require_imageExtract.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 = require_imageExtract.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_pdfObjects.PdfName.of("/DCTDecode"));
+		if (img.colorSpace === "DeviceCMYK" && channels === 3) dict.set("/ColorSpace", require_pdfObjects.PdfName.of("/DeviceRGB"));
+		if (channels === 1) dict.set("/ColorSpace", require_pdfObjects.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
+Object.defineProperty(exports, 'batchOptimize_exports', {
+  enumerable: true,
+  get: function () {
+    return batchOptimize_exports;
+  }
+});
+Object.defineProperty(exports, 'convertToGrayscale', {
+  enumerable: true,
+  get: function () {
+    return convertToGrayscale;
+  }
+});
+Object.defineProperty(exports, 'isGrayscaleImage', {
+  enumerable: true,
+  get: function () {
+    return isGrayscaleImage;
+  }
+});
+Object.defineProperty(exports, 'optimizeAllImages', {
+  enumerable: true,
+  get: function () {
+    return optimizeAllImages;
+  }
+});
+//# sourceMappingURL=batchOptimize-DYQOX1-7.cjs.map

package/dist/bridge-DN7BOHRW.cjs

@@ -0,0 +1,132 @@
+const require_rolldown_runtime = require('./rolldown-runtime-CKhH4XqG.cjs');
+
+//#region src/wasm/jpeg/bridge.ts
+var bridge_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
+	decodeJpegWasm: () => decodeJpegWasm,
+	encodeJpegWasm: () => encodeJpegWasm,
+	initJpegWasm: () => initJpegWasm,
+	isJpegWasmReady: () => isJpegWasmReady
+});
+let wasmModule;
+/**
+* Initialize the JPEG WASM module.
+*
+* @param wasmSource - The WASM binary as `Uint8Array`, URL, `Response`,
+*                     or a pre-built wasm-bindgen module.  When omitted,
+*                     the function uses the universal WASM loader.
+*/
+async function initJpegWasm(wasmSource) {
+	if (wasmModule) return;
+	try {
+		if (wasmSource && typeof wasmSource.encode_jpeg === "function") {
+			wasmModule = wasmSource;
+			return;
+		}
+		const { loadWasmModule: loadWasm } = await Promise.resolve().then(() => require("./loader-DdB5Xo5D.cjs"));
+		const wasmBytes = await loadWasm("jpeg");
+		wasmModule = (await WebAssembly.instantiate(wasmBytes.buffer, { env: {} })).instance.exports;
+	} catch {
+		wasmModule = void 0;
+	}
+}
+/**
+* Check whether the JPEG WASM module has been initialized.
+*
+* @returns `true` if {@link initJpegWasm} completed successfully.
+*/
+function isJpegWasmReady() {
+	return wasmModule !== void 0;
+}
+/**
+* Map a `ChromaSubsampling` string to the numeric code expected by WASM.
+* @internal
+*/
+function chromaToCode(chroma) {
+	switch (chroma) {
+		case "4:4:4": return 0;
+		case "4:2:2": return 1;
+		default: return 2;
+	}
+}
+/**
+* Encode raw pixel data to JPEG using the WASM encoder.
+*
+* @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: 1 (grayscale), 3 (RGB), or 4 (RGBA).
+* @param quality  - JPEG quality 1–100.
+* @param progressive - Encode as progressive JPEG (default: false).
+* @param chroma   - Chroma subsampling mode (default: '4:2:0').
+* @returns JPEG-encoded bytes, or `undefined` if WASM is not available.
+*/
+function encodeJpegWasm(pixels, width, height, channels, quality, progressive = false, chroma = "4:2:0") {
+	if (!wasmModule) return void 0;
+	try {
+		return wasmModule.encode_jpeg(pixels, width, height, channels, Math.max(1, Math.min(100, Math.round(quality))), progressive, chromaToCode(chroma));
+	} catch {
+		return;
+	}
+}
+/**
+* Decode JPEG bytes to raw pixel data using the WASM decoder.
+*
+* The WASM module returns a flat byte array with layout:
+* `[width_u32_le, height_u32_le, channels_u8, ...pixels]`.
+*
+* @param jpegBytes - JPEG-encoded image data.
+* @returns Decoded pixel data with metadata, or `undefined` if WASM is not
+*          available or decoding failed.
+*/
+function decodeJpegWasm(jpegBytes) {
+	if (!wasmModule) return void 0;
+	try {
+		const raw = wasmModule.decode_jpeg(jpegBytes);
+		if (raw.length < 9) return void 0;
+		const view = new DataView(raw.buffer, raw.byteOffset, raw.byteLength);
+		const width = view.getUint32(0, true);
+		const height = view.getUint32(4, true);
+		const channels = raw[8];
+		return {
+			pixels: raw.slice(9),
+			width,
+			height,
+			channels
+		};
+	} catch {
+		return;
+	}
+}
+
+//#endregion
+Object.defineProperty(exports, 'bridge_exports', {
+  enumerable: true,
+  get: function () {
+    return bridge_exports;
+  }
+});
+Object.defineProperty(exports, 'decodeJpegWasm', {
+  enumerable: true,
+  get: function () {
+    return decodeJpegWasm;
+  }
+});
+Object.defineProperty(exports, 'encodeJpegWasm', {
+  enumerable: true,
+  get: function () {
+    return encodeJpegWasm;
+  }
+});
+Object.defineProperty(exports, 'initJpegWasm', {
+  enumerable: true,
+  get: function () {
+    return initJpegWasm;
+  }
+});
+Object.defineProperty(exports, 'isJpegWasmReady', {
+  enumerable: true,
+  get: function () {
+    return isJpegWasmReady;
+  }
+});
+//# sourceMappingURL=bridge-DN7BOHRW.cjs.map

package/dist/bridge-DpzMOnHd.mjs

@@ -0,0 +1,103 @@
+import { t as __exportAll } from "./rolldown-runtime-95iHPtFO.mjs";
+
+//#region src/wasm/jpeg/bridge.ts
+var bridge_exports = /* @__PURE__ */ __exportAll({
+	decodeJpegWasm: () => decodeJpegWasm,
+	encodeJpegWasm: () => encodeJpegWasm,
+	initJpegWasm: () => initJpegWasm,
+	isJpegWasmReady: () => isJpegWasmReady
+});
+let wasmModule;
+/**
+* Initialize the JPEG WASM module.
+*
+* @param wasmSource - The WASM binary as `Uint8Array`, URL, `Response`,
+*                     or a pre-built wasm-bindgen module.  When omitted,
+*                     the function uses the universal WASM loader.
+*/
+async function initJpegWasm(wasmSource) {
+	if (wasmModule) return;
+	try {
+		if (wasmSource && typeof wasmSource.encode_jpeg === "function") {
+			wasmModule = wasmSource;
+			return;
+		}
+		const { loadWasmModule: loadWasm } = await import("./loader-B6VIrZOJ.mjs");
+		const wasmBytes = await loadWasm("jpeg");
+		wasmModule = (await WebAssembly.instantiate(wasmBytes.buffer, { env: {} })).instance.exports;
+	} catch {
+		wasmModule = void 0;
+	}
+}
+/**
+* Check whether the JPEG WASM module has been initialized.
+*
+* @returns `true` if {@link initJpegWasm} completed successfully.
+*/
+function isJpegWasmReady() {
+	return wasmModule !== void 0;
+}
+/**
+* Map a `ChromaSubsampling` string to the numeric code expected by WASM.
+* @internal
+*/
+function chromaToCode(chroma) {
+	switch (chroma) {
+		case "4:4:4": return 0;
+		case "4:2:2": return 1;
+		default: return 2;
+	}
+}
+/**
+* Encode raw pixel data to JPEG using the WASM encoder.
+*
+* @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: 1 (grayscale), 3 (RGB), or 4 (RGBA).
+* @param quality  - JPEG quality 1–100.
+* @param progressive - Encode as progressive JPEG (default: false).
+* @param chroma   - Chroma subsampling mode (default: '4:2:0').
+* @returns JPEG-encoded bytes, or `undefined` if WASM is not available.
+*/
+function encodeJpegWasm(pixels, width, height, channels, quality, progressive = false, chroma = "4:2:0") {
+	if (!wasmModule) return void 0;
+	try {
+		return wasmModule.encode_jpeg(pixels, width, height, channels, Math.max(1, Math.min(100, Math.round(quality))), progressive, chromaToCode(chroma));
+	} catch {
+		return;
+	}
+}
+/**
+* Decode JPEG bytes to raw pixel data using the WASM decoder.
+*
+* The WASM module returns a flat byte array with layout:
+* `[width_u32_le, height_u32_le, channels_u8, ...pixels]`.
+*
+* @param jpegBytes - JPEG-encoded image data.
+* @returns Decoded pixel data with metadata, or `undefined` if WASM is not
+*          available or decoding failed.
+*/
+function decodeJpegWasm(jpegBytes) {
+	if (!wasmModule) return void 0;
+	try {
+		const raw = wasmModule.decode_jpeg(jpegBytes);
+		if (raw.length < 9) return void 0;
+		const view = new DataView(raw.buffer, raw.byteOffset, raw.byteLength);
+		const width = view.getUint32(0, true);
+		const height = view.getUint32(4, true);
+		const channels = raw[8];
+		return {
+			pixels: raw.slice(9),
+			width,
+			height,
+			channels
+		};
+	} catch {
+		return;
+	}
+}
+
+//#endregion
+export { isJpegWasmReady as a, initJpegWasm as i, decodeJpegWasm as n, encodeJpegWasm as r, bridge_exports as t };
+//# sourceMappingURL=bridge-DpzMOnHd.mjs.map