cross-image 0.4.0 → 0.4.1

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
      */

package/script/src/formats/tiff.js

@@ -5,6 +5,7 @@ const tiff_lzw_js_1 = require("../utils/tiff_lzw.js");
 const tiff_packbits_js_1 = require("../utils/tiff_packbits.js");
 const tiff_deflate_js_1 = require("../utils/tiff_deflate.js");
 const security_js_1 = require("../utils/security.js");
+const image_processing_js_1 = require("../utils/image_processing.js");
 // Constants for unit conversions
 const DEFAULT_DPI = 72;
 /**
@@ -139,6 +140,7 @@ class TIFFFormat {
         const compression = opts?.compression ?? "none";
         const grayscale = opts?.grayscale ?? false;
         const rgb = opts?.rgb ?? false;
+        const cmyk = opts?.cmyk ?? false;
         // Convert RGBA to grayscale if requested
         let sourceData;
         let samplesPerPixel;
@@ -153,6 +155,16 @@ class TIFFFormat {
                 sourceData[i] = Math.round(0.299 * r + 0.587 * g + 0.114 * b);
             }
         }
+        else if (cmyk) {
+            // Convert RGBA to CMYK
+            const cmykData = (0, image_processing_js_1.rgbaToCmyk)(data);
+            sourceData = new Uint8Array(width * height * 4);
+            samplesPerPixel = 4;
+            // Convert Float32Array CMYK (0-1) to Uint8Array (0-255)
+            for (let i = 0; i < cmykData.length; i++) {
+                sourceData[i] = Math.round(cmykData[i] * 255);
+            }
+        }
         else if (rgb) {
             // Convert RGBA to RGB (strip alpha channel)
             sourceData = new Uint8Array(width * height * 3);
@@ -244,8 +256,8 @@ class TIFFFormat {
         }
         // Compression (0x0103) - 1 = uncompressed, 5 = LZW
         this.writeIFDEntry(result, 0x0103, 3, 1, compressionCode);
-        // PhotometricInterpretation (0x0106) - 1 = BlackIsZero (grayscale), 2 = RGB
-        this.writeIFDEntry(result, 0x0106, 3, 1, grayscale ? 1 : 2);
+        // PhotometricInterpretation (0x0106) - 1 = BlackIsZero (grayscale), 2 = RGB, 5 = CMYK
+        this.writeIFDEntry(result, 0x0106, 3, 1, grayscale ? 1 : (cmyk ? 5 : 2));
         // StripOffsets (0x0111)
         this.writeIFDEntry(result, 0x0111, 4, 1, 8);
         // SamplesPerPixel (0x0115) - 1 for grayscale, 3 for RGB, 4 for RGBA
@@ -795,14 +807,16 @@ class TIFFFormat {
         }
         // Check photometric interpretation
         const photometric = this.getIFDValue(data, ifdOffset, 0x0106, isLittleEndian);
-        if (photometric !== 0 && photometric !== 1 && photometric !== 2) {
-            // Support: 0 = WhiteIsZero, 1 = BlackIsZero, 2 = RGB
+        if (photometric !== 0 && photometric !== 1 && photometric !== 2 &&
+            photometric !== 5) {
+            // Support: 0 = WhiteIsZero, 1 = BlackIsZero, 2 = RGB, 5 = CMYK
             return null;
         }
         // Get samples per pixel
         const samplesPerPixel = this.getIFDValue(data, ifdOffset, 0x0115, isLittleEndian);
         // For grayscale (photometric 0 or 1), expect 1 sample per pixel
         // For RGB, expect 3 or 4 samples per pixel
+        // For CMYK, expect 4 samples per pixel
         if (!samplesPerPixel) {
             return null;
         }
@@ -814,6 +828,10 @@ class TIFFFormat {
             // RGB requires 3 or 4 samples per pixel
             return null;
         }
+        if (photometric === 5 && samplesPerPixel !== 4) {
+            // CMYK requires 4 samples per pixel
+            return null;
+        }
         // Get strip offset
         const stripOffset = this.getIFDValue(data, ifdOffset, 0x0111, isLittleEndian);
         if (!stripOffset || stripOffset >= data.length) {
@@ -871,6 +889,29 @@ class TIFFFormat {
                 }
             }
         }
+        else if (photometric === 5) {
+            // CMYK image - convert to RGB
+            for (let y = 0; y < height; y++) {
+                for (let x = 0; x < width; x++) {
+                    const dstIdx = (y * width + x) * 4;
+                    if (srcPos + 4 > pixelData.length) {
+                        return null; // Not enough data
+                    }
+                    // TIFF stores CMYK in order, values are 0-255
+                    // Convert to 0-1 range for conversion
+                    const c = pixelData[srcPos++] / 255;
+                    const m = pixelData[srcPos++] / 255;
+                    const yVal = pixelData[srcPos++] / 255;
+                    const k = pixelData[srcPos++] / 255;
+                    // Convert CMYK to RGB
+                    const [r, g, b] = (0, image_processing_js_1.cmykToRgb)(c, m, yVal, k);
+                    rgba[dstIdx] = r; // R
+                    rgba[dstIdx + 1] = g; // G
+                    rgba[dstIdx + 2] = b; // B
+                    rgba[dstIdx + 3] = 255; // A (opaque)
+                }
+            }
+        }
         else {
             // RGB/RGBA image
             for (let y = 0; y < height; y++) {
@@ -903,14 +944,16 @@ class TIFFFormat {
         }
         // Check photometric interpretation
         const photometric = this.getIFDValue(data, ifdOffset, 0x0106, isLittleEndian);
-        if (photometric !== 0 && photometric !== 1 && photometric !== 2) {
-            // Support: 0 = WhiteIsZero, 1 = BlackIsZero, 2 = RGB
+        if (photometric !== 0 && photometric !== 1 && photometric !== 2 &&
+            photometric !== 5) {
+            // Support: 0 = WhiteIsZero, 1 = BlackIsZero, 2 = RGB, 5 = CMYK
             return null;
         }
         // Get samples per pixel
         const samplesPerPixel = this.getIFDValue(data, ifdOffset, 0x0115, isLittleEndian);
         // For grayscale (photometric 0 or 1), expect 1 sample per pixel
         // For RGB, expect 3 or 4 samples per pixel
+        // For CMYK, expect 4 samples per pixel
         if (!samplesPerPixel) {
             return null;
         }
@@ -922,6 +965,10 @@ class TIFFFormat {
             // RGB requires 3 or 4 samples per pixel
             return null;
         }
+        if (photometric === 5 && samplesPerPixel !== 4) {
+            // CMYK requires 4 samples per pixel
+            return null;
+        }
         // Get strip offset
         const stripOffset = this.getIFDValue(data, ifdOffset, 0x0111, isLittleEndian);
         if (!stripOffset || stripOffset >= data.length) {
@@ -979,6 +1026,29 @@ class TIFFFormat {
                 }
             }
         }
+        else if (photometric === 5) {
+            // CMYK image - convert to RGB
+            for (let y = 0; y < height; y++) {
+                for (let x = 0; x < width; x++) {
+                    const dstIdx = (y * width + x) * 4;
+                    if (srcPos + 4 > pixelData.length) {
+                        return null; // Not enough data
+                    }
+                    // TIFF stores CMYK in order, values are 0-255
+                    // Convert to 0-1 range for conversion
+                    const c = pixelData[srcPos++] / 255;
+                    const m = pixelData[srcPos++] / 255;
+                    const yVal = pixelData[srcPos++] / 255;
+                    const k = pixelData[srcPos++] / 255;
+                    // Convert CMYK to RGB
+                    const [r, g, b] = (0, image_processing_js_1.cmykToRgb)(c, m, yVal, k);
+                    rgba[dstIdx] = r; // R
+                    rgba[dstIdx + 1] = g; // G
+                    rgba[dstIdx + 2] = b; // B
+                    rgba[dstIdx + 3] = 255; // A (opaque)
+                }
+            }
+        }
         else {
             // RGB/RGBA image
             for (let y = 0; y < height; y++) {

package/script/src/image.d.ts

@@ -350,5 +350,20 @@ export declare class Image {
      * @returns This image instance for chaining
      */
     flipVertical(): this;
