cross-image 0.2.0 → 0.2.1

package/script/src/formats/apng.js

@@ -0,0 +1,368 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APNGFormat = void 0;
+const security_js_1 = require("../utils/security.js");
+const png_base_js_1 = require("./png_base.js");
+/**
+ * APNG (Animated PNG) format handler
+ * Implements support for animated PNG images with multiple frames
+ * APNG extends PNG with animation control chunks (acTL, fcTL, fdAT)
+ */
+class APNGFormat extends png_base_js_1.PNGBase {
+    constructor() {
+        super(...arguments);
+        /** Format name identifier */
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "apng"
+        });
+        /** MIME type for APNG images */
+        Object.defineProperty(this, "mimeType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "image/apng"
+        });
+    }
+    /**
+     * Check if this format supports multiple frames (animations)
+     * @returns true for APNG format
+     */
+    supportsMultipleFrames() {
+        return true;
+    }
+    /**
+     * Check if the given data is an APNG image
+     * @param data Raw image data to check
+     * @returns true if data has PNG signature and contains acTL chunk
+     */
+    canDecode(data) {
+        // PNG signature: 137 80 78 71 13 10 26 10
+        if (data.length < 8 ||
+            data[0] !== 137 || data[1] !== 80 ||
+            data[2] !== 78 || data[3] !== 71 ||
+            data[4] !== 13 || data[5] !== 10 ||
+            data[6] !== 26 || data[7] !== 10) {
+            return false;
+        }
+        // Check for acTL (animation control) chunk to identify APNG
+        let pos = 8;
+        while (pos + 8 < data.length) {
+            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 (type === "acTL") {
+                return true;
+            }
+            pos += length + 4; // Skip chunk data and CRC
+            if (type === "IDAT") {
+                // If we hit IDAT before acTL, it's not an APNG
+                return false;
+            }
+        }
+        return false;
+    }
+    /**
+     * Decode APNG image data to RGBA (first frame only)
+     * @param data Raw APNG image data
+     * @returns Decoded image data with RGBA pixels of first frame
+     */
+    async decode(data) {
+        const frames = await this.decodeFrames(data);
+        const firstFrame = frames.frames[0];
+        return {
+            width: firstFrame.width,
+            height: firstFrame.height,
+            data: firstFrame.data,
+            metadata: frames.metadata,
+        };
+    }
+    /**
+     * Decode all frames from APNG image
+     * @param data Raw APNG image data
+     * @returns Decoded multi-frame image data
+     */
+    async decodeFrames(data) {
+        if (!this.canDecode(data)) {
+            throw new Error("Invalid APNG signature or missing acTL chunk");
+        }
+        let pos = 8; // Skip PNG signature
+        let width = 0;
+        let height = 0;
+        let bitDepth = 0;
+        let colorType = 0;
+        const metadata = {};
+        const frames = [];
+        // First pass: parse structure and extract metadata
+        const chunkList = [];
+        while (pos < data.length) {
+            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;
+            const chunkData = data.slice(pos, pos + length);
+            const chunkPos = pos;
+            pos += length;
+            pos += 4; // Skip CRC
+            chunkList.push({ type, data: chunkData, pos: chunkPos });
+            if (type === "IHDR") {
+                width = this.readUint32(chunkData, 0);
+                height = this.readUint32(chunkData, 4);
+                bitDepth = chunkData[8];
+                colorType = chunkData[9];
+            }
+            else if (type === "acTL") {
+                // Animation control chunk - we'll use frame count later if needed
+                // const numFrames = this.readUint32(chunkData, 0);
+                // const numPlays = this.readUint32(chunkData, 4);
+            }
+            else if (type === "pHYs") {
+                this.parsePhysChunk(chunkData, metadata, width, height);
+            }
+            else if (type === "tEXt") {
+                this.parseTextChunk(chunkData, metadata);
+            }
+            else if (type === "iTXt") {
+                this.parseITxtChunk(chunkData, metadata);
+            }
+            else if (type === "eXIf") {
+                this.parseExifChunk(chunkData, metadata);
+            }
+            else if (type === "IEND") {
+                break;
+            }
+        }
+        if (width === 0 || height === 0) {
+            throw new Error("Invalid APNG: missing IHDR chunk");
+        }
+        (0, security_js_1.validateImageDimensions)(width, height);
+        // Second pass: decode frames
+        let currentFrameControl = null;
+        let frameDataChunks = [];
+        let defaultImageChunks = [];
+        let hasSeenFcTL = false;
+        for (const chunk of chunkList) {
+            if (chunk.type === "fcTL") {
+                // If we have a previous frame to decode
+                if (frameDataChunks.length > 0 && currentFrameControl) {
+                    const frameData = await this.decodeFrameData(frameDataChunks, currentFrameControl.width, currentFrameControl.height, bitDepth, colorType);
+                    frames.push({
+                        width: currentFrameControl.width,
+                        height: currentFrameControl.height,
+                        data: frameData,
+                        frameMetadata: {
+                            delay: currentFrameControl.delay,
+                            disposal: currentFrameControl.disposal,
+                            left: currentFrameControl.xOffset,
+                            top: currentFrameControl.yOffset,
+                        },
+                    });
+                    frameDataChunks = [];
+                }
+                // Parse frame control
+                const _fcSeq = this.readUint32(chunk.data, 0);
+                const fcWidth = this.readUint32(chunk.data, 4);
+                const fcHeight = this.readUint32(chunk.data, 8);
+                const fcXOffset = this.readUint32(chunk.data, 12);
+                const fcYOffset = this.readUint32(chunk.data, 16);
+                const delayNum = this.readUint16(chunk.data, 20);
+                const delayDen = this.readUint16(chunk.data, 22);
+                const disposeOp = chunk.data[24];
+                const blendOp = chunk.data[25];
+                const delay = delayDen === 0
+                    ? delayNum * 10
+                    : Math.round((delayNum / delayDen) * 1000);
+                let disposal = "none";
+                if (disposeOp === 1)
+                    disposal = "background";
+                else if (disposeOp === 2)
+                    disposal = "previous";
+                currentFrameControl = {
+                    width: fcWidth,
+                    height: fcHeight,
+                    xOffset: fcXOffset,
+                    yOffset: fcYOffset,
+                    delay,
+                    disposal,
+                    blend: blendOp === 1 ? "over" : "source",
+                };
+                // If this is the first fcTL and we have default image data, use it for this frame
+                if (frames.length === 0 && defaultImageChunks.length > 0) {
+                    frameDataChunks = defaultImageChunks;
+                    defaultImageChunks = [];
+                }
+                hasSeenFcTL = true;
+            }
+            else if (chunk.type === "IDAT") {
+                if (!hasSeenFcTL) {
+                    // Collect default image chunks
+                    defaultImageChunks.push(chunk.data);
+                }
+                else if (currentFrameControl) {
+                    // IDAT after first fcTL belongs to that frame
+                    frameDataChunks.push(chunk.data);
+                }
+            }
+            else if (chunk.type === "fdAT") {
+                // Frame data chunk (skip sequence number)
+                const _frameSeq = this.readUint32(chunk.data, 0);
+                frameDataChunks.push(chunk.data.slice(4));
+            }
+            else if (chunk.type === "IEND") {
+                // Decode last frame if any
+                if (frameDataChunks.length > 0 && currentFrameControl) {
+                    const frameData = await this.decodeFrameData(frameDataChunks, currentFrameControl.width, currentFrameControl.height, bitDepth, colorType);
+                    frames.push({
+                        width: currentFrameControl.width,
+                        height: currentFrameControl.height,
+                        data: frameData,
+                        frameMetadata: {
+                            delay: currentFrameControl.delay,
+                            disposal: currentFrameControl.disposal,
+                            left: currentFrameControl.xOffset,
+                            top: currentFrameControl.yOffset,
+                        },
+                    });
+                }
+                else if (defaultImageChunks.length > 0) {
+                    // Only default image, no fcTL found - treat as single frame
+                    const frameData = await this.decodeFrameData(defaultImageChunks, width, height, bitDepth, colorType);
+                    frames.push({
+                        width,
+                        height,
+                        data: frameData,
+                        frameMetadata: {
+                            delay: 0,
+                            disposal: "none",
+                            left: 0,
+                            top: 0,
+                        },
+                    });
+                }
+                break;
+            }
+        }
+        return {
+            width,
+            height,
+            frames,
+            metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+        };
+    }
+    /**
+     * Encode RGBA image data to APNG format (single frame)
+     * @param imageData Image data to encode
+     * @returns Encoded APNG image bytes
+     */
+    encode(imageData) {
+        // For single frame, create a multi-frame with one frame
+        const multiFrame = {
+            width: imageData.width,
+            height: imageData.height,
+            frames: [{
+                    width: imageData.width,
+                    height: imageData.height,
+                    data: imageData.data,
+                    frameMetadata: { delay: 0 },
+                }],
+            metadata: imageData.metadata,
+        };
+        return this.encodeFrames(multiFrame);
+    }
+    /**
+     * Encode multi-frame image data to APNG format
+     * @param imageData Multi-frame image data to encode
+     * @returns Encoded APNG image bytes
+     */
+    async encodeFrames(imageData) {
+        const { width, height, frames, metadata } = imageData;
+        if (frames.length === 0) {
+            throw new Error("No frames to encode");
+        }
+        // Prepare IHDR chunk
+        const ihdr = new Uint8Array(13);
+        this.writeUint32(ihdr, 0, width);
+        this.writeUint32(ihdr, 4, height);
+        ihdr[8] = 8; // bit depth
+        ihdr[9] = 6; // color type: RGBA
+        ihdr[10] = 0; // compression method
+        ihdr[11] = 0; // filter method
+        ihdr[12] = 0; // interlace method
+        // Build PNG
+        const chunks = [];
+        chunks.push(new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10])); // PNG signature
+        chunks.push(this.createChunk("IHDR", ihdr));
+        // Add acTL chunk for animation control
+        const actl = new Uint8Array(8);
+        this.writeUint32(actl, 0, frames.length); // num_frames
+        this.writeUint32(actl, 4, 0); // num_plays (0 = infinite)
+        chunks.push(this.createChunk("acTL", actl));
+        // Add metadata chunks if available
+        this.addMetadataChunks(chunks, metadata);
+        // Add frames
+        let sequenceNumber = 0;
+        for (let i = 0; i < frames.length; i++) {
+            const frame = frames[i];
+            const fctl = new Uint8Array(26);
+            this.writeUint32(fctl, 0, sequenceNumber++); // sequence_number
+            this.writeUint32(fctl, 4, frame.width); // width
+            this.writeUint32(fctl, 8, frame.height); // height
+            this.writeUint32(fctl, 12, frame.frameMetadata?.left ?? 0); // x_offset
+            this.writeUint32(fctl, 16, frame.frameMetadata?.top ?? 0); // y_offset
+            // Convert delay from milliseconds to fraction
+            const delay = frame.frameMetadata?.delay ?? 100;
+            // Use milliseconds directly if possible (up to ~65 seconds)
+            if (delay < 65536) {
+                this.writeUint16(fctl, 20, delay); // delay_num
+                this.writeUint16(fctl, 22, 1000); // delay_den (1/1000 sec)
+            }
+            else {
+                // Fallback to 1/100 sec for longer delays
+                this.writeUint16(fctl, 20, Math.round(delay / 10)); // delay_num
+                this.writeUint16(fctl, 22, 100); // delay_den (1/100 sec)
+            }
+            // Disposal method
+            let disposeOp = 0; // APNG_DISPOSE_OP_NONE
+            if (frame.frameMetadata?.disposal === "background") {
+                disposeOp = 1; // APNG_DISPOSE_OP_BACKGROUND
+            }
+            else if (frame.frameMetadata?.disposal === "previous") {
+                disposeOp = 2; // APNG_DISPOSE_OP_PREVIOUS
+            }
+            fctl[24] = disposeOp;
+            fctl[25] = 0; // blend_op: APNG_BLEND_OP_SOURCE
+            chunks.push(this.createChunk("fcTL", fctl));
+            // Filter and compress frame data
+            const filtered = this.filterData(frame.data, frame.width, frame.height);
+            const compressed = await this.deflate(filtered);
+            if (i === 0) {
+                // First frame uses IDAT
+                chunks.push(this.createChunk("IDAT", compressed));
+            }
+            else {
+                // Subsequent frames use fdAT with sequence number
+                const fdat = new Uint8Array(4 + compressed.length);
+                this.writeUint32(fdat, 0, sequenceNumber++);
+                fdat.set(compressed, 4);
+                chunks.push(this.createChunk("fdAT", fdat));
+            }
+        }
+        chunks.push(this.createChunk("IEND", new Uint8Array(0)));
+        // Concatenate all chunks
+        return this.concatenateArrays(chunks);
+    }
+    // Helper methods for frame decoding
+    async decodeFrameData(chunks, width, height, bitDepth, colorType) {
+        // Concatenate chunks
+        const idatData = this.concatenateArrays(chunks);
+        // Decompress data
+        const decompressed = await this.inflate(idatData);
+        // Unfilter and convert to RGBA
+        const rgba = this.unfilterAndConvert(decompressed, width, height, bitDepth, colorType);
+        return rgba;
+    }
+}
+exports.APNGFormat = APNGFormat;

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

