cross-image 0.2.3 → 0.4.0

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat } from "../types.js";
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata } from "../types.js";
 /**
  * PPM format handler
  * Implements the Netpbm PPM (Portable PixMap) format.
@@ -34,17 +34,27 @@ 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)
      */
     private isWhitespace;
+    /**
+     * Get the list of metadata fields supported by PPM format
+     */
+    getSupportedMetadata(): Array<keyof ImageMetadata>;
+    /**
+     * Extract metadata from PPM data without fully decoding the pixel data
+     * @param data Raw PPM data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data: Uint8Array): Promise<ImageMetadata | undefined>;
 }
 //# sourceMappingURL=ppm.d.ts.map

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) {
@@ -239,4 +239,38 @@ export class PPMFormat {
     isWhitespace(byte) {
         return byte === 0x20 || byte === 0x09 || byte === 0x0a || byte === 0x0d;
     }
+    /**
+     * Get the list of metadata fields supported by PPM format
+     */
+    getSupportedMetadata() {
+        return []; // PPM format doesn't support metadata preservation
+    }
+    /**
+     * Extract metadata from PPM data without fully decoding the pixel data
+     * @param data Raw PPM data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data) {
+        if (!this.canDecode(data)) {
+            return Promise.resolve(undefined);
+        }
+        const metadata = {
+            format: "ppm",
+            compression: "none",
+            frameCount: 1,
+            bitDepth: 8,
+            colorType: "rgb",
+        };
+        // PPM is always RGB, uncompressed, and typically 8-bit
+        // P3 is ASCII, P6 is binary
+        if (data[1] === 0x33) {
+            // '3'
+            metadata.compression = "none"; // ASCII encoding
+        }
+        else if (data[1] === 0x36) {
+            // '6'
+            metadata.compression = "none"; // Binary encoding
+        }
+        return Promise.resolve(metadata);
+    }
 }

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;
@@ -79,5 +68,12 @@ export declare class TIFFFormat implements ImageFormat {
      * TIFF supports extensive EXIF metadata including GPS and InteropIFD
      */
     getSupportedMetadata(): Array<keyof ImageMetadata>;
