cross-image 0.2.3 → 0.2.4

package/esm/src/formats/webp.js

@@ -567,4 +567,96 @@ export class WebPFormat {
             "focalLength",
         ];
     }
+    /**
+     * 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) {
+        if (!this.canDecode(data)) {
+            return Promise.resolve(undefined);
+        }
+        const metadata = {
+            format: "webp",
+            frameCount: 1,
+            bitDepth: 8,
+        };
+        let pos = 12; // Skip "RIFF" + size + "WEBP"
+        const readUint32LE = (data, offset) => {
+            return data[offset] | (data[offset + 1] << 8) | (data[offset + 2] << 16) |
+                (data[offset + 3] << 24);
+        };
+        const readUint16LE = (data, offset) => {
+            return data[offset] | (data[offset + 1] << 8);
+        };
+        // Parse chunks for metadata
+        while (pos + 8 <= data.length) {
+            const chunkType = String.fromCharCode(data[pos], data[pos + 1], data[pos + 2], data[pos + 3]);
+            const chunkSize = readUint32LE(data, pos + 4);
+            pos += 8;
+            // Stop if we've gone past the end
+            if (pos + chunkSize > data.length)
+                break;
+            const chunkData = data.slice(pos, pos + chunkSize);
+            if (chunkType === "VP8 ") {
+                // Lossy VP8 chunk
+                metadata.compression = "vp8";
+                metadata.colorType = "rgb";
+            }
+            else if (chunkType === "VP8L") {
+                // Lossless VP8L chunk
+                metadata.compression = "vp8l";
+                metadata.colorType = "rgba";
+            }
+            else if (chunkType === "VP8X") {
+                // Extended format chunk - contains animation info
+                if (chunkData.length >= 10) {
+                    const flags = chunkData[0];
+                    const _hasAnimation = (flags & 0x02) !== 0;
+                    const hasAlpha = (flags & 0x10) !== 0;
+                    if (hasAlpha) {
+                        metadata.colorType = "rgba";
+                    }
+                    else {
+                        metadata.colorType = "rgb";
+                    }
+                    // Animation is handled in ANIM chunk
+                }
+            }
+            else if (chunkType === "ANIM") {
+                // Animation parameters chunk
+                if (chunkData.length >= 6) {
+                    // Background color at bytes 0-3
+                    // Loop count at bytes 4-5
+                    const _loopCount = readUint16LE(chunkData, 4);
+                    // Note: Frame count is not directly in ANIM chunk, need to count ANMF chunks
+                    // Reset frame count to 0 to start counting ANMF frames
+                    metadata.frameCount = 0;
+                }
+            }
+            else if (chunkType === "ANMF") {
+                // Animation frame - count frames
+                if (metadata.frameCount !== undefined) {
+                    metadata.frameCount++;
+                }
+                else {
+                    metadata.frameCount = 1;
+                }
+            }
+            else if (chunkType === "EXIF") {
+                // EXIF metadata chunk
+                this.parseEXIF(chunkData, metadata);
+            }
+            else if (chunkType === "XMP ") {
+                // XMP metadata chunk
+                this.parseXMP(chunkData, metadata);
+            }
+            pos += chunkSize;
+            // Chunks are padded to even length
+            if (chunkSize % 2 === 1)
+                pos++;
+        }
+        return Promise.resolve(Object.keys(metadata).length > 0 ? metadata : undefined);
+    }
 }

package/esm/src/image.d.ts

@@ -85,6 +85,15 @@ export declare class Image {
      * @returns Array of supported metadata field names, or undefined if format doesn't support metadata
      */
     static getSupportedMetadata(format: string): Array<keyof ImageMetadata> | undefined;
