cross-image 0.2.4 → 0.4.1

package/esm/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 { APNGEncoderOptions, ASCIIEncoderOptions, AVIFEncoderOptions, FrameMetadata, GIFEncoderOptions, HEICEncoderOptions, ImageData, ImageDecoderOptions, ImageFormat, ImageFrame, ImageMetadata, JPEGEncoderOptions, MultiFrameImageData, PNGEncoderOptions, 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";
@@ -59,4 +59,6 @@ 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";
+export { decodeBase64, encodeBase64, parseDataUrl, toDataUrl } from "./src/utils/base64.js";
+export { cmykToRgb, cmykToRgba, rgbaToCmyk, rgbToCmyk } from "./src/utils/image_processing.js";
 //# sourceMappingURL=mod.d.ts.map

package/esm/mod.js

@@ -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);
@@ -58,3 +58,5 @@ 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";
+export { decodeBase64, encodeBase64, parseDataUrl, toDataUrl } from "./src/utils/base64.js";
+export { cmykToRgb, cmykToRgba, rgbaToCmyk, rgbToCmyk } from "./src/utils/image_processing.js";

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, ImageMetadata, MultiFrameImageData } from "../types.js";
+import type { APNGEncoderOptions, ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata, MultiFrameImageData } from "../types.js";
 import { PNGBase } from "./png_base.js";
 /**
  * APNG (Animated PNG) format handler
@@ -26,25 +26,27 @@ 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
+     * @param options Encoding options (compressionLevel 0-9, default 6)
      * @returns Encoded APNG image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, options?: APNGEncoderOptions): Promise<Uint8Array>;
     /**
      * Encode multi-frame image data to APNG format
      * @param imageData Multi-frame image data to encode
+     * @param options Encoding options (compressionLevel 0-9, default 6)
      * @returns Encoded APNG image bytes
      */
-    encodeFrames(imageData: MultiFrameImageData): Promise<Uint8Array>;
+    encodeFrames(imageData: MultiFrameImageData, options?: APNGEncoderOptions): Promise<Uint8Array>;
     private decodeFrameData;
     /**
      * Get the list of metadata fields supported by APNG format

package/esm/src/formats/apng.js

@@ -67,8 +67,8 @@ export class APNGFormat extends PNGBase {
      * @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);
+    async decode(data, settings) {
+        const frames = await this.decodeFrames(data, settings);
         const firstFrame = frames.frames[0];
         return {
             width: firstFrame.width,
@@ -82,7 +82,7 @@ export class APNGFormat extends PNGBase {
      * @param data Raw APNG image data
      * @returns Decoded multi-frame image data
      */
-    async decodeFrames(data) {
+    async decodeFrames(data, _settings) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid APNG signature or missing acTL chunk");
         }
@@ -169,9 +169,7 @@ export class APNGFormat extends PNGBase {
                 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);
+                const delay = delayDen === 0 ? delayNum * 10 : Math.round((delayNum / delayDen) * 1000);
                 let disposal = "none";
                 if (disposeOp === 1)
                     disposal = "background";
