cross-image 0.1.2

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

@@ -0,0 +1,27 @@
+import type { ASCIIOptions, ImageData, ImageFormat } from "../types.js";
+/**
+ * ASCII format handler
+ * Converts images to ASCII art text representation
+ *
+ * Format structure:
+ * - Magic bytes (6 bytes): "ASCII\n" (0x41 0x53 0x43 0x49 0x49 0x0A)
+ * - Options line: "width:W charset:C aspectRatio:A invert:I\n"
+ * - ASCII art text (UTF-8 encoded)
+ *
+ * Note: This format is primarily for encoding (image to ASCII).
+ * Decoding reconstructs a basic grayscale approximation.
+ */
+export declare class ASCIIFormat implements ImageFormat {
+    readonly name = "ascii";
+    readonly mimeType = "text/plain";
+    private readonly MAGIC_BYTES;
+    private readonly CHARSETS;
+    canDecode(data: Uint8Array): boolean;
+    decode(data: Uint8Array): Promise<ImageData>;
+    encode(imageData: ImageData, options?: ASCIIOptions): Promise<Uint8Array>;
+    /**
+     * Parse options from the options line
+     */
+    private parseOptions;
+}
+//# sourceMappingURL=ascii.d.ts.map

package/esm/src/formats/ascii.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ascii.d.ts","sourceRoot":"","sources":["../../../src/src/formats/ascii.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAExE;;;;;;;;;;;GAWG;AACH,qBAAa,WAAY,YAAW,WAAW;IAC7C,QAAQ,CAAC,IAAI,WAAW;IACxB,QAAQ,CAAC,QAAQ,gBAAgB;IAEjC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAOzB;IAGH,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAOvB;IAEF,SAAS,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO;IAcpC,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC;IA+D5C,MAAM,CACJ,SAAS,EAAE,SAAS,EACpB,OAAO,GAAE,YAAiB,GACzB,OAAO,CAAC,UAAU,CAAC;IAoDtB;;OAEG;IACH,OAAO,CAAC,YAAY;CA6BrB"}

package/esm/src/formats/ascii.js

