cross-image 0.4.0 → 0.4.2

package/esm/src/utils/jpeg_decoder.js

@@ -211,10 +211,18 @@ export class JPEGDecoder {
             writable: true,
             value: 0
         }); // Remaining blocks to skip due to EOBn
+        // Storage for quantized coefficients (when extractCoefficients is true)
+        Object.defineProperty(this, "quantizedCoefficients", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
         this.data = data;
         this.options = {
             tolerantDecoding: settings.tolerantDecoding ?? true,
             onWarning: settings.onWarning,
+            extractCoefficients: settings.extractCoefficients ?? false,
         };
     }
     decode() {
@@ -276,7 +284,8 @@ export class JPEGDecoder {
         // For progressive JPEGs, perform IDCT on all blocks after all scans are complete
         // This ensures that frequency-domain coefficients from multiple scans are properly
         // accumulated before transformation to spatial domain
-        if (this.isProgressive) {
+        // Skip IDCT when extracting coefficients - we want the quantized DCT values
+        if (this.isProgressive && !this.options.extractCoefficients) {
             for (const component of this.components) {
                 if (component.blocks) {
                     for (const row of component.blocks) {
@@ -287,9 +296,63 @@ export class JPEGDecoder {
                 }
             }
         }
+        // If extracting coefficients, store them before converting to RGB
+        if (this.options.extractCoefficients) {
+            this.storeQuantizedCoefficients();
+        }
         // Convert YCbCr to RGB
         return this.convertToRGB();
     }
+    /**
+     * Get the quantized DCT coefficients after decoding
+     * Only available if extractCoefficients option was set to true
+     * @returns JPEGQuantizedCoefficients or undefined if not available
+     */
+    getQuantizedCoefficients() {
+        return this.quantizedCoefficients ?? undefined;
+    }
+    /**
+     * Store quantized coefficients in the output structure
+     * Called after decoding when extractCoefficients is true
+     */
+    storeQuantizedCoefficients() {
+        // Calculate MCU dimensions
+        const maxH = Math.max(...this.components.map((c) => c.h));
+        const maxV = Math.max(...this.components.map((c) => c.v));
+        const mcuWidth = Math.ceil(this.width / (8 * maxH));
+        const mcuHeight = Math.ceil(this.height / (8 * maxV));
+        // Build component coefficients
+        const componentCoeffs = this.components.map((comp) => ({
+            id: comp.id,
+            h: comp.h,
+            v: comp.v,
+            qTable: comp.qTable,
+            blocks: comp.blocks.map((row) => row.map((block) => {
+                // Convert to Int32Array if not already
+                if (block instanceof Int32Array) {
+                    return block;
+                }
+                return new Int32Array(block);
+            })),
+        }));
+        // Copy quantization tables
+        const qTables = this.qTables.map((table) => {
+            if (table instanceof Uint8Array) {
+                return new Uint8Array(table);
+            }
+            return new Uint8Array(table);
+        });
+        this.quantizedCoefficients = {
+            format: "jpeg",
+            width: this.width,
+            height: this.height,
+            isProgressive: this.isProgressive,
+            components: componentCoeffs,
+            quantizationTables: qTables,
+            mcuWidth,
+            mcuHeight,
+        };
+    }
     readMarker() {
         while (this.pos < this.data.length && this.data[this.pos] !== 0xFF) {
             this.pos++;
@@ -590,7 +653,13 @@ export class JPEGDecoder {
                 component.pred += dcDiff;
                 // For successive approximation, shift the coefficient left by Al bits
                 const coeff = component.pred << this.successiveLow;
-                block[0] = coeff * this.qTables[component.qTable][0];
+                // When extracting coefficients, store quantized value without dequantization
+                if (this.options.extractCoefficients) {
+                    block[0] = coeff;
+                }
+                else {
+                    block[0] = coeff * this.qTables[component.qTable][0];
+                }
             }
             else {
                 // DC refinement scan: add a refinement bit
@@ -598,7 +667,12 @@ export class JPEGDecoder {
                 if (bit) {
                     // Add the refinement bit at position Al
                     const refinement = 1 << this.successiveLow;
-                    block[0] += refinement * this.qTables[component.qTable][0];
+                    if (this.options.extractCoefficients) {
+                        block[0] += refinement;
+                    }
+                    else {
+                        block[0] += refinement * this.qTables[component.qTable][0];
+                    }
                 }
             }
         }
@@ -645,8 +719,14 @@ export class JPEGDecoder {
                             break;
                         // For successive approximation, shift the coefficient left by Al bits
                         const coeff = this.receiveBits(s) << this.successiveLow;
-                        block[ZIGZAG[k]] = coeff *
-                            this.qTables[component.qTable][ZIGZAG[k]];
+                        // When extracting coefficients, store quantized value without dequantization
+                        if (this.options.extractCoefficients) {
+                            block[ZIGZAG[k]] = coeff;
+                        }
+                        else {
+                            block[ZIGZAG[k]] = coeff *
+                                this.qTables[component.qTable][ZIGZAG[k]];
+                        }
                         k++;
                     }
                 }
@@ -693,7 +773,10 @@ export class JPEGDecoder {
                             if (current !== 0) {
                                 const bit = this.readBit();
                                 if (bit) {
-                                    const refinement = (1 << this.successiveLow) * qTable[z];
+                                    // When extracting coefficients, don't dequantize
+                                    const refinement = this.options.extractCoefficients
+                                        ? (1 << this.successiveLow)
+                                        : (1 << this.successiveLow) * qTable[z];
                                     block[z] += direction * refinement;
                                 }
                             }
@@ -708,13 +791,17 @@ export class JPEGDecoder {
                             if (current !== 0) {
                                 const bit = this.readBit();
                                 if (bit) {
-                                    const refinement = (1 << this.successiveLow) * qTable[z];
+                                    // When extracting coefficients, don't dequantize
+                                    const refinement = this.options.extractCoefficients
+                                        ? (1 << this.successiveLow)
+                                        : (1 << this.successiveLow) * qTable[z];
                                     block[z] += direction * refinement;
                                 }
                             }
                             else {
                                 const newCoeff = successiveACNextValue << this.successiveLow;
-                                block[z] = newCoeff * qTable[z];
+                                // When extracting coefficients, don't dequantize
+                                block[z] = this.options.extractCoefficients ? newCoeff : newCoeff * qTable[z];
                                 successiveACState = 0;
                             }
                             break;
@@ -722,7 +809,10 @@ export class JPEGDecoder {
                             if (current !== 0) {
                                 const bit = this.readBit();
                                 if (bit) {
-                                    const refinement = (1 << this.successiveLow) * qTable[z];
+                                    // When extracting coefficients, don't dequantize
+                                    const refinement = this.options.extractCoefficients
+                                        ? (1 << this.successiveLow)
+                                        : (1 << this.successiveLow) * qTable[z];
                                     block[z] += direction * refinement;
                                 }
                             }
@@ -741,7 +831,8 @@ export class JPEGDecoder {
         // Perform IDCT only for baseline JPEGs
         // For progressive JPEGs, IDCT is deferred until all scans are complete
         // to preserve frequency-domain coefficients for accumulation across scans
-        if (!this.isProgressive) {
+        // Skip IDCT when extracting coefficients - we want the quantized DCT values
+        if (!this.isProgressive && !this.options.extractCoefficients) {
             this.idct(block);
         }
     }

package/esm/src/utils/jpeg_encoder.d.ts

@@ -5,6 +5,7 @@
  * This is a simplified implementation focusing on correctness over performance.
  * For production use with better quality/size, the OffscreenCanvas API is preferred.
  */
+import type { JPEGQuantizedCoefficients } from "../types.js";
 export interface JPEGEncoderOptions {
     quality?: number;
     progressive?: boolean;
@@ -43,5 +44,23 @@ export declare class JPEGEncoder {
     private forwardDCT;
     private encodeDC;
     private encodeAC;
+    /**
+     * 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: JPEGQuantizedCoefficients, _options?: JPEGEncoderOptions): Uint8Array;
+    private writeDQTFromCoeffs;
+    private writeSOF0FromCoeffs;
+    private writeSOF2FromCoeffs;
+    private encodeScanFromCoeffs;
+    private encodeACFromCoeffs;
+    private encodeProgressiveFromCoeffs;
+    private encodeProgressiveDCScanFromCoeffs;
+    private encodeProgressiveACScanFromCoeffs;
+    private encodeOnlyACFromCoeffs;
 }
 //# sourceMappingURL=jpeg_encoder.d.ts.map

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.0",
+  "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 { ASCIIEncoderOptions, FrameMetadata, ImageData, ImageDecoderOptions, ImageFormat, ImageFrame, ImageMetadata, JPEGEncoderOptions, MultiFrameImageData, 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";
@@ -59,4 +59,6 @@ export { PPMFormat } from "./src/formats/ppm.js";
 export { ASCIIFormat } from "./src/formats/ascii.js";
 export { HEICFormat } from "./src/formats/heic.js";
 export { AVIFFormat } from "./src/formats/avif.js";
+export { decodeBase64, encodeBase64, parseDataUrl, toDataUrl } from "./src/utils/base64.js";
+export { cmykToRgb, cmykToRgba, rgbaToCmyk, rgbToCmyk } from "./src/utils/image_processing.js";
 //# sourceMappingURL=mod.d.ts.map

package/script/mod.js

@@ -44,7 +44,7 @@
  * ```
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AVIFFormat = exports.HEICFormat = exports.ASCIIFormat = exports.PPMFormat = exports.PCXFormat = exports.PAMFormat = exports.DNGFormat = exports.ICOFormat = exports.BMPFormat = exports.TIFFFormat = exports.GIFFormat = exports.WebPFormat = exports.JPEGFormat = exports.APNGFormat = exports.PNGFormat = exports.Image = void 0;
+exports.rgbToCmyk = exports.rgbaToCmyk = exports.cmykToRgba = exports.cmykToRgb = exports.toDataUrl = exports.parseDataUrl = exports.encodeBase64 = exports.decodeBase64 = exports.AVIFFormat = exports.HEICFormat = exports.ASCIIFormat = exports.PPMFormat = exports.PCXFormat = exports.PAMFormat = exports.DNGFormat = exports.ICOFormat = exports.BMPFormat = exports.TIFFFormat = exports.GIFFormat = exports.WebPFormat = exports.JPEGFormat = exports.APNGFormat = exports.PNGFormat = exports.Image = void 0;
 var image_js_1 = require("./src/image.js");
 Object.defineProperty(exports, "Image", { enumerable: true, get: function () { return image_js_1.Image; } });
 var png_js_1 = require("./src/formats/png.js");
@@ -77,3 +77,13 @@ var heic_js_1 = require("./src/formats/heic.js");
 Object.defineProperty(exports, "HEICFormat", { enumerable: true, get: function () { return heic_js_1.HEICFormat; } });
 var avif_js_1 = require("./src/formats/avif.js");
 Object.defineProperty(exports, "AVIFFormat", { enumerable: true, get: function () { return avif_js_1.AVIFFormat; } });
+var base64_js_1 = require("./src/utils/base64.js");
+Object.defineProperty(exports, "decodeBase64", { enumerable: true, get: function () { return base64_js_1.decodeBase64; } });
+Object.defineProperty(exports, "encodeBase64", { enumerable: true, get: function () { return base64_js_1.encodeBase64; } });
+Object.defineProperty(exports, "parseDataUrl", { enumerable: true, get: function () { return base64_js_1.parseDataUrl; } });
+Object.defineProperty(exports, "toDataUrl", { enumerable: true, get: function () { return base64_js_1.toDataUrl; } });
+var image_processing_js_1 = require("./src/utils/image_processing.js");
+Object.defineProperty(exports, "cmykToRgb", { enumerable: true, get: function () { return image_processing_js_1.cmykToRgb; } });
+Object.defineProperty(exports, "cmykToRgba", { enumerable: true, get: function () { return image_processing_js_1.cmykToRgba; } });
+Object.defineProperty(exports, "rgbaToCmyk", { enumerable: true, get: function () { return image_processing_js_1.rgbaToCmyk; } });
+Object.defineProperty(exports, "rgbToCmyk", { enumerable: true, get: function () { return image_processing_js_1.rgbToCmyk; } });

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata, MultiFrameImageData } from "../types.js";
+import type { APNGEncoderOptions, ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata, MultiFrameImageData } from "../types.js";
 import { PNGBase } from "./png_base.js";
 /**
  * APNG (Animated PNG) format handler
@@ -36,15 +36,17 @@ export declare class APNGFormat extends PNGBase implements ImageFormat {
     /**
      * Encode RGBA image data to APNG format (single frame)
      * @param imageData Image data to encode
+     * @param options Encoding options (compressionLevel 0-9, default 6)
      * @returns Encoded APNG image bytes
      */
-    encode(imageData: ImageData, _options?: unknown): Promise<Uint8Array>;
+    encode(imageData: ImageData, options?: APNGEncoderOptions): Promise<Uint8Array>;
     /**
      * Encode multi-frame image data to APNG format
      * @param imageData Multi-frame image data to encode
+     * @param options Encoding options (compressionLevel 0-9, default 6)
      * @returns Encoded APNG image bytes
      */
-    encodeFrames(imageData: MultiFrameImageData, _options?: unknown): Promise<Uint8Array>;
+    encodeFrames(imageData: MultiFrameImageData, options?: APNGEncoderOptions): Promise<Uint8Array>;
     private decodeFrameData;
     /**
      * Get the list of metadata fields supported by APNG format

package/script/src/formats/apng.js

@@ -253,9 +253,10 @@ class APNGFormat extends png_base_js_1.PNGBase {
     /**
      * Encode RGBA image data to APNG format (single frame)
      * @param imageData Image data to encode
+     * @param options Encoding options (compressionLevel 0-9, default 6)
      * @returns Encoded APNG image bytes
      */
-    encode(imageData, _options) {
+    encode(imageData, options) {
         // For single frame, create a multi-frame with one frame
         const multiFrame = {
             width: imageData.width,
@@ -268,15 +269,21 @@ class APNGFormat extends png_base_js_1.PNGBase {
                 }],
             metadata: imageData.metadata,
         };
-        return this.encodeFrames(multiFrame, _options);
+        return this.encodeFrames(multiFrame, options);
     }
     /**
      * Encode multi-frame image data to APNG format
      * @param imageData Multi-frame image data to encode
+     * @param options Encoding options (compressionLevel 0-9, default 6)
      * @returns Encoded APNG image bytes
      */
-    async encodeFrames(imageData, _options) {
+    async encodeFrames(imageData, options) {
         const { width, height, frames, 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");
+        }
         if (frames.length === 0) {
             throw new Error("No frames to encode");
         }
@@ -334,7 +341,7 @@ class APNGFormat extends png_base_js_1.PNGBase {
             fctl[25] = 0; // blend_op: APNG_BLEND_OP_SOURCE
             chunks.push(this.createChunk("fcTL", fctl));
             // Filter and compress frame data
-            const filtered = this.filterData(frame.data, frame.width, frame.height);
+            const filtered = this.filterData(frame.data, frame.width, frame.height, compressionLevel);
             const compressed = await this.deflate(filtered);
             if (i === 0) {
                 // First frame uses IDAT

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata } from "../types.js";
+import type { AVIFEncoderOptions, ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata } from "../types.js";
 /**
  * AVIF format handler
  * Supports AVIF images using runtime APIs (ImageDecoder/OffscreenCanvas)
@@ -32,7 +32,7 @@ export declare class AVIFFormat implements ImageFormat {
      * @param imageData Image data to encode
      * @returns Encoded AVIF image bytes
      */
-    encode(imageData: ImageData, _options?: unknown): Promise<Uint8Array>;
+    encode(imageData: ImageData, options?: AVIFEncoderOptions): Promise<Uint8Array>;
     /**
      * Decode using runtime APIs
      * @param data Raw AVIF data

package/script/src/formats/avif.js

@@ -82,8 +82,9 @@ class AVIFFormat {
      * @param imageData Image data to encode
      * @returns Encoded AVIF 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 {
@@ -94,10 +95,19 @@ class AVIFFormat {
                     const imgDataData = new Uint8ClampedArray(data);
                     imgData.data.set(imgDataData);
                     ctx.putImageData(imgData, 0, 0);
+                    const quality = requestedQuality === undefined
+                        ? undefined
+                        : (requestedQuality <= 1
+                            ? Math.max(0, Math.min(1, requestedQuality))
+                            : Math.max(1, Math.min(100, requestedQuality)) / 100);
                     // Try to encode as AVIF
                     const blob = await canvas.convertToBlob({
                         type: "image/avif",
+                        ...(quality === undefined ? {} : { quality }),
                     });
+                    if (blob.type !== "image/avif") {
+                        throw new Error(`Runtime did not encode AVIF (got '${blob.type || "(empty)"}')`);
+                    }
                     const arrayBuffer = await blob.arrayBuffer();
                     const encoded = new Uint8Array(arrayBuffer);
                     // Note: Metadata injection for AVIF is complex and would require