cross-image 0.2.4 → 0.4.0

package/script/src/formats/tiff.js

@@ -2,14 +2,16 @@
 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");
 // 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 +57,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,7 +133,7 @@ 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";
@@ -175,6 +177,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;
@@ -332,7 +344,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 +407,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 +432,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 +474,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 +497,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 +612,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 +736,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 +774,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,8 +788,9 @@ 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
@@ -791,6 +832,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);
@@ -842,11 +893,12 @@ 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
@@ -888,6 +940,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);
@@ -1006,9 +1068,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.

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

package/script/src/types.d.ts

@@ -138,7 +138,7 @@ export interface ResizeOptions {
 /**
  * Options for ASCII art encoding
  */
-export interface ASCIIOptions {
+export interface ASCIIEncoderOptions {
     /** Target width in characters (default: 80) */
     width?: number;
     /** Character set to use (default: "simple") */
@@ -148,10 +148,21 @@ export interface ASCIIOptions {
     /** Whether to invert brightness (default: false) */
     invert?: boolean;
 }
+/**
+ * Options for TIFF encoding.
+ */
+export interface TIFFEncoderOptions {
+    /** Compression method: "none" (default), "lzw", "packbits", or "deflate" */
+    compression?: "none" | "lzw" | "packbits" | "deflate";
+    /** Encode as grayscale instead of RGB/RGBA (default: false) */
+    grayscale?: boolean;
+    /** Encode as RGB without alpha channel (default: false, ignored if grayscale is true) */
+    rgb?: boolean;
+}
 /**
  * Options for WebP encoding
  */
-export interface WebPEncodeOptions {
+export interface WebPEncoderOptions {
     /**
      * Encoding quality (1-100, default: 90)
      * - 100 = lossless (VP8L)
@@ -164,6 +175,47 @@ export interface WebPEncodeOptions {
      */
     lossless?: boolean;
 }
+/**
+ * Options for JPEG encoding.
+ */
+export interface JPEGEncoderOptions {
+    /**
+     * Encoding quality (1-100, default depends on encoder backend).
+     */
+    quality?: number;
+    /**
+     * Enable progressive JPEG output when using the pure-JS encoder.
+     * Runtime encoders do not currently expose a progressive toggle.
+     */
+    progressive?: boolean;
+}
+/**
+ * Common options for decode APIs.
+ *
+ * These options are runtime-agnostic and can be passed to `Image.decode()` and
+ * `Image.decodeFrames()`.
+ */
+export interface ImageDecoderOptions {
+    /**
+     * Controls tolerant decoding in the pure-JS decoders.
+     *
+     * - true (default): try to recover from corruption and continue
+     * - false: strict mode (fail fast)
+     */
+    tolerantDecoding?: boolean;
+    /**
+     * Optional warning callback used by pure-JS decoders when non-fatal issues are
+     * encountered.
+     */
+    onWarning?: (message: string, details?: unknown) => void;
+    /**
+     * Runtime decoder strategy.
+     *
+     * - "prefer" (default): try runtime decoders first (ImageDecoder/Canvas), then fall back to pure JS
+     * - "never": skip runtime decoders and use pure JS when available
+     */
+    runtimeDecoding?: "prefer" | "never";
+}
 /**
  * Image format handler interface
  */
@@ -177,7 +229,7 @@ export interface ImageFormat {
      * @param data Raw image data
      * @returns Decoded image data
      */
-    decode(data: Uint8Array): Promise<ImageData>;
+    decode(data: Uint8Array, options?: ImageDecoderOptions): Promise<ImageData>;
     /**
      * Encode image data to bytes
      * @param imageData Image data to encode
@@ -196,7 +248,7 @@ export interface ImageFormat {
      * @param data Raw image data
      * @returns Decoded multi-frame image data
      */
-    decodeFrames?(data: Uint8Array): Promise<MultiFrameImageData>;
+    decodeFrames?(data: Uint8Array, options?: ImageDecoderOptions): Promise<MultiFrameImageData>;
     /**
      * Encode multi-frame image data to bytes (optional)
      * @param imageData Multi-frame image data to encode

package/script/src/utils/gif_decoder.d.ts

@@ -2,6 +2,7 @@
  * Pure JavaScript GIF decoder implementation
  * Supports GIF87a and GIF89a formats with LZW decompression
  */
+import type { ImageDecoderOptions } from "../types.js";
 interface GIFImage {
     width: number;
     height: number;
@@ -19,7 +20,8 @@ interface GIFFrame {
 export declare class GIFDecoder {
     private data;
     private pos;
-    constructor(data: Uint8Array);
+    private options;
+    constructor(data: Uint8Array, settings?: ImageDecoderOptions);
     private readByte;
     private readUint16LE;
     private readBytes;
@@ -36,6 +38,7 @@ export declare class GIFDecoder {
         frames: GIFFrame[];
     };
     private indexedToRGBA;
+    private decodeFrame;
     private deinterlace;
 }
 export {};