@@ -0,0 +1,172 @@
+/**
+ * ASCII format handler
+ * Converts images to ASCII art text representation
+ *
+ * Format structure:
+ * - Magic bytes (6 bytes): "ASCII\n" (0x41 0x53 0x43 0x49 0x49 0x0A)
+ * - Options line: "width:W charset:C aspectRatio:A invert:I\n"
+ * - ASCII art text (UTF-8 encoded)
+ *
+ * Note: This format is primarily for encoding (image to ASCII).
+ * Decoding reconstructs a basic grayscale approximation.
+ */
+export class ASCIIFormat {
+    constructor() {
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "ascii"
+        });
+        Object.defineProperty(this, "mimeType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "text/plain"
+        });
+        Object.defineProperty(this, "MAGIC_BYTES", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Uint8Array([
+                0x41,
+                0x53,
+                0x43,
+                0x49,
+                0x49,
+                0x0A,
+            ])
+        }); // "ASCII\n"
+        // Character sets ordered from darkest to lightest
+        Object.defineProperty(this, "CHARSETS", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                simple: " .:-=+*#%@",
+                extended: " .'`^\",:;Il!i><~+_-?][}{1)(|\\/tfjrxnuvczXYUJCLQ0OZmwqpdbkhao*#MW&8%B@$",
+                blocks: " ░▒▓█",
+                detailed: " .`-_':,;^=+/\"|)\\<>)iv%xclrs{*}I?!][1taeo7zjLunT#JCwfy325Fh9kP6pqdbVOlS8X$KHEA4D3RZG0MQNWU&%B@",
+            }
+        });
+    }
+    canDecode(data) {
+        // Check if data starts with "ASCII\n"
+        if (data.length < 6) {
+            return false;
+        }
+        return data[0] === this.MAGIC_BYTES[0] &&
+            data[1] === this.MAGIC_BYTES[1] &&
+            data[2] === this.MAGIC_BYTES[2] &&
+            data[3] === this.MAGIC_BYTES[3] &&
+            data[4] === this.MAGIC_BYTES[4] &&
+            data[5] === this.MAGIC_BYTES[5];
+    }
+    decode(data) {
+        if (!this.canDecode(data)) {
+            throw new Error("Invalid ASCII art signature");
+        }
+        // Convert to string
+        const text = new TextDecoder().decode(data);
+        const lines = text.split("\n");
+        if (lines.length < 2) {
+            throw new Error("Invalid ASCII art format");
+        }
+        // Parse options from second line
+        const optionsLine = lines[1];
+        const options = this.parseOptions(optionsLine);
+        // Get ASCII art content (skip magic line and options line)
+        const artLines = lines.slice(2).filter((line) => line.length > 0);
+        if (artLines.length === 0) {
+            throw new Error("No ASCII art content found");
+        }
+        // Calculate dimensions
+        const height = artLines.length;
+        const width = Math.max(...artLines.map((line) => line.length));
+        // Convert ASCII art back to image data
+        const imageData = new Uint8Array(width * height * 4);
+        const charset = this.CHARSETS[options.charset] || this.CHARSETS.simple;
+        for (let y = 0; y < height; y++) {
+            const line = artLines[y];
+            for (let x = 0; x < width; x++) {
+                const char = x < line.length ? line[x] : " ";
+                const charIndex = charset.indexOf(char);
+                // Calculate brightness (0-255)
+                let brightness;
+                if (charIndex === -1) {
+                    brightness = 0; // Unknown character = black
+                }
+                else {
+                    brightness = Math.floor((charIndex / (charset.length - 1)) * 255);
+                }
+                if (options.invert) {
+                    brightness = 255 - brightness;
+                }
+                const offset = (y * width + x) * 4;
+                imageData[offset] = brightness; // R
+                imageData[offset + 1] = brightness; // G
+                imageData[offset + 2] = brightness; // B
+                imageData[offset + 3] = 255; // A
+            }
+        }
+        return Promise.resolve({ width, height, data: imageData });
+    }
+    encode(imageData, options = {}) {
+        const { width: targetWidth = 80, charset = "simple", aspectRatio = 0.5, invert = false, } = options;
+        // Get character set
+        const chars = this.CHARSETS[charset] || this.CHARSETS.simple;
+        // Calculate target height based on aspect ratio
+        const { width: imgWidth, height: imgHeight, data } = imageData;
+        const targetHeight = Math.floor((imgHeight / imgWidth) * targetWidth * aspectRatio);
+        // Build ASCII art
+        const lines = [];
+        for (let y = 0; y < targetHeight; y++) {
+            let line = "";
+            for (let x = 0; x < targetWidth; x++) {
+                // Map to source pixel
+                const srcX = Math.floor((x / targetWidth) * imgWidth);
+                const srcY = Math.floor((y / targetHeight) * imgHeight);
+                const offset = (srcY * imgWidth + srcX) * 4;
+                // Calculate grayscale value
+                const r = data[offset];
+                const g = data[offset + 1];
+                const b = data[offset + 2];
+                const gray = Math.floor(0.299 * r + 0.587 * g + 0.114 * b);
+                // Map to character
+                const brightness = invert ? 255 - gray : gray;
+                const charIndex = Math.floor((brightness / 255) * (chars.length - 1));
+                line += chars[charIndex];
+            }
+            lines.push(line);
+        }
+        // Create output with magic bytes and options
+        const optionsLine = `width:${targetWidth} charset:${charset} aspectRatio:${aspectRatio} invert:${invert}`;
+        const content = `ASCII\n${optionsLine}\n${lines.join("\n")}`;
+        return Promise.resolve(new TextEncoder().encode(content));
+    }
+    /**
+     * Parse options from the options line
+     */
+    parseOptions(line) {
+        const defaults = {
+            charset: "simple",
+            invert: false,
+        };
+        if (!line)
+            return defaults;
+        const parts = line.split(" ");
+        const options = { ...defaults };
+        for (const part of parts) {
+            const [key, value] = part.split(":");
+            if (key === "charset" && value) {
+                if (["simple", "extended", "blocks", "detailed"].includes(value)) {
+                    options.charset = value;
+                }
+            }
+            else if (key === "invert" && value) {
+                options.invert = value === "true";
+            }
+        }
+        return options;
+    }
+}

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

