cross-image 0.2.2 → 0.2.4

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/png_base.d.ts

@@ -76,6 +76,8 @@ export declare abstract class PNGBase {
      * Parse eXIf (EXIF) chunk
      */
     protected parseExifChunk(data: Uint8Array, metadata: ImageMetadata): void;
+    protected parseGPSIFD(data: Uint8Array, gpsIfdOffset: number, littleEndian: boolean, metadata: ImageMetadata): void;
+    protected readRational(data: Uint8Array, offset: number, littleEndian: boolean): number;
     /**
      * Create pHYs (physical pixel dimensions) chunk
      */
@@ -88,6 +90,8 @@ export declare abstract class PNGBase {
      * Create eXIf (EXIF) chunk
      */
     protected createExifChunk(metadata: ImageMetadata): Uint8Array | null;
+    protected createGPSIFD(metadata: ImageMetadata, gpsIfdStart: number): number[];
+    protected writeRational(output: number[], numerator: number, denominator: number): void;
     /**
      * Concatenate multiple byte arrays into a single Uint8Array
      */
@@ -104,5 +108,9 @@ export declare abstract class PNGBase {
      * Shared method to avoid duplication between PNG and APNG encoding
      */
     protected addMetadataChunks(chunks: Uint8Array[], metadata: ImageMetadata | undefined): void;
+    /**
+     * Get the list of metadata fields supported by PNG format
+     */
+    getSupportedMetadata(): Array<keyof ImageMetadata>;
 }
 //# sourceMappingURL=png_base.d.ts.map

package/script/src/formats/png_base.js

@@ -318,6 +318,7 @@ class PNGBase {
             const numEntries = littleEndian
                 ? data[ifd0Offset] | (data[ifd0Offset + 1] << 8)
                 : (data[ifd0Offset] << 8) | data[ifd0Offset + 1];
+            let gpsIfdOffset = 0;
             for (let i = 0; i < numEntries; i++) {
                 const entryOffset = ifd0Offset + 2 + i * 12;
                 if (entryOffset + 12 > data.length)
@@ -342,12 +343,96 @@ class PNGBase {
                         }
                     }
                 }
+                // GPS IFD Pointer tag (0x8825)
+                if (tag === 0x8825) {
+                    gpsIfdOffset = littleEndian
+                        ? data[entryOffset + 8] | (data[entryOffset + 9] << 8) |
+                            (data[entryOffset + 10] << 16) | (data[entryOffset + 11] << 24)
+                        : (data[entryOffset + 8] << 24) | (data[entryOffset + 9] << 16) |
+                            (data[entryOffset + 10] << 8) | data[entryOffset + 11];
+                }
+            }
+            // Parse GPS IFD if present
+            if (gpsIfdOffset > 0 && gpsIfdOffset + 2 <= data.length) {
+                this.parseGPSIFD(data, gpsIfdOffset, littleEndian, metadata);
             }
         }
         catch (_e) {
             // Ignore EXIF parsing errors
         }
     }
