cross-image 0.2.4 → 0.4.1

package/script/src/formats/avif.js

@@ -52,10 +52,13 @@ 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
@@ -79,8 +82,9 @@ 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 {
@@ -91,20 +95,26 @@ 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/script/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/script/src/formats/bmp.js

@@ -41,7 +41,7 @@ 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");
         }
@@ -118,7 +118,7 @@ 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/script/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/script/src/formats/dng.js

@@ -77,7 +77,7 @@ class DNGFormat extends tiff_js_1.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/script/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/script/src/formats/gif.js

@@ -59,13 +59,16 @@ 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 gif_decoder_js_1.GIFDecoder(data);
+            const decoder = new gif_decoder_js_1.GIFDecoder(data, {
+                tolerantDecoding: settings?.tolerantDecoding ?? true,
+                onWarning: settings?.onWarning,
+            });
             const result = decoder.decode();
             // Validate dimensions for security (prevent integer overflow and heap exhaustion)
             (0, security_js_1.validateImageDimensions)(result.width, result.height);
@@ -78,9 +81,8 @@ 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 = (0, byte_utils_js_1.readUint16LE)(data, pos);
             pos += 2;
@@ -154,12 +156,12 @@ 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 gif_encoder_js_1.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);
@@ -167,9 +169,8 @@ 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);
@@ -202,12 +203,15 @@ 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 gif_decoder_js_1.GIFDecoder(data);
+            const decoder = new gif_decoder_js_1.GIFDecoder(data, {
+                tolerantDecoding: settings?.tolerantDecoding ?? true,
+                onWarning: settings?.onWarning,
+            });
             const result = decoder.decodeAllFrames();
             // Extract metadata from comment extensions
             const metadata = this.extractGIFMetadata(data);
@@ -236,7 +240,7 @@ 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");
         }
@@ -246,7 +250,7 @@ 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/script/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/script/src/formats/heic.js

@@ -53,10 +53,13 @@ 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
@@ -80,8 +83,9 @@ 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 {
@@ -92,20 +96,26 @@ 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/script/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/script/src/formats/ico.js

@@ -52,7 +52,7 @@ 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");
         }
@@ -103,7 +103,7 @@ 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);
@@ -185,10 +185,10 @@ 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/script/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;

package/script/src/formats/jpeg.js