@@ -252,9 +250,10 @@ export class APNGFormat extends PNGBase {
     /**
      * Encode RGBA image data to APNG format (single frame)
      * @param imageData Image data to encode
+     * @param options Encoding options (compressionLevel 0-9, default 6)
      * @returns Encoded APNG image bytes
      */
-    encode(imageData) {
+    encode(imageData, options) {
         // For single frame, create a multi-frame with one frame
         const multiFrame = {
             width: imageData.width,
@@ -267,15 +266,21 @@ export class APNGFormat extends PNGBase {
                 }],
             metadata: imageData.metadata,
         };
-        return this.encodeFrames(multiFrame);
+        return this.encodeFrames(multiFrame, options);
     }
     /**
      * Encode multi-frame image data to APNG format
      * @param imageData Multi-frame image data to encode
+     * @param options Encoding options (compressionLevel 0-9, default 6)
      * @returns Encoded APNG image bytes
      */
-    async encodeFrames(imageData) {
+    async encodeFrames(imageData, options) {
         const { width, height, frames, metadata } = imageData;
+        const compressionLevel = options?.compressionLevel ?? 6;
+        // Validate compression level
+        if (compressionLevel < 0 || compressionLevel > 9) {
+            throw new Error("Compression level must be between 0 and 9");
+        }
         if (frames.length === 0) {
             throw new Error("No frames to encode");
         }
@@ -333,7 +338,7 @@ export class APNGFormat extends PNGBase {
             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 filtered = this.filterData(frame.data, frame.width, frame.height, compressionLevel);
             const compressed = await this.deflate(filtered);
             if (i === 0) {
                 // First frame uses IDAT

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

@@ -1,4 +1,4 @@
-import type { ASCIIOptions, ImageData, ImageFormat, ImageMetadata } from "../types.js";
+import type { ASCIIEncoderOptions, ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata } from "../types.js";
 /**
  * ASCII format handler
  * Converts images to ASCII art text representation
@@ -22,14 +22,14 @@ export declare class ASCIIFormat implements ImageFormat {
      * @param data Raw ASCII art data
      * @returns Decoded image data with grayscale RGBA pixels
      */
-    decode(data: Uint8Array): Promise<ImageData>;
+    decode(data: Uint8Array, _options?: ImageDecoderOptions): 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>;
+    encode(imageData: ImageData, options?: ASCIIEncoderOptions): Promise<Uint8Array>;
     /**
      * Parse options from the options line
      */

package/esm/src/formats/ascii.js

@@ -68,7 +68,7 @@ export class ASCIIFormat {
      * @param data Raw ASCII art data
      * @returns Decoded image data with grayscale RGBA pixels
      */
-    decode(data) {
+    decode(data, _options) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid ASCII art signature");
         }

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, ImageMetadata } from "../types.js";
+import type { AVIFEncoderOptions, ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata } from "../types.js";
 /**
  * AVIF format handler
  * Supports AVIF images using runtime APIs (ImageDecoder/OffscreenCanvas)
@@ -21,7 +21,7 @@ export declare class AVIFFormat implements ImageFormat {
      * @param data Raw AVIF image data
      * @returns Decoded image data with RGBA pixels
      */
-    decode(data: Uint8Array): Promise<ImageData>;
+    decode(data: Uint8Array, settings?: ImageDecoderOptions): Promise<ImageData>;
     /**
      * Encode RGBA image data to AVIF format
      * Uses runtime APIs (OffscreenCanvas) for encoding
@@ -32,7 +32,7 @@ export declare class AVIFFormat implements ImageFormat {
      * @param imageData Image data to encode
      * @returns Encoded AVIF image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, options?: AVIFEncoderOptions): Promise<Uint8Array>;
     /**
      * Decode using runtime APIs
      * @param data Raw AVIF data

package/esm/src/formats/avif.js

@@ -49,10 +49,13 @@ export class AVIFFormat {
      * @param data Raw AVIF image data
      * @returns Decoded image data with RGBA pixels
      */
-    async decode(data) {
+    async decode(data, settings) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid AVIF signature");
         }
+        if (settings?.runtimeDecoding === "never") {
+            throw new Error("AVIF decoding requires runtime APIs; set runtimeDecoding to 'prefer'");
+        }
         // Extract metadata before decoding pixels
         const metadata = await this.extractMetadata(data);
         // Use runtime decoder
@@ -76,8 +79,9 @@ export class AVIFFormat {
      * @param imageData Image data to encode
      * @returns Encoded AVIF image bytes
      */
-    async encode(imageData) {
-        const { width, height, data, metadata } = imageData;
+    async encode(imageData, options) {
+        const { width, height, data, metadata: _metadata } = imageData;
+        const requestedQuality = options?.quality;
         // Try to use runtime encoding if available
         if (typeof OffscreenCanvas !== "undefined") {
             try {
@@ -88,20 +92,26 @@ export class AVIFFormat {
                     const imgDataData = new Uint8ClampedArray(data);
                     imgData.data.set(imgDataData);
                     ctx.putImageData(imgData, 0, 0);
+                    const quality = requestedQuality === undefined
+                        ? undefined
+                        : (requestedQuality <= 1
+                            ? Math.max(0, Math.min(1, requestedQuality))
+                            : Math.max(1, Math.min(100, requestedQuality)) / 100);
                     // Try to encode as AVIF
                     const blob = await canvas.convertToBlob({
                         type: "image/avif",
+                        ...(quality === undefined ? {} : { quality }),
                     });
+                    if (blob.type !== "image/avif") {
+                        throw new Error(`Runtime did not encode AVIF (got '${blob.type || "(empty)"}')`);
+                    }
                     const arrayBuffer = await blob.arrayBuffer();
                     const encoded = new Uint8Array(arrayBuffer);
                     // Note: Metadata injection for AVIF is complex and would require
                     // parsing and modifying the ISOBMFF container structure
                     // For now, we rely on the runtime encoder to preserve metadata
                     // if it was passed through the canvas
-                    if (metadata) {
-                        // Future enhancement: inject metadata into AVIF container
-                        console.warn("AVIF metadata injection not yet implemented, metadata may be lost");
-                    }
+                    // Future enhancement: inject metadata into AVIF container
                     return encoded;
                 }
             }

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, ImageMetadata } from "../types.js";
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata } from "../types.js";
 /**
  * BMP format handler
  * Implements a pure JavaScript BMP decoder and encoder
@@ -19,13 +19,13 @@ export declare class BMPFormat implements ImageFormat {
      * @param data Raw BMP image data
      * @returns Decoded image data with RGBA pixels
      */
-    decode(data: Uint8Array): Promise<ImageData>;
+    decode(data: Uint8Array, _options?: ImageDecoderOptions): Promise<ImageData>;
     /**
      * Encode RGBA image data to BMP format
      * @param imageData Image data to encode
      * @returns Encoded BMP image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, _options?: unknown): Promise<Uint8Array>;
     /**
      * Get the list of metadata fields supported by BMP format
      */

package/esm/src/formats/bmp.js

@@ -38,7 +38,7 @@ export class BMPFormat {
      * @param data Raw BMP image data
      * @returns Decoded image data with RGBA pixels
      */
-    decode(data) {
+    decode(data, _options) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid BMP signature");
         }
@@ -115,7 +115,7 @@ export class BMPFormat {
      * @param imageData Image data to encode
      * @returns Encoded BMP image bytes
      */
-    encode(imageData) {
+    encode(imageData, _options) {
         const { width, height, data, metadata } = imageData;
         // Calculate sizes
         const bytesPerPixel = 4; // We'll encode as 32-bit RGBA

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

@@ -22,7 +22,7 @@ export declare class DNGFormat extends TIFFFormat {
      * @param imageData Image data to encode
      * @returns Encoded DNG image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, _options?: unknown): Promise<Uint8Array>;
     /**
      * Get the list of metadata fields supported by DNG format
      * DNG is based on TIFF, so it supports all TIFF metadata fields

package/esm/src/formats/dng.js

@@ -74,7 +74,7 @@ export class DNGFormat extends TIFFFormat {
      * @param imageData Image data to encode
      * @returns Encoded DNG image bytes
      */
-    encode(imageData) {
+    encode(imageData, _options) {
         const { width, height, data } = imageData;
         // We'll create a Linear DNG (demosaiced RGB)
         // This is very similar to a standard TIFF but with specific tags.

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, ImageMetadata, MultiFrameImageData } from "../types.js";
+import type { GIFEncoderOptions, ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata, MultiFrameImageData } from "../types.js";
 /**
  * GIF format handler
  * Now includes pure-JS implementation with custom LZW compression/decompression
@@ -32,22 +32,22 @@ export declare class GIFFormat implements ImageFormat {
      * @param data Raw GIF image data
      * @returns Decoded image data with RGBA pixels of first frame
      */
-    decode(data: Uint8Array): Promise<ImageData>;
+    decode(data: Uint8Array, settings?: ImageDecoderOptions): Promise<ImageData>;
     private extractGIFMetadata;
     /**
      * Encode RGBA image data to GIF format (single frame)
      * @param imageData Image data to encode
      * @returns Encoded GIF image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, options?: GIFEncoderOptions): Promise<Uint8Array>;
     /**
      * Decode all frames from an animated GIF
      */
-    decodeFrames(data: Uint8Array): Promise<MultiFrameImageData>;
+    decodeFrames(data: Uint8Array, settings?: ImageDecoderOptions): Promise<MultiFrameImageData>;
     /**
      * Encode multi-frame image data to animated GIF
      */
-    encodeFrames(imageData: MultiFrameImageData, _options?: unknown): Promise<Uint8Array>;
+    encodeFrames(imageData: MultiFrameImageData, options?: GIFEncoderOptions): Promise<Uint8Array>;
     private mapDisposalMethod;
     private decodeUsingRuntime;
     private readDataSubBlocks;

package/esm/src/formats/gif.js

@@ -56,13 +56,16 @@ export class GIFFormat {
      * @param data Raw GIF image data
      * @returns Decoded image data with RGBA pixels of first frame
      */
-    async decode(data) {
+    async decode(data, settings) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid GIF signature");
         }
-        // Try pure-JS decoder first
+        // Try pure-JS decoder first with tolerant decoding enabled by default
         try {
-            const decoder = new GIFDecoder(data);
+            const decoder = new GIFDecoder(data, {
+                tolerantDecoding: settings?.tolerantDecoding ?? true,
+                onWarning: settings?.onWarning,
+            });
             const result = decoder.decode();
             // Validate dimensions for security (prevent integer overflow and heap exhaustion)
             validateImageDimensions(result.width, result.height);
@@ -75,9 +78,8 @@ export class GIFFormat {
                 metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
             };
         }
-        catch (error) {
+        catch (_error) {
             // Fall back to runtime decoder if pure-JS fails
-            console.warn("Pure-JS GIF decoder failed, falling back to runtime:", error);
             let pos = 6; // Skip "GIF89a" or "GIF87a"
             const width = readUint16LE(data, pos);
             pos += 2;
@@ -151,12 +153,12 @@ export class GIFFormat {
      * @param imageData Image data to encode
      * @returns Encoded GIF image bytes
      */
-    async encode(imageData) {
+    async encode(imageData, options) {
         const { width, height, data, metadata } = imageData;
         // Try pure-JS encoder first
         try {
             const encoder = new GIFEncoder(width, height, data);
-            const encoded = encoder.encode();
+            const encoded = encoder.encode(options);
             // Inject metadata if present
             if (metadata && Object.keys(metadata).length > 0) {
                 const injected = this.injectMetadata(encoded, metadata);
@@ -164,9 +166,8 @@ export class GIFFormat {
             }
             return encoded;
         }
-        catch (error) {
+        catch (_error) {
             // Fall back to runtime encoding if pure-JS fails
-            console.warn("Pure-JS GIF encoder failed, falling back to runtime:", error);
             if (typeof OffscreenCanvas !== "undefined") {
                 try {
                     const canvas = new OffscreenCanvas(width, height);
@@ -199,12 +200,15 @@ export class GIFFormat {
     /**
      * Decode all frames from an animated GIF
      */
-    decodeFrames(data) {
+    decodeFrames(data, settings) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid GIF signature");
         }
         try {
-            const decoder = new GIFDecoder(data);
+            const decoder = new GIFDecoder(data, {
+                tolerantDecoding: settings?.tolerantDecoding ?? true,
+                onWarning: settings?.onWarning,
+            });
             const result = decoder.decodeAllFrames();
             // Extract metadata from comment extensions
             const metadata = this.extractGIFMetadata(data);
@@ -233,7 +237,7 @@ export class GIFFormat {
     /**
      * Encode multi-frame image data to animated GIF
      */
-    encodeFrames(imageData, _options) {
+    encodeFrames(imageData, options) {
         if (imageData.frames.length === 0) {
             throw new Error("No frames to encode");
         }
@@ -243,7 +247,7 @@ export class GIFFormat {
             const delay = frame.frameMetadata?.delay ?? 100;
             encoder.addFrame(frame.data, delay);
         }
-        return Promise.resolve(encoder.encode());
+        return Promise.resolve(encoder.encode(options));
     }
     mapDisposalMethod(disposal) {
         switch (disposal) {

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, ImageMetadata } from "../types.js";
+import type { HEICEncoderOptions, ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata } from "../types.js";
 /**
  * HEIC format handler
  * Supports HEIC/HEIF images using runtime APIs (ImageDecoder/OffscreenCanvas)
@@ -21,7 +21,7 @@ export declare class HEICFormat implements ImageFormat {
      * @param data Raw HEIC image data
      * @returns Decoded image data with RGBA pixels
      */
-    decode(data: Uint8Array): Promise<ImageData>;
+    decode(data: Uint8Array, settings?: ImageDecoderOptions): Promise<ImageData>;
     /**
      * Encode RGBA image data to HEIC format
      * Uses runtime APIs (OffscreenCanvas) for encoding
@@ -32,7 +32,7 @@ export declare class HEICFormat implements ImageFormat {
      * @param imageData Image data to encode
      * @returns Encoded HEIC image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, options?: HEICEncoderOptions): Promise<Uint8Array>;
     /**
      * Decode using runtime APIs
      * @param data Raw HEIC data

package/esm/src/formats/heic.js

@@ -50,10 +50,13 @@ export class HEICFormat {
      * @param data Raw HEIC image data
      * @returns Decoded image data with RGBA pixels
      */
-    async decode(data) {
+    async decode(data, settings) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid HEIC signature");
         }
+        if (settings?.runtimeDecoding === "never") {
+            throw new Error("HEIC decoding requires runtime APIs; set runtimeDecoding to 'prefer'");
+        }
         // Extract metadata before decoding pixels
         const metadata = await this.extractMetadata(data);
         // Use runtime decoder
@@ -77,8 +80,9 @@ export class HEICFormat {
      * @param imageData Image data to encode
      * @returns Encoded HEIC image bytes
      */
-    async encode(imageData) {
-        const { width, height, data, metadata } = imageData;
+    async encode(imageData, options) {
+        const { width, height, data, metadata: _metadata } = imageData;
+        const requestedQuality = options?.quality;
         // Try to use runtime encoding if available
         if (typeof OffscreenCanvas !== "undefined") {
             try {
@@ -89,20 +93,26 @@ export class HEICFormat {
                     const imgDataData = new Uint8ClampedArray(data);
                     imgData.data.set(imgDataData);
                     ctx.putImageData(imgData, 0, 0);
+                    const quality = requestedQuality === undefined
+                        ? undefined
+                        : (requestedQuality <= 1
+                            ? Math.max(0, Math.min(1, requestedQuality))
+                            : Math.max(1, Math.min(100, requestedQuality)) / 100);
                     // Try to encode as HEIC
                     const blob = await canvas.convertToBlob({
                         type: "image/heic",
+                        ...(quality === undefined ? {} : { quality }),
                     });
+                    if (blob.type !== "image/heic") {
+                        throw new Error(`Runtime did not encode HEIC (got '${blob.type || "(empty)"}')`);
+                    }
                     const arrayBuffer = await blob.arrayBuffer();
                     const encoded = new Uint8Array(arrayBuffer);
                     // Note: Metadata injection for HEIC is complex and would require
                     // parsing and modifying the ISOBMFF container structure
                     // For now, we rely on the runtime encoder to preserve metadata
                     // if it was passed through the canvas
-                    if (metadata) {
-                        // Future enhancement: inject metadata into HEIC container
-                        console.warn("HEIC metadata injection not yet implemented, metadata may be lost");
-                    }
+                    // Future enhancement: inject metadata into HEIC container
                     return encoded;
                 }
             }

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, ImageMetadata } from "../types.js";
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata } from "../types.js";
 /**
  * ICO format handler
  * Implements a pure JavaScript ICO (Windows Icon) decoder and encoder
@@ -24,7 +24,7 @@ export declare class ICOFormat implements ImageFormat {
      * @param data Raw ICO image data
      * @returns Decoded image data with RGBA pixels
      */
-    decode(data: Uint8Array): Promise<ImageData>;
+    decode(data: Uint8Array, options?: ImageDecoderOptions): Promise<ImageData>;
     /**
      * Decode a DIB (Device Independent Bitmap) format
      * This is a BMP without the 14-byte file header
@@ -36,7 +36,7 @@ export declare class ICOFormat implements ImageFormat {
      * @param imageData Image data to encode
      * @returns Encoded ICO image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, _options?: unknown): Promise<Uint8Array>;
     /**
      * Get the list of metadata fields supported by ICO format
      */

package/esm/src/formats/ico.js

@@ -49,7 +49,7 @@ export class ICOFormat {
      * @param data Raw ICO image data
      * @returns Decoded image data with RGBA pixels
      */
-    async decode(data) {
+    async decode(data, options) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid ICO signature");
         }
@@ -100,7 +100,7 @@ export class ICOFormat {
             imageData[2] === 0x4e &&
             imageData[3] === 0x47) {
             // It's a PNG, decode it
-            return await this.pngFormat.decode(imageData);
+            return await this.pngFormat.decode(imageData, options);
         }
         // Otherwise, it's a BMP without the file header (DIB format)
         return this.decodeDIB(imageData);
@@ -182,10 +182,10 @@ export class ICOFormat {
      * @param imageData Image data to encode
      * @returns Encoded ICO image bytes
      */
-    async encode(imageData) {
+    async encode(imageData, _options) {
         const { width, height } = imageData;
         // Encode the image as PNG
-        const pngData = await this.pngFormat.encode(imageData);
+        const pngData = await this.pngFormat.encode(imageData, undefined);
         // Create ICO file structure
         // ICONDIR (6 bytes) + ICONDIRENTRY (16 bytes) + PNG data
         const icoSize = 6 + 16 + pngData.length;

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, ImageMetadata } from "../types.js";
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata, JPEGEncoderOptions } from "../types.js";
 /**
  * JPEG format handler
  * Implements a basic JPEG decoder and encoder
@@ -19,13 +19,13 @@ export declare class JPEGFormat implements ImageFormat {
      * @param data Raw JPEG image data
      * @returns Decoded image data with RGBA pixels
      */
-    decode(data: Uint8Array): Promise<ImageData>;
+    decode(data: Uint8Array, settings?: ImageDecoderOptions): Promise<ImageData>;
     /**
      * Encode RGBA image data to JPEG format
      * @param imageData Image data to encode
      * @returns Encoded JPEG image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, options?: JPEGEncoderOptions): Promise<Uint8Array>;
     private injectMetadata;
     private decodeUsingRuntime;
     private parseJFIF;