cross-image 0.1.2 → 0.1.5

package/esm/src/formats/tiff.js

@@ -1,4 +1,5 @@
 import { TIFFLZWDecoder, TIFFLZWEncoder } from "../utils/tiff_lzw.js";
+import { validateImageDimensions } from "../utils/security.js";
 // Constants for unit conversions
 const DEFAULT_DPI = 72;
 /**
@@ -10,12 +11,14 @@ const DEFAULT_DPI = 72;
  */
 export class TIFFFormat {
     constructor() {
+        /** Format name identifier */
         Object.defineProperty(this, "name", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: "tiff"
         });
+        /** MIME type for TIFF images */
         Object.defineProperty(this, "mimeType", {
             enumerable: true,
             configurable: true,
@@ -23,9 +26,18 @@ export class TIFFFormat {
             value: "image/tiff"
         });
     }
+    /**
+     * Check if this format supports multiple frames (pages)
+     * @returns true for TIFF format
+     */
     supportsMultipleFrames() {
         return true;
     }
+    /**
+     * Check if the given data is a TIFF image
+     * @param data Raw image data to check
+     * @returns true if data has TIFF signature
+     */
     canDecode(data) {
         // TIFF signature: "II" (little-endian) or "MM" (big-endian) followed by 42
         return data.length >= 4 &&
@@ -35,6 +47,11 @@ export class TIFFFormat {
                     data[3] === 0x2a) // "MM\0*"
             );
     }
+    /**
+     * Decode TIFF image data to RGBA (first page only)
+     * @param data Raw TIFF image data
+     * @returns Decoded image data with RGBA pixels of first page
+     */
     async decode(data) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid TIFF signature");
