modern-pdf-lib 0.15.1 → 0.22.9

package/dist/batchOptimize-CxyY4fZe.mjs

@@ -0,0 +1,392 @@
+import { Ka as __exportAll } from "./index-BtYOx5wh.d.mts";
+import { i as PdfName, l as PdfStream, o as PdfNumber, r as PdfDict, t as PdfArray } from "./pdfObjects-uEsWlfzU.mjs";
+import { n as extractImages, t as decodeImageStream } from "./imageExtract-Dnk_Ssv7.mjs";
+import { n as isGrayscaleImage, t as convertToGrayscale } from "./grayscaleDetect-C6kFF3dk.mjs";
+
+//#region src/assets/image/iccProfile.ts
+/**
+* @module assets/image/iccProfile
+*
+* ICC color profile extraction and preservation for PDF image XObjects.
+*
+* When images are recompressed during optimization, their ICC color
+* profiles can be stripped, causing color shifts in print workflows.
+* This module extracts ICC profiles from the original image's color
+* space entry and re-embeds them after recompression, preserving
+* color fidelity.
+*
+* No Buffer — uses Uint8Array exclusively.
+*/
+/**
+* Known ICC color space signatures (4 bytes at offset 16 in the profile header).
+* @internal
+*/
+const ICC_COLOR_SPACE_MAP = {
+	"RGB ": "RGB",
+	"CMYK": "CMYK",
+	"GRAY": "GRAY",
+	"Lab ": "Lab",
+	"XYZ ": "XYZ",
+	"Luv ": "Luv",
+	"YCbr": "YCbCr",
+	"Yxy ": "Yxy",
+	"HSV ": "HSV",
+	"HLS ": "HLS"
+};
+/**
+* Read the color space signature from raw ICC profile data.
+*
+* The ICC profile header stores a 4-byte color space of data field
+* at byte offset 16. This function reads and decodes that signature
+* into a human-readable string.
+*
+* @param data - Raw ICC profile bytes.
+* @returns The color space name (e.g. `'RGB'`, `'CMYK'`, `'GRAY'`),
+*          or `'Unknown'` if the data is too short or the signature
+*          is not recognized.
+*
+* @example
+* ```ts
+* import { parseIccColorSpace } from 'modern-pdf-lib';
+*
+* const colorSpace = parseIccColorSpace(iccProfileBytes);
+* console.log(colorSpace); // 'RGB'
+* ```
+*/
+function parseIccColorSpace(data) {
+	if (data.length < 20) return "Unknown";
+	return ICC_COLOR_SPACE_MAP[String.fromCharCode(data[16], data[17], data[18], data[19])] ?? "Unknown";
+}
+/**
+* Parse the human-readable description from an ICC profile's 'desc' tag.
+*
+* Searches the ICC tag table for a tag with signature `'desc'`
+* (0x64657363) and reads the ASCII description string from it.
+*
+* The 'desc' tag (ICC v2) has the structure:
+* - Bytes 0–3: type signature ('desc')
+* - Bytes 4–7: reserved (0)
+* - Bytes 8–11: ASCII description length (uint32 BE)
+* - Bytes 12+: ASCII description string
+*
+* @param data - Raw ICC profile bytes.
+* @returns The description string, or `undefined` if the tag is not
+*          found or cannot be parsed.
+*/
+function parseIccDescription(data) {
+	if (data.length < 132) return void 0;
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	const tagCount = view.getUint32(128, false);
+	const tagTableStart = 132;
+	if (data.length < tagTableStart + tagCount * 12) return void 0;
+	for (let i = 0; i < tagCount; i++) {
+		const entryOffset = tagTableStart + i * 12;
+		if (view.getUint32(entryOffset, false) !== 1684370275) continue;
+		const tagOffset = view.getUint32(entryOffset + 4, false);
+		const tagSize = view.getUint32(entryOffset + 8, false);
+		if (tagOffset + tagSize > data.length) return void 0;
+		if (tagSize < 12) return void 0;
+		const descLen = view.getUint32(tagOffset + 8, false);
+		if (descLen === 0) return void 0;
+		const strEnd = Math.min(tagOffset + 12 + descLen - 1, tagOffset + tagSize);
+		if (strEnd <= tagOffset + 12) return void 0;
+		const chars = [];
+		for (let j = tagOffset + 12; j < strEnd; j++) {
+			const c = data[j];
+			if (c === 0) break;
+			chars.push(String.fromCharCode(c));
+		}
+		return chars.length > 0 ? chars.join("") : void 0;
+	}
+}
+/**
+* Extract the ICC color profile from a PDF image XObject's `/ColorSpace`.
+*
+* Checks whether the image's `/ColorSpace` entry is an ICCBased array
+* (i.e. `[/ICCBased <stream ref>]`), and if so, extracts the raw ICC
+* profile bytes and metadata from the referenced stream.
+*
+* @param stream   - The `PdfStream` for the image XObject.
+* @param registry - The document's `PdfObjectRegistry` for resolving
+*                   indirect references.
+* @returns An `IccProfile` if the image uses an ICCBased color space,
+*          or `undefined` if no ICC profile is attached.
+*
+* @example
+* ```ts
+* import { extractIccProfile, extractImages, loadPdf } from 'modern-pdf-lib';
+*
+* const doc = await loadPdf(pdfBytes);
+* const images = extractImages(doc);
+*
+* for (const img of images) {
+*   const profile = extractIccProfile(img.stream, doc.getRegistry());
+*   if (profile) {
+*     console.log(`ICC: ${profile.colorSpace}, ${profile.components} channels`);
+*     console.log(`Description: ${profile.description ?? 'none'}`);
+*   }
+* }
+* ```
+*/
+function extractIccProfile(stream, registry) {
+	const csEntry = stream.dict.get("/ColorSpace");
+	if (!csEntry) return void 0;
+	let cs = csEntry;
+	if (cs.kind === "ref") {
+		const resolved = registry.resolve(cs);
+		if (!resolved) return void 0;
+		cs = resolved;
+	}
+	if (cs.kind !== "array") return void 0;
+	const arr = cs;
+	if (arr.items.length < 2) return void 0;
+	const first = arr.items[0];
+	if (first.kind !== "name") return void 0;
+	if (first.value !== "/ICCBased") return void 0;
+	let profileObj = arr.items[1];
+	if (profileObj.kind === "ref") {
+		const resolved = registry.resolve(profileObj);
+		if (!resolved) return void 0;
+		profileObj = resolved;
+	}
+	if (profileObj.kind !== "stream") return void 0;
+	const profileStream = profileObj;
+	const profileData = profileStream.data;
+	const nEntry = profileStream.dict.get("/N");
+	const components = nEntry && nEntry.kind === "number" ? nEntry.value : 0;
+	if (components < 1 || components > 4) return void 0;
+	return {
+		data: profileData,
+		components,
+		colorSpace: parseIccColorSpace(profileData),
+		description: parseIccDescription(profileData)
+	};
+}
+/**
+* Embed an ICC color profile into the PDF object registry and return
+* a reference that can be used as a `/ColorSpace` entry.
+*
+* Creates a new `PdfStream` for the ICC profile data with the required
+* `/N` (number of components) entry, registers it, and returns a
+* `PdfRef` to the stream. The caller should then set the image's
+* `/ColorSpace` to `[/ICCBased <returned ref>]`.
+*
+* @param profile  - The `IccProfile` to embed.
+* @param registry - The document's `PdfObjectRegistry`.
+* @returns A `PdfRef` pointing to the newly created ICC profile stream.
+*
+* @example
+* ```ts
+* import { embedIccProfile, extractIccProfile } from 'modern-pdf-lib';
+*
+* const profile = extractIccProfile(imageStream, registry);
+* if (profile) {
+*   const profileRef = embedIccProfile(profile, registry);
+*   const colorSpace = PdfArray.of([PdfName.of('/ICCBased'), profileRef]);
+*   imageStream.dict.set('/ColorSpace', colorSpace);
+* }
+* ```
+*/
+function embedIccProfile(profile, registry) {
+	const dict = new PdfDict();
+	dict.set("/N", PdfNumber.of(profile.components));
+	dict.set("/Length", PdfNumber.of(profile.data.length));
+	if (profile.components === 1) dict.set("/Alternate", PdfName.of("/DeviceGray"));
+	else if (profile.components === 3) dict.set("/Alternate", PdfName.of("/DeviceRGB"));
+	else if (profile.components === 4) dict.set("/Alternate", PdfName.of("/DeviceCMYK"));
+	const stream = new PdfStream(dict, profile.data);
+	return registry.register(stream);
+}
+
+//#endregion
+//#region src/assets/image/batchOptimize.ts
+var batchOptimize_exports = /* @__PURE__ */ __exportAll({ optimizeAllImages: () => optimizeAllImages });
+/** Minimum image size to bother optimizing (10 KB). */
+const SMALL_IMAGE_THRESHOLD = 10240;
+/**
+* Process items concurrently with a maximum parallelism limit.
+* Workers pull from a shared index — no item is processed twice.
+*/
+async function processWithConcurrency(items, concurrency, processor) {
+	let nextIndex = 0;
+	const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+		while (nextIndex < items.length) {
+			const index = nextIndex++;
+			await processor(items[index], index);
+		}
+	});
+	await Promise.all(workers);
+}
+/**
+* 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 concurrency = Math.max(1, options.concurrency ?? 1);
+	const { pageRange, minImageSize, colorSpaces, namePattern } = options;
+	const { encodeJpegWasm, isJpegWasmReady } = await import("./bridge-DTH5LMAK.mjs").then((n) => n.t);
+	const { decodeJpegWasm } = await import("./bridge-DTH5LMAK.mjs").then((n) => n.t);
+	const images = extractImages(doc);
+	const registry = doc.getRegistry();
+	const results = new Array(images.length);
+	/** Process a single image and write the result into `results[index]`. */
+	const processImage = async (img, index) => {
+		const skip = (skippedByFilter, reason) => {
+			results[index] = {
+				name: img.name,
+				pageIndex: img.pageIndex,
+				originalSize: img.compressedSize,
+				newSize: img.compressedSize,
+				skipped: true,
+				skippedByFilter,
+				reason
+			};
+		};
+		if (pageRange && (img.pageIndex < pageRange.start || img.pageIndex > pageRange.end)) return skip(true, `Page ${img.pageIndex} outside range [${pageRange.start}, ${pageRange.end}]`);
+		if (minImageSize && img.compressedSize < minImageSize) return skip(true, `Compressed size ${img.compressedSize} below minimum ${minImageSize} bytes`);
+		if (colorSpaces && !colorSpaces.includes(img.colorSpace)) return skip(true, `Color space '${img.colorSpace}' not in allowed list`);
+		if (namePattern && !namePattern.test(img.name)) return skip(true, `Name '${img.name}' does not match pattern ${namePattern}`);
+		if (!isJpegWasmReady()) return skip(false, "JPEG WASM encoder not initialized");
+		if (skipSmall && img.compressedSize < SMALL_IMAGE_THRESHOLD) return skip(false, `Below size threshold (${SMALL_IMAGE_THRESHOLD} bytes)`);
+		if (img.bitsPerComponent !== 8) return skip(false, `Unsupported bits per component: ${img.bitsPerComponent}`);
+		if (img.colorSpace === "Indexed") return skip(false, "Indexed color space not suitable for JPEG");
+		let iccProfile;
+		try {
+			iccProfile = extractIccProfile(img.stream, registry);
+		} catch {
+			iccProfile = void 0;
+		}
+		let pixels;
+		let channels = img.channels;
+		try {
+			if (img.filters[0] === "DCTDecode") {
+				const decoded = decodeJpegWasm(img.stream.data);
+				if (!decoded) return skip(false, "Failed to decode existing JPEG");
+				pixels = decoded.pixels;
+				channels = decoded.channels;
+			} else pixels = decodeImageStream(img);
+		} catch {
+			return skip(false, "Failed to decode image stream");
+		}
+		const expectedLen = img.width * img.height * channels;
+		if (pixels.length !== expectedLen) return skip(false, `Pixel data length mismatch: got ${pixels.length}, expected ${expectedLen}`);
+		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;
+		}
+		let convertedToGrayscale = false;
+		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;
+				convertedToGrayscale = true;
+			}
+		}
+		const jpegBytes = encodeJpegWasm(pixels, img.width, img.height, channels, quality, progressive, chromaSubsampling);
+		if (!jpegBytes) return skip(false, "JPEG encoding failed");
+		const savingsPercent = (img.compressedSize - jpegBytes.length) / img.compressedSize * 100;
+		if (savingsPercent < minSavingsPercent) return skip(false, `Savings ${savingsPercent.toFixed(1)}% below threshold ${minSavingsPercent}%`);
+		img.stream.data = jpegBytes;
+		img.stream.syncLength();
+		const dict = img.stream.dict;
+		dict.set("/Filter", PdfName.of("/DCTDecode"));
+		if (channels === 1) dict.set("/ColorSpace", PdfName.of("/DeviceGray"));
+		else if (iccProfile && !convertedToGrayscale && iccProfile.components === channels) {
+			const profileRef = embedIccProfile(iccProfile, registry);
+			dict.set("/ColorSpace", PdfArray.of([PdfName.of("/ICCBased"), profileRef]));
+		} else if (img.colorSpace === "DeviceCMYK" && channels === 3) dict.set("/ColorSpace", PdfName.of("/DeviceRGB"));
+		else if (channels === 3) dict.set("/ColorSpace", PdfName.of("/DeviceRGB"));
+		dict.delete("/DecodeParms");
+		if (img.colorSpace === "DeviceCMYK") dict.delete("/Decode");
+		results[index] = {
+			name: img.name,
+			pageIndex: img.pageIndex,
+			originalSize: img.compressedSize,
+			newSize: jpegBytes.length,
+			skipped: false,
+			skippedByFilter: false
+		};
+	};
+	await processWithConcurrency(images, concurrency, processImage);
+	let totalOriginal = 0;
+	let totalNew = 0;
+	let optimizedCount = 0;
+	let skippedByFilterCount = 0;
+	let cumulativeSavedBytes = 0;
+	const { onProgress } = options;
+	for (let i = 0; i < results.length; i++) {
+		const entry = results[i];
+		totalOriginal += entry.originalSize;
+		totalNew += entry.newSize;
+		if (!entry.skipped) optimizedCount++;
+		if (entry.skippedByFilter) skippedByFilterCount++;
+		if (onProgress) {
+			const saved = entry.originalSize - entry.newSize;
+			cumulativeSavedBytes += saved;
+			onProgress({
+				current: i + 1,
+				total: images.length,
+				imageName: entry.name,
+				pageIndex: entry.pageIndex,
+				savedBytes: saved,
+				totalSavedBytes: cumulativeSavedBytes,
+				skipped: entry.skipped
+			});
+		}
+	}
+	const overallSavings = totalOriginal > 0 ? (totalOriginal - totalNew) / totalOriginal * 100 : 0;
+	return {
+		totalImages: images.length,
+		optimizedImages: optimizedCount,
+		skippedByFilter: skippedByFilterCount,
+		originalTotalBytes: totalOriginal,
+		optimizedTotalBytes: totalNew,
+		savings: overallSavings,
+		perImage: results
+	};
+}
+
+//#endregion
+export { parseIccColorSpace as a, extractIccProfile as i, optimizeAllImages as n, parseIccDescription as o, embedIccProfile as r, batchOptimize_exports as t };
+//# sourceMappingURL=batchOptimize-CxyY4fZe.mjs.map

