cross-image 0.2.0 → 0.2.2

package/README.md

@@ -1,20 +1,24 @@
 # @cross/image
 
 A pure JavaScript, dependency-free, cross-runtime image processing library for
-Deno, Node.js, and Bun.
+Deno, Node.js, and Bun. Decode, encode, manipulate, and process images in
+multiple formats including PNG, JPEG, WebP, GIF, and more—all without native
+dependencies.
 
-📚 **[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, PPM, PCX and ASCII support
 - ✂️ **Image manipulation** - Resize, crop, composite, and more
-- 🎛️ **Image processing** - Adjust brightness, contrast, saturation, exposure
+- 🎛️ **Image processing** - Chainable filters including `brightness`,
+  `contrast`, `saturation`, `exposure`, `blur`, `sharpen`, `sepia`, and more
 - 🖌️ **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
@@ -64,11 +68,13 @@ const canvas = Image.create(800, 600, 255, 255, 255); // white background
 // Composite the loaded image on top
 canvas.composite(image, 50, 50);
 
-// Apply image processing
+// Apply image processing filters
 canvas
   .brightness(0.1)
   .contrast(0.2)
-  .saturation(-0.1);
+  .saturation(-0.1)
+  .blur(1)
+  .sharpen(0.3);
 
 // Encode in a different format
 const jpeg = await canvas.encode("jpeg");
@@ -83,7 +89,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,39 +97,46 @@ 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);
 ```
 
 ## Supported Formats
 
-| Format | Pure-JS     | Notes                           |
-| ------ | ----------- | ------------------------------- |
-| PNG    | ✅ Full     | Complete pure-JS implementation |
-| BMP    | ✅ Full     | Complete pure-JS implementation |
-| GIF    | ✅ Full     | Complete pure-JS implementation |
-| RAW    | ✅ Full     | Uncompressed RGBA               |
-| 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      |
+| Format | Pure-JS     | Notes                                  |
+| ------ | ----------- | -------------------------------------- |
+| PNG    | ✅ Full     | Complete pure-JS implementation        |
+| APNG   | ✅ Full     | Animated PNG with multi-frame          |
+| BMP    | ✅ Full     | Complete pure-JS implementation        |
+| ICO    | ✅ Full     | Windows Icon format                    |
+| GIF    | ✅ Full     | Animated GIF with multi-frame          |
+| DNG    | ✅ Full     | Linear DNG (Uncompressed RGBA)         |
+| PAM    | ✅ Full     | Netpbm PAM format                      |
+| PPM    | ✅ Full     | Netpbm PPM format (P3/P6)              |
+| 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, & grayscale |
 
 See the
-[full format support documentation](https://cross-org.github.io/image/formats.html)
-for detailed compatibility information.
+[full format support documentation](https://cross-image.56k.guru/formats/) 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/)** - 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/)** - Usage examples for
+  common tasks
+- **[Format Support](https://cross-image.56k.guru/formats/)** - Supported
+  formats and specifications
+- **[JPEG Implementation](https://cross-image.56k.guru/implementation/jpeg-implementation/)** -
   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/)** -
   Technical details for WebP
+- **[TIFF Implementation](https://cross-image.56k.guru/implementation/tiff-implementation/)** -
+  Technical details for TIFF
 
 ## 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, PPM, PCX).
  * Includes image processing capabilities like compositing, level adjustments, and pixel manipulation.
  *
  * @example
@@ -45,13 +45,16 @@
 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";
+export { PPMFormat } from "./src/formats/ppm.js";
 export { ASCIIFormat } from "./src/formats/ascii.js";
 //# sourceMappingURL=mod.d.ts.map

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, PPM, PCX).
  * Includes image processing capabilities like compositing, level adjustments, and pixel manipulation.
  *
  * @example
@@ -44,12 +44,15 @@
  */
 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";
+export { PPMFormat } from "./src/formats/ppm.js";
 export { ASCIIFormat } from "./src/formats/ascii.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