@@ -144,7 +161,7 @@ export class TIFFFormat {
         // IFD (Image File Directory)
         const ifdStart = result.length;
         // Count number of entries (including metadata)
-        let numEntries = 11; // Base entries
+        let numEntries = 12; // Base entries (including ExtraSamples)
         if (metadata?.description)
             numEntries++;
         if (metadata?.author)
@@ -184,6 +201,8 @@ export class TIFFFormat {
         const yResOffset = dataOffset;
         this.writeIFDEntry(result, 0x011b, 5, 1, yResOffset);
         dataOffset += 8;
+        // ExtraSamples (0x0152) - 2 = unassociated alpha
+        this.writeIFDEntry(result, 0x0152, 3, 1, 2);
         // Optional metadata entries
         if (metadata?.description) {
             const descBytes = new TextEncoder().encode(metadata.description + "\0");
@@ -210,6 +229,11 @@ export class TIFFFormat {
         // Next IFD offset (0 = no more IFDs)
         this.writeUint32LE(result, 0);
         // Write variable-length data
+        // BitsPerSample values (must be written first to match offset calculation)
+        this.writeUint16LE(result, 8);
+        this.writeUint16LE(result, 8);
+        this.writeUint16LE(result, 8);
+        this.writeUint16LE(result, 8);
         // XResolution value (rational)
         const dpiX = metadata?.dpiX ?? DEFAULT_DPI;
         this.writeUint32LE(result, dpiX);
@@ -218,11 +242,6 @@ export class TIFFFormat {
         const dpiY = metadata?.dpiY ?? DEFAULT_DPI;
         this.writeUint32LE(result, dpiY);
         this.writeUint32LE(result, 1);
-        // BitsPerSample values
-        this.writeUint16LE(result, 8);
-        this.writeUint16LE(result, 8);
-        this.writeUint16LE(result, 8);
-        this.writeUint16LE(result, 8);
         // Write metadata strings
         if (metadata?.description) {
             const descBytes = new TextEncoder().encode(metadata.description + "\0");
@@ -358,7 +377,7 @@ export class TIFFFormat {
             ifdOffsets.push(currentOffset);
             const ifdStart = result.length;
             // Count number of entries (including metadata only for first page)
-            let numEntries = 11;
+            let numEntries = 12; // Base entries (including ExtraSamples)
             if (i === 0 && imageData.metadata) {
                 if (imageData.metadata.description)
                     numEntries++;
@@ -402,6 +421,8 @@ export class TIFFFormat {
             const yResOffset = dataOffset;
             this.writeIFDEntry(result, 0x011b, 5, 1, yResOffset);
             dataOffset += 8;
+            // ExtraSamples (0x0152) - 2 = unassociated alpha
+            this.writeIFDEntry(result, 0x0152, 3, 1, 2);
             // Metadata (only for first page)
             if (i === 0 && imageData.metadata) {
                 if (imageData.metadata.description) {
@@ -432,6 +453,11 @@ export class TIFFFormat {
             this.writeUint32LE(result, nextIFDOffset);
             currentOffset = dataOffset;
             // Write variable-length data
+            // BitsPerSample values (must be written first to match offset calculation)
+            this.writeUint16LE(result, 8);
+            this.writeUint16LE(result, 8);
+            this.writeUint16LE(result, 8);
+            this.writeUint16LE(result, 8);
             // XResolution value (rational)
             const dpiX = (i === 0 && imageData.metadata?.dpiX) ||
                 DEFAULT_DPI;
@@ -442,11 +468,6 @@ export class TIFFFormat {
                 DEFAULT_DPI;
             this.writeUint32LE(result, dpiY);
             this.writeUint32LE(result, 1);
-            // BitsPerSample values
-            this.writeUint16LE(result, 8);
-            this.writeUint16LE(result, 8);
-            this.writeUint16LE(result, 8);
-            this.writeUint16LE(result, 8);
             // Write metadata strings (only for first page)
             if (i === 0 && imageData.metadata) {
                 if (imageData.metadata.description) {
@@ -707,6 +728,8 @@ export class TIFFFormat {
             // Uncompressed
             pixelData = data.slice(stripOffset, stripOffset + stripByteCount);
         }
+        // Validate dimensions for security (prevent integer overflow and heap exhaustion)
+        validateImageDimensions(width, height);
         // Convert to RGBA
         const rgba = new Uint8Array(width * height * 4);
         let srcPos = 0;
@@ -770,6 +793,8 @@ export class TIFFFormat {
             // Uncompressed
             pixelData = data.slice(stripOffset, stripOffset + stripByteCount);
         }
+        // Validate dimensions for security (prevent integer overflow and heap exhaustion)
+        validateImageDimensions(width, height);
         // Convert to RGBA
         const rgba = new Uint8Array(width * height * 4);
         let srcPos = 0;

package/esm/src/formats/webp.d.ts

@@ -4,10 +4,28 @@ import type { ImageData, ImageFormat, WebPEncodeOptions } from "../types.js";
  * Implements a basic WebP decoder and encoder
  */
 export declare class WebPFormat implements ImageFormat {
+    /** Format name identifier */
     readonly name = "webp";
+    /** MIME type for WebP images */
     readonly mimeType = "image/webp";
+    /**
+     * Check if the given data is a WebP image
+     * @param data Raw image data to check
+     * @returns true if data has WebP signature
+     */
     canDecode(data: Uint8Array): boolean;
+    /**
+     * Decode WebP image data to RGBA
+     * @param data Raw WebP image data
+     * @returns Decoded image data with RGBA pixels
+     */
     decode(data: Uint8Array): Promise<ImageData>;
+    /**
+     * Encode RGBA image data to WebP format
+     * @param imageData Image data to encode
+     * @param options Optional WebP encoding options
+     * @returns Encoded WebP image bytes
+     */
     encode(imageData: ImageData, options?: WebPEncodeOptions): Promise<Uint8Array>;
     private readUint32LE;
     private readUint24LE;

package/esm/src/formats/webp.js

@@ -1,3 +1,4 @@
+import { validateImageDimensions } from "../utils/security.js";
 // Default quality for WebP encoding when not specified
 const DEFAULT_WEBP_QUALITY = 90;
 /**
@@ -6,12 +7,14 @@ const DEFAULT_WEBP_QUALITY = 90;
  */
 export class WebPFormat {
     constructor() {
+        /** Format name identifier */
         Object.defineProperty(this, "name", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: "webp"
         });
+        /** MIME type for WebP images */
         Object.defineProperty(this, "mimeType", {
             enumerable: true,
             configurable: true,
@@ -19,6 +22,11 @@ export class WebPFormat {
             value: "image/webp"
         });
     }
+    /**
+     * Check if the given data is a WebP image
+     * @param data Raw image data to check
+     * @returns true if data has WebP signature
+     */
     canDecode(data) {
         // WebP signature: "RIFF" + size + "WEBP"
         return data.length >= 12 &&
@@ -27,6 +35,11 @@ export class WebPFormat {
             data[8] === 0x57 && data[9] === 0x45 && // "WE"
             data[10] === 0x42 && data[11] === 0x50; // "BP"
     }
+    /**
+     * Decode WebP image data to RGBA
+     * @param data Raw WebP image data
+     * @returns Decoded image data with RGBA pixels
+     */
     async decode(data) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid WebP signature");
@@ -89,6 +102,8 @@ export class WebPFormat {
         if (width === 0 || height === 0) {
             throw new Error("Could not determine WebP dimensions");
         }
+        // Validate dimensions for security (prevent integer overflow and heap exhaustion)
+        validateImageDimensions(width, height);
         // For a pure JS implementation, we'd need to implement full WebP decoding
         // which is very complex. Instead, we'll use the browser/runtime's decoder.
         const rgba = await this.decodeUsingRuntime(data, width, height);
@@ -99,6 +114,12 @@ export class WebPFormat {
             metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
         };
     }
+    /**
+     * Encode RGBA image data to WebP format
+     * @param imageData Image data to encode
+     * @param options Optional WebP encoding options
+     * @returns Encoded WebP image bytes
+     */
     async encode(imageData, options) {
         const { width, height, data, metadata } = imageData;
         const quality = options?.quality ?? DEFAULT_WEBP_QUALITY;

package/esm/src/image.d.ts

@@ -72,24 +72,49 @@ export declare class Image {
      * Get all registered formats
      */
     static getFormats(): readonly ImageFormat[];
+    /**
+     * Decode an image from bytes
+     * @param data Raw image data
+     * @param format Optional format hint (e.g., "png", "jpeg", "webp")
+     * @returns Image instance
+     */
+    static decode(data: Uint8Array, format?: string): Promise<Image>;
     /**
      * Read an image from bytes
+     * @deprecated Use `decode()` instead. This method will be removed in a future version.
      * @param data Raw image data
      * @param format Optional format hint (e.g., "png", "jpeg", "webp")
      * @returns Image instance
      */
     static read(data: Uint8Array, format?: string): Promise<Image>;
+    /**
+     * Decode all frames from a multi-frame image (GIF animation, multi-page TIFF)
+     * @param data Raw image data
+     * @param format Optional format hint (e.g., "gif", "tiff")
+     * @returns MultiFrameImageData with all frames
+     */
+    static decodeFrames(data: Uint8Array, format?: string): Promise<MultiFrameImageData>;
     /**
      * Read all frames from a multi-frame image (GIF animation, multi-page TIFF)
+     * @deprecated Use `decodeFrames()` instead. This method will be removed in a future version.
      * @param data Raw image data
      * @param format Optional format hint (e.g., "gif", "tiff")
      * @returns MultiFrameImageData with all frames
      */
     static readFrames(data: Uint8Array, format?: string): Promise<MultiFrameImageData>;
+    /**
+     * Encode multi-frame image data to bytes in the specified format
+     * @param format Format name (e.g., "gif", "tiff")
+     * @param imageData Multi-frame image data to encode
+     * @param options Optional format-specific encoding options
+     * @returns Encoded image bytes
+     */
+    static encodeFrames(format: string, imageData: MultiFrameImageData, options?: unknown): Promise<Uint8Array>;
     /**
      * Save multi-frame image data to bytes in the specified format
+     * @deprecated Use `encodeFrames()` instead. This method will be removed in a future version.
      * @param format Format name (e.g., "gif", "tiff")
-     * @param imageData Multi-frame image data to save
+     * @param imageData Multi-frame image data to encode
      * @param options Optional format-specific encoding options
      * @returns Encoded image bytes
      */
@@ -108,8 +133,16 @@ export declare class Image {
      * @returns This image instance for chaining
      */
     resize(options: ResizeOptions): this;
+    /**
+     * Encode the image to bytes in the specified format
+     * @param format Format name (e.g., "png", "jpeg", "webp", "ascii")
+     * @param options Optional format-specific encoding options
+     * @returns Encoded image bytes
+     */
+    encode(format: string, options?: unknown): Promise<Uint8Array>;
     /**
      * Save the image to bytes in the specified format
+     * @deprecated Use `encode()` instead. This method will be removed in a future version.
      * @param format Format name (e.g., "png", "jpeg", "webp", "ascii")
      * @param options Optional format-specific encoding options
      * @returns Encoded image bytes

package/esm/src/image.js

@@ -7,6 +7,7 @@ import { TIFFFormat } from "./formats/tiff.js";
 import { BMPFormat } from "./formats/bmp.js";
 import { RAWFormat } from "./formats/raw.js";
 import { ASCIIFormat } from "./formats/ascii.js";
+import { validateImageDimensions } from "./utils/security.js";
 /**
  * Main Image class for reading, manipulating, and saving images
  */
@@ -150,12 +151,12 @@ export class Image {
         return Image.formats;
     }
     /**
-     * Read an image from bytes
+     * Decode an image from bytes
      * @param data Raw image data
      * @param format Optional format hint (e.g., "png", "jpeg", "webp")
      * @returns Image instance
      */
-    static async read(data, format) {
+    static async decode(data, format) {
         const image = new Image();
         // Try specified format first
         if (format) {
@@ -175,12 +176,22 @@ export class Image {
         throw new Error("Unsupported or unrecognized image format");
     }
     /**
-     * Read all frames from a multi-frame image (GIF animation, multi-page TIFF)
+     * Read an image from bytes
+     * @deprecated Use `decode()` instead. This method will be removed in a future version.
+     * @param data Raw image data
+     * @param format Optional format hint (e.g., "png", "jpeg", "webp")
+     * @returns Image instance
+     */
+    static read(data, format) {
+        return Image.decode(data, format);
+    }
+    /**
+     * Decode all frames from a multi-frame image (GIF animation, multi-page TIFF)
      * @param data Raw image data
      * @param format Optional format hint (e.g., "gif", "tiff")
      * @returns MultiFrameImageData with all frames
      */
-    static async readFrames(data, format) {
+    static async decodeFrames(data, format) {
         // Try specified format first
         if (format) {
             const handler = Image.formats.find((f) => f.name === format);
@@ -197,13 +208,23 @@ export class Image {
         throw new Error("Unsupported or unrecognized multi-frame image format");
     }
     /**
-     * Save multi-frame image data to bytes in the specified format
+     * Read all frames from a multi-frame image (GIF animation, multi-page TIFF)
+     * @deprecated Use `decodeFrames()` instead. This method will be removed in a future version.
+     * @param data Raw image data
+     * @param format Optional format hint (e.g., "gif", "tiff")
+     * @returns MultiFrameImageData with all frames
+     */
+    static readFrames(data, format) {
+        return Image.decodeFrames(data, format);
+    }
+    /**
+     * Encode multi-frame image data to bytes in the specified format
      * @param format Format name (e.g., "gif", "tiff")
-     * @param imageData Multi-frame image data to save
+     * @param imageData Multi-frame image data to encode
      * @param options Optional format-specific encoding options
      * @returns Encoded image bytes
      */
-    static async saveFrames(format, imageData, options) {
+    static async encodeFrames(format, imageData, options) {
         const handler = Image.formats.find((f) => f.name === format);
         if (!handler) {
             throw new Error(`Unsupported format: ${format}`);
@@ -213,6 +234,17 @@ export class Image {
         }
         return await handler.encodeFrames(imageData, options);
     }
+    /**
+     * Save multi-frame image data to bytes in the specified format
+     * @deprecated Use `encodeFrames()` instead. This method will be removed in a future version.
+     * @param format Format name (e.g., "gif", "tiff")
+     * @param imageData Multi-frame image data to encode
+     * @param options Optional format-specific encoding options
+     * @returns Encoded image bytes
+     */
+    static saveFrames(format, imageData, options) {
+        return Image.encodeFrames(format, imageData, options);
+    }
     /**
      * Create an image from raw RGBA data
      * @param width Image width
@@ -221,6 +253,8 @@ export class Image {
      * @returns Image instance
      */
     static fromRGBA(width, height, data) {
+        // Validate dimensions for security (prevent integer overflow and heap exhaustion)
+        validateImageDimensions(width, height);
         if (data.length !== width * height * 4) {
             throw new Error(`Data length mismatch: expected ${width * height * 4}, got ${data.length}`);
         }
@@ -237,6 +271,8 @@ export class Image {
         if (!this.imageData)
             throw new Error("No image loaded");
         const { width, height, method = "bilinear" } = options;
+        // Validate new dimensions for security (prevent integer overflow and heap exhaustion)
+        validateImageDimensions(width, height);
         const { data: srcData, width: srcWidth, height: srcHeight } = this.imageData;
         let resizedData;
         if (method === "nearest") {
@@ -265,12 +301,12 @@ export class Image {
         return this;
     }
     /**
-     * Save the image to bytes in the specified format
+     * Encode the image to bytes in the specified format
      * @param format Format name (e.g., "png", "jpeg", "webp", "ascii")
      * @param options Optional format-specific encoding options
      * @returns Encoded image bytes
      */
-    async save(format, options) {
+    async encode(format, options) {
         if (!this.imageData)
             throw new Error("No image loaded");
         const handler = Image.formats.find((f) => f.name === format);
@@ -279,6 +315,16 @@ export class Image {
         }
         return await handler.encode(this.imageData, options);
     }
+    /**
+     * Save the image to bytes in the specified format
+     * @deprecated Use `encode()` instead. This method will be removed in a future version.
+     * @param format Format name (e.g., "png", "jpeg", "webp", "ascii")
+     * @param options Optional format-specific encoding options
+     * @returns Encoded image bytes
+     */
+    save(format, options) {
+        return this.encode(format, options);
+    }
     /**
      * Clone this image
      * @returns New image instance with copied data and metadata

package/esm/src/utils/security.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Security utilities for image processing
+ * Prevents integer overflow, heap exhaustion, and decompression bombs
+ */
+/**
+ * Maximum safe image dimensions
+ * These limits prevent integer overflow and heap exhaustion attacks
+ */
+export declare const MAX_IMAGE_DIMENSION = 65535;
+export declare const MAX_IMAGE_PIXELS = 178956970;
+/**
+ * Validates image dimensions to prevent security vulnerabilities
+ *
+ * @param width Image width in pixels
+ * @param height Image height in pixels
+ * @throws Error if dimensions are invalid or unsafe
+ */
+export declare function validateImageDimensions(width: number, height: number): void;
+/**
+ * Safely calculates buffer size for RGBA image data
+ *
+ * @param width Image width in pixels
+ * @param height Image height in pixels
+ * @returns Buffer size in bytes (width * height * 4)
+ * @throws Error if calculation would overflow
+ */
+export declare function calculateBufferSize(width: number, height: number): number;
+//# sourceMappingURL=security.d.ts.map

package/esm/src/utils/security.js

@@ -0,0 +1,48 @@
+/**
+ * Security utilities for image processing
+ * Prevents integer overflow, heap exhaustion, and decompression bombs
+ */
+/**
+ * Maximum safe image dimensions
+ * These limits prevent integer overflow and heap exhaustion attacks
+ */
+export const MAX_IMAGE_DIMENSION = 65535; // 2^16 - 1 (reasonable for most use cases)
+export const MAX_IMAGE_PIXELS = 178956970; // ~179 megapixels (fits safely in memory)
+/**
+ * Validates image dimensions to prevent security vulnerabilities
+ *
+ * @param width Image width in pixels
+ * @param height Image height in pixels
+ * @throws Error if dimensions are invalid or unsafe
+ */
+export function validateImageDimensions(width, height) {
+    // Check for negative or zero dimensions
+    if (width <= 0 || height <= 0) {
+        throw new Error(`Invalid image dimensions: ${width}x${height} (dimensions must be positive)`);
+    }
+    // Check if dimensions are integers
+    if (!Number.isInteger(width) || !Number.isInteger(height)) {
+        throw new Error(`Invalid image dimensions: ${width}x${height} (dimensions must be integers)`);
+    }
+    // Check individual dimension limits
+    if (width > MAX_IMAGE_DIMENSION || height > MAX_IMAGE_DIMENSION) {
+        throw new Error(`Image dimensions too large: ${width}x${height} (maximum ${MAX_IMAGE_DIMENSION}x${MAX_IMAGE_DIMENSION})`);
+    }
+    // Check total pixel count to prevent excessive memory allocation
+    const pixelCount = width * height;
+    if (pixelCount > MAX_IMAGE_PIXELS) {
+        throw new Error(`Image size too large: ${width}x${height} (${pixelCount} pixels exceeds maximum ${MAX_IMAGE_PIXELS})`);
+    }
+}
+/**
+ * Safely calculates buffer size for RGBA image data
+ *
+ * @param width Image width in pixels
+ * @param height Image height in pixels
+ * @returns Buffer size in bytes (width * height * 4)
+ * @throws Error if calculation would overflow
+ */
+export function calculateBufferSize(width, height) {
+    validateImageDimensions(width, height);
+    return width * height * 4;
+}

package/esm/src/utils/webp_decoder.js

@@ -19,6 +19,7 @@
  * @see https://developers.google.com/speed/webp/docs/riff_container
  * @see https://developers.google.com/speed/webp/docs/webp_lossless_bitstream_specification
  */
+import { validateImageDimensions } from "./security.js";
 // Helper to read little-endian values
 function readUint24LE(data, offset) {
     return data[offset] | (data[offset + 1] << 8) | (data[offset + 2] << 16);
@@ -252,6 +253,8 @@ export class WebPDecoder {
         }
         // Read Huffman codes
         const huffmanTables = this.readHuffmanCodes(reader, useColorCache, colorCacheBits);
+        // Validate dimensions for security (prevent integer overflow and heap exhaustion)
+        validateImageDimensions(width, height);
         // Decode the image using Huffman codes
         const pixelData = new Uint8Array(width * height * 4);
         let pixelIndex = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cross-image",
-  "version": "0.1.2",
+  "version": "0.1.5",
   "description": "A pure JavaScript, dependency-free, cross-runtime image processing library for Deno, Node.js, and Bun.",
   "keywords": [
     "image",
@@ -34,8 +34,5 @@
     }
   },
   "scripts": {},
-  "devDependencies": {
-    "@types/node": "^20.9.0"
-  },
   "_generatedBy": "dnt@dev"
 }

package/script/mod.d.ts

@@ -2,21 +2,21 @@
  * @module @cross/image
  *
  * A pure JavaScript, dependency-free, cross-runtime image processing library.
- * Supports reading, resizing, and saving common image formats (PNG, JPEG, WebP, GIF, TIFF, BMP, RAW).
+ * Supports decoding, resizing, and encoding common image formats (PNG, JPEG, WebP, GIF, TIFF, BMP, RAW).
  *
  * @example
  * ```ts
  * import { Image } from "@cross/image";
  *
- * // Read an image
+ * // Decode an image
  * const data = await Deno.readFile("input.png");
- * const image = await Image.read(data);
+ * const image = await Image.decode(data);
  *
  * // Resize it
  * image.resize({ width: 200, height: 200 });
  *
- * // Save as different format
- * const output = await image.save("jpeg");
+ * // Encode as different format
+ * const output = await image.encode("jpeg");
  * await Deno.writeFile("output.jpg", output);
  * ```
  */

package/script/mod.js

@@ -3,21 +3,21 @@
  * @module @cross/image
  *
  * A pure JavaScript, dependency-free, cross-runtime image processing library.
- * Supports reading, resizing, and saving common image formats (PNG, JPEG, WebP, GIF, TIFF, BMP, RAW).
+ * Supports decoding, resizing, and encoding common image formats (PNG, JPEG, WebP, GIF, TIFF, BMP, RAW).
  *
  * @example
  * ```ts
  * import { Image } from "@cross/image";
  *
- * // Read an image
+ * // Decode an image
  * const data = await Deno.readFile("input.png");
- * const image = await Image.read(data);
+ * const image = await Image.decode(data);
  *
  * // Resize it
  * image.resize({ width: 200, height: 200 });
  *
- * // Save as different format
- * const output = await image.save("jpeg");
+ * // Encode as different format
+ * const output = await image.encode("jpeg");
  * await Deno.writeFile("output.jpg", output);
  * ```
  */

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

@@ -17,7 +17,18 @@ export declare class ASCIIFormat implements ImageFormat {
     private readonly MAGIC_BYTES;
     private readonly CHARSETS;
     canDecode(data: Uint8Array): boolean;
+    /**
+     * Decode ASCII art to a basic grayscale RGBA image
+     * @param data Raw ASCII art data
+     * @returns Decoded image data with grayscale RGBA pixels
+     */
     decode(data: Uint8Array): Promise<ImageData>;
+    /**
+     * Encode RGBA image data to ASCII art
+     * @param imageData Image data to encode
+     * @param options Optional ASCII encoding options
+     * @returns Encoded ASCII art as UTF-8 bytes
+     */
     encode(imageData: ImageData, options?: ASCIIOptions): Promise<Uint8Array>;
     /**
      * Parse options from the options line