cross-image 0.2.3 → 0.2.4

package/script/src/formats/jpeg.js

@@ -1096,5 +1096,81 @@ class JPEGFormat {
             "dpiY",
         ];
     }
+    /**
+     * Extract metadata from JPEG data without fully decoding the pixel data
+     * This quickly parses JFIF and EXIF markers to extract metadata
+     * @param data Raw JPEG data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data) {
+        if (!this.canDecode(data)) {
+            return Promise.resolve(undefined);
+        }
+        // Parse JPEG structure to extract metadata
+        let pos = 2; // Skip initial FF D8
+        const metadata = {
+            format: "jpeg",
+            compression: "dct",
+            frameCount: 1,
+            bitDepth: 8,
+            colorType: "rgb",
+        };
+        let width = 0;
+        let height = 0;
+        while (pos < data.length - 1) {
+            if (data[pos] !== 0xff) {
+                pos++;
+                continue;
+            }
+            const marker = data[pos + 1];
+            pos += 2;
+            // SOF markers (Start of Frame) - get dimensions for DPI calculation
+            if (marker >= 0xc0 && marker <= 0xcf &&
+                marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc) {
+                const length = (data[pos] << 8) | data[pos + 1];
+                // precision at pos+2
+                const precision = data[pos + 2];
+                if (precision && precision !== 8) {
+                    metadata.bitDepth = precision;
+                }
+                height = (data[pos + 3] << 8) | data[pos + 4];
+                width = (data[pos + 5] << 8) | data[pos + 6];
+                // Check number of components
+                const numComponents = data[pos + 7];
+                if (numComponents === 1) {
+                    metadata.colorType = "grayscale";
+                }
+                // Don't break - continue parsing for metadata
+                pos += length;
+                continue;
+            }
+            // APP0 marker (JFIF)
+            if (marker === 0xe0) {
+                const length = (data[pos] << 8) | data[pos + 1];
+                const appData = data.slice(pos + 2, pos + length);
+                this.parseJFIF(appData, metadata, width, height);
+                pos += length;
+                continue;
+            }
+            // APP1 marker (EXIF)
+            if (marker === 0xe1) {
+                const length = (data[pos] << 8) | data[pos + 1];
+                const appData = data.slice(pos + 2, pos + length);
+                this.parseEXIF(appData, metadata);
+                pos += length;
+                continue;
+            }
+            // Skip other markers
+            if (marker === 0xd9 || marker === 0xda)
+                break; // EOI or SOS
+            if (marker >= 0xd0 && marker <= 0xd8)
+                continue; // RST markers have no length
+            if (marker === 0x01)
+                continue; // TEM has no length
+            const length = (data[pos] << 8) | data[pos + 1];
+            pos += length;
+        }
+        return Promise.resolve(Object.keys(metadata).length > 0 ? metadata : undefined);
+    }
 }
 exports.JPEGFormat = JPEGFormat;

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat } from "../types.js";
+import type { ImageData, ImageFormat, ImageMetadata } from "../types.js";
 /**
  * PAM format handler
  * Implements the Netpbm PAM (Portable Arbitrary Map) format.
@@ -39,5 +39,15 @@ export declare class PAMFormat implements ImageFormat {
      * @returns Encoded PAM image bytes
      */
     encode(imageData: ImageData): Promise<Uint8Array>;