@@ -73,7 +73,7 @@ class JPEGFormat {
      * @param data Raw JPEG image data
      * @returns Decoded image data with RGBA pixels
      */
-    async decode(data) {
+    async decode(data, settings) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid JPEG signature");
         }
@@ -131,7 +131,7 @@ class JPEGFormat {
         (0, security_js_1.validateImageDimensions)(width, height);
         // For a pure JS implementation, we'd need to implement full JPEG decoding
         // which is very complex. Instead, we'll use the browser/runtime's decoder.
-        const rgba = await this.decodeUsingRuntime(data, width, height);
+        const rgba = await this.decodeUsingRuntime(data, width, height, settings);
         return {
             width,
             height,
@@ -144,10 +144,13 @@ class JPEGFormat {
      * @param imageData Image data to encode
      * @returns Encoded JPEG image bytes
      */
-    async encode(imageData) {
+    async encode(imageData, options) {
         const { width, height, data, metadata } = imageData;
+        const requestedQuality = options?.quality;
+        const requestedProgressive = options?.progressive;
         // Try to use runtime encoding if available (better quality)
-        if (typeof OffscreenCanvas !== "undefined") {
+        // Note: progressive output is only supported by the pure-JS encoder.
+        if (!requestedProgressive && typeof OffscreenCanvas !== "undefined") {
             try {
                 const canvas = new OffscreenCanvas(width, height);
                 const ctx = canvas.getContext("2d");
@@ -156,9 +159,12 @@ class JPEGFormat {
                     const imgDataData = new Uint8ClampedArray(data);
                     imgData.data.set(imgDataData);
                     ctx.putImageData(imgData, 0, 0);
+                    const quality = requestedQuality === undefined
+                        ? 0.9
+                        : Math.max(1, Math.min(100, requestedQuality)) / 100;
                     const blob = await canvas.convertToBlob({
                         type: "image/jpeg",
-                        quality: 0.9,
+                        quality,
                     });
                     const arrayBuffer = await blob.arrayBuffer();
                     const encoded = new Uint8Array(arrayBuffer);
@@ -177,7 +183,10 @@ class JPEGFormat {
         const { JPEGEncoder } = await Promise.resolve().then(() => __importStar(require("../utils/jpeg_encoder.js")));
         const dpiX = metadata?.dpiX ?? 72;
         const dpiY = metadata?.dpiY ?? 72;
-        const encoder = new JPEGEncoder(85); // Quality 85
+        const encoder = new JPEGEncoder({
+            quality: requestedQuality,
+            progressive: requestedProgressive,
+        });
         const encoded = encoder.encode(width, height, data, dpiX, dpiY);
         // Add EXIF metadata if present
         if (metadata && Object.keys(metadata).length > 0) {
@@ -221,9 +230,10 @@ class JPEGFormat {
         result.set(encoded.slice(pos), pos + app1.length);
         return result;
     }
-    async decodeUsingRuntime(data, _width, _height) {
+    async decodeUsingRuntime(data, _width, _height, settings) {
         // Try to use ImageDecoder API if available (Deno, modern browsers)
-        if (typeof ImageDecoder !== "undefined") {
+        if (settings?.runtimeDecoding !== "never" &&
+            typeof ImageDecoder !== "undefined") {
             try {
                 const decoder = new ImageDecoder({ data, type: "image/jpeg" });
                 const result = await decoder.decode();
@@ -238,15 +248,17 @@ class JPEGFormat {
                 bitmap.close();
                 return new Uint8Array(imageData.data.buffer);
             }
-            catch (error) {
+            catch (_error) {
                 // ImageDecoder API failed, fall through to pure JS decoder
-                console.warn("JPEG decoding with ImageDecoder failed, using pure JS decoder:", error);
             }
         }
         // Fallback to pure JavaScript decoder
         try {
             const { JPEGDecoder } = await Promise.resolve().then(() => __importStar(require("../utils/jpeg_decoder.js")));
-            const decoder = new JPEGDecoder(data);
+            const decoder = new JPEGDecoder(data, {
+                tolerantDecoding: settings?.tolerantDecoding ?? true,
+                onWarning: settings?.onWarning,
+            });
             return decoder.decode();
         }
         catch (error) {

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, ImageMetadata } from "../types.js";
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata } from "../types.js";
 /**
  * PAM format handler
  * Implements the Netpbm PAM (Portable Arbitrary Map) format.
@@ -32,13 +32,13 @@ export declare class PAMFormat implements ImageFormat {
      * @param data Raw PAM 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 PAM format
      * @param imageData Image data to encode
      * @returns Encoded PAM image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, _options?: unknown): Promise<Uint8Array>;
     /**
      * Get the list of metadata fields supported by PAM format
      */

package/script/src/formats/pam.js

@@ -56,7 +56,7 @@ class PAMFormat {
      * @param data Raw PAM image data
      * @returns Decoded image data with RGBA pixels
      */
-    decode(data) {
+    decode(data, _options) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid PAM signature");
         }
@@ -153,7 +153,7 @@ class PAMFormat {
      * @param imageData Image data to encode
      * @returns Encoded PAM image bytes
      */
-    encode(imageData) {
+    encode(imageData, _options) {
         const { width, height, data } = imageData;
         // Validate input
         if (data.length !== width * height * 4) {

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, ImageMetadata } from "../types.js";
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata } from "../types.js";
 /**
  * PCX format handler
  * Implements PCX decoder and encoder
@@ -7,8 +7,8 @@ export declare class PCXFormat implements ImageFormat {
     readonly name = "pcx";
     readonly mimeType = "image/x-pcx";
     canDecode(data: Uint8Array): boolean;
-    decode(data: Uint8Array): Promise<ImageData>;
-    encode(image: ImageData): Promise<Uint8Array>;
+    decode(data: Uint8Array, _options?: ImageDecoderOptions): Promise<ImageData>;
+    encode(image: ImageData, _options?: unknown): Promise<Uint8Array>;
     /**
      * Get the list of metadata fields supported by PCX format
      */

package/script/src/formats/pcx.js

@@ -31,7 +31,7 @@ class PCXFormat {
                 data[1] === 5) &&
             data[2] === 1;
     }
-    decode(data) {
+    decode(data, _options) {
         if (!this.canDecode(data)) {
             return Promise.reject(new Error("Invalid PCX data"));
         }
@@ -137,7 +137,7 @@ class PCXFormat {
             data: rgba,
         });
     }
-    encode(image) {
+    encode(image, _options) {
         const width = image.width;
         const height = image.height;
         const data = image.data;

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, ImageMetadata } from "../types.js";
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata, PNGEncoderOptions } from "../types.js";
 import { PNGBase } from "./png_base.js";
 /**
  * PNG format handler
@@ -20,13 +20,14 @@ export declare class PNGFormat extends PNGBase implements ImageFormat {
      * @param data Raw PNG 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 PNG format
      * @param imageData Image data to encode
+     * @param options Encoding options (compressionLevel 0-9, default 6)
      * @returns Encoded PNG image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, options?: PNGEncoderOptions): Promise<Uint8Array>;
     /**
      * Get the list of metadata fields supported by PNG format
      * Delegates to PNGBase implementation

package/script/src/formats/png.js

@@ -43,7 +43,7 @@ class PNGFormat extends png_base_js_1.PNGBase {
      * @param data Raw PNG image data
      * @returns Decoded image data with RGBA pixels
      */
-    async decode(data) {
+    async decode(data, _options) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid PNG signature");
         }
@@ -113,10 +113,16 @@ class PNGFormat extends png_base_js_1.PNGBase {
     /**
      * Encode RGBA image data to PNG format
      * @param imageData Image data to encode
+     * @param options Encoding options (compressionLevel 0-9, default 6)
      * @returns Encoded PNG image bytes
      */
-    async encode(imageData) {
+    async encode(imageData, options) {
         const { width, height, data, 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");
+        }
         // Prepare IHDR chunk
         const ihdr = new Uint8Array(13);
         this.writeUint32(ihdr, 0, width);
@@ -127,7 +133,7 @@ class PNGFormat extends png_base_js_1.PNGBase {
         ihdr[11] = 0; // filter method
         ihdr[12] = 0; // interlace method
         // Filter and compress image data
-        const filtered = this.filterData(data, width, height);
+        const filtered = this.filterData(data, width, height, compressionLevel);
         const compressed = await this.deflate(filtered);
         // Build PNG
         const chunks = [];