cross-image 0.2.0 → 0.2.1

package/README.md

@@ -3,18 +3,20 @@
 A pure JavaScript, dependency-free, cross-runtime image processing library for
 Deno, Node.js, and Bun.
 
-📚 **[Full Documentation](https://cross-org.github.io/image/)**
+📚 **[Full Documentation](https://cross-image.56k.guru/)**
 
 ## Features
 
 - 🚀 **Pure JavaScript** - No native dependencies
 - 🔌 **Pluggable formats** - Easy to extend with custom formats
 - 📦 **Cross-runtime** - Works on Deno, Node.js (18+), and Bun
-- 🎨 **Multiple formats** - PNG, JPEG, WebP, GIF, TIFF, BMP, DNG, PAM, and PCX
-  support
+- 🎨 **Multiple formats** - PNG, APNG, JPEG, WebP, GIF, TIFF, BMP, ICO, DNG,
+  PAM, PCX and ASCII support
 - ✂️ **Image manipulation** - Resize, crop, composite, and more
-- 🎛️ **Image processing** - Adjust brightness, contrast, saturation, exposure
+- 🎛️ **Image processing** - Chainable `brightness`, `contrast`, `saturation`,
+  and `exposure` helpers
 - 🖌️ **Drawing operations** - Create, fill, and manipulate pixels
+- 🧩 **Multi-frame** - Decode/encode animated GIFs, APNGs and multi-page TIFFs
 - 🔧 **Simple API** - Easy to use, intuitive interface
 
 ## Installation
@@ -83,7 +85,7 @@ import { readFile, writeFile } from "node:fs/promises";
 
 // Read an image (auto-detects format)
 const data = await readFile("input.png");
-const image = await Image.read(data);
+const image = await Image.decode(data);
 
 console.log(`Image size: ${image.width}x${image.height}`);
 
@@ -91,7 +93,7 @@ console.log(`Image size: ${image.width}x${image.height}`);
 image.resize({ width: 800, height: 600 });
 
 // Save in a different format
-const jpeg = await image.save("jpeg");
+const jpeg = await image.encode("jpeg");
 await writeFile("output.jpg", jpeg);
 ```
 
@@ -100,29 +102,33 @@ await writeFile("output.jpg", jpeg);
 | Format | Pure-JS     | Notes                           |
 | ------ | ----------- | ------------------------------- |
 | PNG    | ✅ Full     | Complete pure-JS implementation |
+| APNG   | ✅ Full     | Animated PNG with multi-frame   |
 | BMP    | ✅ Full     | Complete pure-JS implementation |
-| GIF    | ✅ Full     | Complete pure-JS implementation |
-| RAW    | ✅ Full     | Uncompressed RGBA               |
+| ICO    | ✅ Full     | Windows Icon format             |
+| GIF    | ✅ Full     | Animated GIF with multi-frame   |
+| DNG    | ✅ Full     | Linear DNG (Uncompressed RGBA)  |
+| PAM    | ✅ Full     | Netpbm PAM format               |
+| PCX    | ✅ Full     | ZSoft PCX (RLE compressed)      |
 | ASCII  | ✅ Full     | Text-based ASCII art            |
 | JPEG   | ⚠️ Baseline | Pure-JS baseline DCT only       |
 | WebP   | ⚠️ Lossless | Pure-JS lossless VP8L           |
 | TIFF   | ⚠️ Basic    | Pure-JS uncompressed + LZW      |
 
 See the
-[full format support documentation](https://cross-org.github.io/image/formats.html)
+[full format support documentation](https://cross-image.56k.guru/formats.html)
 for detailed compatibility information.
 
 ## Documentation
 
-- **[API Reference](https://cross-org.github.io/image/api.html)** - Complete API
+- **[API Reference](https://cross-image.56k.guru/api.html)** - Complete API
   documentation
-- **[Examples](https://cross-org.github.io/image/examples.html)** - Usage
-  examples for common tasks
-- **[Format Support](https://cross-org.github.io/image/formats.html)** -
-  Supported formats and specifications
-- **[JPEG Implementation](https://cross-org.github.io/image/jpeg-implementation.html)** -
+- **[Examples](https://cross-image.56k.guru/examples.html)** - Usage examples
+  for common tasks
+- **[Format Support](https://cross-image.56k.guru/formats.html)** - Supported
+  formats and specifications
+- **[JPEG Implementation](https://cross-image.56k.guru/implementation/jpeg-implementation.html)** -
   Technical details for JPEG
-- **[WebP Implementation](https://cross-org.github.io/image/webp-implementation.html)** -
+- **[WebP Implementation](https://cross-image.56k.guru/implementation/webp-implementation.html)** -
   Technical details for WebP
 
 ## Development

package/esm/mod.d.ts

@@ -2,7 +2,7 @@
  * @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, DNG, PAM, PCX).
+ * 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
@@ -45,11 +45,13 @@
 export { Image } from "./src/image.js";
 export type { ASCIIOptions, FrameMetadata, ImageData, ImageFormat, ImageFrame, ImageMetadata, MultiFrameImageData, ResizeOptions, WebPEncodeOptions, } from "./src/types.js";
 export { PNGFormat } from "./src/formats/png.js";
+export { APNGFormat } from "./src/formats/apng.js";
 export { JPEGFormat } from "./src/formats/jpeg.js";
 export { WebPFormat } from "./src/formats/webp.js";
 export { GIFFormat } from "./src/formats/gif.js";
 export { type TIFFEncodeOptions, TIFFFormat } from "./src/formats/tiff.js";
 export { BMPFormat } from "./src/formats/bmp.js";
+export { ICOFormat } from "./src/formats/ico.js";
 export { DNGFormat } from "./src/formats/dng.js";
 export { PAMFormat } from "./src/formats/pam.js";
 export { PCXFormat } from "./src/formats/pcx.js";

package/esm/mod.js

@@ -2,7 +2,7 @@
  * @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, DNG, PAM, PCX).
+ * 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
@@ -44,11 +44,13 @@
  */
 export { Image } from "./src/image.js";
 export { PNGFormat } from "./src/formats/png.js";
+export { APNGFormat } from "./src/formats/apng.js";
 export { JPEGFormat } from "./src/formats/jpeg.js";
 export { WebPFormat } from "./src/formats/webp.js";
 export { GIFFormat } from "./src/formats/gif.js";
 export { TIFFFormat } from "./src/formats/tiff.js";
 export { BMPFormat } from "./src/formats/bmp.js";
+export { ICOFormat } from "./src/formats/ico.js";
 export { DNGFormat } from "./src/formats/dng.js";
 export { PAMFormat } from "./src/formats/pam.js";
 export { PCXFormat } from "./src/formats/pcx.js";

package/esm/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/esm/src/formats/apng.js

@@ -0,0 +1,364 @@
+import { validateImageDimensions } from "../utils/security.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 class APNGFormat extends 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");
+        }
+        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;
+    }
+}

package/esm/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/esm/src/formats/bmp.js

@@ -1,4 +1,5 @@
 import { validateImageDimensions } from "../utils/security.js";
+import { readInt32LE, readUint16LE, readUint32LE, writeInt32LE, writeUint16LE, writeUint32LE, } from "../utils/byte_utils.js";
 // Constants for unit conversions
 const INCHES_PER_METER = 39.3701;
 /**
@@ -42,10 +43,10 @@ export 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 = readUint32LE(data, 2);
+        const dataOffset = readUint32LE(data, 10);
         // Read DIB header (at least 40 bytes for BITMAPINFOHEADER)
-        const dibHeaderSize = this.readUint32LE(data, 14);
+        const dibHeaderSize = readUint32LE(data, 14);
         let width;
         let height;
         let bitDepth;
@@ -53,13 +54,13 @@ export 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 = readInt32LE(data, 18);
+            height = readInt32LE(data, 22);
+            bitDepth = readUint16LE(data, 28);
+            compression = readUint32LE(data, 30);
             // Read DPI information (pixels per meter)
-            const xPixelsPerMeter = this.readInt32LE(data, 38);
-            const yPixelsPerMeter = this.readInt32LE(data, 42);
+            const xPixelsPerMeter = readInt32LE(data, 38);
+            const yPixelsPerMeter = readInt32LE(data, 42);
             if (xPixelsPerMeter > 0 && yPixelsPerMeter > 0) {
                 // Convert pixels per meter to DPI
                 metadata.dpiX = Math.round(xPixelsPerMeter / INCHES_PER_METER);
@@ -134,21 +135,21 @@ export 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)
+        writeUint32LE(result, 2, fileSize); // File size
+        writeUint32LE(result, 6, 0); // Reserved
+        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
+        writeUint32LE(result, 14, 40); // DIB header size
+        writeInt32LE(result, 18, width); // Width
+        writeInt32LE(result, 22, height); // Height (positive = bottom-up)
+        writeUint16LE(result, 26, 1); // Planes
+        writeUint16LE(result, 28, 32); // Bits per pixel
+        writeUint32LE(result, 30, 0); // Compression (0 = uncompressed)
+        writeUint32LE(result, 34, pixelDataSize); // Image size
+        writeInt32LE(result, 38, xPixelsPerMeter); // X pixels per meter
+        writeInt32LE(result, 42, yPixelsPerMeter); // Y pixels per meter
+        writeUint32LE(result, 46, 0); // Colors in palette
+        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--) {
@@ -167,28 +168,4 @@ export 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);
-    }
 }