cross-image 0.1.5 → 0.2.1

package/script/mod.js

@@ -3,7 +3,8 @@
  * @module @cross/image
  *
  * A pure JavaScript, dependency-free, cross-runtime image processing library.
- * Supports decoding, resizing, and encoding common image formats (PNG, JPEG, WebP, GIF, TIFF, BMP, RAW).
+ * Supports decoding, resizing, and encoding common image formats (PNG, APNG, JPEG, WebP, GIF, TIFF, BMP, ICO, DNG, PAM, PCX).
+ * Includes image processing capabilities like compositing, level adjustments, and pixel manipulation.
  *
  * @example
  * ```ts
@@ -13,20 +14,43 @@
  * const data = await Deno.readFile("input.png");
  * const image = await Image.decode(data);
  *
- * // Resize it
- * image.resize({ width: 200, height: 200 });
+ * // Apply image processing
+ * image
+ *   .resize({ width: 200, height: 200 })
+ *   .brightness(0.1)
+ *   .contrast(0.2);
  *
  * // Encode as different format
  * const output = await image.encode("jpeg");
  * await Deno.writeFile("output.jpg", output);
  * ```
+ *
+ * @example
+ * ```ts
+ * import { Image } from "@cross/image";
+ *
+ * // Create a blank canvas
+ * const canvas = Image.create(400, 300, 255, 255, 255);
+ *
+ * // Draw on it
+ * canvas.fillRect(50, 50, 100, 100, 255, 0, 0, 255);
+ *
+ * // Load and composite another image
+ * const overlay = await Image.decode(await Deno.readFile("logo.png"));
+ * canvas.composite(overlay, 10, 10, 0.8);
+ *
+ * // Save the result
+ * await Deno.writeFile("result.png", await canvas.encode("png"));
+ * ```
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ASCIIFormat = exports.RAWFormat = exports.BMPFormat = exports.TIFFFormat = exports.GIFFormat = exports.WebPFormat = exports.JPEGFormat = exports.PNGFormat = exports.Image = void 0;
+exports.ASCIIFormat = 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");
 Object.defineProperty(exports, "PNGFormat", { enumerable: true, get: function () { return png_js_1.PNGFormat; } });
+var apng_js_1 = require("./src/formats/apng.js");
+Object.defineProperty(exports, "APNGFormat", { enumerable: true, get: function () { return apng_js_1.APNGFormat; } });
 var jpeg_js_1 = require("./src/formats/jpeg.js");
 Object.defineProperty(exports, "JPEGFormat", { enumerable: true, get: function () { return jpeg_js_1.JPEGFormat; } });
 var webp_js_1 = require("./src/formats/webp.js");
@@ -37,7 +61,13 @@ var tiff_js_1 = require("./src/formats/tiff.js");
 Object.defineProperty(exports, "TIFFFormat", { enumerable: true, get: function () { return tiff_js_1.TIFFFormat; } });
 var bmp_js_1 = require("./src/formats/bmp.js");
 Object.defineProperty(exports, "BMPFormat", { enumerable: true, get: function () { return bmp_js_1.BMPFormat; } });
-var raw_js_1 = require("./src/formats/raw.js");
-Object.defineProperty(exports, "RAWFormat", { enumerable: true, get: function () { return raw_js_1.RAWFormat; } });
+var ico_js_1 = require("./src/formats/ico.js");
+Object.defineProperty(exports, "ICOFormat", { enumerable: true, get: function () { return ico_js_1.ICOFormat; } });
+var dng_js_1 = require("./src/formats/dng.js");
+Object.defineProperty(exports, "DNGFormat", { enumerable: true, get: function () { return dng_js_1.DNGFormat; } });
+var pam_js_1 = require("./src/formats/pam.js");
+Object.defineProperty(exports, "PAMFormat", { enumerable: true, get: function () { return pam_js_1.PAMFormat; } });
+var pcx_js_1 = require("./src/formats/pcx.js");
+Object.defineProperty(exports, "PCXFormat", { enumerable: true, get: function () { return pcx_js_1.PCXFormat; } });
 var ascii_js_1 = require("./src/formats/ascii.js");
 Object.defineProperty(exports, "ASCIIFormat", { enumerable: true, get: function () { return ascii_js_1.ASCIIFormat; } });

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

@@ -0,0 +1,50 @@
+import type { ImageData, ImageFormat, MultiFrameImageData } from "../types.js";
+import { PNGBase } from "./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)
+ */
+export declare class APNGFormat extends PNGBase implements ImageFormat {
+    /** Format name identifier */
+    readonly name = "apng";
+    /** MIME type for APNG images */
+    readonly mimeType = "image/apng";
+    /**
+     * Check if this format supports multiple frames (animations)
+     * @returns true for APNG format
+     */
+    supportsMultipleFrames(): boolean;
+    /**
+     * 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: Uint8Array): boolean;
+    /**
+     * 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
+     */
+    decode(data: Uint8Array): Promise<ImageData>;
+    /**
+     * Decode all frames from APNG image
+     * @param data Raw APNG image data
+     * @returns Decoded multi-frame image data
+     */
+    decodeFrames(data: Uint8Array): Promise<MultiFrameImageData>;
+    /**
+     * Encode RGBA image data to APNG format (single frame)
+     * @param imageData Image data to encode
+     * @returns Encoded APNG image bytes
+     */
+    encode(imageData: ImageData): Promise<Uint8Array>;
+    /**
+     * Encode multi-frame image data to APNG format
+     * @param imageData Multi-frame image data to encode
+     * @returns Encoded APNG image bytes
+     */
+    encodeFrames(imageData: MultiFrameImageData): Promise<Uint8Array>;
+    private decodeFrameData;
+}
+//# sourceMappingURL=apng.d.ts.map

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

@@ -0,0 +1,27 @@
+import type { ImageData } from "../types.js";
+import { TIFFFormat } from "./tiff.js";
+/**
+ * DNG format handler
+ * Implements a basic Linear DNG (Digital Negative) writer.
+ * DNG is based on TIFF/EP. This implementation creates a valid DNG
+ * containing uncompressed linear RGB data (demosaiced).
+ */
+export declare class DNGFormat extends TIFFFormat {
+    /** Format name identifier */
+    readonly name = "dng";
+    /** MIME type for DNG images */
+    readonly mimeType = "image/x-adobe-dng";
+    /**
+     * Check if the given data is a DNG image
+     * @param data Raw image data to check
+     * @returns true if data has DNG signature (TIFF signature + DNGVersion tag)
+     */
+    canDecode(data: Uint8Array): boolean;
+    /**
+     * Encode RGBA image data to DNG format (Linear DNG)
+     * @param imageData Image data to encode
+     * @returns Encoded DNG image bytes
+     */
+    encode(imageData: ImageData): Promise<Uint8Array>;
+}
+//# sourceMappingURL=dng.d.ts.map