modern-pdf-lib 0.15.0 → 0.15.1

package/dist/batchOptimize-ClXizv19.mjs

@@ -0,0 +1,306 @@
+import { t as __exportAll } from "./rolldown-runtime-95iHPtFO.mjs";
+import { i as PdfName } from "./pdfObjects-DZZ2GPRW.mjs";
+import { n as extractImages, t as decodeImageStream } from "./imageExtract-vjyQyFcT.mjs";
+
+//#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__ */ __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 import("./bridge-DpzMOnHd.mjs").then((n) => n.t);
+	const { decodeJpegWasm } = await import("./bridge-DpzMOnHd.mjs").then((n) => n.t);
+	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", PdfName.of("/DCTDecode"));
+		if (img.colorSpace === "DeviceCMYK" && channels === 3) dict.set("/ColorSpace", PdfName.of("/DeviceRGB"));
+		if (channels === 1) dict.set("/ColorSpace", 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
+export { isGrayscaleImage as i, optimizeAllImages as n, convertToGrayscale as r, batchOptimize_exports as t };
+//# sourceMappingURL=batchOptimize-ClXizv19.mjs.map

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-DUcJFVsk.cjs → bridge-DN7BOHRW.cjs}

@@ -22,7 +22,7 @@ async function initJpegWasm(wasmSource) {
 			wasmModule = wasmSource;
 			return;
 		}
-		const { loadWasmModule: loadWasm } = await Promise.resolve().then(() => require("./loader-CKlBOHma.cjs"));
+		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 {
@@ -129,4 +129,4 @@ Object.defineProperty(exports, 'isJpegWasmReady', {
     return isJpegWasmReady;
   }
 });
-//# sourceMappingURL=bridge-DUcJFVsk.cjs.map
+//# sourceMappingURL=bridge-DN7BOHRW.cjs.map

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

@@ -22,7 +22,7 @@ async function initJpegWasm(wasmSource) {
 			wasmModule = wasmSource;
 			return;
 		}
-		const { loadWasmModule: loadWasm } = await import("./loader-1VJXLlMZ.mjs");
+		const { loadWasmModule: loadWasm } = await import("./loader-B6VIrZOJ.mjs");
 		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-C7U4E7St.mjs.map
+//# sourceMappingURL=bridge-DpzMOnHd.mjs.map