+    /**
+     * Extract metadata from image data without fully decoding the pixel data
+     * This is useful for quickly reading EXIF, XMP, or other metadata from images
+     * that may have unsupported features or compression methods
+     * @param data Raw image data
+     * @param format Optional format hint (e.g., "png", "jpeg", "webp")
+     * @returns Metadata extracted from the image, or undefined if extraction fails or format is unsupported
+     */
+    static extractMetadata(data: Uint8Array, format?: string): Promise<ImageMetadata | undefined>;
     /**
      * Read an image from bytes
      * @deprecated Use `decode()` instead. This method will be removed in a future version.

package/esm/src/image.js

@@ -13,6 +13,8 @@ import { PAMFormat } from "./formats/pam.js";
 import { PCXFormat } from "./formats/pcx.js";
 import { PPMFormat } from "./formats/ppm.js";
 import { ASCIIFormat } from "./formats/ascii.js";
+import { HEICFormat } from "./formats/heic.js";
+import { AVIFFormat } from "./formats/avif.js";
 import { validateImageDimensions } from "./utils/security.js";
 /**
  * Main Image class for reading, manipulating, and saving images
@@ -193,6 +195,30 @@ export class Image {
         }
         return formatHandler.getSupportedMetadata?.();
     }
+    /**
+     * Extract metadata from image data without fully decoding the pixel data
+     * This is useful for quickly reading EXIF, XMP, or other metadata from images
+     * that may have unsupported features or compression methods
+     * @param data Raw image data
+     * @param format Optional format hint (e.g., "png", "jpeg", "webp")
+     * @returns Metadata extracted from the image, or undefined if extraction fails or format is unsupported
+     */
+    static async extractMetadata(data, format) {
+        // Try specified format first
+        if (format) {
+            const handler = Image.formats.find((f) => f.name === format);
+            if (handler && handler.canDecode(data) && handler.extractMetadata) {
+                return await handler.extractMetadata(data);
+            }
+        }
+        // Auto-detect format
+        for (const handler of Image.formats) {
+            if (handler.canDecode(data) && handler.extractMetadata) {
+                return await handler.extractMetadata(data);
+            }
+        }
+        return undefined;
+    }
     /**
      * Read an image from bytes
      * @deprecated Use `decode()` instead. This method will be removed in a future version.
@@ -841,5 +867,7 @@ Object.defineProperty(Image, "formats", {
         new PCXFormat(),
         new PPMFormat(),
         new ASCIIFormat(),
+        new HEICFormat(),
+        new AVIFFormat(),
     ]
 });

package/esm/src/types.d.ts

@@ -50,6 +50,16 @@ export interface ImageMetadata {
     software?: string;
     /** User comment / notes */
     userComment?: string;
+    /** Image file format (e.g., "png", "jpeg", "gif", "webp", "tiff") */
+    format?: string;
+    /** Compression algorithm used (e.g., "deflate", "lzw", "dct", "vp8", "vp8l", "none") */
+    compression?: string;
+    /** Number of frames in multi-frame images (e.g., animated GIFs, APNGs, multi-page TIFFs) */
+    frameCount?: number;
+    /** Bit depth per channel (e.g., 8, 16) */
+    bitDepth?: number;
+    /** Color type (e.g., "grayscale", "rgb", "rgba", "indexed", "grayscale-alpha") */
+    colorType?: string;
     /** Custom metadata fields */
     custom?: Record<string, string | number | boolean>;
 }
@@ -203,5 +213,13 @@ export interface ImageFormat {
      * @returns Array of metadata field names that can be persisted
      */
     getSupportedMetadata?(): Array<keyof ImageMetadata>;
+    /**
+     * Extract metadata from image data without fully decoding the pixel data
+     * This is useful for quickly reading EXIF, XMP, or other metadata from images
+     * that may have unsupported features or compression methods
+     * @param data Raw image data
+     * @returns Metadata extracted from the image, or undefined if extraction fails
+     */
+    extractMetadata?(data: Uint8Array): Promise<ImageMetadata | undefined>;
 }
 //# sourceMappingURL=types.d.ts.map

package/package.json

@@ -1,20 +1,34 @@
 {
   "name": "cross-image",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "A pure JavaScript, dependency-free, cross-runtime image processing library for Deno, Node.js, and Bun.",
   "keywords": [
     "image",
     "image-processing",
+    "image-manipulation",
+    "image-resize",
+    "image-decode",
+    "image-encode",
     "png",
+    "apng",
     "jpeg",
     "webp",
     "gif",
     "tiff",
     "bmp",
+    "ico",
     "dng",
+    "heic",
+    "avif",
     "pam",
+    "ppm",
     "pcx",
+    "ascii-art",
+    "metadata",
+    "exif",
     "cross-runtime",
+    "pure-javascript",
+    "no-dependencies",
     "deno",
     "node",
     "bun"
@@ -37,5 +51,8 @@
     }
   },
   "scripts": {},