+    /**
+     * Extract metadata from TIFF data without fully decoding the pixel data
+     * This quickly parses IFD entries to extract metadata
+     * @param data Raw TIFF data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data: Uint8Array): Promise<ImageMetadata | undefined>;
 }
 //# sourceMappingURL=tiff.d.ts.map

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);
@@ -963,4 +1025,141 @@ export class TIFFFormat {
             "physicalHeight",
         ];
     }
+    /**
+     * Extract metadata from TIFF data without fully decoding the pixel data
+     * This quickly parses IFD entries to extract metadata
+     * @param data Raw TIFF data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data) {
+        if (!this.canDecode(data)) {
+            return Promise.resolve(undefined);
+        }
+        // Determine byte order
+        const isLittleEndian = data[0] === 0x49 && data[1] === 0x49;
+        if (!isLittleEndian && !(data[0] === 0x4d && data[1] === 0x4d)) {
+            return Promise.resolve(undefined);
+        }
+        // Read IFD offset
+        const ifdOffset = this.readUint32(data, 4, isLittleEndian);
+        if (ifdOffset >= data.length) {
+            return Promise.resolve(undefined);
+        }
+        // Get dimensions for DPI calculation
+        const width = this.getIFDValue(data, ifdOffset, 0x0100, isLittleEndian);
+        const height = this.getIFDValue(data, ifdOffset, 0x0101, isLittleEndian);
+        if (!width || !height) {
+            return Promise.resolve(undefined);
+        }
+        // Extract metadata from TIFF tags
+        const metadata = {
+            format: "tiff",
+            frameCount: 1,
+            bitDepth: 8,
+        };
+        // Get compression type
+        const compression = this.getIFDValue(data, ifdOffset, 0x0103, isLittleEndian);
+        if (compression === 1) {
+            metadata.compression = "none";
+        }
+        else if (compression === 5) {
+            metadata.compression = "lzw";
+        }
+        else if (compression === 7 || compression === 6) {
+            metadata.compression = "jpeg";
+        }
+        else if (compression === 8) {
+            metadata.compression = "deflate";
+        }
+        else if (compression === 32773) {
+            metadata.compression = "packbits";
+        }
+        else if (compression) {
+            metadata.compression = `unknown-${compression}`;
+        }
+        // Get bits per sample
+        const bitsPerSample = this.getIFDValue(data, ifdOffset, 0x0102, isLittleEndian);
+        if (bitsPerSample) {
+            metadata.bitDepth = bitsPerSample;
+        }
+        // Get photometric interpretation for color type
+        const photometric = this.getIFDValue(data, ifdOffset, 0x0106, isLittleEndian);
+        const samplesPerPixel = this.getIFDValue(data, ifdOffset, 0x0115, isLittleEndian);
+        if (photometric === 0 || photometric === 1) {
+            metadata.colorType = "grayscale";
+        }
+        else if (photometric === 2) {
+            if (samplesPerPixel === 3) {
+                metadata.colorType = "rgb";
+            }
+            else if (samplesPerPixel === 4) {
+                metadata.colorType = "rgba";
+            }
+        }
+        else if (photometric === 3) {
+            metadata.colorType = "indexed";
+        }
+        // Count IFDs (pages/frames) by following the chain
+        let currentIfdOffset = ifdOffset;
+        let frameCount = 0;
+        while (currentIfdOffset > 0 && currentIfdOffset < data.length &&
+            frameCount < 1000) {
+            frameCount++;
+            // Read number of entries in this IFD
+            const numEntries = this.readUint16(data, currentIfdOffset, isLittleEndian);
+            // Next IFD offset is after all entries (2 + numEntries * 12 bytes)
+            const nextIfdOffsetPos = currentIfdOffset + 2 + (numEntries * 12);
+            if (nextIfdOffsetPos + 4 > data.length)
+                break;
+            currentIfdOffset = this.readUint32(data, nextIfdOffsetPos, isLittleEndian);
+        }
+        metadata.frameCount = frameCount;
+        // XResolution (0x011a) and YResolution (0x011b) for DPI
+        const xResOffset = this.getIFDValue(data, ifdOffset, 0x011a, isLittleEndian);
+        const yResOffset = this.getIFDValue(data, ifdOffset, 0x011b, isLittleEndian);
+        if (xResOffset && xResOffset < data.length - 8) {
+            const numerator = this.readUint32(data, xResOffset, isLittleEndian);
+            const denominator = this.readUint32(data, xResOffset + 4, isLittleEndian);
+            if (denominator > 0) {
+                metadata.dpiX = Math.round(numerator / denominator);
+            }
+        }
+        if (yResOffset && yResOffset < data.length - 8) {
+            const numerator = this.readUint32(data, yResOffset, isLittleEndian);
+            const denominator = this.readUint32(data, yResOffset + 4, isLittleEndian);
+            if (denominator > 0) {
+                metadata.dpiY = Math.round(numerator / denominator);
+            }
+        }
+        // Calculate physical dimensions if DPI is available
+        if (metadata.dpiX && metadata.dpiY) {
+            metadata.physicalWidth = width / metadata.dpiX;
+            metadata.physicalHeight = height / metadata.dpiY;
+        }
+        // ImageDescription (0x010e)
+        const descOffset = this.getIFDValue(data, ifdOffset, 0x010e, isLittleEndian);
+        if (descOffset && descOffset < data.length) {
+            metadata.description = this.readString(data, descOffset);
+        }
+        // Artist (0x013b)
+        const artistOffset = this.getIFDValue(data, ifdOffset, 0x013b, isLittleEndian);
+        if (artistOffset && artistOffset < data.length) {
+            metadata.author = this.readString(data, artistOffset);
+        }
+        // Copyright (0x8298)
+        const copyrightOffset = this.getIFDValue(data, ifdOffset, 0x8298, isLittleEndian);
+        if (copyrightOffset && copyrightOffset < data.length) {
+            metadata.copyright = this.readString(data, copyrightOffset);
+        }
+        // DateTime (0x0132)
+        const dateTimeOffset = this.getIFDValue(data, ifdOffset, 0x0132, isLittleEndian);
+        if (dateTimeOffset && dateTimeOffset < data.length) {
+            const dateStr = this.readString(data, dateTimeOffset);
+            const match = dateStr.match(/^(\d{4}):(\d{2}):(\d{2}) (\d{2}):(\d{2}):(\d{2})$/);
+            if (match) {
+                metadata.creationDate = new Date(parseInt(match[1]), parseInt(match[2]) - 1, parseInt(match[3]), parseInt(match[4]), parseInt(match[5]), parseInt(match[6]));
+            }
+        }
+        return Promise.resolve(Object.keys(metadata).length > 0 ? metadata : undefined);
+    }
 }

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;
@@ -42,5 +42,12 @@ export declare class WebPFormat implements ImageFormat {
      * Get the list of metadata fields supported by WebP format
      */
     getSupportedMetadata(): Array<keyof ImageMetadata>;
+    /**
+     * Extract metadata from WebP data without fully decoding the pixel data
+     * This quickly parses RIFF chunks to extract EXIF and XMP metadata
+     * @param data Raw WebP data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data: Uint8Array): Promise<ImageMetadata | undefined>;
 }
 //# sourceMappingURL=webp.d.ts.map