modern-pdf-lib 0.15.0 → 0.19.9

package/README.md

@@ -15,7 +15,7 @@ Create, parse, fill, merge, sign, and manipulate PDF documents<br />in Node, Den
 
 [![npm version](https://img.shields.io/npm/v/modern-pdf-lib?style=flat-square&color=cb3837)](https://www.npmjs.com/package/modern-pdf-lib)
 [![bundle size](https://img.shields.io/badge/gzip-36kb_core-blue?style=flat-square)](https://bundlephobia.com/package/modern-pdf-lib)
-[![tests](https://img.shields.io/badge/tests-2%2C323_passing-brightgreen?style=flat-square)](#)
+[![tests](https://img.shields.io/badge/tests-3%2C260_passing-brightgreen?style=flat-square)](#)
 [![TypeScript](https://img.shields.io/badge/TypeScript-6.0-3178c6?style=flat-square&logo=typescript&logoColor=white)](#)
 [![License: MIT](https://img.shields.io/badge/license-MIT-yellow?style=flat-square)](LICENSE)
 
@@ -55,6 +55,44 @@ const stream = doc.saveAsStream();       // ReadableStream
 const blob = await doc.saveAsBlob();     // Blob (browsers)
 ```
 
+### CDN (no install)
+
+Use directly in the browser via CDN — no bundler required:
+
+```html
+<script type="module">
+  import { createPdf, PageSizes, rgb } from 'https://cdn.jsdelivr.net/npm/modern-pdf-lib/dist/browser.mjs';
+
+  const doc = createPdf();
+  const page = doc.addPage(PageSizes.A4);
+  page.drawText('Hello from CDN!', { x: 50, y: 750, size: 24, color: rgb(0, 0, 0) });
+  const bytes = await doc.save();
+  console.log('PDF size:', bytes.length, 'bytes');
+</script>
+```
+
+Also available via:
+- **unpkg:** `https://unpkg.com/modern-pdf-lib/dist/browser.mjs`
+- **esm.sh:** `https://esm.sh/modern-pdf-lib`
+
+### Script Tag (no modules)
+
+For environments without ES module support, use the IIFE bundle which exposes a `window.ModernPdf` global:
+
+```html
+<script src="https://cdn.jsdelivr.net/npm/modern-pdf-lib/dist/modern-pdf-lib.iife.js"></script>
+<script>
+  const { createPdf, PageSizes, rgb } = ModernPdf;
+
+  const doc = createPdf();
+  const page = doc.addPage(PageSizes.A4);
+  page.drawText('Hello from script tag!', { x: 50, y: 750, size: 24, color: rgb(0, 0, 0) });
+  doc.save().then(function (bytes) {
+    console.log('PDF size:', bytes.length, 'bytes');
+  });
+</script>
+```
+
 <br />
 
 ## Features
@@ -101,13 +139,14 @@ const blob = await doc.saveAsBlob();     // Blob (browsers)
 <td width="50%" valign="top">
 
 **Advanced**
+- QR codes & barcodes (9 formats)
+- Table layout engine with pagination
 - Outlines / bookmarks
 - Optional content layers (OCGs)
-- File attachments
-- Watermarks
+- File attachments & watermarks
 - Linearization (fast web view)
-- 60+ low-level PDF operators
-- Custom appearance providers
+- Browser helpers (download, blob, data URL)
+- Service Worker & Web Worker support
 - CLI: `npx modern-pdf optimize`
 
 </td>
@@ -197,6 +236,18 @@ const blob = await doc.saveAsBlob();     // Blob (browsers)
 <td align="center">Yes</td>
 <td align="center">No</td></tr>
 
+<tr><td><strong>QR codes & barcodes</strong></td>
+<td align="center">9 formats (QR, EAN, Code 128, PDF417…)</td>
+<td align="center">No</td></tr>
+
+<tr><td><strong>Table layout</strong></td>
+<td align="center">Spanning, pagination, presets, overflow</td>
+<td align="center">No</td></tr>
+
+<tr><td><strong>Browser utilities</strong></td>
+<td align="center">Download, blob, Web Worker, Service Worker</td>
+<td align="center">No</td></tr>
+
 <tr><td><strong>Image optimization</strong></td>
 <td align="center">JPEG recompress, dedup, grayscale</td>
 <td align="center">No</td></tr>
@@ -390,6 +441,51 @@ npx modern-pdf optimize report.pdf report-opt.pdf --quality 60 --grayscale --ded
 ```
 </details>
 
+<details>
+<summary><strong>Tables</strong> &mdash; layout engine with spanning, pagination, presets</summary>
+
+```ts
+import { createPdf, PageSizes, professionalPreset, applyPreset } from 'modern-pdf-lib';
+
+const doc = createPdf();
+const page = doc.addPage(PageSizes.A4);
+
+page.drawTable(applyPreset(professionalPreset(), {
+  x: 50,
+  y: 750,
+  width: 495,
+  headerRows: 1,
+  rows: [
+    { cells: ['Product', 'Qty', 'Price', 'Total'] },
+    { cells: ['Widget A', '10', '$5.00', '$50.00'] },
+    { cells: ['Widget B', '25', '$3.50', '$87.50'] },
+    { cells: [{ content: 'Grand Total', colSpan: 3, align: 'right' }, '$137.50'] },
+  ],
+  columns: [{ flex: 2 }, { width: 60 }, { width: 80 }, { width: 80, align: 'right' }],
+}));
+```
+</details>
+
+<details>
+<summary><strong>QR Codes & Barcodes</strong> &mdash; 9 formats</summary>
+
+```ts
+import { createPdf, PageSizes } from 'modern-pdf-lib';
+
+const doc = createPdf();
+const page = doc.addPage(PageSizes.A4);
+
+// QR code
+page.drawQrCode('https://example.com', { x: 50, y: 700, size: 120 });
+
+// Barcodes (Code 128, EAN-13, UPC-A, Code 39, ITF, PDF417, Data Matrix)
+import { encodeCode128, encodeEan13, renderStyledBarcode } from 'modern-pdf-lib';
+
+const barcode = encodeCode128('ABC-12345');
+const ops = renderStyledBarcode(barcode, { x: 50, y: 500, height: 60 });
+```
+</details>
+
 <details>
 <summary><strong>PDF/A & Accessibility</strong></summary>
 
@@ -471,12 +567,15 @@ modern-pdf-lib/
     crypto/         AES-256, RC4, MD5, SHA-256/384/512
     compression/    Deflate (fflate + optional WASM)
     assets/         Font metrics/embed/subset, image embed, SVG
+    barcode/        QR, Code 128, EAN, UPC, Code 39, ITF, PDF417, Data Matrix
+    layout/         Table engine (spanning, pagination, presets, overflow)
+    browser/        Download helpers, Service Worker, Web Worker
     layers/         Optional content groups (OCG)
     outline/        Bookmarks / document outline
     metadata/       XMP metadata, viewer preferences
     wasm/           Rust crate sources (6 modules)
     cli/            CLI tool (modern-pdf optimize)
-  tests/            2,323 tests across 110 suites
+  tests/            3,260 tests across 158 suites
   docs/             VitePress documentation
 ```
 
@@ -488,7 +587,7 @@ modern-pdf-lib/
 git clone https://github.com/ABCrimson/modern-pdf-lib.git
 cd modern-pdf-lib
 npm install
-npm test          # 2,323 tests
+npm test          # 3,260 tests
 npm run typecheck # TypeScript 6.0 strict
 npm run build     # ESM + CJS + declarations
 ```

package/dist/batchOptimize-7U_kD3_j.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-B6OvUEp-.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-7U_kD3_j.mjs.map