@@ -26,11 +26,5 @@ export declare class BMPFormat implements ImageFormat {
      * @returns Encoded BMP image bytes
      */
     encode(imageData: ImageData): Promise<Uint8Array>;
-    private readUint16LE;
-    private readUint32LE;
-    private readInt32LE;
-    private writeUint16LE;
-    private writeUint32LE;
-    private writeInt32LE;
 }
 //# sourceMappingURL=bmp.d.ts.map

package/script/src/formats/bmp.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BMPFormat = void 0;
 const security_js_1 = require("../utils/security.js");
+const byte_utils_js_1 = require("../utils/byte_utils.js");
 // Constants for unit conversions
 const INCHES_PER_METER = 39.3701;
 /**
@@ -45,10 +46,10 @@ class BMPFormat {
             throw new Error("Invalid BMP signature");
         }
         // Read BMP file header (14 bytes)
-        const _fileSize = this.readUint32LE(data, 2);
-        const dataOffset = this.readUint32LE(data, 10);
+        const _fileSize = (0, byte_utils_js_1.readUint32LE)(data, 2);
+        const dataOffset = (0, byte_utils_js_1.readUint32LE)(data, 10);
         // Read DIB header (at least 40 bytes for BITMAPINFOHEADER)
-        const dibHeaderSize = this.readUint32LE(data, 14);
+        const dibHeaderSize = (0, byte_utils_js_1.readUint32LE)(data, 14);
         let width;
         let height;
         let bitDepth;
@@ -56,13 +57,13 @@ class BMPFormat {
         const metadata = {};
         if (dibHeaderSize >= 40) {
             // BITMAPINFOHEADER or later
-            width = this.readInt32LE(data, 18);
-            height = this.readInt32LE(data, 22);
-            bitDepth = this.readUint16LE(data, 28);
-            compression = this.readUint32LE(data, 30);
+            width = (0, byte_utils_js_1.readInt32LE)(data, 18);
+            height = (0, byte_utils_js_1.readInt32LE)(data, 22);
+            bitDepth = (0, byte_utils_js_1.readUint16LE)(data, 28);
+            compression = (0, byte_utils_js_1.readUint32LE)(data, 30);
             // Read DPI information (pixels per meter)
-            const xPixelsPerMeter = this.readInt32LE(data, 38);
-            const yPixelsPerMeter = this.readInt32LE(data, 42);
+            const xPixelsPerMeter = (0, byte_utils_js_1.readInt32LE)(data, 38);
+            const yPixelsPerMeter = (0, byte_utils_js_1.readInt32LE)(data, 42);
             if (xPixelsPerMeter > 0 && yPixelsPerMeter > 0) {
                 // Convert pixels per meter to DPI
                 metadata.dpiX = Math.round(xPixelsPerMeter / INCHES_PER_METER);
@@ -137,21 +138,21 @@ class BMPFormat {
         // BMP File Header (14 bytes)
         result[0] = 0x42; // 'B'
         result[1] = 0x4d; // 'M'
-        this.writeUint32LE(result, 2, fileSize); // File size
-        this.writeUint32LE(result, 6, 0); // Reserved
-        this.writeUint32LE(result, 10, 54); // Offset to pixel data (14 + 40)
+        (0, byte_utils_js_1.writeUint32LE)(result, 2, fileSize); // File size
+        (0, byte_utils_js_1.writeUint32LE)(result, 6, 0); // Reserved
+        (0, byte_utils_js_1.writeUint32LE)(result, 10, 54); // Offset to pixel data (14 + 40)
         // DIB Header (BITMAPINFOHEADER - 40 bytes)
-        this.writeUint32LE(result, 14, 40); // DIB header size
-        this.writeInt32LE(result, 18, width); // Width
-        this.writeInt32LE(result, 22, height); // Height (positive = bottom-up)
-        this.writeUint16LE(result, 26, 1); // Planes
-        this.writeUint16LE(result, 28, 32); // Bits per pixel
-        this.writeUint32LE(result, 30, 0); // Compression (0 = uncompressed)
-        this.writeUint32LE(result, 34, pixelDataSize); // Image size
-        this.writeInt32LE(result, 38, xPixelsPerMeter); // X pixels per meter
-        this.writeInt32LE(result, 42, yPixelsPerMeter); // Y pixels per meter
-        this.writeUint32LE(result, 46, 0); // Colors in palette
-        this.writeUint32LE(result, 50, 0); // Important colors
+        (0, byte_utils_js_1.writeUint32LE)(result, 14, 40); // DIB header size
+        (0, byte_utils_js_1.writeInt32LE)(result, 18, width); // Width
+        (0, byte_utils_js_1.writeInt32LE)(result, 22, height); // Height (positive = bottom-up)
+        (0, byte_utils_js_1.writeUint16LE)(result, 26, 1); // Planes
+        (0, byte_utils_js_1.writeUint16LE)(result, 28, 32); // Bits per pixel
+        (0, byte_utils_js_1.writeUint32LE)(result, 30, 0); // Compression (0 = uncompressed)
+        (0, byte_utils_js_1.writeUint32LE)(result, 34, pixelDataSize); // Image size
+        (0, byte_utils_js_1.writeInt32LE)(result, 38, xPixelsPerMeter); // X pixels per meter
+        (0, byte_utils_js_1.writeInt32LE)(result, 42, yPixelsPerMeter); // Y pixels per meter
+        (0, byte_utils_js_1.writeUint32LE)(result, 46, 0); // Colors in palette
+        (0, byte_utils_js_1.writeUint32LE)(result, 50, 0); // Important colors
         // Write pixel data (bottom-to-top, BGR(A) format)
         let offset = 54;
         for (let y = height - 1; y >= 0; y--) {
@@ -170,29 +171,5 @@ class BMPFormat {
         }
         return Promise.resolve(result);
     }
-    readUint16LE(data, offset) {
-        return data[offset] | (data[offset + 1] << 8);
-    }
-    readUint32LE(data, offset) {
-        return data[offset] | (data[offset + 1] << 8) |
-            (data[offset + 2] << 16) | (data[offset + 3] << 24);
-    }
-    readInt32LE(data, offset) {
-        const value = this.readUint32LE(data, offset);
-        return value > 0x7fffffff ? value - 0x100000000 : value;
-    }
-    writeUint16LE(data, offset, value) {
-        data[offset] = value & 0xff;
-        data[offset + 1] = (value >>> 8) & 0xff;
-    }
-    writeUint32LE(data, offset, value) {
-        data[offset] = value & 0xff;
-        data[offset + 1] = (value >>> 8) & 0xff;
-        data[offset + 2] = (value >>> 16) & 0xff;
-        data[offset + 3] = (value >>> 24) & 0xff;
-    }
-    writeInt32LE(data, offset, value) {
-        this.writeUint32LE(data, offset, value < 0 ? value + 0x100000000 : value);
-    }
 }
 exports.BMPFormat = BMPFormat;

package/script/src/formats/dng.js

@@ -81,7 +81,7 @@ class DNGFormat extends tiff_js_1.TIFFFormat {
      * @param imageData Image data to encode
      * @returns Encoded DNG image bytes
      */
