cross-image 0.2.4 → 0.4.1

package/script/src/formats/tiff.js

@@ -2,14 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TIFFFormat = void 0;
 const tiff_lzw_js_1 = require("../utils/tiff_lzw.js");
+const tiff_packbits_js_1 = require("../utils/tiff_packbits.js");
+const tiff_deflate_js_1 = require("../utils/tiff_deflate.js");
 const security_js_1 = require("../utils/security.js");
+const image_processing_js_1 = require("../utils/image_processing.js");
 // Constants for unit conversions
 const DEFAULT_DPI = 72;
 /**
  * TIFF format handler
- * Implements pure-JS TIFF decoder for uncompressed and LZW-compressed RGB/RGBA images
- * and encoder for uncompressed and LZW-compressed RGBA TIFFs. Falls back to ImageDecoder
- * for other compressed TIFFs (JPEG, PackBits, etc.)
+ * Implements pure-JS TIFF decoder for uncompressed, LZW, PackBits, and Deflate-compressed RGB/RGBA images
+ * and encoder for uncompressed, LZW, PackBits, and Deflate-compressed RGBA TIFFs. Falls back to ImageDecoder
+ * for JPEG-compressed TIFFs.
  * Supports multi-page TIFF files.
  */
 class TIFFFormat {
@@ -55,7 +58,7 @@ class TIFFFormat {
      * @param data Raw TIFF image data
      * @returns Decoded image data with RGBA pixels of first page
      */
-    async decode(data) {
+    async decode(data, _options) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid TIFF signature");
         }
@@ -131,12 +134,13 @@ class TIFFFormat {
             metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
         };
     }
-    encode(imageData, options) {
+    async encode(imageData, options) {
         const { width, height, data, metadata } = imageData;
         const opts = options;
         const compression = opts?.compression ?? "none";
         const grayscale = opts?.grayscale ?? false;
         const rgb = opts?.rgb ?? false;
+        const cmyk = opts?.cmyk ?? false;
         // Convert RGBA to grayscale if requested
         let sourceData;
         let samplesPerPixel;
@@ -151,6 +155,16 @@ class TIFFFormat {
                 sourceData[i] = Math.round(0.299 * r + 0.587 * g + 0.114 * b);
             }
         }
+        else if (cmyk) {
+            // Convert RGBA to CMYK
+            const cmykData = (0, image_processing_js_1.rgbaToCmyk)(data);
+            sourceData = new Uint8Array(width * height * 4);
+            samplesPerPixel = 4;
+            // Convert Float32Array CMYK (0-1) to Uint8Array (0-255)
+            for (let i = 0; i < cmykData.length; i++) {
+                sourceData[i] = Math.round(cmykData[i] * 255);
+            }
+        }
         else if (rgb) {
             // Convert RGBA to RGB (strip alpha channel)
             sourceData = new Uint8Array(width * height * 3);
@@ -175,6 +189,16 @@ class TIFFFormat {
             pixelData = encoder.compress(sourceData);
             compressionCode = 5;
         }
+        else if (compression === "packbits") {
+            // PackBits compress the pixel data
+            pixelData = (0, tiff_packbits_js_1.packBitsCompress)(sourceData);
+            compressionCode = 32773;
+        }
+        else if (compression === "deflate") {
+            // Deflate compress the pixel data
+            pixelData = await (0, tiff_deflate_js_1.deflateCompress)(sourceData);
+            compressionCode = 8;
+        }
         else {
             // Uncompressed
             pixelData = sourceData;
@@ -232,8 +256,8 @@ class TIFFFormat {
         }
         // Compression (0x0103) - 1 = uncompressed, 5 = LZW
         this.writeIFDEntry(result, 0x0103, 3, 1, compressionCode);
-        // PhotometricInterpretation (0x0106) - 1 = BlackIsZero (grayscale), 2 = RGB
-        this.writeIFDEntry(result, 0x0106, 3, 1, grayscale ? 1 : 2);
+        // PhotometricInterpretation (0x0106) - 1 = BlackIsZero (grayscale), 2 = RGB, 5 = CMYK
+        this.writeIFDEntry(result, 0x0106, 3, 1, grayscale ? 1 : (cmyk ? 5 : 2));
         // StripOffsets (0x0111)
         this.writeIFDEntry(result, 0x0111, 4, 1, 8);
         // SamplesPerPixel (0x0115) - 1 for grayscale, 3 for RGB, 4 for RGBA
@@ -332,7 +356,7 @@ class TIFFFormat {
     /**
      * Decode all pages from a multi-page TIFF
      */
-    async decodeFrames(data) {
+    async decodeFrames(data, _options) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid TIFF signature");
         }
@@ -395,7 +419,7 @@ class TIFFFormat {
     /**
      * Encode multi-page TIFF
      */
-    encodeFrames(imageData, options) {
+    async encodeFrames(imageData, options) {
         const opts = options;
         const compression = opts?.compression ?? "none";
         if (imageData.frames.length === 0) {
@@ -420,6 +444,12 @@ class TIFFFormat {
                 const encoder = new tiff_lzw_js_1.TIFFLZWEncoder();
                 pixelData = encoder.compress(frame.data);
             }
+            else if (compression === "packbits") {
+                pixelData = (0, tiff_packbits_js_1.packBitsCompress)(frame.data);
+            }
+            else if (compression === "deflate") {
+                pixelData = await (0, tiff_deflate_js_1.deflateCompress)(frame.data);
+            }
             else {
                 pixelData = frame.data;
             }
@@ -456,7 +486,19 @@ class TIFFFormat {
             this.writeIFDEntry(result, 0x0102, 3, 4, dataOffset);
             dataOffset += 8;
             // Compression
-            const compressionCode = compression === "lzw" ? 5 : 1;
+            let compressionCode;
+            if (compression === "lzw") {
+                compressionCode = 5;
+            }
+            else if (compression === "packbits") {
+                compressionCode = 32773;
+            }
+            else if (compression === "deflate") {
+                compressionCode = 8;
+            }
+            else {
+                compressionCode = 1;
+            }
             this.writeIFDEntry(result, 0x0103, 3, 1, compressionCode);
             // PhotometricInterpretation
             this.writeIFDEntry(result, 0x0106, 3, 1, 2);
@@ -467,9 +509,19 @@ class TIFFFormat {
             // RowsPerStrip
             this.writeIFDEntry(result, 0x0116, 4, 1, frame.height);
             // StripByteCounts
-            const pixelDataSize = compression === "lzw"
-                ? new tiff_lzw_js_1.TIFFLZWEncoder().compress(frame.data).length
-                : frame.data.length;
+            let pixelDataSize;
+            if (compression === "lzw") {
+                pixelDataSize = new tiff_lzw_js_1.TIFFLZWEncoder().compress(frame.data).length;
+            }
+            else if (compression === "packbits") {
+                pixelDataSize = (0, tiff_packbits_js_1.packBitsCompress)(frame.data).length;
+            }
+            else if (compression === "deflate") {
+                pixelDataSize = (await (0, tiff_deflate_js_1.deflateCompress)(frame.data)).length;
+            }
+            else {
+                pixelDataSize = frame.data.length;
+            }
             this.writeIFDEntry(result, 0x0117, 4, 1, pixelDataSize);
             // XResolution
             const xResOffset = dataOffset;
@@ -572,7 +624,7 @@ class TIFFFormat {
         const isLittleEndian = data[0] === 0x49;
         // Try pure JavaScript decoder first
         try {
-            const pureJSResult = this.decodePureJSFromIFD(data, ifdOffset, width, height, isLittleEndian);
+            const pureJSResult = await this.decodePureJSFromIFD(data, ifdOffset, width, height, isLittleEndian);
             if (pureJSResult) {
                 return pureJSResult;
             }
@@ -696,7 +748,7 @@ class TIFFFormat {
     async decodeUsingRuntime(data, width, height) {
         // Try pure JavaScript decoder first for uncompressed TIFFs
         try {
-            const pureJSResult = this.decodePureJS(data, width, height);
+            const pureJSResult = await this.decodePureJS(data, width, height);
             if (pureJSResult) {
                 return pureJSResult;
             }
@@ -734,10 +786,10 @@ class TIFFFormat {
         return new TextDecoder().decode(data.slice(offset, endIndex));
     }
     /**
-     * Pure JavaScript TIFF decoder for uncompressed and LZW-compressed RGB/RGBA images
+     * Pure JavaScript TIFF decoder for uncompressed, LZW, PackBits, and Deflate-compressed RGB/RGBA images
      * Returns null if the TIFF uses unsupported features
      */
-    decodePureJS(data, width, height) {
+    async decodePureJS(data, width, height) {
         // Validate minimum TIFF header size
         if (data.length < 8) {
             return null;
@@ -748,20 +800,23 @@ class TIFFFormat {
         const ifdOffset = this.readUint32(data, 4, isLittleEndian);
         // Check compression
         const compression = this.getIFDValue(data, ifdOffset, 0x0103, isLittleEndian);
-        if (compression !== 1 && compression !== 5) {
-            // Only support uncompressed (1) and LZW (5)
+        if (compression !== 1 && compression !== 5 && compression !== 8 &&
+            compression !== 32773) {
+            // Support: 1 = uncompressed, 5 = LZW, 8 = Deflate, 32773 = PackBits
             return null;
         }
         // Check photometric interpretation
         const photometric = this.getIFDValue(data, ifdOffset, 0x0106, isLittleEndian);
-        if (photometric !== 0 && photometric !== 1 && photometric !== 2) {
-            // Support: 0 = WhiteIsZero, 1 = BlackIsZero, 2 = RGB
+        if (photometric !== 0 && photometric !== 1 && photometric !== 2 &&
+            photometric !== 5) {
+            // Support: 0 = WhiteIsZero, 1 = BlackIsZero, 2 = RGB, 5 = CMYK
             return null;
         }
         // Get samples per pixel
         const samplesPerPixel = this.getIFDValue(data, ifdOffset, 0x0115, isLittleEndian);
         // For grayscale (photometric 0 or 1), expect 1 sample per pixel
         // For RGB, expect 3 or 4 samples per pixel
+        // For CMYK, expect 4 samples per pixel
         if (!samplesPerPixel) {
             return null;
         }
@@ -773,6 +828,10 @@ class TIFFFormat {
             // RGB requires 3 or 4 samples per pixel
             return null;
         }
+        if (photometric === 5 && samplesPerPixel !== 4) {
+            // CMYK requires 4 samples per pixel
+            return null;
+        }
         // Get strip offset
         const stripOffset = this.getIFDValue(data, ifdOffset, 0x0111, isLittleEndian);
         if (!stripOffset || stripOffset >= data.length) {
@@ -791,6 +850,16 @@ class TIFFFormat {
             const decoder = new tiff_lzw_js_1.TIFFLZWDecoder(compressedData);
             pixelData = decoder.decompress();
         }
+        else if (compression === 32773) {
+            // PackBits compressed
+            const compressedData = data.slice(stripOffset, stripOffset + stripByteCount);
+            pixelData = (0, tiff_packbits_js_1.packBitsDecompress)(compressedData);
+        }
+        else if (compression === 8) {
+            // Deflate compressed
+            const compressedData = data.slice(stripOffset, stripOffset + stripByteCount);
+            pixelData = await (0, tiff_deflate_js_1.deflateDecompress)(compressedData);
+        }
         else {
             // Uncompressed
             pixelData = data.slice(stripOffset, stripOffset + stripByteCount);
@@ -820,6 +889,29 @@ class TIFFFormat {
                 }
             }
         }
+        else if (photometric === 5) {
+            // CMYK image - convert to RGB
+            for (let y = 0; y < height; y++) {
+                for (let x = 0; x < width; x++) {
+                    const dstIdx = (y * width + x) * 4;
+                    if (srcPos + 4 > pixelData.length) {
+                        return null; // Not enough data
+                    }
+                    // TIFF stores CMYK in order, values are 0-255
+                    // Convert to 0-1 range for conversion
+                    const c = pixelData[srcPos++] / 255;
+                    const m = pixelData[srcPos++] / 255;
+                    const yVal = pixelData[srcPos++] / 255;
+                    const k = pixelData[srcPos++] / 255;
+                    // Convert CMYK to RGB
+                    const [r, g, b] = (0, image_processing_js_1.cmykToRgb)(c, m, yVal, k);
+                    rgba[dstIdx] = r; // R
+                    rgba[dstIdx + 1] = g; // G
+                    rgba[dstIdx + 2] = b; // B
+                    rgba[dstIdx + 3] = 255; // A (opaque)
+                }
+            }
+        }
         else {
             // RGB/RGBA image
             for (let y = 0; y < height; y++) {
@@ -842,23 +934,26 @@ class TIFFFormat {
      * Pure JavaScript TIFF decoder for a specific IFD
      * Returns null if the TIFF uses unsupported features
      */
-    decodePureJSFromIFD(data, ifdOffset, width, height, isLittleEndian) {
+    async decodePureJSFromIFD(data, ifdOffset, width, height, isLittleEndian) {
         // Check compression
         const compression = this.getIFDValue(data, ifdOffset, 0x0103, isLittleEndian);
-        if (compression !== 1 && compression !== 5) {
-            // Only support uncompressed (1) and LZW (5)
+        if (compression !== 1 && compression !== 5 && compression !== 8 &&
+            compression !== 32773) {
+            // Support: 1 = uncompressed, 5 = LZW, 8 = Deflate, 32773 = PackBits
             return null;
         }
         // Check photometric interpretation
         const photometric = this.getIFDValue(data, ifdOffset, 0x0106, isLittleEndian);
-        if (photometric !== 0 && photometric !== 1 && photometric !== 2) {
-            // Support: 0 = WhiteIsZero, 1 = BlackIsZero, 2 = RGB
+        if (photometric !== 0 && photometric !== 1 && photometric !== 2 &&
+            photometric !== 5) {
+            // Support: 0 = WhiteIsZero, 1 = BlackIsZero, 2 = RGB, 5 = CMYK
             return null;
         }
         // Get samples per pixel
         const samplesPerPixel = this.getIFDValue(data, ifdOffset, 0x0115, isLittleEndian);
         // For grayscale (photometric 0 or 1), expect 1 sample per pixel
         // For RGB, expect 3 or 4 samples per pixel
+        // For CMYK, expect 4 samples per pixel
         if (!samplesPerPixel) {
             return null;
         }
@@ -870,6 +965,10 @@ class TIFFFormat {
             // RGB requires 3 or 4 samples per pixel
             return null;
         }
+        if (photometric === 5 && samplesPerPixel !== 4) {
+            // CMYK requires 4 samples per pixel
+            return null;
+        }
         // Get strip offset
         const stripOffset = this.getIFDValue(data, ifdOffset, 0x0111, isLittleEndian);
         if (!stripOffset || stripOffset >= data.length) {
@@ -888,6 +987,16 @@ class TIFFFormat {
             const decoder = new tiff_lzw_js_1.TIFFLZWDecoder(compressedData);
             pixelData = decoder.decompress();
         }
+        else if (compression === 32773) {
+            // PackBits compressed
+            const compressedData = data.slice(stripOffset, stripOffset + stripByteCount);
+            pixelData = (0, tiff_packbits_js_1.packBitsDecompress)(compressedData);
+        }
+        else if (compression === 8) {
+            // Deflate compressed
+            const compressedData = data.slice(stripOffset, stripOffset + stripByteCount);
+            pixelData = await (0, tiff_deflate_js_1.deflateDecompress)(compressedData);
+        }
         else {
             // Uncompressed
             pixelData = data.slice(stripOffset, stripOffset + stripByteCount);
@@ -917,6 +1026,29 @@ class TIFFFormat {
                 }
             }
         }
+        else if (photometric === 5) {
+            // CMYK image - convert to RGB
+            for (let y = 0; y < height; y++) {
+                for (let x = 0; x < width; x++) {
+                    const dstIdx = (y * width + x) * 4;
+                    if (srcPos + 4 > pixelData.length) {
+                        return null; // Not enough data
+                    }
+                    // TIFF stores CMYK in order, values are 0-255
+                    // Convert to 0-1 range for conversion
+                    const c = pixelData[srcPos++] / 255;
+                    const m = pixelData[srcPos++] / 255;
+                    const yVal = pixelData[srcPos++] / 255;
+                    const k = pixelData[srcPos++] / 255;
+                    // Convert CMYK to RGB
+                    const [r, g, b] = (0, image_processing_js_1.cmykToRgb)(c, m, yVal, k);
+                    rgba[dstIdx] = r; // R
+                    rgba[dstIdx + 1] = g; // G
+                    rgba[dstIdx + 2] = b; // B
+                    rgba[dstIdx + 3] = 255; // A (opaque)
+                }
+            }
+        }
         else {
             // RGB/RGBA image
             for (let y = 0; y < height; y++) {
@@ -1006,9 +1138,12 @@ class TIFFFormat {
         else if (compression === 5) {
             metadata.compression = "lzw";
         }
-        else if (compression === 7) {
+        else if (compression === 7 || compression === 6) {
             metadata.compression = "jpeg";
         }
+        else if (compression === 8) {
+            metadata.compression = "deflate";
+        }
         else if (compression === 32773) {
             metadata.compression = "packbits";
         }

package/script/src/formats/webp.d.ts

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, ImageMetadata, WebPEncodeOptions } from "../types.js";
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata, WebPEncoderOptions } from "../types.js";
 /**
  * WebP format handler
  * Implements a basic WebP decoder and encoder
@@ -19,14 +19,14 @@ export declare class WebPFormat implements ImageFormat {
      * @param data Raw WebP image data
      * @returns Decoded image data with RGBA pixels
      */
-    decode(data: Uint8Array): Promise<ImageData>;
+    decode(data: Uint8Array, settings?: ImageDecoderOptions): Promise<ImageData>;
     /**
      * Encode RGBA image data to WebP format
      * @param imageData Image data to encode
      * @param options Optional WebP encoding options
      * @returns Encoded WebP image bytes
      */
-    encode(imageData: ImageData, options?: WebPEncodeOptions): Promise<Uint8Array>;
+    encode(imageData: ImageData, options?: WebPEncoderOptions): Promise<Uint8Array>;
     private readUint24LE;
     private decodeUsingRuntime;
     private parseEXIF;

package/script/src/formats/webp.js

@@ -78,7 +78,7 @@ class WebPFormat {
      * @param data Raw WebP image data
      * @returns Decoded image data with RGBA pixels
      */
-    async decode(data) {
+    async decode(data, settings) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid WebP signature");
         }
@@ -144,7 +144,7 @@ class WebPFormat {
         (0, security_js_1.validateImageDimensions)(width, height);
         // For a pure JS implementation, we'd need to implement full WebP decoding
         // which is very complex. Instead, we'll use the browser/runtime's decoder.
-        const rgba = await this.decodeUsingRuntime(data, width, height);
+        const rgba = await this.decodeUsingRuntime(data, width, height, settings);
         return {
             width,
             height,
@@ -207,9 +207,10 @@ class WebPFormat {
     readUint24LE(data, offset) {
         return data[offset] | (data[offset + 1] << 8) | (data[offset + 2] << 16);
     }
-    async decodeUsingRuntime(data, _width, _height) {
+    async decodeUsingRuntime(data, _width, _height, settings) {
         // Try to use ImageDecoder API if available (Deno, modern browsers)
-        if (typeof ImageDecoder !== "undefined") {
+        if (settings?.runtimeDecoding !== "never" &&
+            typeof ImageDecoder !== "undefined") {
             try {
                 const decoder = new ImageDecoder({ data, type: "image/webp" });
                 const result = await decoder.decode();
@@ -224,15 +225,17 @@ class WebPFormat {
                 bitmap.close();
                 return new Uint8Array(imageData.data.buffer);
             }
-            catch (error) {
+            catch (_error) {
                 // ImageDecoder API failed, fall through to pure JS decoder
-                console.warn("WebP decoding with ImageDecoder failed, using pure JS decoder:", error);
             }
         }
-        // Fallback to pure JavaScript decoder (VP8L lossless only)
+        // Fallback to pure JavaScript decoder (VP8L lossless only) with tolerant mode
         try {
             const { WebPDecoder } = await Promise.resolve().then(() => __importStar(require("../utils/webp_decoder.js")));
-            const decoder = new WebPDecoder(data);
+            const decoder = new WebPDecoder(data, {
+                tolerantDecoding: settings?.tolerantDecoding ?? true,
+                onWarning: settings?.onWarning,
+            });
             const result = decoder.decode();
             return result.data;
         }

package/script/src/image.d.ts

@@ -1,4 +1,4 @@
-import type { ImageFormat, ImageMetadata, MultiFrameImageData, ResizeOptions } from "./types.js";
+import type { ImageDecoderOptions, ImageFormat, ImageMetadata, MultiFrameImageData, ResizeOptions } from "./types.js";
 /**
  * Main Image class for reading, manipulating, and saving images
  */
@@ -78,7 +78,11 @@ export declare class Image {
      * @param format Optional format hint (e.g., "png", "jpeg", "webp")
      * @returns Image instance
      */
-    static decode(data: Uint8Array, format?: string): Promise<Image>;
+    static decode(data: Uint8Array): Promise<Image>;
+    static decode(data: Uint8Array, format: string): Promise<Image>;
+    static decode(data: Uint8Array, format: string, options?: ImageDecoderOptions): Promise<Image>;
+    static decode(data: Uint8Array, options?: ImageDecoderOptions): Promise<Image>;
+    private static decodeWithSettings;
     /**
      * Get supported metadata fields for a specific format
      * @param format Format name (e.g., "jpeg", "png", "webp")
@@ -108,7 +112,11 @@ export declare class Image {
      * @param format Optional format hint (e.g., "gif", "tiff")
      * @returns MultiFrameImageData with all frames
      */
-    static decodeFrames(data: Uint8Array, format?: string): Promise<MultiFrameImageData>;
+    static decodeFrames(data: Uint8Array): Promise<MultiFrameImageData>;
+    static decodeFrames(data: Uint8Array, format: string): Promise<MultiFrameImageData>;
+    static decodeFrames(data: Uint8Array, format: string, options?: ImageDecoderOptions): Promise<MultiFrameImageData>;
+    static decodeFrames(data: Uint8Array, options?: ImageDecoderOptions): Promise<MultiFrameImageData>;
+    private static decodeFramesWithSettings;
     /**
      * Read all frames from a multi-frame image (GIF animation, multi-page TIFF)
      * @deprecated Use `decodeFrames()` instead. This method will be removed in a future version.
@@ -342,5 +350,20 @@ export declare class Image {
      * @returns This image instance for chaining
      */
     flipVertical(): this;
+    /**
+     * Convert the image to CMYK color space
+     * Returns a Float32Array with 4 values per pixel (C, M, Y, K) in 0-1 range
+     * @returns CMYK image data as Float32Array
+     */
+    toCMYK(): Float32Array;
+    /**
+     * Create an Image from CMYK data
+     * @param cmykData CMYK image data (4 values per pixel in 0-1 range)
+     * @param width Image width
+     * @param height Image height
+     * @param alpha Optional alpha value for all pixels (0-255, default: 255)
+     * @returns New Image instance
+     */
+    static fromCMYK(cmykData: Float32Array, width: number, height: number, alpha?: number): Image;
 }
 //# sourceMappingURL=image.d.ts.map

package/script/src/image.js

@@ -161,26 +161,37 @@ class Image {
     static getFormats() {
         return Image.formats;
     }
-    /**
-     * Decode an image from bytes
-     * @param data Raw image data
-     * @param format Optional format hint (e.g., "png", "jpeg", "webp")
-     * @returns Image instance
-     */
-    static async decode(data, format) {
+    static async decode(data, formatOrOptions, options) {
+        // Backward-compatible overloads:
+        // - decode(data)
+        // - decode(data, "jpeg")
+        // New:
+        // - decode(data, { tolerantDecoding, onWarning, runtimeDecoding })
+        // - decode(data, "jpeg", { ...options })
+        if (typeof formatOrOptions === "string") {
+            return await Image.decodeWithSettings(data, formatOrOptions, options);
+        }
+        return await Image.decodeWithSettings(data, undefined, formatOrOptions);
+    }
+    static async decodeWithSettings(data, format, settings) {
         const image = new Image();
+        const normalizedSettings = {
+            tolerantDecoding: settings?.tolerantDecoding ?? true,
+            onWarning: settings?.onWarning,
+            runtimeDecoding: settings?.runtimeDecoding ?? "prefer",
+        };
         // Try specified format first
         if (format) {
             const handler = Image.formats.find((f) => f.name === format);
             if (handler && handler.canDecode(data)) {
-                image.imageData = await handler.decode(data);
+                image.imageData = await handler.decode(data, normalizedSettings);
                 return image;
             }
         }
         // Auto-detect format
         for (const handler of Image.formats) {
             if (handler.canDecode(data)) {
-                image.imageData = await handler.decode(data);
+                image.imageData = await handler.decode(data, normalizedSettings);
                 return image;
             }
         }
@@ -230,26 +241,31 @@ class Image {
      * @returns Image instance
      */
     static read(data, format) {
-        return Image.decode(data, format);
+        return format ? Image.decode(data, format) : Image.decode(data);
     }
-    /**
-     * Decode all frames from a multi-frame image (GIF animation, multi-page TIFF)
-     * @param data Raw image data
-     * @param format Optional format hint (e.g., "gif", "tiff")
-     * @returns MultiFrameImageData with all frames
-     */
-    static async decodeFrames(data, format) {
+    static async decodeFrames(data, formatOrOptions, options) {
+        if (typeof formatOrOptions === "string") {
+            return await Image.decodeFramesWithSettings(data, formatOrOptions, options);
+        }
+        return await Image.decodeFramesWithSettings(data, undefined, formatOrOptions);
+    }
+    static async decodeFramesWithSettings(data, format, settings) {
+        const normalizedSettings = {
+            tolerantDecoding: settings?.tolerantDecoding ?? true,
+            onWarning: settings?.onWarning,
+            runtimeDecoding: settings?.runtimeDecoding ?? "prefer",
+        };
         // Try specified format first
         if (format) {
             const handler = Image.formats.find((f) => f.name === format);
             if (handler && handler.canDecode(data) && handler.decodeFrames) {
-                return await handler.decodeFrames(data);
+                return await handler.decodeFrames(data, normalizedSettings);
             }
         }
         // Auto-detect format
         for (const handler of Image.formats) {
             if (handler.canDecode(data) && handler.decodeFrames) {
-                return await handler.decodeFrames(data);
+                return await handler.decodeFrames(data, normalizedSettings);
             }
         }
         throw new Error("Unsupported or unrecognized multi-frame image format");
@@ -262,7 +278,7 @@ class Image {
      * @returns MultiFrameImageData with all frames
      */
     static readFrames(data, format) {
-        return Image.decodeFrames(data, format);
+        return format ? Image.decodeFrames(data, format) : Image.decodeFrames(data);
     }
     /**
      * Encode multi-frame image data to bytes in the specified format
@@ -851,6 +867,34 @@ class Image {
         this.imageData.data = (0, image_processing_js_1.flipVertical)(this.imageData.data, this.imageData.width, this.imageData.height);
         return this;
     }
+    /**
+     * Convert the image to CMYK color space
+     * Returns a Float32Array with 4 values per pixel (C, M, Y, K) in 0-1 range
+     * @returns CMYK image data as Float32Array
+     */
+    toCMYK() {
+        if (!this.imageData)
+            throw new Error("No image loaded");
+        return (0, image_processing_js_1.rgbaToCmyk)(this.imageData.data);
+    }
+    /**
+     * Create an Image from CMYK data
+     * @param cmykData CMYK image data (4 values per pixel in 0-1 range)
+     * @param width Image width
+     * @param height Image height
+     * @param alpha Optional alpha value for all pixels (0-255, default: 255)
+     * @returns New Image instance
+     */
+    static fromCMYK(cmykData, width, height, alpha = 255) {
+        const rgbaData = (0, image_processing_js_1.cmykToRgba)(cmykData, alpha);
+        const image = new Image();
+        image.imageData = {
+            width,
+            height,
+            data: rgbaData,
+        };
+        return image;
+    }
 }
 exports.Image = Image;
 Object.defineProperty(Image, "formats", {