+    parseGPSIFD(data, gpsIfdOffset, littleEndian, metadata) {
+        try {
+            const numEntries = littleEndian
+                ? data[gpsIfdOffset] | (data[gpsIfdOffset + 1] << 8)
+                : (data[gpsIfdOffset] << 8) | data[gpsIfdOffset + 1];
+            let latRef = "";
+            let lonRef = "";
+            let latitude;
+            let longitude;
+            for (let i = 0; i < numEntries; i++) {
+                const entryOffset = gpsIfdOffset + 2 + i * 12;
+                if (entryOffset + 12 > data.length)
+                    break;
+                const tag = littleEndian
+                    ? data[entryOffset] | (data[entryOffset + 1] << 8)
+                    : (data[entryOffset] << 8) | data[entryOffset + 1];
+                const type = littleEndian
+                    ? data[entryOffset + 2] | (data[entryOffset + 3] << 8)
+                    : (data[entryOffset + 2] << 8) | data[entryOffset + 3];
+                const valueOffset = littleEndian
+                    ? data[entryOffset + 8] | (data[entryOffset + 9] << 8) |
+                        (data[entryOffset + 10] << 16) | (data[entryOffset + 11] << 24)
+                    : (data[entryOffset + 8] << 24) | (data[entryOffset + 9] << 16) |
+                        (data[entryOffset + 10] << 8) | data[entryOffset + 11];
+                // GPSLatitudeRef (0x0001)
+                if (tag === 0x0001 && type === 2) {
+                    latRef = String.fromCharCode(data[entryOffset + 8]);
+                }
+                // GPSLatitude (0x0002)
+                if (tag === 0x0002 && type === 5 && valueOffset + 24 <= data.length) {
+                    const degrees = this.readRational(data, valueOffset, littleEndian);
+                    const minutes = this.readRational(data, valueOffset + 8, littleEndian);
+                    const seconds = this.readRational(data, valueOffset + 16, littleEndian);
+                    latitude = degrees + minutes / 60 + seconds / 3600;
+                }
+                // GPSLongitudeRef (0x0003)
+                if (tag === 0x0003 && type === 2) {
+                    lonRef = String.fromCharCode(data[entryOffset + 8]);
+                }
+                // GPSLongitude (0x0004)
+                if (tag === 0x0004 && type === 5 && valueOffset + 24 <= data.length) {
+                    const degrees = this.readRational(data, valueOffset, littleEndian);
+                    const minutes = this.readRational(data, valueOffset + 8, littleEndian);
+                    const seconds = this.readRational(data, valueOffset + 16, littleEndian);
+                    longitude = degrees + minutes / 60 + seconds / 3600;
+                }
+            }
+            // Apply hemisphere references
+            if (latitude !== undefined && latRef) {
+                metadata.latitude = latRef === "S" ? -latitude : latitude;
+            }
+            if (longitude !== undefined && lonRef) {
+                metadata.longitude = lonRef === "W" ? -longitude : longitude;
+            }
+        }
+        catch (_e) {
+            // Ignore GPS parsing errors
+        }
+    }
+    readRational(data, offset, littleEndian) {
+        const numerator = littleEndian
+            ? data[offset] | (data[offset + 1] << 8) | (data[offset + 2] << 16) |
+                (data[offset + 3] << 24)
+            : (data[offset] << 24) | (data[offset + 1] << 16) |
+                (data[offset + 2] << 8) | data[offset + 3];
+        const denominator = littleEndian
+            ? data[offset + 4] | (data[offset + 5] << 8) | (data[offset + 6] << 16) |
+                (data[offset + 7] << 24)
+            : (data[offset + 4] << 24) | (data[offset + 5] << 16) |
+                (data[offset + 6] << 8) | data[offset + 7];
+        return denominator !== 0 ? numerator / denominator : 0;
+    }
     /**
      * Create pHYs (physical pixel dimensions) chunk
      */
@@ -388,14 +473,19 @@ class PNGBase {
                 value: new TextEncoder().encode(dateStr),
             });
         }
-        if (entries.length === 0)
+        // Check if we have GPS data
+        const hasGPS = metadata.latitude !== undefined &&
+            metadata.longitude !== undefined;
+        if (entries.length === 0 && !hasGPS)
             return null;
         const exif = [];
         exif.push(0x49, 0x49); // "II"
         exif.push(0x2a, 0x00); // 42
         exif.push(0x08, 0x00, 0x00, 0x00);
-        exif.push(entries.length & 0xff, (entries.length >> 8) & 0xff);
-        let dataOffset = 8 + 2 + entries.length * 12 + 4;
+        // Number of entries (add GPS IFD pointer if we have GPS data)
+        const ifd0Entries = entries.length + (hasGPS ? 1 : 0);
+        exif.push(ifd0Entries & 0xff, (ifd0Entries >> 8) & 0xff);
+        let dataOffset = 8 + 2 + ifd0Entries * 12 + 4;
         for (const entry of entries) {
             exif.push(entry.tag & 0xff, (entry.tag >> 8) & 0xff);
             exif.push(entry.type & 0xff, (entry.type >> 8) & 0xff);
@@ -411,6 +501,16 @@ class PNGBase {
                 dataOffset += entry.value.length;
             }
         }
+        // Add GPS IFD pointer if we have GPS data
+        let gpsIfdOffset = 0;
+        if (hasGPS) {
+            gpsIfdOffset = dataOffset;
+            // GPS IFD Pointer tag (0x8825), type 4 (LONG), count 1
+            exif.push(0x25, 0x88); // Tag
+            exif.push(0x04, 0x00); // Type
+            exif.push(0x01, 0x00, 0x00, 0x00); // Count
+            exif.push(gpsIfdOffset & 0xff, (gpsIfdOffset >> 8) & 0xff, (gpsIfdOffset >> 16) & 0xff, (gpsIfdOffset >> 24) & 0xff);
+        }
         exif.push(0x00, 0x00, 0x00, 0x00);
         for (const entry of entries) {
             if (entry.value.length > 4) {
@@ -419,8 +519,65 @@ class PNGBase {
                 }
             }
         }
