cross-image 0.2.4 → 0.4.0

package/script/src/formats/dng.js

@@ -77,7 +77,7 @@ class DNGFormat extends tiff_js_1.TIFFFormat {
      * @param imageData Image data to encode
      * @returns Encoded DNG image bytes
      */
-    encode(imageData) {
+    encode(imageData, _options) {
         const { width, height, data } = imageData;
         // We'll create a Linear DNG (demosaiced RGB)
         // This is very similar to a standard TIFF but with specific tags.

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, ImageMetadata, MultiFrameImageData } from "../types.js";
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata, MultiFrameImageData } from "../types.js";
 /**
  * GIF format handler
  * Now includes pure-JS implementation with custom LZW compression/decompression
@@ -32,18 +32,18 @@ export declare class GIFFormat implements ImageFormat {
      * @param data Raw GIF image data
      * @returns Decoded image data with RGBA pixels of first frame
      */
-    decode(data: Uint8Array): Promise<ImageData>;
+    decode(data: Uint8Array, settings?: ImageDecoderOptions): Promise<ImageData>;
     private extractGIFMetadata;
     /**
      * Encode RGBA image data to GIF format (single frame)
      * @param imageData Image data to encode
      * @returns Encoded GIF image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, _options?: unknown): Promise<Uint8Array>;
     /**
      * Decode all frames from an animated GIF
      */
-    decodeFrames(data: Uint8Array): Promise<MultiFrameImageData>;
+    decodeFrames(data: Uint8Array, settings?: ImageDecoderOptions): Promise<MultiFrameImageData>;
     /**
      * Encode multi-frame image data to animated GIF
      */

package/script/src/formats/gif.js

@@ -59,13 +59,16 @@ class GIFFormat {
      * @param data Raw GIF image data
      * @returns Decoded image data with RGBA pixels of first frame
      */
-    async decode(data) {
+    async decode(data, settings) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid GIF signature");
         }
-        // Try pure-JS decoder first
+        // Try pure-JS decoder first with tolerant decoding enabled by default
         try {
-            const decoder = new gif_decoder_js_1.GIFDecoder(data);
+            const decoder = new gif_decoder_js_1.GIFDecoder(data, {
+                tolerantDecoding: settings?.tolerantDecoding ?? true,
+                onWarning: settings?.onWarning,
+            });
             const result = decoder.decode();
             // Validate dimensions for security (prevent integer overflow and heap exhaustion)
             (0, security_js_1.validateImageDimensions)(result.width, result.height);
@@ -78,9 +81,8 @@ class GIFFormat {
                 metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
             };
         }
-        catch (error) {
+        catch (_error) {
             // Fall back to runtime decoder if pure-JS fails
-            console.warn("Pure-JS GIF decoder failed, falling back to runtime:", error);
             let pos = 6; // Skip "GIF89a" or "GIF87a"
             const width = (0, byte_utils_js_1.readUint16LE)(data, pos);
             pos += 2;
@@ -154,7 +156,7 @@ class GIFFormat {
      * @param imageData Image data to encode
      * @returns Encoded GIF image bytes
      */
-    async encode(imageData) {
+    async encode(imageData, _options) {
         const { width, height, data, metadata } = imageData;
         // Try pure-JS encoder first
         try {
@@ -167,9 +169,8 @@ class GIFFormat {
             }
             return encoded;
         }
-        catch (error) {
+        catch (_error) {
             // Fall back to runtime encoding if pure-JS fails
-            console.warn("Pure-JS GIF encoder failed, falling back to runtime:", error);
             if (typeof OffscreenCanvas !== "undefined") {
                 try {
                     const canvas = new OffscreenCanvas(width, height);
@@ -202,12 +203,15 @@ class GIFFormat {
     /**
      * Decode all frames from an animated GIF
      */
-    decodeFrames(data) {
+    decodeFrames(data, settings) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid GIF signature");
         }
         try {
-            const decoder = new gif_decoder_js_1.GIFDecoder(data);
+            const decoder = new gif_decoder_js_1.GIFDecoder(data, {
+                tolerantDecoding: settings?.tolerantDecoding ?? true,
+                onWarning: settings?.onWarning,
+            });
             const result = decoder.decodeAllFrames();
             // Extract metadata from comment extensions
             const metadata = this.extractGIFMetadata(data);

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, ImageMetadata } from "../types.js";
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata } from "../types.js";
 /**
  * HEIC format handler
  * Supports HEIC/HEIF images using runtime APIs (ImageDecoder/OffscreenCanvas)
@@ -21,7 +21,7 @@ export declare class HEICFormat implements ImageFormat {
      * @param data Raw HEIC 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 HEIC format
      * Uses runtime APIs (OffscreenCanvas) for encoding
@@ -32,7 +32,7 @@ export declare class HEICFormat implements ImageFormat {
      * @param imageData Image data to encode
      * @returns Encoded HEIC image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, _options?: unknown): Promise<Uint8Array>;
     /**
      * Decode using runtime APIs
      * @param data Raw HEIC data

package/script/src/formats/heic.js

@@ -53,10 +53,13 @@ class HEICFormat {
      * @param data Raw HEIC image data
      * @returns Decoded image data with RGBA pixels
      */
-    async decode(data) {
+    async decode(data, settings) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid HEIC signature");
         }
+        if (settings?.runtimeDecoding === "never") {
+            throw new Error("HEIC decoding requires runtime APIs; set runtimeDecoding to 'prefer'");
+        }
         // Extract metadata before decoding pixels
         const metadata = await this.extractMetadata(data);
         // Use runtime decoder
@@ -80,8 +83,8 @@ class HEICFormat {
      * @param imageData Image data to encode
      * @returns Encoded HEIC image bytes
      */
-    async encode(imageData) {
-        const { width, height, data, metadata } = imageData;
+    async encode(imageData, _options) {
+        const { width, height, data, metadata: _metadata } = imageData;
         // Try to use runtime encoding if available
         if (typeof OffscreenCanvas !== "undefined") {
             try {
@@ -102,10 +105,7 @@ class HEICFormat {
                     // parsing and modifying the ISOBMFF container structure
                     // For now, we rely on the runtime encoder to preserve metadata
                     // if it was passed through the canvas
-                    if (metadata) {
-                        // Future enhancement: inject metadata into HEIC container
-                        console.warn("HEIC metadata injection not yet implemented, metadata may be lost");
-                    }
+                    // Future enhancement: inject metadata into HEIC container
                     return encoded;
                 }
             }

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, ImageMetadata } from "../types.js";
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata } from "../types.js";
 /**
  * ICO format handler
  * Implements a pure JavaScript ICO (Windows Icon) decoder and encoder
@@ -24,7 +24,7 @@ export declare class ICOFormat implements ImageFormat {
      * @param data Raw ICO image data
      * @returns Decoded image data with RGBA pixels
      */
-    decode(data: Uint8Array): Promise<ImageData>;
+    decode(data: Uint8Array, options?: ImageDecoderOptions): Promise<ImageData>;
     /**
      * Decode a DIB (Device Independent Bitmap) format
      * This is a BMP without the 14-byte file header
@@ -36,7 +36,7 @@ export declare class ICOFormat implements ImageFormat {
      * @param imageData Image data to encode
      * @returns Encoded ICO image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, _options?: unknown): Promise<Uint8Array>;
     /**
      * Get the list of metadata fields supported by ICO format
      */

package/script/src/formats/ico.js

@@ -52,7 +52,7 @@ class ICOFormat {
      * @param data Raw ICO image data
      * @returns Decoded image data with RGBA pixels
      */
-    async decode(data) {
+    async decode(data, options) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid ICO signature");
         }
@@ -103,7 +103,7 @@ class ICOFormat {
             imageData[2] === 0x4e &&
             imageData[3] === 0x47) {
             // It's a PNG, decode it
-            return await this.pngFormat.decode(imageData);
+            return await this.pngFormat.decode(imageData, options);
         }
         // Otherwise, it's a BMP without the file header (DIB format)
         return this.decodeDIB(imageData);
@@ -185,10 +185,10 @@ class ICOFormat {
      * @param imageData Image data to encode
      * @returns Encoded ICO image bytes
      */
-    async encode(imageData) {
+    async encode(imageData, _options) {
         const { width, height } = imageData;
         // Encode the image as PNG
-        const pngData = await this.pngFormat.encode(imageData);
+        const pngData = await this.pngFormat.encode(imageData, undefined);
         // Create ICO file structure
         // ICONDIR (6 bytes) + ICONDIRENTRY (16 bytes) + PNG data
         const icoSize = 6 + 16 + pngData.length;

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, ImageMetadata } from "../types.js";
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata, JPEGEncoderOptions } from "../types.js";
 /**
  * JPEG format handler
  * Implements a basic JPEG decoder and encoder
@@ -19,13 +19,13 @@ export declare class JPEGFormat implements ImageFormat {
      * @param data Raw JPEG 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 JPEG format
      * @param imageData Image data to encode
      * @returns Encoded JPEG image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, options?: JPEGEncoderOptions): Promise<Uint8Array>;
     private injectMetadata;
     private decodeUsingRuntime;
     private parseJFIF;

package/script/src/formats/jpeg.js

@@ -73,7 +73,7 @@ class JPEGFormat {
      * @param data Raw JPEG image data
      * @returns Decoded image data with RGBA pixels
      */
-    async decode(data) {
+    async decode(data, settings) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid JPEG signature");
         }
@@ -131,7 +131,7 @@ class JPEGFormat {
         (0, security_js_1.validateImageDimensions)(width, height);
         // For a pure JS implementation, we'd need to implement full JPEG 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,
@@ -144,10 +144,13 @@ class JPEGFormat {
      * @param imageData Image data to encode
      * @returns Encoded JPEG image bytes
      */
-    async encode(imageData) {
+    async encode(imageData, options) {
         const { width, height, data, metadata } = imageData;
+        const requestedQuality = options?.quality;
+        const requestedProgressive = options?.progressive;
         // Try to use runtime encoding if available (better quality)
-        if (typeof OffscreenCanvas !== "undefined") {
+        // Note: progressive output is only supported by the pure-JS encoder.
+        if (!requestedProgressive && typeof OffscreenCanvas !== "undefined") {
             try {
                 const canvas = new OffscreenCanvas(width, height);
                 const ctx = canvas.getContext("2d");
@@ -156,9 +159,12 @@ class JPEGFormat {
                     const imgDataData = new Uint8ClampedArray(data);
                     imgData.data.set(imgDataData);
                     ctx.putImageData(imgData, 0, 0);
+                    const quality = requestedQuality === undefined
+                        ? 0.9
+                        : Math.max(1, Math.min(100, requestedQuality)) / 100;
                     const blob = await canvas.convertToBlob({
                         type: "image/jpeg",
-                        quality: 0.9,
+                        quality,
                     });
                     const arrayBuffer = await blob.arrayBuffer();
                     const encoded = new Uint8Array(arrayBuffer);
@@ -177,7 +183,10 @@ class JPEGFormat {
         const { JPEGEncoder } = await Promise.resolve().then(() => __importStar(require("../utils/jpeg_encoder.js")));
         const dpiX = metadata?.dpiX ?? 72;
         const dpiY = metadata?.dpiY ?? 72;
-        const encoder = new JPEGEncoder(85); // Quality 85
+        const encoder = new JPEGEncoder({
+            quality: requestedQuality,
+            progressive: requestedProgressive,
+        });
         const encoded = encoder.encode(width, height, data, dpiX, dpiY);
         // Add EXIF metadata if present
         if (metadata && Object.keys(metadata).length > 0) {
@@ -221,9 +230,10 @@ class JPEGFormat {
         result.set(encoded.slice(pos), pos + app1.length);
         return result;
     }
-    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/jpeg" });
                 const result = await decoder.decode();
@@ -238,15 +248,17 @@ class JPEGFormat {
                 bitmap.close();
                 return new Uint8Array(imageData.data.buffer);
             }
-            catch (error) {
+            catch (_error) {
                 // ImageDecoder API failed, fall through to pure JS decoder
-                console.warn("JPEG decoding with ImageDecoder failed, using pure JS decoder:", error);
             }
         }
         // Fallback to pure JavaScript decoder
         try {
             const { JPEGDecoder } = await Promise.resolve().then(() => __importStar(require("../utils/jpeg_decoder.js")));
-            const decoder = new JPEGDecoder(data);
+            const decoder = new JPEGDecoder(data, {
+                tolerantDecoding: settings?.tolerantDecoding ?? true,
+                onWarning: settings?.onWarning,
+            });
             return decoder.decode();
         }
         catch (error) {

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, ImageMetadata } from "../types.js";
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata } from "../types.js";
 /**
  * PAM format handler
  * Implements the Netpbm PAM (Portable Arbitrary Map) format.
@@ -32,13 +32,13 @@ export declare class PAMFormat implements ImageFormat {
      * @param data Raw PAM 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 PAM format
      * @param imageData Image data to encode
      * @returns Encoded PAM image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, _options?: unknown): Promise<Uint8Array>;
     /**
      * Get the list of metadata fields supported by PAM format
      */

package/script/src/formats/pam.js

@@ -56,7 +56,7 @@ 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");
         }
@@ -153,7 +153,7 @@ 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/script/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/script/src/formats/pcx.js

@@ -31,7 +31,7 @@ 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"));
         }
@@ -137,7 +137,7 @@ class PCXFormat {
             data: rgba,
         });
     }
-    encode(image) {
+    encode(image, _options) {
         const width = image.width;
         const height = image.height;
         const data = image.data;

package/script/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/script/src/formats/png.js

@@ -43,7 +43,7 @@ class PNGFormat extends png_base_js_1.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");
         }
@@ -115,7 +115,7 @@ class PNGFormat extends png_base_js_1.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/script/src/formats/png_base.js

@@ -108,9 +108,7 @@ 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;
@@ -124,8 +122,7 @@ 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/script/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/script/src/formats/ppm.js

@@ -59,7 +59,7 @@ 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");
         }
@@ -211,7 +211,7 @@ 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/script/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;