+  "engines": {
+    "node": ">=18.0.0"
+  },
   "_generatedBy": "dnt@dev"
 }

package/script/mod.d.ts

@@ -57,4 +57,6 @@ export { PAMFormat } from "./src/formats/pam.js";
 export { PCXFormat } from "./src/formats/pcx.js";
 export { PPMFormat } from "./src/formats/ppm.js";
 export { ASCIIFormat } from "./src/formats/ascii.js";
+export { HEICFormat } from "./src/formats/heic.js";
+export { AVIFFormat } from "./src/formats/avif.js";
 //# sourceMappingURL=mod.d.ts.map

package/script/mod.js

@@ -44,7 +44,7 @@
  * ```
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ASCIIFormat = exports.PPMFormat = exports.PCXFormat = exports.PAMFormat = exports.DNGFormat = exports.ICOFormat = exports.BMPFormat = exports.TIFFFormat = exports.GIFFormat = exports.WebPFormat = exports.JPEGFormat = exports.APNGFormat = exports.PNGFormat = exports.Image = void 0;
+exports.AVIFFormat = exports.HEICFormat = exports.ASCIIFormat = exports.PPMFormat = exports.PCXFormat = exports.PAMFormat = exports.DNGFormat = exports.ICOFormat = exports.BMPFormat = exports.TIFFFormat = exports.GIFFormat = exports.WebPFormat = exports.JPEGFormat = exports.APNGFormat = exports.PNGFormat = exports.Image = void 0;
 var image_js_1 = require("./src/image.js");
 Object.defineProperty(exports, "Image", { enumerable: true, get: function () { return image_js_1.Image; } });
 var png_js_1 = require("./src/formats/png.js");
@@ -73,3 +73,7 @@ var ppm_js_1 = require("./src/formats/ppm.js");
 Object.defineProperty(exports, "PPMFormat", { enumerable: true, get: function () { return ppm_js_1.PPMFormat; } });
 var ascii_js_1 = require("./src/formats/ascii.js");
 Object.defineProperty(exports, "ASCIIFormat", { enumerable: true, get: function () { return ascii_js_1.ASCIIFormat; } });
+var heic_js_1 = require("./src/formats/heic.js");
+Object.defineProperty(exports, "HEICFormat", { enumerable: true, get: function () { return heic_js_1.HEICFormat; } });
+var avif_js_1 = require("./src/formats/avif.js");
+Object.defineProperty(exports, "AVIFFormat", { enumerable: true, get: function () { return avif_js_1.AVIFFormat; } });

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, MultiFrameImageData } from "../types.js";
+import type { ImageData, ImageFormat, ImageMetadata, MultiFrameImageData } from "../types.js";
 import { PNGBase } from "./png_base.js";
 /**
  * APNG (Animated PNG) format handler
@@ -46,5 +46,17 @@ export declare class APNGFormat extends PNGBase implements ImageFormat {
      */
     encodeFrames(imageData: MultiFrameImageData): Promise<Uint8Array>;
     private decodeFrameData;
+    /**
+     * Get the list of metadata fields supported by APNG format
+     * Includes all PNG fields plus frame count
+     */
+    getSupportedMetadata(): Array<keyof ImageMetadata>;
+    /**
+     * Extract metadata from APNG data without fully decoding the pixel data
+     * This quickly parses PNG chunks to extract metadata including frame count
+     * @param data Raw APNG data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data: Uint8Array): Promise<ImageMetadata | undefined>;
 }
 //# sourceMappingURL=apng.d.ts.map

package/script/src/formats/apng.js

@@ -364,5 +364,102 @@ class APNGFormat extends png_base_js_1.PNGBase {
         const rgba = this.unfilterAndConvert(decompressed, width, height, bitDepth, colorType);
         return rgba;
     }
+    /**
+     * Get the list of metadata fields supported by APNG format
+     * Includes all PNG fields plus frame count
+     */
+    getSupportedMetadata() {
+        return [
+            ...super.getSupportedMetadata(),
+            "frameCount", // acTL chunk
+        ];
+    }
+    /**
+     * Extract metadata from APNG data without fully decoding the pixel data
+     * This quickly parses PNG chunks to extract metadata including frame count
+     * @param data Raw APNG 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;
+        let frameCount = 0;
+        const metadata = {
+            format: "apng",
+            compression: "deflate",
+        };
+        // 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 === "acTL") {
+                // Animation control chunk - contains frame count
+                if (chunkData.length >= 4) {
+                    frameCount = this.readUint32(chunkData, 0);
+                    metadata.frameCount = frameCount;
+                }
+            }
+            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.APNGFormat = APNGFormat;

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

@@ -1,4 +1,4 @@
-import type { ASCIIOptions, ImageData, ImageFormat } from "../types.js";
+import type { ASCIIOptions, ImageData, ImageFormat, ImageMetadata } from "../types.js";
 /**
  * ASCII format handler
  * Converts images to ASCII art text representation
@@ -34,5 +34,15 @@ export declare class ASCIIFormat implements ImageFormat {
      * Parse options from the options line
      */
     private parseOptions;
+    /**
+     * Get the list of metadata fields supported by ASCII format
+     */
+    getSupportedMetadata(): Array<keyof ImageMetadata>;
+    /**
+     * Extract metadata from ASCII art data without fully decoding
+     * @param data Raw ASCII art data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data: Uint8Array): Promise<ImageMetadata | undefined>;
 }
 //# sourceMappingURL=ascii.d.ts.map

package/script/src/formats/ascii.js

@@ -186,5 +186,29 @@ class ASCIIFormat {
         }
         return options;
     }
+    /**
+     * Get the list of metadata fields supported by ASCII format
+     */
+    getSupportedMetadata() {
+        return []; // ASCII art doesn't support metadata preservation
+    }
+    /**
+     * Extract metadata from ASCII art data without fully decoding
+     * @param data Raw ASCII art data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data) {
+        if (!this.canDecode(data)) {
+            return Promise.resolve(undefined);
+        }
+        const metadata = {
+            format: "ascii",
+            compression: "none",
+            frameCount: 1,
+            bitDepth: 1, // ASCII is 1-bit (character or no character)
+            colorType: "grayscale",
+        };
+        return Promise.resolve(metadata);
+    }
 }
 exports.ASCIIFormat = ASCIIFormat;

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

@@ -0,0 +1,96 @@
+import type { ImageData, ImageFormat, ImageMetadata } from "../types.js";
+/**
+ * AVIF format handler
+ * Supports AVIF images using runtime APIs (ImageDecoder/OffscreenCanvas)
+ * Note: Pure JavaScript encode/decode is not supported due to complexity
+ */
+export declare class AVIFFormat implements ImageFormat {
+    /** Format name identifier */
+    readonly name = "avif";
+    /** MIME type for AVIF images */
+    readonly mimeType = "image/avif";
+    /**
+     * Check if the given data is an AVIF image
+     * @param data Raw image data to check
+     * @returns true if data has AVIF signature
+     */
+    canDecode(data: Uint8Array): boolean;
+    /**
+     * Decode AVIF image data to RGBA
+     * Uses runtime APIs (ImageDecoder) for decoding
+     * @param data Raw AVIF image data
+     * @returns Decoded image data with RGBA pixels
+     */
+    decode(data: Uint8Array): Promise<ImageData>;
+    /**
+     * Encode RGBA image data to AVIF 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 AVIF image bytes
+     */
+    encode(imageData: ImageData): Promise<Uint8Array>;
+    /**
+     * Decode using runtime APIs
+     * @param data Raw AVIF data
+     * @returns Decoded image dimensions and pixel data
+     */
+    private decodeUsingRuntime;
+    /**
+     * Parse EXIF metadata from AVIF 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 AVIF 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 AVIF format
+     */
+    getSupportedMetadata(): Array<keyof ImageMetadata>;
+    /**
+     * Extract metadata from AVIF data without fully decoding the pixel data
+     * @param data Raw AVIF data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data: Uint8Array): Promise<ImageMetadata | undefined>;
+}
+//# sourceMappingURL=avif.d.ts.map