+    /**
+     * Convert the image to CMYK color space
+     * Returns a Float32Array with 4 values per pixel (C, M, Y, K) in 0-1 range
+     * @returns CMYK image data as Float32Array
+     */
+    toCMYK(): Float32Array;
+    /**
+     * Create an Image from CMYK data
+     * @param cmykData CMYK image data (4 values per pixel in 0-1 range)
+     * @param width Image width
+     * @param height Image height
+     * @param alpha Optional alpha value for all pixels (0-255, default: 255)
+     * @returns New Image instance
+     */
+    static fromCMYK(cmykData: Float32Array, width: number, height: number, alpha?: number): Image;
 }
 //# sourceMappingURL=image.d.ts.map

package/script/src/image.js

@@ -867,6 +867,34 @@ class Image {
         this.imageData.data = (0, image_processing_js_1.flipVertical)(this.imageData.data, this.imageData.width, this.imageData.height);
         return this;
     }
+    /**
+     * Convert the image to CMYK color space
+     * Returns a Float32Array with 4 values per pixel (C, M, Y, K) in 0-1 range
+     * @returns CMYK image data as Float32Array
+     */
+    toCMYK() {
+        if (!this.imageData)
+            throw new Error("No image loaded");
+        return (0, image_processing_js_1.rgbaToCmyk)(this.imageData.data);
+    }
+    /**
+     * Create an Image from CMYK data
+     * @param cmykData CMYK image data (4 values per pixel in 0-1 range)
+     * @param width Image width
+     * @param height Image height
+     * @param alpha Optional alpha value for all pixels (0-255, default: 255)
+     * @returns New Image instance
+     */
+    static fromCMYK(cmykData, width, height, alpha = 255) {
+        const rgbaData = (0, image_processing_js_1.cmykToRgba)(cmykData, alpha);
+        const image = new Image();
+        image.imageData = {
+            width,
+            height,
+            data: rgbaData,
+        };
+        return image;
+    }
 }
 exports.Image = Image;
 Object.defineProperty(Image, "formats", {

package/script/src/types.d.ts

@@ -135,6 +135,42 @@ export interface ResizeOptions {
      */
     fit?: "stretch" | "fit" | "fill" | "cover" | "contain";
 }
+/**
+ * Options for PNG encoding.
+ */
+export interface PNGEncoderOptions {
+    /**
+     * Compression level (0-9)
+     * - 0-2: No filtering (fastest)
+     * - 3-6: Sub filter (balanced, default is 6)
+     * - 7-9: Adaptive filtering per scanline (best compression)
+     *
+     * Default: 6 (balanced)
+     *
+     * Note: Affects PNG filter selection. The native deflate compression
+     * is used regardless of level.
+     */
+    compressionLevel?: number;
+}
+/**
+ * Options for APNG (Animated PNG) encoding.
+ *
+ * APNG uses PNG encoding for each frame.
+ */
+export interface APNGEncoderOptions extends PNGEncoderOptions {
+}
+/**
+ * Options for GIF encoding.
+ */
+export interface GIFEncoderOptions {
+    /**
+     * Loop count for animated GIFs.
+     * - 0 (default): Loop infinitely
+     * - 1+: Loop a specific number of times
+     * - undefined or not set: Loop infinitely (same as 0)
+     */
+    loop?: number;
+}
 /**
  * Options for ASCII art encoding
  */
@@ -158,6 +194,8 @@ export interface TIFFEncoderOptions {
     grayscale?: boolean;
     /** Encode as RGB without alpha channel (default: false, ignored if grayscale is true) */
     rgb?: boolean;
+    /** Encode as CMYK color space (default: false, ignored if grayscale is true) */
+    cmyk?: boolean;
 }
 /**
  * Options for WebP encoding
@@ -189,6 +227,34 @@ export interface JPEGEncoderOptions {
      */
     progressive?: boolean;
 }
+/**
+ * Options for AVIF encoding.
+ *
+ * Note: AVIF encoding is currently delegated to runtime APIs (OffscreenCanvas).
+ * Many runtimes ignore `quality` for AVIF, or may not support AVIF encoding at all.
+ */
+export interface AVIFEncoderOptions {
+    /**
+     * Best-effort encoding quality.
+     *
+     * Accepts either 0-1 (canvas-style) or 1-100 (library-style).
+     */
+    quality?: number;
+}
+/**
+ * Options for HEIC encoding.
+ *
+ * Note: HEIC encoding is currently delegated to runtime APIs (OffscreenCanvas).
+ * Many runtimes do not support HEIC encoding.
+ */
+export interface HEICEncoderOptions {
+    /**
+     * Best-effort encoding quality.
+     *
+     * Accepts either 0-1 (canvas-style) or 1-100 (library-style).
+     */
+    quality?: number;
+}
 /**
  * Common options for decode APIs.
  *

package/script/src/utils/base64.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Base64 utilities.
+ *
+ * Designed to work across Deno, Node.js, and Bun without external dependencies.
+ */
+/**
+ * Encode bytes into a standard Base64 string.
+ */
+export declare function encodeBase64(bytes: Uint8Array): string;
+/**
+ * Decode a Base64 (or Base64URL) string into bytes.
+ *
+ * - Whitespace is ignored.
+ * - Missing padding is tolerated.
+ * - `-`/`_` are accepted as URL-safe variants.
+ */
+export declare function decodeBase64(base64: string): Uint8Array;
+export interface ParsedDataUrl {
+    mime: string;
+    bytes: Uint8Array;
+}
+/**
+ * Create a base64 data URL.
+ */
+export declare function toDataUrl(mime: string, bytes: Uint8Array): string;
+/**
+ * Parse a base64 data URL.
+ *
+ * Supports `data:<mime>;base64,<payload>`.
+ */
+export declare function parseDataUrl(url: string): ParsedDataUrl;
+//# sourceMappingURL=base64.d.ts.map