+    /**
+     * Get the list of metadata fields supported by PAM format
+     */
+    getSupportedMetadata(): Array<keyof ImageMetadata>;
+    /**
+     * Extract metadata from PAM data without fully decoding the pixel data
+     * @param data Raw PAM data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data: Uint8Array): Promise<ImageMetadata | undefined>;
 }
 //# sourceMappingURL=pam.d.ts.map

package/script/src/formats/pam.js

@@ -177,5 +177,71 @@ class PAMFormat {
         output.set(data, headerBytes.length);
         return Promise.resolve(output);
     }
+    /**
+     * Get the list of metadata fields supported by PAM format
+     */
+    getSupportedMetadata() {
+        return []; // PAM format doesn't support metadata preservation
+    }
+    /**
+     * Extract metadata from PAM data without fully decoding the pixel data
+     * @param data Raw PAM data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data) {
+        if (!this.canDecode(data)) {
+            return Promise.resolve(undefined);
+        }
+        const metadata = {
+            format: "pam",
+            compression: "none",
+            frameCount: 1,
+            bitDepth: 8, // PAM typically uses 8 bits per channel
+            colorType: "rgba",
+        };
+        // Try to parse the header to get actual color type
+        const decoder = new TextDecoder();
+        const headerText = decoder.decode(data.slice(0, Math.min(200, data.length)));
+        // Look for TUPLTYPE to determine color type
+        const tupltypeMatch = headerText.match(/TUPLTYPE\s+(\S+)/);
+        if (tupltypeMatch) {
+            const tupltype = tupltypeMatch[1];
+            if (tupltype === "GRAYSCALE") {
+                metadata.colorType = "grayscale";
+            }
+            else if (tupltype === "RGB") {
+                metadata.colorType = "rgb";
+            }
+            else if (tupltype === "RGB_ALPHA") {
+                metadata.colorType = "rgba";
+            }
+        }
+        // Look for DEPTH to determine number of channels
+        const depthMatch = headerText.match(/DEPTH\s+(\d+)/);
+        if (depthMatch) {
+            const depth = parseInt(depthMatch[1]);
+            if (depth === 1) {
+                metadata.colorType = "grayscale";
+            }
+            else if (depth === 3) {
+                metadata.colorType = "rgb";
+            }
+            else if (depth === 4) {
+                metadata.colorType = "rgba";
+            }
+        }
+        // Look for MAXVAL to determine bit depth
+        const maxvalMatch = headerText.match(/MAXVAL\s+(\d+)/);
+        if (maxvalMatch) {
+            const maxval = parseInt(maxvalMatch[1]);
+            if (maxval === 255) {
+                metadata.bitDepth = 8;
+            }
+            else if (maxval === 65535) {
+                metadata.bitDepth = 16;
+            }
+        }
+        return Promise.resolve(metadata);
+    }
 }
 exports.PAMFormat = PAMFormat;

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat } from "../types.js";
+import type { ImageData, ImageFormat, ImageMetadata } from "../types.js";
 /**
  * PCX format handler
  * Implements PCX decoder and encoder
@@ -9,5 +9,15 @@ export declare class PCXFormat implements ImageFormat {
     canDecode(data: Uint8Array): boolean;
     decode(data: Uint8Array): Promise<ImageData>;
     encode(image: ImageData): Promise<Uint8Array>;
+    /**
+     * Get the list of metadata fields supported by PCX format
+     */
+    getSupportedMetadata(): Array<keyof ImageMetadata>;
+    /**
+     * Extract metadata from PCX data without fully decoding the pixel data
+     * @param data Raw PCX data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data: Uint8Array): Promise<ImageMetadata | undefined>;
 }
 //# sourceMappingURL=pcx.d.ts.map

package/script/src/formats/pcx.js

@@ -204,5 +204,50 @@ class PCXFormat {
         result.set(rleData, header.length);
         return Promise.resolve(result);
     }
+    /**
+     * Get the list of metadata fields supported by PCX format
+     */
+    getSupportedMetadata() {
+        return [
+            "dpiX", // DPI in header
+            "dpiY", // DPI in header
+        ];
+    }
+    /**
+     * Extract metadata from PCX data without fully decoding the pixel data
+     * @param data Raw PCX data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data) {
+        if (!this.canDecode(data)) {
+            return Promise.resolve(undefined);
+        }
+        const metadata = {
+            format: "pcx",
+            compression: "rle",
+            frameCount: 1,
+            bitDepth: data[3], // Bits per pixel per plane
+            colorType: "rgb",
+        };
+        // Check number of planes to determine color type
+        const numPlanes = data[65];
+        if (numPlanes === 1) {
+            metadata.colorType = "indexed";
+        }
+        else if (numPlanes === 3) {
+            metadata.colorType = "rgb";
+        }
+        else if (numPlanes === 4) {
+            metadata.colorType = "rgba";
+        }
+        // DPI information
+        const dpiX = data[12] | (data[13] << 8);
+        const dpiY = data[14] | (data[15] << 8);
+        if (dpiX > 0)
+            metadata.dpiX = dpiX;
+        if (dpiY > 0)
+            metadata.dpiY = dpiY;
+        return Promise.resolve(metadata);
+    }
 }
 exports.PCXFormat = PCXFormat;

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat } from "../types.js";
+import type { ImageData, ImageFormat, ImageMetadata } from "../types.js";
 import { PNGBase } from "./png_base.js";
 /**
  * PNG format handler
@@ -27,5 +27,17 @@ export declare class PNGFormat extends PNGBase implements ImageFormat {
      * @returns Encoded PNG image bytes
      */
     encode(imageData: ImageData): Promise<Uint8Array>;
