cross-image 0.2.3 → 0.4.0

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

@@ -19,9 +19,11 @@
  * @see https://developers.google.com/speed/webp/docs/riff_container
  * @see https://developers.google.com/speed/webp/docs/webp_lossless_bitstream_specification
  */
+import type { ImageDecoderOptions } from "../types.js";
 export declare class WebPDecoder {
     private data;
-    constructor(data: Uint8Array);
+    private options;
+    constructor(data: Uint8Array, settings?: ImageDecoderOptions);
     decode(): {
         width: number;
         height: number;

package/esm/src/utils/webp_decoder.js

@@ -93,7 +93,6 @@ class HuffmanTable {
             const bit = reader.readBits(1);
             node = bit === 0 ? node.left : node.right;
             if (!node) {
-                // console.log("Invalid Huffman code - walked off tree");
                 throw new Error("Invalid Huffman code");
             }
         }
@@ -164,14 +163,24 @@ class BitReader {
     }
 }
 export class WebPDecoder {
-    constructor(data) {
+    constructor(data, settings = {}) {
         Object.defineProperty(this, "data", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.data = data;
+        this.options = {
+            tolerantDecoding: settings.tolerantDecoding ?? true,
+            onWarning: settings.onWarning,
+        };
     }
     decode() {
         // Verify WebP signature
@@ -278,66 +287,142 @@ export class WebPDecoder {
         const numPixels = width * height;
         // Color cache for repeated colors
         const colorCache = new Uint32Array(colorCacheSize);
-        for (let i = 0; i < numPixels;) {
-            // Read green channel (which determines the code type)
-            const green = huffmanTables.green.readSymbol(reader);
-            if (green < 256) {
-                // Literal pixel
-                const red = huffmanTables.red.readSymbol(reader);
-                const blue = huffmanTables.blue.readSymbol(reader);
-                const alpha = alphaUsed !== 0
-                    ? huffmanTables.alpha.readSymbol(reader)
-                    : 255;
-                pixelData[pixelIndex++] = red;
-                pixelData[pixelIndex++] = green;
-                pixelData[pixelIndex++] = blue;
-                pixelData[pixelIndex++] = alpha;
-                // Add to color cache if enabled
-                if (useColorCache) {
-                    const color = (alpha << 24) | (blue << 16) | (green << 8) | red;
-                    colorCache[i % colorCacheSize] = color;
+        if (this.options.tolerantDecoding) {
+            // Tolerant mode: continue decoding even if errors occur
+            try {
+                for (let i = 0; i < numPixels;) {
+                    // Read green channel (which determines the code type)
+                    const green = huffmanTables.green.readSymbol(reader);
+                    if (green < 256) {
+                        // Literal pixel
+                        const red = huffmanTables.red.readSymbol(reader);
+                        const blue = huffmanTables.blue.readSymbol(reader);
+                        const alpha = alphaUsed !== 0 ? huffmanTables.alpha.readSymbol(reader) : 255;
+                        pixelData[pixelIndex++] = red;
+                        pixelData[pixelIndex++] = green;
+                        pixelData[pixelIndex++] = blue;
+                        pixelData[pixelIndex++] = alpha;
+                        // Add to color cache if enabled
+                        if (useColorCache) {
+                            const color = (alpha << 24) | (blue << 16) | (green << 8) | red;
+                            colorCache[i % colorCacheSize] = color;
+                        }
+                        i++;
+                    }
+                    else if (green < 256 + 24) {
+                        // Backward reference (LZ77)
+                        const lengthSymbol = green - 256;
+                        const length = this.getLength(lengthSymbol, reader);
+                        const distancePrefix = huffmanTables.distance.readSymbol(reader);
+                        const distance = this.getDistance(distancePrefix, reader);
+                        // Copy pixels from earlier in the stream
+                        const srcIndex = pixelIndex - distance * 4;
+                        if (srcIndex < 0) {
+                            throw new Error("Invalid backward reference");
+                        }
+                        for (let j = 0; j < length; j++) {
+                            pixelData[pixelIndex++] = pixelData[srcIndex + j * 4];
+                            pixelData[pixelIndex++] = pixelData[srcIndex + j * 4 + 1];
+                            pixelData[pixelIndex++] = pixelData[srcIndex + j * 4 + 2];
+                            pixelData[pixelIndex++] = pixelData[srcIndex + j * 4 + 3];
+                            // Add to color cache
+                            if (useColorCache) {
+                                const color = (pixelData[pixelIndex - 1] << 24) |
+                                    (pixelData[pixelIndex - 2] << 16) |
+                                    (pixelData[pixelIndex - 3] << 8) |
+                                    pixelData[pixelIndex - 4];
+                                colorCache[(i + j) % colorCacheSize] = color;
+                            }
+                        }
+                        i += length;
+                    }
+                    else {
+                        // Color cache reference
+                        const cacheIndex = green - 256 - 24;
+                        if (cacheIndex >= colorCacheSize) {
+                            throw new Error("Invalid color cache index");
+                        }
+                        const color = colorCache[cacheIndex];
+                        pixelData[pixelIndex++] = color & 0xff; // R
+                        pixelData[pixelIndex++] = (color >> 8) & 0xff; // G
+                        pixelData[pixelIndex++] = (color >> 16) & 0xff; // B
+                        pixelData[pixelIndex++] = (color >> 24) & 0xff; // A
+                        i++;
+                    }
                 }
-                i++;
             }
-            else if (green < 256 + 24) {
-                // Backward reference (LZ77)
-                const lengthSymbol = green - 256;
-                const length = this.getLength(lengthSymbol, reader);
-                const distancePrefix = huffmanTables.distance.readSymbol(reader);
-                const distance = this.getDistance(distancePrefix, reader);
-                // Copy pixels from earlier in the stream
-                const srcIndex = pixelIndex - distance * 4;
-                if (srcIndex < 0) {
-                    throw new Error("Invalid backward reference");
+            catch (e) {
+                // Tolerant decoding: fill remaining pixels with gray (128, 128, 128, 255)
+                this.options.onWarning?.(`WebP VP8L: Partial decode at pixel ${pixelIndex / 4}/${numPixels}`, e);
+                while (pixelIndex < pixelData.length) {
+                    pixelData[pixelIndex++] = 128; // R
+                    pixelData[pixelIndex++] = 128; // G
+                    pixelData[pixelIndex++] = 128; // B
+                    pixelData[pixelIndex++] = 255; // A
                 }
-                for (let j = 0; j < length; j++) {
-                    pixelData[pixelIndex++] = pixelData[srcIndex + j * 4];
-                    pixelData[pixelIndex++] = pixelData[srcIndex + j * 4 + 1];
-                    pixelData[pixelIndex++] = pixelData[srcIndex + j * 4 + 2];
-                    pixelData[pixelIndex++] = pixelData[srcIndex + j * 4 + 3];
-                    // Add to color cache
+            }
+        }
+        else {
+            // Non-tolerant mode: throw on first error
+            for (let i = 0; i < numPixels;) {
+                // Read green channel (which determines the code type)
+                const green = huffmanTables.green.readSymbol(reader);
+                if (green < 256) {
+                    // Literal pixel
+                    const red = huffmanTables.red.readSymbol(reader);
+                    const blue = huffmanTables.blue.readSymbol(reader);
+                    const alpha = alphaUsed !== 0 ? huffmanTables.alpha.readSymbol(reader) : 255;
+                    pixelData[pixelIndex++] = red;
+                    pixelData[pixelIndex++] = green;
+                    pixelData[pixelIndex++] = blue;
+                    pixelData[pixelIndex++] = alpha;
+                    // Add to color cache if enabled
                     if (useColorCache) {
-                        const color = (pixelData[pixelIndex - 1] << 24) |
-                            (pixelData[pixelIndex - 2] << 16) |
-                            (pixelData[pixelIndex - 3] << 8) |
-                            pixelData[pixelIndex - 4];
-                        colorCache[(i + j) % colorCacheSize] = color;
+                        const color = (alpha << 24) | (blue << 16) | (green << 8) | red;
+                        colorCache[i % colorCacheSize] = color;
                     }
+                    i++;
                 }
-                i += length;
-            }
-            else {
-                // Color cache reference
-                const cacheIndex = green - 256 - 24;
-                if (cacheIndex >= colorCacheSize) {
-                    throw new Error("Invalid color cache index");
+                else if (green < 256 + 24) {
+                    // Backward reference (LZ77)
+                    const lengthSymbol = green - 256;
+                    const length = this.getLength(lengthSymbol, reader);
+                    const distancePrefix = huffmanTables.distance.readSymbol(reader);
+                    const distance = this.getDistance(distancePrefix, reader);
+                    // Copy pixels from earlier in the stream
+                    const srcIndex = pixelIndex - distance * 4;
+                    if (srcIndex < 0) {
+                        throw new Error("Invalid backward reference");
+                    }
+                    for (let j = 0; j < length; j++) {
+                        pixelData[pixelIndex++] = pixelData[srcIndex + j * 4];
+                        pixelData[pixelIndex++] = pixelData[srcIndex + j * 4 + 1];
+                        pixelData[pixelIndex++] = pixelData[srcIndex + j * 4 + 2];
+                        pixelData[pixelIndex++] = pixelData[srcIndex + j * 4 + 3];
+                        // Add to color cache
+                        if (useColorCache) {
+                            const color = (pixelData[pixelIndex - 1] << 24) |
+                                (pixelData[pixelIndex - 2] << 16) |
+                                (pixelData[pixelIndex - 3] << 8) |
+                                pixelData[pixelIndex - 4];
+                            colorCache[(i + j) % colorCacheSize] = color;
+                        }
+                    }
+                    i += length;
+                }
+                else {
+                    // Color cache reference
+                    const cacheIndex = green - 256 - 24;
+                    if (cacheIndex >= colorCacheSize) {
+                        throw new Error("Invalid color cache index");
+                    }
+                    const color = colorCache[cacheIndex];
+                    pixelData[pixelIndex++] = color & 0xff; // R
+                    pixelData[pixelIndex++] = (color >> 8) & 0xff; // G
+                    pixelData[pixelIndex++] = (color >> 16) & 0xff; // B
+                    pixelData[pixelIndex++] = (color >> 24) & 0xff; // A
+                    i++;
                 }
-                const color = colorCache[cacheIndex];
-                pixelData[pixelIndex++] = color & 0xff; // R
-                pixelData[pixelIndex++] = (color >> 8) & 0xff; // G
-                pixelData[pixelIndex++] = (color >> 16) & 0xff; // B
-                pixelData[pixelIndex++] = (color >> 24) & 0xff; // A
-                i++;
             }
         }
         return pixelData;
@@ -378,9 +463,7 @@ export class WebPDecoder {
             const isFirstEightBits = reader.readBits(1);
             const symbols = [];
             for (let i = 0; i < numSymbols; i++) {
-                const symbolBits = isFirstEightBits
-                    ? reader.readBits(8)
-                    : reader.readBits(1);
+                const symbolBits = isFirstEightBits ? reader.readBits(8) : reader.readBits(1);
                 symbols.push(symbolBits);
             }
             // Build simple Huffman table
@@ -396,9 +479,7 @@ export class WebPDecoder {
         }
         else {
             // Complex code - read code lengths
-            const maxSymbol = isGreen
-                ? (256 + 24 + (useColorCache ? (1 << colorCacheBits) : 0))
-                : 256;
+            const maxSymbol = isGreen ? (256 + 24 + (useColorCache ? (1 << colorCacheBits) : 0)) : 256;
             const codeLengths = this.readCodeLengths(reader, maxSymbol);
             this.buildHuffmanTable(table, codeLengths);
         }
@@ -406,7 +487,7 @@ export class WebPDecoder {
     readCodeLengths(reader, maxSymbol) {
         // Read code length codes (used to encode the actual code lengths)
         const numCodeLengthCodes = reader.readBits(4) + 4;
-        const codeLengthCodeLengths = new Array(19).fill(0);
+        const codeLengthCodeLengths = new Uint8Array(19);
         // Code length code order
         const codeLengthCodeOrder = [
             17,
@@ -442,7 +523,7 @@ export class WebPDecoder {
         const codeLengthTable = new HuffmanTable();
         this.buildHuffmanTable(codeLengthTable, codeLengthCodeLengths);
         // Read actual code lengths
-        const codeLengths = new Array(maxSymbol).fill(0);
+        const codeLengths = new Uint8Array(maxSymbol);
         let i = 0;
         while (i < maxSymbol) {
             const code = codeLengthTable.readSymbol(reader);

package/esm/src/utils/webp_encoder.js

@@ -369,7 +369,7 @@ export class WebPEncoder {
      * Returns an array where index is the symbol and value is the code length
      */
     calculateCodeLengths(frequencies, maxSymbol, maxCodeLength = 15) {
-        const codeLengths = new Array(maxSymbol).fill(0);
+        const codeLengths = new Uint8Array(maxSymbol);
         // Get symbols with non-zero frequencies
         const symbols = Array.from(frequencies.keys()).sort((a, b) => a - b);
         if (symbols.length === 0)
@@ -377,7 +377,6 @@ export class WebPEncoder {
         // For a single symbol, use code length 1
         // (Canonical Huffman codes require length >= 1)
         if (symbols.length === 1) {
-            // console.log(`Single symbol ${symbols[0]}, forcing length 1`);
             codeLengths[symbols[0]] = 1;
             return codeLengths;
         }
@@ -424,7 +423,6 @@ export class WebPEncoder {
         // If tree is too deep, flatten frequencies and rebuild
         let attempts = 0;
         while (maxDepth > maxCodeLength && attempts < 5) {
-            // console.log(`Tree too deep (${maxDepth} > ${maxCodeLength}), flattening...`);
             attempts++;
             // Add bias to frequencies to flatten the tree
             // Increase bias with each attempt
@@ -439,11 +437,8 @@ export class WebPEncoder {
             maxDepth = 0;
             checkDepth(root, 0);
         }
-        if (maxDepth > maxCodeLength) {
-            console.warn(`Failed to reduce Huffman tree depth to ${maxCodeLength} (current: ${maxDepth})`);
-            // Force hard limit by sorting and assigning lengths?
-            // For now, let's just see if this is happening.
-        }
+        // If tree depth couldn't be reduced, encoding may fail but we'll try anyway
+        // This is an internal limitation that doesn't affect most images
         // Calculate code lengths by traversing tree (iterative to avoid deep recursion)
         const stack = [{
                 node: root,
@@ -485,7 +480,7 @@ export class WebPEncoder {
             }
         }
         // Count symbols at each length
-        const lengthCounts = new Array(maxLength + 1).fill(0);
+        const lengthCounts = new Uint32Array(maxLength + 1);
         for (let i = 0; i < codeLengths.length; i++) {
             if (codeLengths[i] > 0) {
                 lengthCounts[codeLengths[i]]++;
@@ -493,7 +488,7 @@ export class WebPEncoder {
         }
         // Generate first code for each length
         let code = 0;
-        const nextCode = new Array(maxLength + 1).fill(0);
+        const nextCode = new Uint32Array(maxLength + 1);
         for (let len = 1; len <= maxLength; len++) {
             code = (code + lengthCounts[len - 1]) << 1;
             nextCode[len] = code;
@@ -625,7 +620,6 @@ export class WebPEncoder {
         }
         numCodeLengthCodes = Math.max(4, numCodeLengthCodes);
         // Write number of code length codes
-        // console.log(`Complex Huffman: numCodeLengthCodes=${numCodeLengthCodes}, rleEncoded.length=${rleEncoded.length}`);
         writer.writeBits(numCodeLengthCodes - 4, 4);
         // Write code length code lengths
         for (let i = 0; i < numCodeLengthCodes; i++) {

package/package.json

@@ -1,20 +1,34 @@
 {
   "name": "cross-image",
-  "version": "0.2.3",
+  "version": "0.4.0",
   "description": "A pure JavaScript, dependency-free, cross-runtime image processing library for Deno, Node.js, and Bun.",
   "keywords": [
     "image",
     "image-processing",
+    "image-manipulation",
+    "image-resize",
+    "image-decode",
+    "image-encode",
     "png",
+    "apng",
     "jpeg",
     "webp",
     "gif",
     "tiff",
     "bmp",
+    "ico",
     "dng",
+    "heic",
+    "avif",
     "pam",
+    "ppm",
     "pcx",
+    "ascii-art",
+    "metadata",
+    "exif",
     "cross-runtime",
+    "pure-javascript",
+    "no-dependencies",
     "deno",
     "node",
     "bun"
@@ -37,5 +51,8 @@
     }
   },
   "scripts": {},
+  "engines": {
+    "node": ">=18.0.0"
+  },
   "_generatedBy": "dnt@dev"
 }

package/script/mod.d.ts

@@ -7,7 +7,7 @@
  *
  * @example
  * ```ts
- * import { Image } from "@cross/image";
+ * import { Image } from "jsr:@cross/image";
  *
  * // Decode an image
  * const data = await Deno.readFile("input.png");
@@ -26,7 +26,7 @@
  *
  * @example
  * ```ts
- * import { Image } from "@cross/image";
+ * import { Image } from "jsr:@cross/image";
  *
  * // Create a blank canvas
  * const canvas = Image.create(400, 300, 255, 255, 255);
@@ -43,13 +43,13 @@
  * ```
  */
 export { Image } from "./src/image.js";
-export type { ASCIIOptions, FrameMetadata, ImageData, ImageFormat, ImageFrame, ImageMetadata, MultiFrameImageData, ResizeOptions, WebPEncodeOptions, } from "./src/types.js";
+export type { ASCIIEncoderOptions, FrameMetadata, ImageData, ImageDecoderOptions, ImageFormat, ImageFrame, ImageMetadata, JPEGEncoderOptions, MultiFrameImageData, ResizeOptions, TIFFEncoderOptions, WebPEncoderOptions, } 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 { 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";
@@ -57,4 +57,6 @@ 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";
+export { HEICFormat } from "./src/formats/heic.js";
+export { AVIFFormat } from "./src/formats/avif.js";
 //# sourceMappingURL=mod.d.ts.map

package/script/mod.js

@@ -8,7 +8,7 @@
  *
  * @example
  * ```ts
- * import { Image } from "@cross/image";
+ * import { Image } from "jsr:@cross/image";
  *
  * // Decode an image
  * const data = await Deno.readFile("input.png");
@@ -27,7 +27,7 @@
  *
  * @example
  * ```ts
- * import { Image } from "@cross/image";
+ * import { Image } from "jsr:@cross/image";
  *
  * // Create a blank canvas
  * const canvas = Image.create(400, 300, 255, 255, 255);
@@ -44,7 +44,7 @@
  * ```
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ASCIIFormat = exports.PPMFormat = exports.PCXFormat = exports.PAMFormat = exports.DNGFormat = exports.ICOFormat = exports.BMPFormat = exports.TIFFFormat = exports.GIFFormat = exports.WebPFormat = exports.JPEGFormat = exports.APNGFormat = exports.PNGFormat = exports.Image = void 0;
+exports.AVIFFormat = exports.HEICFormat = exports.ASCIIFormat = exports.PPMFormat = exports.PCXFormat = exports.PAMFormat = exports.DNGFormat = exports.ICOFormat = exports.BMPFormat = exports.TIFFFormat = exports.GIFFormat = exports.WebPFormat = exports.JPEGFormat = exports.APNGFormat = exports.PNGFormat = exports.Image = void 0;
 var image_js_1 = require("./src/image.js");
 Object.defineProperty(exports, "Image", { enumerable: true, get: function () { return image_js_1.Image; } });
 var png_js_1 = require("./src/formats/png.js");
@@ -73,3 +73,7 @@ var ppm_js_1 = require("./src/formats/ppm.js");
 Object.defineProperty(exports, "PPMFormat", { enumerable: true, get: function () { return ppm_js_1.PPMFormat; } });
 var ascii_js_1 = require("./src/formats/ascii.js");
 Object.defineProperty(exports, "ASCIIFormat", { enumerable: true, get: function () { return ascii_js_1.ASCIIFormat; } });
+var heic_js_1 = require("./src/formats/heic.js");
+Object.defineProperty(exports, "HEICFormat", { enumerable: true, get: function () { return heic_js_1.HEICFormat; } });
+var avif_js_1 = require("./src/formats/avif.js");
+Object.defineProperty(exports, "AVIFFormat", { enumerable: true, get: function () { return avif_js_1.AVIFFormat; } });

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, MultiFrameImageData } from "../types.js";
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata, MultiFrameImageData } from "../types.js";
 import { PNGBase } from "./png_base.js";
 /**
  * APNG (Animated PNG) format handler
@@ -26,25 +26,37 @@ export declare class APNGFormat extends PNGBase implements ImageFormat {
      * @param data Raw APNG image data
      * @returns Decoded image data with RGBA pixels of first frame
      */
-    decode(data: Uint8Array): Promise<ImageData>;
+    decode(data: Uint8Array, settings?: ImageDecoderOptions): 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>;
+    decodeFrames(data: Uint8Array, _settings?: ImageDecoderOptions): 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(imageData: ImageData, _options?: unknown): 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>;
+    encodeFrames(imageData: MultiFrameImageData, _options?: unknown): Promise<Uint8Array>;
     private decodeFrameData;
+    /**
+     * Get the list of metadata fields supported by APNG format
+     * Includes all PNG fields plus frame count
+     */
+    getSupportedMetadata(): Array<keyof ImageMetadata>;
+    /**
+     * Extract metadata from APNG data without fully decoding the pixel data
+     * This quickly parses PNG chunks to extract metadata including frame count
+     * @param data Raw APNG data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data: Uint8Array): Promise<ImageMetadata | undefined>;
 }
 //# sourceMappingURL=apng.d.ts.map