@@ -0,0 +1,19 @@
+import type { ImageData, ImageFormat } from "../types.js";
+/**
+ * BMP format handler
+ * Implements a pure JavaScript BMP decoder and encoder
+ */
+export declare class BMPFormat implements ImageFormat {
+    readonly name = "bmp";
+    readonly mimeType = "image/bmp";
+    canDecode(data: Uint8Array): boolean;
+    decode(data: Uint8Array): Promise<ImageData>;
+    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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bmp.d.ts","sourceRoot":"","sources":["../../../src/src/formats/bmp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAiB,MAAM,aAAa,CAAC;AAKzE;;;GAGG;AACH,qBAAa,SAAU,YAAW,WAAW;IAC3C,QAAQ,CAAC,IAAI,SAAS;IACtB,QAAQ,CAAC,QAAQ,eAAe;IAEhC,SAAS,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO;IAMpC,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC;IAwF5C,MAAM,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC;IA8DjD,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,YAAY;IAKpB,OAAO,CAAC,WAAW;IAKnB,OAAO,CAAC,aAAa;IAKrB,OAAO,CAAC,aAAa;IAOrB,OAAO,CAAC,YAAY;CAGrB"}

package/esm/src/formats/bmp.js

@@ -0,0 +1,174 @@
+// Constants for unit conversions
+const INCHES_PER_METER = 39.3701;
+/**
+ * BMP format handler
+ * Implements a pure JavaScript BMP decoder and encoder
+ */
+export class BMPFormat {
+    constructor() {
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "bmp"
+        });
+        Object.defineProperty(this, "mimeType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "image/bmp"
+        });
+    }
+    canDecode(data) {
+        // BMP signature: 'BM' (0x42 0x4D)
+        return data.length >= 2 &&
+            data[0] === 0x42 && data[1] === 0x4d;
+    }
+    decode(data) {
+        if (!this.canDecode(data)) {
+            throw new Error("Invalid BMP signature");
+        }
+        // Read BMP file header (14 bytes)
+        const _fileSize = this.readUint32LE(data, 2);
+        const dataOffset = this.readUint32LE(data, 10);
+        // Read DIB header (at least 40 bytes for BITMAPINFOHEADER)
+        const dibHeaderSize = this.readUint32LE(data, 14);
+        let width;
+        let height;
+        let bitDepth;
+        let compression;
+        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);
+            // Read DPI information (pixels per meter)
+            const xPixelsPerMeter = this.readInt32LE(data, 38);
+            const yPixelsPerMeter = this.readInt32LE(data, 42);
+            if (xPixelsPerMeter > 0 && yPixelsPerMeter > 0) {
+                // Convert pixels per meter to DPI
+                metadata.dpiX = Math.round(xPixelsPerMeter / INCHES_PER_METER);
+                metadata.dpiY = Math.round(yPixelsPerMeter / INCHES_PER_METER);
+                metadata.physicalWidth = Math.abs(width) / metadata.dpiX;
+                metadata.physicalHeight = Math.abs(height) / metadata.dpiY;
+            }
+        }
+        else {
+            throw new Error("Unsupported BMP header format");
+        }
+        // Handle negative height (top-down bitmap)
+        const isTopDown = height < 0;
+        const absHeight = Math.abs(height);
+        // Only support uncompressed BMPs for now
+        if (compression !== 0) {
+            throw new Error(`Compressed BMP not supported (compression type: ${compression})`);
+        }
+        // Only support 24-bit and 32-bit BMPs
+        if (bitDepth !== 24 && bitDepth !== 32) {
+            throw new Error(`Unsupported bit depth: ${bitDepth}. Only 24 and 32-bit BMPs are supported.`);
+        }
+        // Calculate row size (must be multiple of 4 bytes)
+        const bytesPerPixel = bitDepth / 8;
+        const rowSize = Math.floor((bitDepth * width + 31) / 32) * 4;
+        // Read pixel data
+        const rgba = new Uint8Array(width * absHeight * 4);
+        for (let y = 0; y < absHeight; y++) {
+            const rowIndex = isTopDown ? y : (absHeight - 1 - y); // BMP stores bottom-to-top by default
+            const rowOffset = dataOffset + y * rowSize;
+            for (let x = 0; x < width; x++) {
+                const pixelOffset = rowOffset + x * bytesPerPixel;
+                const outIndex = (rowIndex * width + x) * 4;
+                // BMP stores pixels as BGR(A)
+                rgba[outIndex] = data[pixelOffset + 2]; // R
+                rgba[outIndex + 1] = data[pixelOffset + 1]; // G
+                rgba[outIndex + 2] = data[pixelOffset]; // B
+                rgba[outIndex + 3] = bitDepth === 32 ? data[pixelOffset + 3] : 255; // A
+            }
+        }
+        return Promise.resolve({
+            width,
+            height: absHeight,
+            data: rgba,
+            metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+        });
+    }
+    encode(imageData) {
+        const { width, height, data, metadata } = imageData;
+        // Calculate sizes
+        const bytesPerPixel = 4; // We'll encode as 32-bit RGBA
+        const rowSize = Math.floor((32 * width + 31) / 32) * 4;
+        const pixelDataSize = rowSize * height;
+        const fileSize = 14 + 40 + pixelDataSize; // File header + DIB header + pixel data
+        const result = new Uint8Array(fileSize);
+        // Calculate DPI values
+        let xPixelsPerMeter = 2835; // Default 72 DPI
+        let yPixelsPerMeter = 2835;
+        if (metadata?.dpiX && metadata.dpiX > 0) {
+            xPixelsPerMeter = Math.round(metadata.dpiX * INCHES_PER_METER);
+        }
+        if (metadata?.dpiY && metadata.dpiY > 0) {
+            yPixelsPerMeter = Math.round(metadata.dpiY * INCHES_PER_METER);
+        }
+        // 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)
+        // 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
+        // Write pixel data (bottom-to-top, BGR(A) format)
+        let offset = 54;
+        for (let y = height - 1; y >= 0; y--) {
+            for (let x = 0; x < width; x++) {
+                const srcIndex = (y * width + x) * 4;
+                result[offset++] = data[srcIndex + 2]; // B
+                result[offset++] = data[srcIndex + 1]; // G
+                result[offset++] = data[srcIndex]; // R
+                result[offset++] = data[srcIndex + 3]; // A
+            }
+            // Add padding to make row size multiple of 4
+            const padding = rowSize - width * bytesPerPixel;
+            for (let p = 0; p < padding; p++) {
+                result[offset++] = 0;
+            }
+        }
+        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);
+    }
+}

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

