cross-image 0.2.3 → 0.4.0

package/esm/src/formats/bmp.js

@@ -38,7 +38,7 @@ export class BMPFormat {
      * @param data Raw BMP image data
      * @returns Decoded image data with RGBA pixels
      */
-    decode(data) {
+    decode(data, _options) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid BMP signature");
         }
@@ -115,7 +115,7 @@ export class BMPFormat {
      * @param imageData Image data to encode
      * @returns Encoded BMP image bytes
      */
-    encode(imageData) {
+    encode(imageData, _options) {
         const { width, height, data, metadata } = imageData;
         // Calculate sizes
         const bytesPerPixel = 4; // We'll encode as 32-bit RGBA
@@ -168,4 +168,77 @@ export class BMPFormat {
         }
         return Promise.resolve(result);
     }
+    /**
+     * Get the list of metadata fields supported by BMP format
+     */
+    getSupportedMetadata() {
+        return [
+            "dpiX", // Pixels per meter in header
+            "dpiY", // Pixels per meter in header
+        ];
+    }
+    /**
+     * Extract metadata from BMP data without fully decoding the pixel data
+     * @param data Raw BMP data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data) {
+        if (!this.canDecode(data)) {
+            return Promise.resolve(undefined);
+        }
+        const metadata = {
+            format: "bmp",
+            frameCount: 1,
+            bitDepth: 24,
+            colorType: "rgb",
+        };
+        // Read BMP header to determine version
+        const headerSize = readUint32LE(data, 14);
+        if (headerSize >= 40) {
+            // BITMAPINFOHEADER or later
+            const bitsPerPixel = readUint16LE(data, 28);
+            metadata.bitDepth = bitsPerPixel;
+            if (bitsPerPixel === 1 || bitsPerPixel === 8) {
+                metadata.colorType = "indexed";
+            }
+            else if (bitsPerPixel === 24) {
+                metadata.colorType = "rgb";
+            }
+            else if (bitsPerPixel === 32) {
+                metadata.colorType = "rgba";
+            }
+            const compression = readUint32LE(data, 30);
+            if (compression === 0) {
+                metadata.compression = "none";
+            }
+            else if (compression === 1) {
+                metadata.compression = "rle8";
+            }
+            else if (compression === 2) {
+                metadata.compression = "rle4";
+            }
+            else if (compression === 3) {
+                metadata.compression = "bitfields";
+            }
+            else {
+                metadata.compression = `unknown-${compression}`;
+            }
+            // DPI information (pixels per meter)
+            if (headerSize >= 40) {
+                const xPelsPerMeter = readUint32LE(data, 38);
+                const yPelsPerMeter = readUint32LE(data, 42);
+                if (xPelsPerMeter > 0) {
+                    metadata.dpiX = Math.round(xPelsPerMeter * 0.0254);
+                }
+                if (yPelsPerMeter > 0) {
+                    metadata.dpiY = Math.round(yPelsPerMeter * 0.0254);
+                }
+            }
+        }
+        else {
+            // BITMAPCOREHEADER
+            metadata.compression = "none";
+        }
+        return Promise.resolve(Object.keys(metadata).length > 0 ? metadata : undefined);
+    }
 }

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

@@ -1,4 +1,4 @@
-import type { ImageData } from "../types.js";
+import type { ImageData, ImageMetadata } from "../types.js";
 import { TIFFFormat } from "./tiff.js";
 /**
  * DNG format handler
@@ -22,6 +22,18 @@ export declare class DNGFormat extends TIFFFormat {
      * @param imageData Image data to encode
      * @returns Encoded DNG image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, _options?: unknown): Promise<Uint8Array>;
+    /**
+     * Get the list of metadata fields supported by DNG format
+     * DNG is based on TIFF, so it supports all TIFF metadata fields
+     */
+    getSupportedMetadata(): Array<keyof ImageMetadata>;
+    /**
+     * Extract metadata from DNG data without fully decoding the pixel data
+     * DNG is TIFF-based, so we can use the parent extractMetadata and override format
+     * @param data Raw DNG data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data: Uint8Array): Promise<ImageMetadata | undefined>;
 }
 //# sourceMappingURL=dng.d.ts.map

package/esm/src/formats/dng.js

@@ -22,10 +22,6 @@ export class DNGFormat extends TIFFFormat {
             writable: true,
             value: "image/x-adobe-dng"
         });
-        // Helper methods duplicated from TIFFFormat because they are protected/private there
-        // and we can't easily access them if they are private.
-        // Let's check TIFFFormat visibility.
-        // The read/write helpers were not exported in the previous read_file output.
     }
     /**
      * Check if the given data is a DNG image
@@ -78,7 +74,7 @@ export class DNGFormat extends 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.
@@ -188,4 +184,30 @@ export class DNGFormat extends TIFFFormat {
         }
         return Promise.resolve(new Uint8Array(result));
     }
+    // Helper methods duplicated from TIFFFormat because they are protected/private there
+    // and we can't easily access them if they are private.
+    // Let's check TIFFFormat visibility.
+    // The read/write helpers were not exported in the previous read_file output.
+    /**
+     * Get the list of metadata fields supported by DNG format
+     * DNG is based on TIFF, so it supports all TIFF metadata fields
+     */
+    getSupportedMetadata() {
+        return super.getSupportedMetadata();
+    }
+    /**
+     * Extract metadata from DNG data without fully decoding the pixel data
+     * DNG is TIFF-based, so we can use the parent extractMetadata and override format
+     * @param data Raw DNG data
+     * @returns Extracted metadata or undefined
+     */
+    async extractMetadata(data) {
+        // Use parent TIFF extractMetadata
+        const metadata = await super.extractMetadata(data);
+        if (metadata) {
+            // Override format to indicate this is a DNG
+            metadata.format = "dng";
+        }
+        return metadata;
+    }
 }

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, 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>;
-    private extractMetadata;
+    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
      */
@@ -55,5 +55,18 @@ export declare class GIFFormat implements ImageFormat {
     private parseXMP;
     private injectMetadata;
     private createCommentText;
+    /**
+     * Get the list of metadata fields supported by GIF format
+     */
+    getSupportedMetadata(): Array<keyof ImageMetadata>;
+    /**
+     * Extract metadata from GIF data without fully decoding the pixel data
+     * This quickly parses GIF structure to extract metadata including frame count
+     * @param data Raw GIF data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data: Uint8Array): Promise<ImageMetadata | undefined>;
+    private getSubBlocksSize;
+    private parseGIFCommentMetadata;
 }
 //# sourceMappingURL=gif.d.ts.map

package/esm/src/formats/gif.js

@@ -56,18 +56,21 @@ export 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 GIFDecoder(data);
+            const decoder = new GIFDecoder(data, {
+                tolerantDecoding: settings?.tolerantDecoding ?? true,
+                onWarning: settings?.onWarning,
+            });
             const result = decoder.decode();
             // Validate dimensions for security (prevent integer overflow and heap exhaustion)
             validateImageDimensions(result.width, result.height);
             // Extract metadata from comment extensions
-            const metadata = this.extractMetadata(data);
+            const metadata = this.extractGIFMetadata(data);
             return {
                 width: result.width,
                 height: result.height,
@@ -75,9 +78,8 @@ export 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 = readUint16LE(data, pos);
             pos += 2;
@@ -85,7 +87,7 @@ export class GIFFormat {
             // Validate dimensions for security (prevent integer overflow and heap exhaustion)
             validateImageDimensions(width, height);
             const rgba = await this.decodeUsingRuntime(data, width, height);
-            const metadata = this.extractMetadata(data);
+            const metadata = this.extractGIFMetadata(data);
             return {
                 width,
                 height,
@@ -94,7 +96,7 @@ export class GIFFormat {
             };
         }
     }
-    extractMetadata(data) {
+    extractGIFMetadata(data) {
         const metadata = {};
         let pos = 6; // Skip "GIF89a" or "GIF87a"
         // Read logical screen descriptor
@@ -151,7 +153,7 @@ export 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 {
@@ -164,9 +166,8 @@ export 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);
@@ -199,15 +200,18 @@ export 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 GIFDecoder(data);
+            const decoder = new GIFDecoder(data, {
+                tolerantDecoding: settings?.tolerantDecoding ?? true,
+                onWarning: settings?.onWarning,
+            });
             const result = decoder.decodeAllFrames();
             // Extract metadata from comment extensions
-            const metadata = this.extractMetadata(data);
+            const metadata = this.extractGIFMetadata(data);
             return Promise.resolve({
                 width: result.width,
                 height: result.height,
@@ -402,4 +406,146 @@ export class GIFFormat {
             parts.push(`Copyright: ${metadata.copyright}`);
         return parts.length > 0 ? parts.join("\n") : null;
     }
+    /**
+     * Get the list of metadata fields supported by GIF format
+     */
+    getSupportedMetadata() {
+        return [
+            "title", // Comment extension
+            "description", // Comment extension
+            "author", // Comment extension
+            "copyright", // Comment extension
+            "frameCount", // Animation frames
+        ];
+    }
+    /**
+     * Extract metadata from GIF data without fully decoding the pixel data
+     * This quickly parses GIF structure to extract metadata including frame count
+     * @param data Raw GIF data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data) {
+        if (!this.canDecode(data)) {
+            return Promise.resolve(undefined);
+        }
+        const metadata = {
+            format: "gif",
+            compression: "lzw",
+            frameCount: 0,
+            bitDepth: 8,
+            colorType: "indexed",
+        };
+        let pos = 6; // Skip "GIF89a" or "GIF87a"
+        // Read Logical Screen Descriptor
+        const _width = readUint16LE(data, pos);
+        pos += 2;
+        const _height = readUint16LE(data, pos);
+        pos += 2;
+        const packed = data[pos++];
+        const _backgroundColorIndex = data[pos++];
+        const _aspectRatio = data[pos++];
+        // Parse packed fields
+        const hasGlobalColorTable = (packed & 0x80) !== 0;
+        const globalColorTableSize = 2 << (packed & 0x07);
+        // Skip global color table if present
+        if (hasGlobalColorTable) {
+            pos += globalColorTableSize * 3;
+        }
+        // Parse data stream to count frames and extract metadata
+        while (pos < data.length) {
+            const separator = data[pos++];
+            if (separator === 0x21) {
+                // Extension
+                const label = data[pos++];
+                if (label === 0xf9) {
+                    // Graphics Control Extension - indicates a frame
+                    metadata.frameCount++;
+                    // Skip block
+                    const blockSize = data[pos++];
+                    pos += blockSize;
+                    pos++; // Block terminator
+                }
+                else if (label === 0xfe) {
+                    // Comment Extension
+                    const commentResult = this.readDataSubBlocks(data, pos);
+                    pos = commentResult.endPos;
+                    this.parseGIFCommentMetadata(commentResult.text, metadata);
+                }
+                else if (label === 0xff) {
+                    // Application Extension
+                    const blockSize = data[pos++];
+                    pos += blockSize;
+                    // Skip sub-blocks
+                    pos += this.getSubBlocksSize(data, pos);
+                }
+                else {
+                    // Other extension - skip sub-blocks
+                    pos += this.getSubBlocksSize(data, pos);
+                }
+            }
+            else if (separator === 0x2c) {
+                // Image Descriptor - frame data
+                if (metadata.frameCount === 0) {
+                    metadata.frameCount = 1;
+                }
+                pos += 8; // Skip left, top, width, height
+                const localPacked = data[pos++];
+                const hasLocalColorTable = (localPacked & 0x80) !== 0;
+                if (hasLocalColorTable) {
+                    const localColorTableSize = 2 << (localPacked & 0x07);
+                    pos += localColorTableSize * 3;
+                }
+                // Skip LZW minimum code size
+                pos++;
+                // Skip image data sub-blocks
+                pos += this.getSubBlocksSize(data, pos);
+            }
+            else if (separator === 0x3b) {
+                // Trailer - end of GIF
+                break;
+            }
+            else if (separator === 0x00) {
+                // Padding - skip
+                continue;
+            }
+            else {
+                // Unknown - try to continue
+                break;
+            }
+        }
+        // If no frames were counted, assume at least 1
+        if (metadata.frameCount === 0) {
+            metadata.frameCount = 1;
+        }
+        return Promise.resolve(Object.keys(metadata).length > 0 ? metadata : undefined);
+    }
+    getSubBlocksSize(data, pos) {
+        let size = 0;
+        while (pos + size < data.length) {
+            const blockSize = data[pos + size];
+            size++; // For block size byte
+            if (blockSize === 0)
+                break;
+            size += blockSize;
+        }
+        return size;
+    }
+    parseGIFCommentMetadata(commentText, metadata) {
+        const lines = commentText.split("\n");
+        for (const line of lines) {
+            const colonIndex = line.indexOf(":");
+            if (colonIndex > 0) {
+                const key = line.substring(0, colonIndex).trim();
+                const value = line.substring(colonIndex + 1).trim();
+                if (key === "Title")
+                    metadata.title = value;
+                else if (key === "Description")
+                    metadata.description = value;
+                else if (key === "Author")
+                    metadata.author = value;
+                else if (key === "Copyright")
+                    metadata.copyright = value;
+            }
+        }
+    }
 }

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

@@ -0,0 +1,96 @@
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata } from "../types.js";
+/**
+ * HEIC format handler
+ * Supports HEIC/HEIF images using runtime APIs (ImageDecoder/OffscreenCanvas)
+ * Note: Pure JavaScript encode/decode is not supported due to complexity
+ */
+export declare class HEICFormat implements ImageFormat {
+    /** Format name identifier */
+    readonly name = "heic";
+    /** MIME type for HEIC images */
+    readonly mimeType = "image/heic";
+    /**
+     * Check if the given data is a HEIC/HEIF image
+     * @param data Raw image data to check
+     * @returns true if data has HEIC/HEIF signature
+     */
+    canDecode(data: Uint8Array): boolean;
+    /**
+     * Decode HEIC image data to RGBA
+     * Uses runtime APIs (ImageDecoder) for decoding
+     * @param data Raw HEIC image data
+     * @returns Decoded image data with RGBA pixels
+     */
+    decode(data: Uint8Array, settings?: ImageDecoderOptions): Promise<ImageData>;
+    /**
+     * Encode RGBA image data to HEIC format
+     * Uses runtime APIs (OffscreenCanvas) for encoding
+     *
+     * Note: Metadata injection is not currently implemented. Metadata may be lost during encoding
+     * as it would require parsing and modifying the ISOBMFF container structure.
+     *
+     * @param imageData Image data to encode
+     * @returns Encoded HEIC image bytes
+     */
+    encode(imageData: ImageData, _options?: unknown): Promise<Uint8Array>;
+    /**
+     * Decode using runtime APIs
+     * @param data Raw HEIC data
+     * @returns Decoded image dimensions and pixel data
+     */
+    private decodeUsingRuntime;
+    /**
+     * Parse EXIF metadata from HEIC data
+     *
+     * Note: This is a simplified implementation that searches for EXIF headers linearly.
+     * A full implementation would require navigating the ISOBMFF box structure to find
+     * the 'meta' box and then the 'Exif' item. This simplified approach may not work
+     * in all cases but is suitable for basic metadata extraction when runtime APIs are
+     * not available or as a fallback.
+     *
+     * @param data Raw HEIC data
+     * @param metadata Metadata object to populate
+     */
+    private parseEXIF;
+    /**
+     * Parse TIFF-formatted EXIF data
+     * @param data EXIF data in TIFF format
+     * @param metadata Metadata object to populate
+     */
+    private parseTIFFExif;
+    /**
+     * Parse Exif Sub-IFD for camera settings
+     * @param data EXIF data
+     * @param exifIfdOffset Offset to Exif Sub-IFD
+     * @param littleEndian Byte order
+     * @param metadata Metadata object to populate
+     */
+    private parseExifSubIFD;
+    /**
+     * Parse GPS IFD for location data
+     * @param data EXIF data
+     * @param gpsIfdOffset Offset to GPS IFD
+     * @param littleEndian Byte order
+     * @param metadata Metadata object to populate
+     */
+    private parseGPSIFD;
+    /**
+     * Read a rational value (numerator/denominator)
+     * @param data Data buffer
+     * @param offset Offset to rational
+     * @param littleEndian Byte order
+     * @returns Decimal value
+     */
+    private readRational;
+    /**
+     * Get the list of metadata fields supported by HEIC format
+     */
+    getSupportedMetadata(): Array<keyof ImageMetadata>;
+    /**
+     * Extract metadata from HEIC data without fully decoding the pixel data
+     * @param data Raw HEIC data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data: Uint8Array): Promise<ImageMetadata | undefined>;
+}
+//# sourceMappingURL=heic.d.ts.map