cross-image 0.2.4 → 0.4.0

package/esm/src/formats/pam.js

@@ -53,7 +53,7 @@ export class PAMFormat {
      * @param data Raw PAM image data
      * @returns Decoded image data with RGBA pixels
      */
-    decode(data) {
+    decode(data, _options) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid PAM signature");
         }
@@ -150,7 +150,7 @@ export class PAMFormat {
      * @param imageData Image data to encode
      * @returns Encoded PAM image bytes
      */
-    encode(imageData) {
+    encode(imageData, _options) {
         const { width, height, data } = imageData;
         // Validate input
         if (data.length !== width * height * 4) {

package/esm/src/formats/pcx.d.ts

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, ImageMetadata } from "../types.js";
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata } from "../types.js";
 /**
  * PCX format handler
  * Implements PCX decoder and encoder
@@ -7,8 +7,8 @@ export declare class PCXFormat implements ImageFormat {
     readonly name = "pcx";
     readonly mimeType = "image/x-pcx";
     canDecode(data: Uint8Array): boolean;
-    decode(data: Uint8Array): Promise<ImageData>;
-    encode(image: ImageData): Promise<Uint8Array>;
+    decode(data: Uint8Array, _options?: ImageDecoderOptions): Promise<ImageData>;
+    encode(image: ImageData, _options?: unknown): Promise<Uint8Array>;
     /**
      * Get the list of metadata fields supported by PCX format
      */

package/esm/src/formats/pcx.js

@@ -28,7 +28,7 @@ export class PCXFormat {
                 data[1] === 5) &&
             data[2] === 1;
     }
-    decode(data) {
+    decode(data, _options) {
         if (!this.canDecode(data)) {
             return Promise.reject(new Error("Invalid PCX data"));
         }
@@ -134,7 +134,7 @@ export class PCXFormat {
             data: rgba,
         });
     }
-    encode(image) {
+    encode(image, _options) {
         const width = image.width;
         const height = image.height;
         const data = image.data;

package/esm/src/formats/png.d.ts

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, ImageMetadata } from "../types.js";
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata } from "../types.js";
 import { PNGBase } from "./png_base.js";
 /**
  * PNG format handler
@@ -20,13 +20,13 @@ export declare class PNGFormat extends PNGBase implements ImageFormat {
      * @param data Raw PNG image data
      * @returns Decoded image data with RGBA pixels
      */
-    decode(data: Uint8Array): Promise<ImageData>;
+    decode(data: Uint8Array, _options?: ImageDecoderOptions): Promise<ImageData>;
     /**
      * Encode RGBA image data to PNG format
      * @param imageData Image data to encode
      * @returns Encoded PNG image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, _options?: unknown): Promise<Uint8Array>;
     /**
      * Get the list of metadata fields supported by PNG format
      * Delegates to PNGBase implementation

package/esm/src/formats/png.js

@@ -40,7 +40,7 @@ export class PNGFormat extends PNGBase {
      * @param data Raw PNG image data
      * @returns Decoded image data with RGBA pixels
      */
-    async decode(data) {
+    async decode(data, _options) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid PNG signature");
         }
@@ -112,7 +112,7 @@ export class PNGFormat extends PNGBase {
      * @param imageData Image data to encode
      * @returns Encoded PNG image bytes
      */
-    async encode(imageData) {
+    async encode(imageData, _options) {
         const { width, height, data, metadata } = imageData;
         // Prepare IHDR chunk
         const ihdr = new Uint8Array(13);

package/esm/src/formats/png_base.js

@@ -105,9 +105,7 @@ export class PNGBase {
         for (let x = 0; x < scanline.length; x++) {
             const left = x >= bytesPerPixel ? scanline[x - bytesPerPixel] : 0;
             const above = prevLine ? prevLine[x] : 0;
-            const upperLeft = (x >= bytesPerPixel && prevLine)
-                ? prevLine[x - bytesPerPixel]
-                : 0;
+            const upperLeft = (x >= bytesPerPixel && prevLine) ? prevLine[x - bytesPerPixel] : 0;
             switch (filterType) {
                 case 0: // None
                     break;
@@ -121,8 +119,7 @@ export class PNGBase {
                     scanline[x] = (scanline[x] + Math.floor((left + above) / 2)) & 0xff;
                     break;
                 case 4: // Paeth
-                    scanline[x] =
-                        (scanline[x] + this.paethPredictor(left, above, upperLeft)) & 0xff;
+                    scanline[x] = (scanline[x] + this.paethPredictor(left, above, upperLeft)) & 0xff;
                     break;
             }
         }

package/esm/src/formats/ppm.d.ts

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, ImageMetadata } from "../types.js";
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata } from "../types.js";
 /**
  * PPM format handler
  * Implements the Netpbm PPM (Portable PixMap) format.
@@ -34,14 +34,14 @@ export declare class PPMFormat implements ImageFormat {
      * @param data Raw PPM image data
      * @returns Decoded image data with RGBA pixels
      */
-    decode(data: Uint8Array): Promise<ImageData>;
+    decode(data: Uint8Array, _options?: ImageDecoderOptions): Promise<ImageData>;
     /**
      * Encode RGBA image data to PPM format (P6 binary)
      * Note: Alpha channel is ignored as PPM doesn't support transparency
      * @param imageData Image data to encode
      * @returns Encoded PPM image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, _options?: unknown): Promise<Uint8Array>;
     /**
      * Check if a byte is whitespace (space, tab, CR, LF)
      */

package/esm/src/formats/ppm.js

@@ -56,7 +56,7 @@ export class PPMFormat {
      * @param data Raw PPM image data
      * @returns Decoded image data with RGBA pixels
      */
-    decode(data) {
+    decode(data, _options) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid PPM signature");
         }
@@ -208,7 +208,7 @@ export class PPMFormat {
      * @param imageData Image data to encode
      * @returns Encoded PPM image bytes
      */
-    encode(imageData) {
+    encode(imageData, _options) {
         const { width, height, data } = imageData;
         // Validate input
         if (data.length !== width * height * 4) {

package/esm/src/formats/tiff.d.ts

@@ -1,20 +1,9 @@
-import type { ImageData, ImageFormat, ImageMetadata, MultiFrameImageData } from "../types.js";
-/**
- * Options for TIFF encoding
- */
-export interface TIFFEncodeOptions {
-    /** Compression method: "none" for uncompressed (default), "lzw" for LZW compression */
-    compression?: "none" | "lzw";
-    /** Encode as grayscale instead of RGB/RGBA */
-    grayscale?: boolean;
-    /** Encode as RGB without alpha channel (ignored if grayscale is true) */
-    rgb?: boolean;
-}
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata, MultiFrameImageData } from "../types.js";
 /**
  * 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.
  */
 export declare class TIFFFormat implements ImageFormat {
@@ -38,12 +27,12 @@ export declare class TIFFFormat implements ImageFormat {
      * @param data Raw TIFF image data
      * @returns Decoded image data with RGBA pixels of first page
      */
-    decode(data: Uint8Array): Promise<ImageData>;
+    decode(data: Uint8Array, _options?: ImageDecoderOptions): Promise<ImageData>;
     encode(imageData: ImageData, options?: unknown): Promise<Uint8Array>;
     /**
      * Decode all pages from a multi-page TIFF
      */
-    decodeFrames(data: Uint8Array): Promise<MultiFrameImageData>;
+    decodeFrames(data: Uint8Array, _options?: ImageDecoderOptions): Promise<MultiFrameImageData>;
     /**
      * Encode multi-page TIFF
      */
@@ -65,7 +54,7 @@ export declare class TIFFFormat implements ImageFormat {
     private decodeUsingRuntime;
     private readString;
     /**
-     * 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
      */
     private decodePureJS;

package/esm/src/formats/tiff.js

@@ -1,12 +1,14 @@
 import { TIFFLZWDecoder, TIFFLZWEncoder } from "../utils/tiff_lzw.js";
+import { packBitsCompress, packBitsDecompress } from "../utils/tiff_packbits.js";
+import { deflateCompress, deflateDecompress } from "../utils/tiff_deflate.js";
 import { validateImageDimensions } from "../utils/security.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.
  */
 export class TIFFFormat {
@@ -52,7 +54,7 @@ export 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");
         }
@@ -128,7 +130,7 @@ export 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";
@@ -172,6 +174,16 @@ export class TIFFFormat {
             pixelData = encoder.compress(sourceData);
             compressionCode = 5;
         }
+        else if (compression === "packbits") {
+            // PackBits compress the pixel data
+            pixelData = packBitsCompress(sourceData);
+            compressionCode = 32773;
+        }
+        else if (compression === "deflate") {
+            // Deflate compress the pixel data
+            pixelData = await deflateCompress(sourceData);
+            compressionCode = 8;
+        }
         else {
             // Uncompressed
             pixelData = sourceData;
@@ -329,7 +341,7 @@ export 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");
         }
@@ -392,7 +404,7 @@ export 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) {
@@ -417,6 +429,12 @@ export class TIFFFormat {
                 const encoder = new TIFFLZWEncoder();
                 pixelData = encoder.compress(frame.data);
             }
+            else if (compression === "packbits") {
+                pixelData = packBitsCompress(frame.data);
+            }
+            else if (compression === "deflate") {
+                pixelData = await deflateCompress(frame.data);
+            }
             else {
                 pixelData = frame.data;
             }
@@ -453,7 +471,19 @@ export 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);
@@ -464,9 +494,19 @@ export class TIFFFormat {
             // RowsPerStrip
             this.writeIFDEntry(result, 0x0116, 4, 1, frame.height);
             // StripByteCounts
-            const pixelDataSize = compression === "lzw"
-                ? new TIFFLZWEncoder().compress(frame.data).length
-                : frame.data.length;
+            let pixelDataSize;
+            if (compression === "lzw") {
+                pixelDataSize = new TIFFLZWEncoder().compress(frame.data).length;
+            }
+            else if (compression === "packbits") {
+                pixelDataSize = packBitsCompress(frame.data).length;
+            }
+            else if (compression === "deflate") {
+                pixelDataSize = (await deflateCompress(frame.data)).length;
+            }
+            else {
+                pixelDataSize = frame.data.length;
+            }
             this.writeIFDEntry(result, 0x0117, 4, 1, pixelDataSize);
             // XResolution
             const xResOffset = dataOffset;
@@ -569,7 +609,7 @@ export 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;
             }
@@ -693,7 +733,7 @@ export 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;
             }
@@ -731,10 +771,10 @@ export 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;
@@ -745,8 +785,9 @@ export 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
@@ -788,6 +829,16 @@ export class TIFFFormat {
             const decoder = new TIFFLZWDecoder(compressedData);
             pixelData = decoder.decompress();
         }
+        else if (compression === 32773) {
+            // PackBits compressed
+            const compressedData = data.slice(stripOffset, stripOffset + stripByteCount);
+            pixelData = packBitsDecompress(compressedData);
+        }
+        else if (compression === 8) {
+            // Deflate compressed
+            const compressedData = data.slice(stripOffset, stripOffset + stripByteCount);
+            pixelData = await deflateDecompress(compressedData);
+        }
         else {
             // Uncompressed
             pixelData = data.slice(stripOffset, stripOffset + stripByteCount);
@@ -839,11 +890,12 @@ export 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
@@ -885,6 +937,16 @@ export class TIFFFormat {
             const decoder = new TIFFLZWDecoder(compressedData);
             pixelData = decoder.decompress();
         }
+        else if (compression === 32773) {
+            // PackBits compressed
+            const compressedData = data.slice(stripOffset, stripOffset + stripByteCount);
+            pixelData = packBitsDecompress(compressedData);
+        }
+        else if (compression === 8) {
+            // Deflate compressed
+            const compressedData = data.slice(stripOffset, stripOffset + stripByteCount);
+            pixelData = await deflateDecompress(compressedData);
+        }
         else {
             // Uncompressed
             pixelData = data.slice(stripOffset, stripOffset + stripByteCount);
@@ -1003,9 +1065,12 @@ export 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/esm/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/esm/src/formats/webp.js

@@ -42,7 +42,7 @@ export 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");
         }
@@ -108,7 +108,7 @@ export class WebPFormat {
         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,
@@ -171,9 +171,10 @@ export 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();
@@ -188,15 +189,17 @@ export 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 import("../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/esm/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.

package/esm/src/image.js

@@ -1,4 +1,4 @@
-import { resizeBicubic, resizeBilinear, resizeNearest, } from "./utils/resize.js";
+import { resizeBicubic, resizeBilinear, resizeNearest } from "./utils/resize.js";
 import { adjustBrightness, adjustContrast, adjustExposure, adjustHue, adjustSaturation, boxBlur, composite, crop, fillRect, flipHorizontal, flipVertical, gaussianBlur, grayscale, invert, medianFilter, rotate180, rotate270, rotate90, sepia, sharpen, } from "./utils/image_processing.js";
 import { PNGFormat } from "./formats/png.js";
 import { APNGFormat } from "./formats/apng.js";
@@ -158,26 +158,37 @@ export 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;
             }
         }
@@ -227,26 +238,31 @@ export 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");
@@ -259,7 +275,7 @@ export 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