+        // Add GPS IFD if we have GPS data
+        if (hasGPS) {
+            const gpsIfd = this.createGPSIFD(metadata, gpsIfdOffset);
+            for (const byte of gpsIfd) {
+                exif.push(byte);
+            }
+        }
         return new Uint8Array(exif);
     }
+    createGPSIFD(metadata, gpsIfdStart) {
+        const gps = [];
+        const numEntries = 4;
+        gps.push(numEntries & 0xff, (numEntries >> 8) & 0xff);
+        const latitude = metadata.latitude;
+        const longitude = metadata.longitude;
+        const absLat = Math.abs(latitude);
+        const absLon = Math.abs(longitude);
+        const latDeg = Math.floor(absLat);
+        const latMin = Math.floor((absLat - latDeg) * 60);
+        const latSec = ((absLat - latDeg) * 60 - latMin) * 60;
+        const lonDeg = Math.floor(absLon);
+        const lonMin = Math.floor((absLon - lonDeg) * 60);
+        const lonSec = ((absLon - lonDeg) * 60 - lonMin) * 60;
+        let dataOffset = gpsIfdStart + 2 + numEntries * 12 + 4;
+        // Entry 1: GPSLatitudeRef
+        gps.push(0x01, 0x00);
+        gps.push(0x02, 0x00);
+        gps.push(0x02, 0x00, 0x00, 0x00);
+        gps.push(latitude >= 0 ? 78 : 83, 0x00, 0x00, 0x00);
+        // Entry 2: GPSLatitude
+        gps.push(0x02, 0x00);
+        gps.push(0x05, 0x00);
+        gps.push(0x03, 0x00, 0x00, 0x00);
+        gps.push(dataOffset & 0xff, (dataOffset >> 8) & 0xff, (dataOffset >> 16) & 0xff, (dataOffset >> 24) & 0xff);
+        dataOffset += 24;
+        // Entry 3: GPSLongitudeRef
+        gps.push(0x03, 0x00);
+        gps.push(0x02, 0x00);
+        gps.push(0x02, 0x00, 0x00, 0x00);
+        gps.push(longitude >= 0 ? 69 : 87, 0x00, 0x00, 0x00);
+        // Entry 4: GPSLongitude
+        gps.push(0x04, 0x00);
+        gps.push(0x05, 0x00);
+        gps.push(0x03, 0x00, 0x00, 0x00);
+        gps.push(dataOffset & 0xff, (dataOffset >> 8) & 0xff, (dataOffset >> 16) & 0xff, (dataOffset >> 24) & 0xff);
+        gps.push(0x00, 0x00, 0x00, 0x00);
+        // Write rationals
+        this.writeRational(gps, latDeg, 1);
+        this.writeRational(gps, latMin, 1);
+        this.writeRational(gps, Math.round(latSec * 1000000), 1000000);
+        this.writeRational(gps, lonDeg, 1);
+        this.writeRational(gps, lonMin, 1);
+        this.writeRational(gps, Math.round(lonSec * 1000000), 1000000);
+        return gps;
+    }
+    writeRational(output, numerator, denominator) {
+        output.push(numerator & 0xff, (numerator >> 8) & 0xff, (numerator >> 16) & 0xff, (numerator >> 24) & 0xff);
+        output.push(denominator & 0xff, (denominator >> 8) & 0xff, (denominator >> 16) & 0xff, (denominator >> 24) & 0xff);
+    }
     /**
      * Concatenate multiple byte arrays into a single Uint8Array
      */
@@ -487,5 +644,21 @@ class PNGBase {
             }
         }
     }
+    /**
+     * Get the list of metadata fields supported by PNG format
+     */
+    getSupportedMetadata() {
+        return [
+            "creationDate", // eXIf chunk
+            "latitude", // eXIf chunk (GPS IFD)
+            "longitude", // eXIf chunk (GPS IFD)
+            "dpiX", // pHYs chunk
+            "dpiY", // pHYs chunk
+            "title", // tEXt chunk
+            "author", // tEXt chunk
+            "description", // tEXt chunk
+            "copyright", // tEXt chunk
+        ];
+    }
 }
 exports.PNGBase = PNGBase;

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, MultiFrameImageData } from "../types.js";
+import type { ImageData, ImageFormat, ImageMetadata, MultiFrameImageData } from "../types.js";
 /**
  * Options for TIFF encoding
  */
@@ -74,5 +74,17 @@ export declare class TIFFFormat implements ImageFormat {
      * Returns null if the TIFF uses unsupported features
      */
     private decodePureJSFromIFD;
+    /**
+     * Get list of metadata fields supported by TIFF format
+     * 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