package/dist/{bridge-DpzMOnHd.mjs → bridge-DTH5LMAK.mjs}

@@ -1,4 +1,4 @@
-import { t as __exportAll } from "./rolldown-runtime-95iHPtFO.mjs";
+import { Ka as __exportAll } from "./index-BtYOx5wh.d.mts";
 
 //#region src/wasm/jpeg/bridge.ts
 var bridge_exports = /* @__PURE__ */ __exportAll({
@@ -22,7 +22,7 @@ async function initJpegWasm(wasmSource) {
 			wasmModule = wasmSource;
 			return;
 		}
-		const { loadWasmModule: loadWasm } = await import("./loader-B6VIrZOJ.mjs");
+		const { loadWasmModule: loadWasm } = await import("./loader-3u6Tw5T-.mjs").then((n) => n.l);
 		const wasmBytes = await loadWasm("jpeg");
 		wasmModule = (await WebAssembly.instantiate(wasmBytes.buffer, { env: {} })).instance.exports;
 	} catch {
@@ -100,4 +100,4 @@ function decodeJpegWasm(jpegBytes) {
 
 //#endregion
 export { isJpegWasmReady as a, initJpegWasm as i, decodeJpegWasm as n, encodeJpegWasm as r, bridge_exports as t };
-//# sourceMappingURL=bridge-DpzMOnHd.mjs.map
+//# sourceMappingURL=bridge-DTH5LMAK.mjs.map

package/dist/{bridge-DN7BOHRW.cjs → bridge-DYCQzxF7.cjs}

@@ -22,7 +22,7 @@ async function initJpegWasm(wasmSource) {
 			wasmModule = wasmSource;
 			return;
 		}
-		const { loadWasmModule: loadWasm } = await Promise.resolve().then(() => require("./loader-DdB5Xo5D.cjs"));
+		const { loadWasmModule: loadWasm } = await Promise.resolve().then(() => require("./loader-I4zdkoWc.cjs")).then((n) => n.loader_exports);
 		const wasmBytes = await loadWasm("jpeg");
 		wasmModule = (await WebAssembly.instantiate(wasmBytes.buffer, { env: {} })).instance.exports;
 	} catch {
@@ -129,4 +129,4 @@ Object.defineProperty(exports, 'isJpegWasmReady', {
     return isJpegWasmReady;
   }
 });
-//# sourceMappingURL=bridge-DN7BOHRW.cjs.map
+//# sourceMappingURL=bridge-DYCQzxF7.cjs.map