-    async encode(imageData) {
+    encode(imageData) {
         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.
@@ -127,7 +127,7 @@ class DNGFormat extends tiff_js_1.TIFFFormat {
         // 4. BitsPerSample (0x0102) - 8, 8, 8, 8
         this.writeIFDEntry(result, 0x0102, 3, 4, dataOffset);
         // Write the actual values later
-        const bitsPerSampleOffset = dataOffset;
+        const _bitsPerSampleOffset = dataOffset;
         dataOffset += 8; // 4 * 2 bytes
         // 5. Compression (0x0103) - 1 = Uncompressed
         this.writeIFDEntry(result, 0x0103, 3, 1, 1);
@@ -164,7 +164,7 @@ class DNGFormat extends tiff_js_1.TIFFFormat {
         const modelName = "Cross Image DNG\0";
         const modelNameBytes = new TextEncoder().encode(modelName);
         this.writeIFDEntry(result, 50708, 2, modelNameBytes.length, dataOffset);
-        const modelNameOffset = dataOffset;
+        const _modelNameOffset = dataOffset;
         dataOffset += modelNameBytes.length;
         // Next IFD offset (0)
         this.writeUint32LE(result, 0);
@@ -189,7 +189,7 @@ class DNGFormat extends tiff_js_1.TIFFFormat {
         for (let i = 0; i < modelNameBytes.length; i++) {
             result.push(modelNameBytes[i]);
         }
-        return new Uint8Array(result);
+        return Promise.resolve(new Uint8Array(result));
     }
 }
 exports.DNGFormat = DNGFormat;

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

@@ -46,11 +46,9 @@ export declare class GIFFormat implements ImageFormat {
     decodeFrames(data: Uint8Array): Promise<MultiFrameImageData>;
     /**
      * Encode multi-frame image data to animated GIF
-     * Note: Currently not implemented, will encode only first frame
      */
     encodeFrames(imageData: MultiFrameImageData, _options?: unknown): Promise<Uint8Array>;
     private mapDisposalMethod;
-    private readUint16LE;
     private decodeUsingRuntime;
     private readDataSubBlocks;
     private parseComment;

package/script/src/formats/gif.js

@@ -4,6 +4,7 @@ exports.GIFFormat = void 0;
 const gif_decoder_js_1 = require("../utils/gif_decoder.js");
 const gif_encoder_js_1 = require("../utils/gif_encoder.js");
 const security_js_1 = require("../utils/security.js");
+const byte_utils_js_1 = require("../utils/byte_utils.js");
 /**
  * GIF format handler
  * Now includes pure-JS implementation with custom LZW compression/decompression
@@ -81,9 +82,9 @@ class GIFFormat {
             // 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 = this.readUint16LE(data, pos);
+            const width = (0, byte_utils_js_1.readUint16LE)(data, pos);
             pos += 2;
-            const height = this.readUint16LE(data, pos);
+            const height = (0, byte_utils_js_1.readUint16LE)(data, pos);
             // Validate dimensions for security (prevent integer overflow and heap exhaustion)
             (0, security_js_1.validateImageDimensions)(width, height);
             const rgba = await this.decodeUsingRuntime(data, width, height);
@@ -234,22 +235,18 @@ class GIFFormat {
     }
     /**
      * Encode multi-frame image data to animated GIF
-     * Note: Currently not implemented, will encode only first frame
      */
     encodeFrames(imageData, _options) {
-        // For now, just encode the first frame using the existing encoder
-        // Full multi-frame encoding would require a more complex GIFEncoder
         if (imageData.frames.length === 0) {
             throw new Error("No frames to encode");
         }
-        const firstFrame = imageData.frames[0];
-        const singleFrameData = {
-            width: firstFrame.width,
-            height: firstFrame.height,
-            data: firstFrame.data,
-            metadata: imageData.metadata,
-        };
-        return this.encode(singleFrameData);
+        const encoder = new gif_encoder_js_1.GIFEncoder(imageData.width, imageData.height);
+        for (const frame of imageData.frames) {
+            // Get delay from metadata (default to 100ms if not set)
+            const delay = frame.frameMetadata?.delay ?? 100;
+            encoder.addFrame(frame.data, delay);
+        }
+        return Promise.resolve(encoder.encode());
     }
     mapDisposalMethod(disposal) {
         switch (disposal) {
@@ -264,9 +261,6 @@ class GIFFormat {
                 return "none";
         }
     }
-    readUint16LE(data, offset) {
-        return data[offset] | (data[offset + 1] << 8);
-    }
     async decodeUsingRuntime(data, _width, _height) {
         // Try to use ImageDecoder API if available (Deno, modern browsers)
         if (typeof ImageDecoder !== "undefined") {

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

@@ -0,0 +1,41 @@
+import type { ImageData, ImageFormat } from "../types.js";
+/**
+ * ICO format handler
+ * Implements a pure JavaScript ICO (Windows Icon) decoder and encoder
+ *
+ * ICO files can contain multiple images at different sizes.
+ * This implementation decodes the largest image and encodes as a single-image ICO.
+ */
+export declare class ICOFormat implements ImageFormat {
+    /** Format name identifier */
+    readonly name = "ico";
+    /** MIME type for ICO images */
+    readonly mimeType = "image/x-icon";
+    private pngFormat;
+    /**
+     * Check if the given data is an ICO image
+     * @param data Raw image data to check
+     * @returns true if data has ICO/CUR signature
+     */
+    canDecode(data: Uint8Array): boolean;
+    /**
+     * Decode ICO image data to RGBA
+     * Selects and decodes the largest image in the ICO file
+     * @param data Raw ICO image data
+     * @returns Decoded image data with RGBA pixels
+     */
+    decode(data: Uint8Array): Promise<ImageData>;
+    /**
+     * Decode a DIB (Device Independent Bitmap) format
+     * This is a BMP without the 14-byte file header
+     */
+    private decodeDIB;
+    /**
+     * Encode RGBA image data to ICO format
+     * Creates an ICO file with a single PNG-encoded image
+     * @param imageData Image data to encode
+     * @returns Encoded ICO image bytes
+     */
+    encode(imageData: ImageData): Promise<Uint8Array>;
+}
+//# sourceMappingURL=ico.d.ts.map