cross-image 0.4.1 → 0.4.2

package/esm/src/utils/jpeg_encoder.js

@@ -1253,4 +1253,271 @@ export class JPEGEncoder {
             bitWriter.writeBits(huffTable.codes[0x00], huffTable.sizes[0x00]);
         }
     }
+    /**
+     * Encode JPEG from pre-quantized DCT coefficients
+     * Skips DCT and quantization - uses provided coefficients directly
+     * Useful for steganography where coefficients are modified and re-encoded
+     * @param coeffs JPEG quantized coefficients
+     * @param _options Optional encoding options (currently unused)
+     * @returns Encoded JPEG bytes
+     */
+    encodeFromCoefficients(coeffs, _options) {
+        const output = [];
+        const { width, height, components, quantizationTables, isProgressive } = coeffs;
+        // SOI (Start of Image)
+        output.push(0xff, 0xd8);
+        // APP0 (JFIF marker) - use default 72 DPI
+        this.writeAPP0(output, 72, 72);
+        // DQT (Define Quantization Tables) - use original tables from coefficients
+        this.writeDQTFromCoeffs(output, quantizationTables);
+        // SOF (Start of Frame)
+        if (isProgressive) {
+            this.writeSOF2FromCoeffs(output, width, height, components);
+        }
+        else {
+            this.writeSOF0FromCoeffs(output, width, height, components);
+        }
+        // DHT (Define Huffman Tables)
+        this.writeDHT(output);
+        if (isProgressive) {
+            // Progressive encoding: encode from coefficients
+            this.encodeProgressiveFromCoeffs(output, coeffs);
+        }
+        else {
+            // Baseline encoding: single scan
+            this.writeSOS(output);
+            // Encode scan data from coefficients
+            const scanData = this.encodeScanFromCoeffs(coeffs);
+            for (let i = 0; i < scanData.length; i++) {
+                output.push(scanData[i]);
+            }
+        }
+        // EOI (End of Image)
+        output.push(0xff, 0xd9);
+        return new Uint8Array(output);
+    }
+    writeDQTFromCoeffs(output, quantizationTables) {
+        // Write each quantization table
+        for (let tableId = 0; tableId < quantizationTables.length; tableId++) {
+            const table = quantizationTables[tableId];
+            if (!table)
+                continue;
+            output.push(0xff, 0xdb); // DQT marker
+            output.push(0x00, 0x43); // Length (67 bytes)
+            output.push(tableId); // Table ID, 8-bit precision
+            // Write table values in zigzag order
+            for (let i = 0; i < 64; i++) {
+                output.push(table[ZIGZAG[i]] ?? 1);
+            }
+        }
+    }
+    writeSOF0FromCoeffs(output, width, height, components) {
+        const numComponents = components.length;
+        const length = 8 + numComponents * 3;
+        output.push(0xff, 0xc0); // SOF0 marker
+        output.push((length >> 8) & 0xff, length & 0xff);
+        output.push(0x08); // Precision (8 bits)
+        output.push((height >> 8) & 0xff, height & 0xff);
+        output.push((width >> 8) & 0xff, width & 0xff);
+        output.push(numComponents);
+        for (const comp of components) {
+            output.push(comp.id);
+            output.push((comp.h << 4) | comp.v);
+            output.push(comp.qTable);
+        }
+    }
+    writeSOF2FromCoeffs(output, width, height, components) {
+        const numComponents = components.length;
+        const length = 8 + numComponents * 3;
+        output.push(0xff, 0xc2); // SOF2 marker (Progressive DCT)
+        output.push((length >> 8) & 0xff, length & 0xff);
+        output.push(0x08); // Precision (8 bits)
+        output.push((height >> 8) & 0xff, height & 0xff);
+        output.push((width >> 8) & 0xff, width & 0xff);
+        output.push(numComponents);
+        for (const comp of components) {
+            output.push(comp.id);
+            output.push((comp.h << 4) | comp.v);
+            output.push(comp.qTable);
+        }
+    }
+    encodeScanFromCoeffs(coeffs) {
+        const bitWriter = new BitWriter();
+        const { components } = coeffs;
+        // DC predictors for each component
+        const dcPreds = new Map();
+        for (const comp of components) {
+            dcPreds.set(comp.id, 0);
+        }
+        // Encode MCUs in raster order
+        // For non-subsampled images (1:1:1), each MCU contains one block per component
+        const mcuHeight = coeffs.mcuHeight;
+        const mcuWidth = coeffs.mcuWidth;
+        for (let mcuY = 0; mcuY < mcuHeight; mcuY++) {
+            for (let mcuX = 0; mcuX < mcuWidth; mcuX++) {
+                // Encode each component's blocks in this MCU
+                for (const comp of components) {
+                    // Handle subsampling: component may have multiple blocks per MCU
+                    for (let v = 0; v < comp.v; v++) {
+                        for (let h = 0; h < comp.h; h++) {
+                            const blockY = mcuY * comp.v + v;
+                            const blockX = mcuX * comp.h + h;
+                            if (blockY < comp.blocks.length &&
+                                blockX < comp.blocks[0].length) {
+                                const block = comp.blocks[blockY][blockX];
+                                // Get the block in zigzag order for encoding
+                                const zigzagBlock = new Int32Array(64);
+                                for (let i = 0; i < 64; i++) {
+                                    zigzagBlock[i] = block[ZIGZAG[i]];
+                                }
+                                // Encode DC coefficient
+                                const prevDC = dcPreds.get(comp.id) ?? 0;
+                                const dcHuffman = comp.id === 1
+                                    ? this.dcLuminanceHuffman
+                                    : this.dcChrominanceHuffman;
+                                const acHuffman = comp.id === 1
+                                    ? this.acLuminanceHuffman
+                                    : this.acChrominanceHuffman;
+                                // DC coefficient is at index 0 of the block (already in zigzag order from decoder)
+                                const dc = block[0];
+                                const dcDiff = dc - prevDC;
+                                this.encodeDC(dcDiff, dcHuffman, bitWriter);
+                                dcPreds.set(comp.id, dc);
+                                // Encode AC coefficients (indices 1-63 in zigzag order)
+                                this.encodeACFromCoeffs(block, acHuffman, bitWriter);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        bitWriter.flush();
+        return Array.from(bitWriter.getBytes());
+    }
+    encodeACFromCoeffs(block, huffTable, bitWriter) {
+        let zeroCount = 0;
+        // Block is stored with DC at index 0, and AC at indices corresponding to zigzag positions
+        // We need to iterate in zigzag order for AC coefficients (indices 1-63)
+        for (let i = 1; i < 64; i++) {
+            const coef = block[ZIGZAG[i]];
+            if (coef === 0) {
+                zeroCount++;
+            }
+            else {
+                // Write any pending zero runs
+                while (zeroCount >= 16) {
+                    bitWriter.writeBits(huffTable.codes[0xf0], huffTable.sizes[0xf0]);
+                    zeroCount -= 16;
+                }
+                // Clamp coefficient
+                const maxAC = 1023;
+                const clampedCoef = Math.max(-maxAC, Math.min(maxAC, coef));
+                const absCoef = Math.abs(clampedCoef);
+                const size = Math.floor(Math.log2(absCoef)) + 1;
+                const symbol = (zeroCount << 4) | size;
+                bitWriter.writeBits(huffTable.codes[symbol], huffTable.sizes[symbol]);
+                const magnitude = clampedCoef < 0 ? clampedCoef + (1 << size) - 1 : clampedCoef;
+                bitWriter.writeBits(magnitude, size);
+                zeroCount = 0;
+            }
+        }
+        // Write EOB if there are trailing zeros
+        if (zeroCount > 0) {
+            bitWriter.writeBits(huffTable.codes[0x00], huffTable.sizes[0x00]);
+        }
+    }
+    encodeProgressiveFromCoeffs(output, coeffs) {
+        const { components } = coeffs;
+        // Pre-extract blocks for each component (already quantized)
+        const componentBlocks = new Map();
+        for (const comp of components) {
+            const blocks = [];
+            for (const row of comp.blocks) {
+                for (const block of row) {
+                    blocks.push(block);
+                }
+            }
+            componentBlocks.set(comp.id, blocks);
+        }
+        // Scan 1: DC-only (interleaved across all components)
+        this.writeProgressiveSOS(output, components.map((c) => c.id), 0, 0, 0, 0);
+        const dcScanData = this.encodeProgressiveDCScanFromCoeffs(componentBlocks, components);
+        for (let i = 0; i < dcScanData.length; i++) {
+            output.push(dcScanData[i]);
+        }
+        // Scan 2+: AC coefficients (one scan per component)
+        for (const comp of components) {
+            this.writeProgressiveSOS(output, [comp.id], 1, 63, 0, 0);
+            const blocks = componentBlocks.get(comp.id) ?? [];
+            const acHuffman = comp.id === 1 ? this.acLuminanceHuffman : this.acChrominanceHuffman;
+            const acScanData = this.encodeProgressiveACScanFromCoeffs(blocks, acHuffman);
+            for (let i = 0; i < acScanData.length; i++) {
+                output.push(acScanData[i]);
+            }
+        }
+    }
+    encodeProgressiveDCScanFromCoeffs(componentBlocks, components) {
+        const bitWriter = new BitWriter();
+        const dcPreds = new Map();
+        for (const comp of components) {
+            dcPreds.set(comp.id, 0);
+        }
+        // Get number of blocks (should be same for all components in interleaved scan)
+        const numBlocks = componentBlocks.get(components[0].id)?.length ?? 0;
+        for (let i = 0; i < numBlocks; i++) {
+            for (const comp of components) {
+                const blocks = componentBlocks.get(comp.id);
+                if (!blocks || i >= blocks.length)
+                    continue;
+                const block = blocks[i];
+                const dc = block[0]; // DC coefficient at index 0
+                const prevDC = dcPreds.get(comp.id) ?? 0;
+                const dcHuffman = comp.id === 1 ? this.dcLuminanceHuffman : this.dcChrominanceHuffman;
+                this.encodeOnlyDC(dc, prevDC, dcHuffman, bitWriter);
+                dcPreds.set(comp.id, dc);
+            }
+        }
+        bitWriter.flush();
+        return Array.from(bitWriter.getBytes());
+    }
+    encodeProgressiveACScanFromCoeffs(blocks, acHuffman) {
+        const bitWriter = new BitWriter();
+        for (const block of blocks) {
+            this.encodeOnlyACFromCoeffs(block, acHuffman, bitWriter);
+        }
+        bitWriter.flush();
+        return Array.from(bitWriter.getBytes());
+    }
+    encodeOnlyACFromCoeffs(block, acTable, bitWriter) {
+        let zeroCount = 0;
+        // Iterate AC coefficients in zigzag order (indices 1-63)
+        for (let i = 1; i < 64; i++) {
+            const coef = block[ZIGZAG[i]];
+            const clampedCoef = Math.max(-1023, Math.min(1023, coef));
+            if (clampedCoef === 0) {
+                zeroCount++;
+                if (zeroCount === 16) {
+                    bitWriter.writeBits(acTable.codes[0xf0], acTable.sizes[0xf0]);
+                    zeroCount = 0;
+                }
+            }
+            else {
+                while (zeroCount >= 16) {
+                    bitWriter.writeBits(acTable.codes[0xf0], acTable.sizes[0xf0]);
+                    zeroCount -= 16;
+                }
+                const absCoef = Math.abs(clampedCoef);
+                const size = Math.floor(Math.log2(absCoef)) + 1;
+                const symbol = (zeroCount << 4) | size;
+                bitWriter.writeBits(acTable.codes[symbol], acTable.sizes[symbol]);
+                const magnitude = clampedCoef < 0 ? clampedCoef + (1 << size) - 1 : clampedCoef;
+                bitWriter.writeBits(magnitude, size);
+                zeroCount = 0;
+            }
+        }
+        // Write EOB if there are trailing zeros
+        if (zeroCount > 0) {
+            bitWriter.writeBits(acTable.codes[0x00], acTable.sizes[0x00]);
+        }
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cross-image",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "A pure JavaScript, dependency-free, cross-runtime image processing library for Deno, Node.js, and Bun.",
   "keywords": [
     "image",

package/script/mod.d.ts

@@ -43,7 +43,7 @@
  * ```
  */
 export { Image } from "./src/image.js";
-export type { APNGEncoderOptions, ASCIIEncoderOptions, AVIFEncoderOptions, FrameMetadata, GIFEncoderOptions, HEICEncoderOptions, ImageData, ImageDecoderOptions, ImageFormat, ImageFrame, ImageMetadata, JPEGEncoderOptions, MultiFrameImageData, PNGEncoderOptions, ResizeOptions, TIFFEncoderOptions, WebPEncoderOptions, } from "./src/types.js";
+export type { APNGEncoderOptions, ASCIIEncoderOptions, AVIFEncoderOptions, CoefficientData, FrameMetadata, GIFEncoderOptions, HEICEncoderOptions, ImageData, ImageDecoderOptions, ImageFormat, ImageFrame, ImageMetadata, JPEGComponentCoefficients, JPEGEncoderOptions, JPEGQuantizedCoefficients, MultiFrameImageData, PNGEncoderOptions, ResizeOptions, TIFFEncoderOptions, WebPEncoderOptions, } from "./src/types.js";
 export { PNGFormat } from "./src/formats/png.js";
 export { APNGFormat } from "./src/formats/apng.js";
 export { JPEGFormat } from "./src/formats/jpeg.js";

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

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.

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
  */
@@ -339,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/jpeg_decoder.d.ts

@@ -8,7 +8,17 @@
  * This is a pure JavaScript implementation that handles common JPEG files.
  * For complex or non-standard JPEGs, the ImageDecoder API fallback is preferred.
  */
-import type { ImageDecoderOptions } from "../types.js";
+import type { ImageDecoderOptions, JPEGQuantizedCoefficients } from "../types.js";
+/**
+ * Extended decoder options including coefficient extraction
+ */
+interface JPEGDecoderOptions extends ImageDecoderOptions {
+    /**
+     * When true, stores quantized DCT coefficients for later retrieval
+     * via getQuantizedCoefficients(). Coefficients are stored in zigzag order.
+     */
+    extractCoefficients?: boolean;
+}
 export declare class JPEGDecoder {
     private data;
     private pos;
@@ -29,8 +39,20 @@ export declare class JPEGDecoder {
     private successiveLow;
     private scanComponentIds;
     private eobRun;
-    constructor(data: Uint8Array, settings?: ImageDecoderOptions);
+    private quantizedCoefficients;
+    constructor(data: Uint8Array, settings?: JPEGDecoderOptions);
     decode(): Uint8Array;
+    /**
+     * Get the quantized DCT coefficients after decoding
+     * Only available if extractCoefficients option was set to true
+     * @returns JPEGQuantizedCoefficients or undefined if not available
+     */
+    getQuantizedCoefficients(): JPEGQuantizedCoefficients | undefined;
+    /**
+     * Store quantized coefficients in the output structure
+     * Called after decoding when extractCoefficients is true
+     */
+    private storeQuantizedCoefficients;
     private readMarker;
     private readUint16;
     private skipSegment;
@@ -49,4 +71,5 @@ export declare class JPEGDecoder {
     private idct;
     private convertToRGB;
 }
+export {};
 //# sourceMappingURL=jpeg_decoder.d.ts.map