+    /**
+     * Get the list of metadata fields supported by PNG format
+     * Delegates to PNGBase implementation
+     */
+    getSupportedMetadata(): Array<keyof ImageMetadata>;
+    /**
+     * Extract metadata from PNG data without fully decoding the pixel data
+     * This quickly parses PNG chunks to extract metadata
+     * @param data Raw PNG data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data: Uint8Array): Promise<ImageMetadata | undefined>;
 }
 //# sourceMappingURL=png.d.ts.map

package/script/src/formats/png.js

@@ -140,5 +140,92 @@ class PNGFormat extends png_base_js_1.PNGBase {
         // Concatenate all chunks
         return this.concatenateArrays(chunks);
     }
+    /**
+     * Get the list of metadata fields supported by PNG format
+     * Delegates to PNGBase implementation
+     */
+    getSupportedMetadata() {
+        return super.getSupportedMetadata();
+    }
+    /**
+     * Extract metadata from PNG data without fully decoding the pixel data
+     * This quickly parses PNG chunks to extract metadata
+     * @param data Raw PNG data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data) {
+        if (!this.canDecode(data)) {
+            return Promise.resolve(undefined);
+        }
+        let pos = 8; // Skip PNG signature
+        let width = 0;
+        let height = 0;
+        const metadata = {
+            format: "png",
+            compression: "deflate",
+            frameCount: 1,
+        };
+        // Parse chunks for metadata only
+        while (pos < data.length) {
+            if (pos + 8 > data.length)
+                break;
+            const length = this.readUint32(data, pos);
+            pos += 4;
+            const type = String.fromCharCode(data[pos], data[pos + 1], data[pos + 2], data[pos + 3]);
+            pos += 4;
+            if (pos + length + 4 > data.length)
+                break;
+            const chunkData = data.slice(pos, pos + length);
+            pos += length;
+            pos += 4; // Skip CRC
+            if (type === "IHDR") {
+                width = this.readUint32(chunkData, 0);
+                height = this.readUint32(chunkData, 4);
+                // Parse bit depth and color type from IHDR
+                if (chunkData.length >= 9) {
+                    metadata.bitDepth = chunkData[8];
+                    const colorTypeCode = chunkData[9];
+                    // PNG color types: 0=grayscale, 2=rgb, 3=indexed, 4=grayscale+alpha, 6=rgba
+                    switch (colorTypeCode) {
+                        case 0:
+                            metadata.colorType = "grayscale";
+                            break;
+                        case 2:
+                            metadata.colorType = "rgb";
+                            break;
+                        case 3:
+                            metadata.colorType = "indexed";
+                            break;
+                        case 4:
+                            metadata.colorType = "grayscale-alpha";
+                            break;
+                        case 6:
+                            metadata.colorType = "rgba";
+                            break;
+                    }
+                }
+            }
+            else if (type === "pHYs") {
+                // Physical pixel dimensions
+                this.parsePhysChunk(chunkData, metadata, width, height);
+            }
+            else if (type === "tEXt") {
+                // Text chunk
+                this.parseTextChunk(chunkData, metadata);
+            }
+            else if (type === "iTXt") {
+                // International text chunk
+                this.parseITxtChunk(chunkData, metadata);
+            }
+            else if (type === "eXIf") {
+                // EXIF chunk
+                this.parseExifChunk(chunkData, metadata);
+            }
+            else if (type === "IEND") {
+                break;
+            }
+        }
+        return Promise.resolve(Object.keys(metadata).length > 0 ? metadata : undefined);
+    }
 }
 exports.PNGFormat = PNGFormat;

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat } from "../types.js";
+import type { ImageData, ImageFormat, ImageMetadata } from "../types.js";
 /**
  * PPM format handler
  * Implements the Netpbm PPM (Portable PixMap) format.
@@ -46,5 +46,15 @@ export declare class PPMFormat implements ImageFormat {
      * 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/script/src/formats/ppm.js

@@ -242,5 +242,39 @@ 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);
+    }
 }
 exports.PPMFormat = PPMFormat;

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

@@ -79,5 +79,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/script/src/formats/tiff.js

@@ -966,5 +966,139 @@ 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) {
+            metadata.compression = "jpeg";
+        }
+        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);
+    }
 }
 exports.TIFFFormat = TIFFFormat;

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

@@ -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