cross-image 0.4.0 → 0.4.2

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageDecoderOptions, 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
@@ -39,7 +39,7 @@ export declare class GIFFormat implements ImageFormat {
      * @param imageData Image data to encode
      * @returns Encoded GIF image bytes
      */
-    encode(imageData: ImageData, _options?: unknown): Promise<Uint8Array>;
+    encode(imageData: ImageData, options?: GIFEncoderOptions): Promise<Uint8Array>;
     /**
      * Decode all frames from an animated GIF
      */
@@ -47,7 +47,7 @@ export declare class GIFFormat implements ImageFormat {
     /**
      * 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

@@ -156,12 +156,12 @@ class GIFFormat {
      * @param imageData Image data to encode
      * @returns Encoded GIF image bytes
      */
-    async encode(imageData, _options) {
+    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);
@@ -240,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");
         }
@@ -250,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, ImageDecoderOptions, 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)
@@ -32,7 +32,7 @@ export declare class HEICFormat implements ImageFormat {
      * @param imageData Image data to encode
      * @returns Encoded HEIC image bytes
      */
-    encode(imageData: ImageData, _options?: unknown): Promise<Uint8Array>;
+    encode(imageData: ImageData, options?: HEICEncoderOptions): Promise<Uint8Array>;
     /**
      * Decode using runtime APIs
      * @param data Raw HEIC data

package/script/src/formats/heic.js

@@ -83,8 +83,9 @@ class HEICFormat {
      * @param imageData Image data to encode
      * @returns Encoded HEIC image bytes
      */
-    async encode(imageData, _options) {
+    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 {
@@ -95,10 +96,19 @@ 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

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata, JPEGEncoderOptions } from "../types.js";
+import type { CoefficientData, ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata, JPEGEncoderOptions, JPEGQuantizedCoefficients } from "../types.js";
 /**
  * JPEG format handler
  * Implements a basic JPEG decoder and encoder
@@ -42,6 +42,26 @@ export declare class JPEGFormat implements ImageFormat {
      * Get the list of metadata fields supported by JPEG format
      */
     getSupportedMetadata(): Array<keyof ImageMetadata>;
+    /**
+     * Extract quantized DCT coefficients from JPEG data
+     * These coefficients can be modified for steganography and re-encoded
+     * @param data Raw JPEG data
+     * @param options Decoder options
+     * @returns JPEGQuantizedCoefficients or undefined if extraction fails
+     */
+    extractCoefficients(data: Uint8Array, options?: ImageDecoderOptions): Promise<JPEGQuantizedCoefficients | undefined>;
+    /**
+     * Type guard to check if coefficient data is JPEG format
+     */
+    private isJPEGCoefficients;
+    /**
+     * Encode JPEG from quantized DCT coefficients
+     * Useful for steganography - modify coefficients and re-encode
+     * @param coeffs JPEG quantized coefficients
+     * @param options Encoding options
+     * @returns Encoded JPEG bytes
+     */
+    encodeFromCoefficients(coeffs: CoefficientData, options?: JPEGEncoderOptions): Promise<Uint8Array>;
     /**
      * Extract metadata from JPEG data without fully decoding the pixel data
      * This quickly parses JFIF and EXIF markers to extract metadata

package/script/src/formats/jpeg.js

@@ -1108,6 +1108,65 @@ class JPEGFormat {
             "dpiY",
         ];
     }
+    /**
+     * Extract quantized DCT coefficients from JPEG data
+     * These coefficients can be modified for steganography and re-encoded
+     * @param data Raw JPEG data
+     * @param options Decoder options
+     * @returns JPEGQuantizedCoefficients or undefined if extraction fails
+     */
+    async extractCoefficients(data, options) {
+        if (!this.canDecode(data)) {
+            return undefined;
+        }
+        try {
+            // Force pure-JS decoding since runtime decoders don't expose coefficients
+            const { JPEGDecoder } = await Promise.resolve().then(() => __importStar(require("../utils/jpeg_decoder.js")));
+            const decoder = new JPEGDecoder(data, {
+                tolerantDecoding: options?.tolerantDecoding ?? true,
+                onWarning: options?.onWarning,
+                extractCoefficients: true,
+            });
+            // Decode to extract coefficients
+            decoder.decode();
+            // Get the quantized coefficients
+            return decoder.getQuantizedCoefficients();
+        }
+        catch (error) {
+            if (options?.onWarning) {
+                options.onWarning(`Failed to extract JPEG coefficients: ${error}`, error);
+            }
+            return undefined;
+        }
+    }
+    /**
+     * Type guard to check if coefficient data is JPEG format
+     */
+    isJPEGCoefficients(coeffs) {
+        return ("format" in coeffs &&
+            coeffs.format === "jpeg" &&
+            "components" in coeffs &&
+            "quantizationTables" in coeffs &&
+            "isProgressive" in coeffs);
+    }
+    /**
+     * Encode JPEG from quantized DCT coefficients
+     * Useful for steganography - modify coefficients and re-encode
+     * @param coeffs JPEG quantized coefficients
+     * @param options Encoding options
+     * @returns Encoded JPEG bytes
+     */
+    async encodeFromCoefficients(coeffs, options) {
+        if (!this.isJPEGCoefficients(coeffs)) {
+            throw new Error("Invalid coefficient format for JPEG");
+        }
+        const { JPEGEncoder } = await Promise.resolve().then(() => __importStar(require("../utils/jpeg_encoder.js")));
+        const encoder = new JPEGEncoder({
+            quality: options?.quality,
+            progressive: options?.progressive ?? coeffs.isProgressive,
+        });
+        return encoder.encodeFromCoefficients(coeffs, options);
+    }
     /**
      * Extract metadata from JPEG data without fully decoding the pixel data
      * This quickly parses JFIF and EXIF markers to extract metadata

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata } from "../types.js";
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata, PNGEncoderOptions } from "../types.js";
 import { PNGBase } from "./png_base.js";
 /**
  * PNG format handler
@@ -24,9 +24,10 @@ export declare class PNGFormat extends PNGBase implements ImageFormat {
     /**
      * 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, _options?: unknown): 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

@@ -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, _options) {
+    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 = [];

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

@@ -43,7 +43,48 @@ export declare abstract class PNGBase {
     /**
      * Filter PNG data for encoding (using filter type 0 - None)
      */
-    protected filterData(data: Uint8Array, width: number, height: number): Uint8Array;
+    /**
+     * Apply PNG filter to image data based on compression level
+     * @param data Raw RGBA pixel data
+     * @param width Image width
+     * @param height Image height
+     * @param compressionLevel Compression level (0-9, default 6)
+     * @returns Filtered data with filter type byte per scanline
+     */
+    protected filterData(data: Uint8Array, width: number, height: number, compressionLevel?: number): Uint8Array;
+    /**
+     * Apply filter type 0 (None) - no filtering
+     */
+    private applyNoFilter;
+    /**
+     * Apply filter type 1 (Sub) - subtract left pixel
+     */
+    private applySubFilter;
+    /**
+     * Apply filter type 2 (Up) - subtract above pixel
+     */
+    private applyUpFilter;
+    /**
+     * Apply filter type 3 (Average) - subtract average of left and above
+     */
+    private applyAverageFilter;
+    /**
+     * Apply filter type 4 (Paeth) - Paeth predictor
+     */
+    private applyPaethFilter;
+    /**
+     * Calculate sum of absolute differences for a filtered scanline
+     * Lower values indicate better compression potential
+     */
+    private calculateFilterScore;
+    /**
+     * Apply adaptive filtering - choose best filter per scanline
+     */
+    private applyAdaptiveFilter;
+    /**
+     * Filter a single scanline with specified filter type
+     */
+    private filterScanline;
     /**
      * Get bytes per pixel for a given color type and bit depth
      */

package/script/src/formats/png_base.js

@@ -144,18 +144,211 @@ class PNGBase {
     /**
      * Filter PNG data for encoding (using filter type 0 - None)
      */
-    filterData(data, width, height) {
-        // Use filter type 0 (None) for simplicity
-        const filtered = new Uint8Array(height * (1 + width * 4));
+    /**
+     * Apply PNG filter to image data based on compression level
+     * @param data Raw RGBA pixel data
+     * @param width Image width
+     * @param height Image height
+     * @param compressionLevel Compression level (0-9, default 6)
+     * @returns Filtered data with filter type byte per scanline
+     */
+    filterData(data, width, height, compressionLevel = 6) {
+        // Choose filtering strategy based on compression level
+        if (compressionLevel <= 2) {
+            // Fast: No filtering
+            return this.applyNoFilter(data, width, height);
+        }
+        else if (compressionLevel <= 6) {
+            // Balanced: Sub filter
+            return this.applySubFilter(data, width, height);
+        }
+        else {
+            // Best: Adaptive filtering (choose best filter per scanline)
+            return this.applyAdaptiveFilter(data, width, height);
+        }
+    }
+    /**
+     * Apply filter type 0 (None) - no filtering
+     */
+    applyNoFilter(data, width, height) {
+        const bytesPerScanline = width * 4;
+        const filtered = new Uint8Array(height * (1 + bytesPerScanline));
         let pos = 0;
         for (let y = 0; y < height; y++) {
             filtered[pos++] = 0; // Filter type: None
-            for (let x = 0; x < width * 4; x++) {
-                filtered[pos++] = data[y * width * 4 + x];
+            const scanlineStart = y * bytesPerScanline;
+            for (let x = 0; x < bytesPerScanline; x++) {
+                filtered[pos++] = data[scanlineStart + x];
+            }
+        }
+        return filtered;
+    }
+    /**
+     * Apply filter type 1 (Sub) - subtract left pixel
+     */
+    applySubFilter(data, width, height) {
+        const bytesPerScanline = width * 4;
+        const filtered = new Uint8Array(height * (1 + bytesPerScanline));
+        let pos = 0;
+        for (let y = 0; y < height; y++) {
+            filtered[pos++] = 1; // Filter type: Sub
+            const scanlineStart = y * bytesPerScanline;
+            for (let x = 0; x < bytesPerScanline; x++) {
+                const current = data[scanlineStart + x];
+                const left = x >= 4 ? data[scanlineStart + x - 4] : 0;
+                filtered[pos++] = (current - left) & 0xff;
+            }
+        }
+        return filtered;
+    }
+    /**
+     * Apply filter type 2 (Up) - subtract above pixel
+     */
+    applyUpFilter(data, width, height) {
+        const bytesPerScanline = width * 4;
+        const filtered = new Uint8Array(height * (1 + bytesPerScanline));
+        let pos = 0;
+        for (let y = 0; y < height; y++) {
+            filtered[pos++] = 2; // Filter type: Up
+            const scanlineStart = y * bytesPerScanline;
+            const prevScanlineStart = (y - 1) * bytesPerScanline;
+            for (let x = 0; x < bytesPerScanline; x++) {
+                const current = data[scanlineStart + x];
+                const up = y > 0 ? data[prevScanlineStart + x] : 0;
+                filtered[pos++] = (current - up) & 0xff;
+            }
+        }
+        return filtered;
+    }
+    /**
+     * Apply filter type 3 (Average) - subtract average of left and above
+     */
+    applyAverageFilter(data, width, height) {
+        const bytesPerScanline = width * 4;
+        const filtered = new Uint8Array(height * (1 + bytesPerScanline));
+        let pos = 0;
+        for (let y = 0; y < height; y++) {
+            filtered[pos++] = 3; // Filter type: Average
+            const scanlineStart = y * bytesPerScanline;
+            const prevScanlineStart = (y - 1) * bytesPerScanline;
+            for (let x = 0; x < bytesPerScanline; x++) {
+                const current = data[scanlineStart + x];
+                const left = x >= 4 ? data[scanlineStart + x - 4] : 0;
+                const up = y > 0 ? data[prevScanlineStart + x] : 0;
+                const avg = Math.floor((left + up) / 2);
+                filtered[pos++] = (current - avg) & 0xff;
             }
         }
         return filtered;
     }
+    /**
+     * Apply filter type 4 (Paeth) - Paeth predictor
+     */
+    applyPaethFilter(data, width, height) {
+        const bytesPerScanline = width * 4;
+        const filtered = new Uint8Array(height * (1 + bytesPerScanline));
+        let pos = 0;
+        for (let y = 0; y < height; y++) {
+            filtered[pos++] = 4; // Filter type: Paeth
+            const scanlineStart = y * bytesPerScanline;
+            const prevScanlineStart = (y - 1) * bytesPerScanline;
+            for (let x = 0; x < bytesPerScanline; x++) {
+                const current = data[scanlineStart + x];
+                const left = x >= 4 ? data[scanlineStart + x - 4] : 0;
+                const up = y > 0 ? data[prevScanlineStart + x] : 0;
+                const upLeft = (y > 0 && x >= 4) ? data[prevScanlineStart + x - 4] : 0;
+                const paeth = this.paethPredictor(left, up, upLeft);
+                filtered[pos++] = (current - paeth) & 0xff;
+            }
+        }
+        return filtered;
+    }
+    /**
+     * Calculate sum of absolute differences for a filtered scanline
+     * Lower values indicate better compression potential
+     */
+    calculateFilterScore(filtered) {
+        let sum = 0;
+        for (let i = 1; i < filtered.length; i++) {
+            const byte = filtered[i];
+            // Penalize larger absolute values
+            sum += byte < 128 ? byte : (256 - byte);
+        }
+        return sum;
+    }
+    /**
+     * Apply adaptive filtering - choose best filter per scanline
+     */
+    applyAdaptiveFilter(data, width, height) {
+        const bytesPerScanline = width * 4;
+        const filtered = new Uint8Array(height * (1 + bytesPerScanline));
+        let outPos = 0;
+        // Try each filter type and choose the best for each scanline
+        const filters = [
+            (y) => this.filterScanline(data, y, width, 0), // None
+            (y) => this.filterScanline(data, y, width, 1), // Sub
+            (y) => this.filterScanline(data, y, width, 2), // Up
+            (y) => this.filterScanline(data, y, width, 3), // Average
+            (y) => this.filterScanline(data, y, width, 4), // Paeth
+        ];
+        for (let y = 0; y < height; y++) {
+            let bestFilter = null;
+            let bestScore = Infinity;
+            // Try each filter type
+            for (const filterFn of filters) {
+                const result = filterFn(y);
+                const score = this.calculateFilterScore(result);
+                if (score < bestScore) {
+                    bestScore = score;
+                    bestFilter = result;
+                }
+            }
+            // Copy best filter result
+            if (bestFilter) {
+                filtered.set(bestFilter, outPos);
+                outPos += bestFilter.length;
+            }
+        }
+        return filtered;
+    }
+    /**
+     * Filter a single scanline with specified filter type
+     */
+    filterScanline(data, y, width, filterType) {
+        const bytesPerScanline = width * 4;
+        const result = new Uint8Array(1 + bytesPerScanline);
+        result[0] = filterType;
+        const scanlineStart = y * bytesPerScanline;
+        const prevScanlineStart = (y - 1) * bytesPerScanline;
+        for (let x = 0; x < bytesPerScanline; x++) {
+            const current = data[scanlineStart + x];
+            const left = x >= 4 ? data[scanlineStart + x - 4] : 0;
+            const up = y > 0 ? data[prevScanlineStart + x] : 0;
+            const upLeft = (y > 0 && x >= 4) ? data[prevScanlineStart + x - 4] : 0;
+            let filtered;
+            switch (filterType) {
+                case 0: // None
+                    filtered = current;
+                    break;
+                case 1: // Sub
+                    filtered = (current - left) & 0xff;
+                    break;
+                case 2: // Up
+                    filtered = (current - up) & 0xff;
+                    break;
+                case 3: // Average
+                    filtered = (current - Math.floor((left + up) / 2)) & 0xff;
+                    break;
+                case 4: // Paeth
+                    filtered = (current - this.paethPredictor(left, up, upLeft)) & 0xff;
+                    break;
+                default:
+                    filtered = current;
+            }
+            result[x + 1] = filtered;
+        }
+        return result;
+    }
     /**
      * Get bytes per pixel for a given color type and bit depth
      */