@@ -0,0 +1,40 @@
+import type { ImageData, ImageFormat, MultiFrameImageData } from "../types.js";
+/**
+ * GIF format handler
+ * Now includes pure-JS implementation with custom LZW compression/decompression
+ *
+ * Features:
+ * - LZW compression/decompression
+ * - Color quantization and palette generation for encoding
+ * - Interlacing support
+ * - Transparency support
+ * - Multi-frame animation support (decoding and encoding)
+ * - Falls back to runtime APIs when pure-JS fails
+ */
+export declare class GIFFormat implements ImageFormat {
+    readonly name = "gif";
+    readonly mimeType = "image/gif";
+    supportsMultipleFrames(): boolean;
+    canDecode(data: Uint8Array): boolean;
+    decode(data: Uint8Array): Promise<ImageData>;
+    private extractMetadata;
+    encode(imageData: ImageData): Promise<Uint8Array>;
+    /**
+     * Decode all frames from an animated GIF
+     */
+    decodeFrames(data: Uint8Array): Promise<MultiFrameImageData>;
+    /**
+     * Encode multi-frame image data to animated GIF
+     * Note: Currently not implemented, will encode only first frame
+     */
+    encodeFrames(imageData: MultiFrameImageData, _options?: unknown): Promise<Uint8Array>;
+    private mapDisposalMethod;
+    private readUint16LE;
+    private decodeUsingRuntime;
+    private readDataSubBlocks;
+    private parseComment;
+    private parseXMP;
+    private injectMetadata;
+    private createCommentText;
+}
+//# sourceMappingURL=gif.d.ts.map

package/esm/src/formats/gif.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gif.d.ts","sourceRoot":"","sources":["../../../src/src/formats/gif.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EACT,WAAW,EAEX,mBAAmB,EACpB,MAAM,aAAa,CAAC;AAIrB;;;;;;;;;;;GAWG;AACH,qBAAa,SAAU,YAAW,WAAW;IAC3C,QAAQ,CAAC,IAAI,SAAS;IACtB,QAAQ,CAAC,QAAQ,eAAe;IAEhC,sBAAsB,IAAI,OAAO;IAIjC,SAAS,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO;IAS9B,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC;IA2ClD,OAAO,CAAC,eAAe;IAwDjB,MAAM,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC;IAyDvD;;OAEG;IACH,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAkC5D;;;OAGG;IACH,YAAY,CACV,SAAS,EAAE,mBAAmB,EAC9B,QAAQ,CAAC,EAAE,OAAO,GACjB,OAAO,CAAC,UAAU,CAAC;IAkBtB,OAAO,CAAC,iBAAiB;IAgBzB,OAAO,CAAC,YAAY;YAIN,kBAAkB;IAqChC,OAAO,CAAC,iBAAiB;IAkBzB,OAAO,CAAC,YAAY;IAmCpB,OAAO,CAAC,QAAQ;IAuBhB,OAAO,CAAC,cAAc;IAqDtB,OAAO,CAAC,iBAAiB;CAY1B"}