cross-image 0.4.0 → 0.4.2

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

@@ -1,4 +1,4 @@
-import type { ImageDecoderOptions, ImageFormat, ImageMetadata, MultiFrameImageData, ResizeOptions } from "./types.js";
+import type { CoefficientData, ImageDecoderOptions, ImageFormat, ImageMetadata, MultiFrameImageData, ResizeOptions } from "./types.js";
 /**
  * Main Image class for reading, manipulating, and saving images
  */
@@ -98,6 +98,44 @@ export declare class Image {
      * @returns Metadata extracted from the image, or undefined if extraction fails or format is unsupported
      */
     static extractMetadata(data: Uint8Array, format?: string): Promise<ImageMetadata | undefined>;
+    /**
+     * Extract coefficients from encoded image data
+     * For JPEG, this returns quantized DCT coefficients that can be modified for steganography
+     * and re-encoded using encodeFromCoefficients()
+     * @param data Raw image data
+     * @param format Optional format hint (e.g., "jpeg")
+     * @param options Optional decoder options
+     * @returns Format-specific coefficient structure or undefined if not supported
+     *
+     * @example
+     * ```ts
+     * // Extract JPEG coefficients for steganography
+     * const coeffs = await Image.extractCoefficients(jpegData, "jpeg");
+     * if (coeffs) {
+     *   // Modify coefficients for steganography...
+     *   const modified = await Image.encodeFromCoefficients(coeffs, "jpeg");
+     * }
+     * ```
+     */
+    static extractCoefficients(data: Uint8Array, format?: string, options?: ImageDecoderOptions): Promise<CoefficientData | undefined>;
+    /**
+     * Encode image from coefficients
+     * For JPEG, accepts quantized DCT coefficients and produces a valid JPEG file
+     * Useful for steganography where coefficients are extracted, modified, and re-encoded
+     * @param coeffs Format-specific coefficient structure
+     * @param format Optional format hint (auto-detected from coeffs.format if available)
+     * @param options Optional format-specific encoding options
+     * @returns Encoded image bytes
+     *
+     * @example
+     * ```ts
+     * // Re-encode modified JPEG coefficients
+     * const coeffs = await Image.extractCoefficients(jpegData, "jpeg");
+     * // Modify coefficients...
+     * const encoded = await Image.encodeFromCoefficients(coeffs, "jpeg");
+     * ```
+     */
+    static encodeFromCoefficients(coeffs: CoefficientData, format?: string, options?: unknown): Promise<Uint8Array>;
     /**
      * Read an image from bytes
      * @deprecated Use `decode()` instead. This method will be removed in a future version.
@@ -350,5 +388,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

@@ -233,6 +233,74 @@ class Image {
         }
         return undefined;
     }
+    /**
+     * Extract coefficients from encoded image data
+     * For JPEG, this returns quantized DCT coefficients that can be modified for steganography
+     * and re-encoded using encodeFromCoefficients()
+     * @param data Raw image data
+     * @param format Optional format hint (e.g., "jpeg")
+     * @param options Optional decoder options
+     * @returns Format-specific coefficient structure or undefined if not supported
+     *
+     * @example
+     * ```ts
+     * // Extract JPEG coefficients for steganography
+     * const coeffs = await Image.extractCoefficients(jpegData, "jpeg");
+     * if (coeffs) {
+     *   // Modify coefficients for steganography...
+     *   const modified = await Image.encodeFromCoefficients(coeffs, "jpeg");
+     * }
+     * ```
+     */
+    static async extractCoefficients(data, format, options) {
+        // Try specified format first
+        if (format) {
+            const handler = Image.formats.find((f) => f.name === format);
+            if (handler && handler.canDecode(data) && handler.extractCoefficients) {
+                return await handler.extractCoefficients(data, options);
+            }
+        }
+        // Auto-detect format
+        for (const handler of Image.formats) {
+            if (handler.canDecode(data) && handler.extractCoefficients) {
+                return await handler.extractCoefficients(data, options);
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Encode image from coefficients
+     * For JPEG, accepts quantized DCT coefficients and produces a valid JPEG file
+     * Useful for steganography where coefficients are extracted, modified, and re-encoded
+     * @param coeffs Format-specific coefficient structure
+     * @param format Optional format hint (auto-detected from coeffs.format if available)
+     * @param options Optional format-specific encoding options
+     * @returns Encoded image bytes
+     *
+     * @example
+     * ```ts
+     * // Re-encode modified JPEG coefficients
+     * const coeffs = await Image.extractCoefficients(jpegData, "jpeg");
+     * // Modify coefficients...
+     * const encoded = await Image.encodeFromCoefficients(coeffs, "jpeg");
+     * ```
+     */
+    static async encodeFromCoefficients(coeffs, format, options) {
+        // Detect format from coefficient structure or use provided format
+        const detectedFormat = format ??
+            coeffs.format;
+        if (!detectedFormat) {
+            throw new Error("Format must be specified or present in coefficient data");
+        }
+        const handler = Image.formats.find((f) => f.name === detectedFormat);
+        if (!handler) {
+            throw new Error(`Unknown format: ${detectedFormat}`);
+        }
+        if (!handler.encodeFromCoefficients) {
+            throw new Error(`Format ${detectedFormat} does not support encoding from coefficients`);
+        }
+        return await handler.encodeFromCoefficients(coeffs, options);
+    }
     /**
      * Read an image from bytes
      * @deprecated Use `decode()` instead. This method will be removed in a future version.
@@ -867,6 +935,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

@@ -1,3 +1,49 @@
+/**
+ * JPEG quantized DCT coefficients for steganography and advanced processing
+ * Contains the frequency-domain representation of the image
+ */
+export interface JPEGQuantizedCoefficients {
+    /** Format identifier */
+    format: "jpeg";
+    /** Image width in pixels */
+    width: number;
+    /** Image height in pixels */
+    height: number;
+    /** Whether the JPEG is progressive */
+    isProgressive: boolean;
+    /** Component data (Y, Cb, Cr for color images) */
+    components: JPEGComponentCoefficients[];
+    /** Quantization tables used (indexed by table ID) */
+    quantizationTables: (Uint8Array | number[])[];
+    /** MCU width (number of 8x8 blocks horizontally) */
+    mcuWidth: number;
+    /** MCU height (number of 8x8 blocks vertically) */
+    mcuHeight: number;
+}
+/**
+ * Coefficients for a single JPEG component (Y, Cb, or Cr)
+ */
+export interface JPEGComponentCoefficients {
+    /** Component ID (1=Y, 2=Cb, 3=Cr typically) */
+    id: number;
+    /** Horizontal sampling factor */
+    h: number;
+    /** Vertical sampling factor */
+    v: number;
+    /** Quantization table index */
+    qTable: number;
+    /**
+     * Quantized DCT coefficient blocks
+     * blocks[blockRow][blockCol] contains a 64-element array in zigzag order
+     * Coefficients are quantized (divided by quantization table values)
+     */
+    blocks: Int32Array[][];
+}
+/**
+ * Union type for coefficient data from different formats
+ * Currently only JPEG is supported, but this allows for future extension
+ */
+export type CoefficientData = JPEGQuantizedCoefficients;
 /**
  * Image metadata
  */
@@ -135,6 +181,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 +240,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 +273,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.
  *
@@ -273,5 +385,22 @@ export interface ImageFormat {
      * @returns Metadata extracted from the image, or undefined if extraction fails
      */
     extractMetadata?(data: Uint8Array): Promise<ImageMetadata | undefined>;
+    /**
+     * Extract coefficients from encoded image data (optional)
+     * For JPEG, this returns quantized DCT coefficients
+     * Useful for steganography and advanced image processing
+     * @param data Raw image data
+     * @param options Decoder options
+     * @returns Format-specific coefficient structure or undefined if not supported
+     */
+    extractCoefficients?(data: Uint8Array, options?: ImageDecoderOptions): Promise<CoefficientData | undefined>;
+    /**
+     * Encode image from coefficients (optional)
+     * For JPEG, accepts quantized DCT coefficients and produces a valid JPEG
+     * @param coeffs Format-specific coefficient structure
+     * @param options Format-specific encoding options
+     * @returns Encoded image bytes
+     */
+    encodeFromCoefficients?(coeffs: CoefficientData, options?: unknown): Promise<Uint8Array>;
 }
 //# sourceMappingURL=types.d.ts.map

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