cross-image 0.2.4 → 0.4.1

package/esm/src/formats/jpeg.js

@@ -37,7 +37,7 @@ export 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");
         }
@@ -95,7 +95,7 @@ export class JPEGFormat {
         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,
@@ -108,10 +108,13 @@ export 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");
@@ -120,9 +123,12 @@ export 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);
@@ -141,7 +147,10 @@ export class JPEGFormat {
         const { JPEGEncoder } = await import("../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) {
@@ -185,9 +194,10 @@ export 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();
@@ -202,15 +212,17 @@ export 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 import("../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/esm/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/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, PNGEncoderOptions } from "../types.js";
 import { PNGBase } from "./png_base.js";
 /**
  * PNG format handler
@@ -20,13 +20,14 @@ 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
+     * @param options Encoding options (compressionLevel 0-9, default 6)
      * @returns Encoded PNG image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, options?: PNGEncoderOptions): 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");
         }
@@ -110,10 +110,16 @@ export class PNGFormat extends PNGBase {
     /**
      * Encode RGBA image data to PNG format
      * @param imageData Image data to encode
+     * @param options Encoding options (compressionLevel 0-9, default 6)
      * @returns Encoded PNG image bytes
      */
-    async encode(imageData) {
+    async encode(imageData, options) {
         const { width, height, data, metadata } = imageData;
+        const compressionLevel = options?.compressionLevel ?? 6;
+        // Validate compression level
+        if (compressionLevel < 0 || compressionLevel > 9) {
+            throw new Error("Compression level must be between 0 and 9");
+        }
         // Prepare IHDR chunk
         const ihdr = new Uint8Array(13);
         this.writeUint32(ihdr, 0, width);
@@ -124,7 +130,7 @@ export class PNGFormat extends PNGBase {
         ihdr[11] = 0; // filter method
         ihdr[12] = 0; // interlace method
         // Filter and compress image data
-        const filtered = this.filterData(data, width, height);
+        const filtered = this.filterData(data, width, height, compressionLevel);
         const compressed = await this.deflate(filtered);
         // Build PNG
         const chunks = [];

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

@@ -43,7 +43,48 @@ export declare abstract class PNGBase {
     /**
      * Filter PNG data for encoding (using filter type 0 - None)
      */
-    protected filterData(data: Uint8Array, width: number, height: number): Uint8Array;
+    /**
+     * Apply PNG filter to image data based on compression level
+     * @param data Raw RGBA pixel data
+     * @param width Image width
+     * @param height Image height
+     * @param compressionLevel Compression level (0-9, default 6)
+     * @returns Filtered data with filter type byte per scanline
+     */
+    protected filterData(data: Uint8Array, width: number, height: number, compressionLevel?: number): Uint8Array;
+    /**
+     * Apply filter type 0 (None) - no filtering
+     */
+    private applyNoFilter;
+    /**
+     * Apply filter type 1 (Sub) - subtract left pixel
+     */
+    private applySubFilter;
+    /**
+     * Apply filter type 2 (Up) - subtract above pixel
+     */
+    private applyUpFilter;
+    /**
+     * Apply filter type 3 (Average) - subtract average of left and above
+     */
+    private applyAverageFilter;
+    /**
+     * Apply filter type 4 (Paeth) - Paeth predictor
+     */
+    private applyPaethFilter;
+    /**
+     * Calculate sum of absolute differences for a filtered scanline
+     * Lower values indicate better compression potential
+     */
+    private calculateFilterScore;
+    /**
+     * Apply adaptive filtering - choose best filter per scanline
+     */
+    private applyAdaptiveFilter;
+    /**
+     * Filter a single scanline with specified filter type
+     */
+    private filterScanline;
     /**
      * Get bytes per pixel for a given color type and bit depth
      */

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;
             }
         }
@@ -144,18 +141,211 @@ export class PNGBase {
     /**
      * Filter PNG data for encoding (using filter type 0 - None)
      */
-    filterData(data, width, height) {
-        // Use filter type 0 (None) for simplicity
-        const filtered = new Uint8Array(height * (1 + width * 4));
+    /**
+     * Apply PNG filter to image data based on compression level
+     * @param data Raw RGBA pixel data
+     * @param width Image width
+     * @param height Image height
+     * @param compressionLevel Compression level (0-9, default 6)
+     * @returns Filtered data with filter type byte per scanline
+     */
+    filterData(data, width, height, compressionLevel = 6) {
+        // Choose filtering strategy based on compression level
+        if (compressionLevel <= 2) {
+            // Fast: No filtering
+            return this.applyNoFilter(data, width, height);
+        }
+        else if (compressionLevel <= 6) {
+            // Balanced: Sub filter
+            return this.applySubFilter(data, width, height);
+        }
+        else {
+            // Best: Adaptive filtering (choose best filter per scanline)
+            return this.applyAdaptiveFilter(data, width, height);
+        }
+    }
+    /**
+     * Apply filter type 0 (None) - no filtering
+     */
+    applyNoFilter(data, width, height) {
+        const bytesPerScanline = width * 4;
+        const filtered = new Uint8Array(height * (1 + bytesPerScanline));
         let pos = 0;
         for (let y = 0; y < height; y++) {
             filtered[pos++] = 0; // Filter type: None
-            for (let x = 0; x < width * 4; x++) {
-                filtered[pos++] = data[y * width * 4 + x];
+            const scanlineStart = y * bytesPerScanline;
+            for (let x = 0; x < bytesPerScanline; x++) {
+                filtered[pos++] = data[scanlineStart + x];
+            }
+        }
+        return filtered;
+    }
+    /**
+     * Apply filter type 1 (Sub) - subtract left pixel
+     */
+    applySubFilter(data, width, height) {
+        const bytesPerScanline = width * 4;
+        const filtered = new Uint8Array(height * (1 + bytesPerScanline));
+        let pos = 0;
+        for (let y = 0; y < height; y++) {
+            filtered[pos++] = 1; // Filter type: Sub
+            const scanlineStart = y * bytesPerScanline;
+            for (let x = 0; x < bytesPerScanline; x++) {
+                const current = data[scanlineStart + x];
+                const left = x >= 4 ? data[scanlineStart + x - 4] : 0;
+                filtered[pos++] = (current - left) & 0xff;
+            }
+        }
+        return filtered;
+    }
+    /**
+     * Apply filter type 2 (Up) - subtract above pixel
+     */
+    applyUpFilter(data, width, height) {
+        const bytesPerScanline = width * 4;
+        const filtered = new Uint8Array(height * (1 + bytesPerScanline));
+        let pos = 0;
+        for (let y = 0; y < height; y++) {
+            filtered[pos++] = 2; // Filter type: Up
+            const scanlineStart = y * bytesPerScanline;
+            const prevScanlineStart = (y - 1) * bytesPerScanline;
+            for (let x = 0; x < bytesPerScanline; x++) {
+                const current = data[scanlineStart + x];
+                const up = y > 0 ? data[prevScanlineStart + x] : 0;
+                filtered[pos++] = (current - up) & 0xff;
+            }
+        }
+        return filtered;
+    }
+    /**
+     * Apply filter type 3 (Average) - subtract average of left and above
+     */
+    applyAverageFilter(data, width, height) {
+        const bytesPerScanline = width * 4;
+        const filtered = new Uint8Array(height * (1 + bytesPerScanline));
+        let pos = 0;
+        for (let y = 0; y < height; y++) {
+            filtered[pos++] = 3; // Filter type: Average
+            const scanlineStart = y * bytesPerScanline;
+            const prevScanlineStart = (y - 1) * bytesPerScanline;
+            for (let x = 0; x < bytesPerScanline; x++) {
+                const current = data[scanlineStart + x];
+                const left = x >= 4 ? data[scanlineStart + x - 4] : 0;
+                const up = y > 0 ? data[prevScanlineStart + x] : 0;
+                const avg = Math.floor((left + up) / 2);
+                filtered[pos++] = (current - avg) & 0xff;
             }
         }
         return filtered;
     }
+    /**
+     * Apply filter type 4 (Paeth) - Paeth predictor
+     */
+    applyPaethFilter(data, width, height) {
+        const bytesPerScanline = width * 4;
+        const filtered = new Uint8Array(height * (1 + bytesPerScanline));
+        let pos = 0;
+        for (let y = 0; y < height; y++) {
+            filtered[pos++] = 4; // Filter type: Paeth
+            const scanlineStart = y * bytesPerScanline;
+            const prevScanlineStart = (y - 1) * bytesPerScanline;
+            for (let x = 0; x < bytesPerScanline; x++) {
+                const current = data[scanlineStart + x];
+                const left = x >= 4 ? data[scanlineStart + x - 4] : 0;
+                const up = y > 0 ? data[prevScanlineStart + x] : 0;
+                const upLeft = (y > 0 && x >= 4) ? data[prevScanlineStart + x - 4] : 0;
+                const paeth = this.paethPredictor(left, up, upLeft);
+                filtered[pos++] = (current - paeth) & 0xff;
+            }
+        }
+        return filtered;
+    }
+    /**
+     * Calculate sum of absolute differences for a filtered scanline
+     * Lower values indicate better compression potential
+     */
+    calculateFilterScore(filtered) {
+        let sum = 0;
+        for (let i = 1; i < filtered.length; i++) {
+            const byte = filtered[i];
+            // Penalize larger absolute values
+            sum += byte < 128 ? byte : (256 - byte);
+        }
+        return sum;
+    }
+    /**
+     * Apply adaptive filtering - choose best filter per scanline
+     */
+    applyAdaptiveFilter(data, width, height) {
+        const bytesPerScanline = width * 4;
+        const filtered = new Uint8Array(height * (1 + bytesPerScanline));
+        let outPos = 0;
+        // Try each filter type and choose the best for each scanline
+        const filters = [
+            (y) => this.filterScanline(data, y, width, 0), // None
+            (y) => this.filterScanline(data, y, width, 1), // Sub
+            (y) => this.filterScanline(data, y, width, 2), // Up
+            (y) => this.filterScanline(data, y, width, 3), // Average
+            (y) => this.filterScanline(data, y, width, 4), // Paeth
+        ];
+        for (let y = 0; y < height; y++) {
+            let bestFilter = null;
+            let bestScore = Infinity;
+            // Try each filter type
+            for (const filterFn of filters) {
+                const result = filterFn(y);
+                const score = this.calculateFilterScore(result);
+                if (score < bestScore) {
+                    bestScore = score;
+                    bestFilter = result;
+                }
+            }
+            // Copy best filter result
+            if (bestFilter) {
+                filtered.set(bestFilter, outPos);
+                outPos += bestFilter.length;
+            }
+        }
+        return filtered;
+    }
+    /**
+     * Filter a single scanline with specified filter type
+     */
+    filterScanline(data, y, width, filterType) {
+        const bytesPerScanline = width * 4;
+        const result = new Uint8Array(1 + bytesPerScanline);
+        result[0] = filterType;
+        const scanlineStart = y * bytesPerScanline;
+        const prevScanlineStart = (y - 1) * bytesPerScanline;
+        for (let x = 0; x < bytesPerScanline; x++) {
+            const current = data[scanlineStart + x];
+            const left = x >= 4 ? data[scanlineStart + x - 4] : 0;
+            const up = y > 0 ? data[prevScanlineStart + x] : 0;
+            const upLeft = (y > 0 && x >= 4) ? data[prevScanlineStart + x - 4] : 0;
+            let filtered;
+            switch (filterType) {
+                case 0: // None
+                    filtered = current;
+                    break;
+                case 1: // Sub
+                    filtered = (current - left) & 0xff;
+                    break;
+                case 2: // Up
+                    filtered = (current - up) & 0xff;
+                    break;
+                case 3: // Average
+                    filtered = (current - Math.floor((left + up) / 2)) & 0xff;
+                    break;
+                case 4: // Paeth
+                    filtered = (current - this.paethPredictor(left, up, upLeft)) & 0xff;
+                    break;
+                default:
+                    filtered = current;
+            }
+            result[x + 1] = filtered;
+        }
+        return result;
+    }
     /**
      * Get bytes per pixel for a given color type and bit depth
      */

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;