cross-image 0.2.4 → 0.4.1

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

@@ -5,15 +5,20 @@
  * This is a simplified implementation focusing on correctness over performance.
  * For production use with better quality/size, the OffscreenCanvas API is preferred.
  */
+export interface JPEGEncoderOptions {
+    quality?: number;
+    progressive?: boolean;
+}
 export declare class JPEGEncoder {
     private quality;
+    private progressive;
     private luminanceQuantTable;
     private chrominanceQuantTable;
     private dcLuminanceHuffman;
     private acLuminanceHuffman;
     private dcChrominanceHuffman;
     private acChrominanceHuffman;
-    constructor(quality?: number);
+    constructor(options?: JPEGEncoderOptions);
     private initQuantizationTables;
     private initHuffmanTables;
     private buildHuffmanTable;
@@ -21,9 +26,18 @@ export declare class JPEGEncoder {
     private writeAPP0;
     private writeDQT;
     private writeSOF0;
+    private writeSOF2;
     private writeDHT;
     private writeHuffmanTable;
     private writeSOS;
+    private writeProgressiveSOS;
+    private encodeProgressive;
+    private dctAndQuantize;
+    private performDCT2D;
+    private encodeProgressiveDCScan;
+    private encodeProgressiveACScanSingle;
+    private encodeOnlyDC;
+    private encodeOnlyAC;
     private encodeScan;
     private encodeBlock;
     private forwardDCT;

package/esm/src/utils/jpeg_encoder.js

@@ -691,13 +691,19 @@ class BitWriter {
     }
 }
 export class JPEGEncoder {
-    constructor(quality = 85) {
+    constructor(options = {}) {
         Object.defineProperty(this, "quality", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "progressive", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "luminanceQuantTable", {
             enumerable: true,
             configurable: true,
@@ -734,14 +740,13 @@ export class JPEGEncoder {
             writable: true,
             value: void 0
         });
-        this.quality = Math.max(1, Math.min(100, quality));
+        this.quality = Math.max(1, Math.min(100, options.quality ?? 85));
+        this.progressive = options.progressive ?? false;
         this.initQuantizationTables();
         this.initHuffmanTables();
     }
     initQuantizationTables() {
-        const scaleFactor = this.quality < 50
-            ? 5000 / this.quality
-            : 200 - this.quality * 2;
+        const scaleFactor = this.quality < 50 ? 5000 / this.quality : 200 - this.quality * 2;
         for (let i = 0; i < 64; i++) {
             let lumVal = Math.floor((STANDARD_LUMINANCE_QUANT_TABLE[i] * scaleFactor + 50) / 100);
             let chromVal = Math.floor((STANDARD_CHROMINANCE_QUANT_TABLE[i] * scaleFactor + 50) / 100);
@@ -758,8 +763,8 @@ export class JPEGEncoder {
         this.acChrominanceHuffman = this.buildHuffmanTable(STD_AC_CHROMINANCE_NRCODES, STD_AC_CHROMINANCE_VALUES);
     }
     buildHuffmanTable(nrcodes, values) {
-        const codes = new Array(256).fill(0);
-        const sizes = new Array(256).fill(0);
+        const codes = new Uint32Array(256);
+        const sizes = new Uint8Array(256);
         let code = 0;
         let valueIndex = 0;
         for (let length = 1; length <= 16; length++) {
@@ -782,16 +787,28 @@ export class JPEGEncoder {
         this.writeAPP0(output, dpiX, dpiY);
         // DQT (Define Quantization Tables)
         this.writeDQT(output);
-        // SOF0 (Start of Frame - Baseline DCT)
-        this.writeSOF0(output, width, height);
+        // SOF (Start of Frame - either baseline or progressive)
+        if (this.progressive) {
+            this.writeSOF2(output, width, height);
+        }
+        else {
+            this.writeSOF0(output, width, height);
+        }
         // DHT (Define Huffman Tables)
         this.writeDHT(output);
-        // SOS (Start of Scan)
-        this.writeSOS(output);
-        // Encode scan data
-        const scanData = this.encodeScan(width, height, rgba);
-        for (let i = 0; i < scanData.length; i++) {
-            output.push(scanData[i]);
+        if (this.progressive) {
+            // Progressive encoding: multiple scans
+            this.encodeProgressive(output, width, height, rgba);
+        }
+        else {
+            // Baseline encoding: single scan
+            // SOS (Start of Scan)
+            this.writeSOS(output);
+            // Encode scan data
+            const scanData = this.encodeScan(width, height, rgba);
+            for (let i = 0; i < scanData.length; i++) {
+                output.push(scanData[i]);
+            }
         }
         // EOI (End of Image)
         output.push(0xff, 0xd9);
@@ -843,6 +860,26 @@ export class JPEGEncoder {
         output.push(0x11); // Sampling factors (1x1)
         output.push(0x01); // Quantization table 1
     }
+    writeSOF2(output, width, height) {
+        output.push(0xff, 0xc2); // SOF2 marker (Progressive DCT)
+        output.push(0x00, 0x11); // Length (17 bytes)
+        output.push(0x08); // Precision (8 bits)
+        output.push((height >> 8) & 0xff, height & 0xff); // Height
+        output.push((width >> 8) & 0xff, width & 0xff); // Width
+        output.push(0x03); // Number of components (3 = YCbCr)
+        // Y component
+        output.push(0x01); // Component ID
+        output.push(0x11); // Sampling factors (1x1)
+        output.push(0x00); // Quantization table 0
+        // Cb component
+        output.push(0x02); // Component ID
+        output.push(0x11); // Sampling factors (1x1)
+        output.push(0x01); // Quantization table 1
+        // Cr component
+        output.push(0x03); // Component ID
+        output.push(0x11); // Sampling factors (1x1)
+        output.push(0x01); // Quantization table 1
+    }
     writeDHT(output) {
         // DC Luminance
         this.writeHuffmanTable(output, 0x00, STD_DC_LUMINANCE_NRCODES, STD_DC_LUMINANCE_VALUES);
@@ -890,6 +927,200 @@ export class JPEGEncoder {
         output.push(0x3f); // End of spectral selection
         output.push(0x00); // Successive approximation
     }
+    writeProgressiveSOS(output, componentIds, spectralStart, spectralEnd, successiveHigh, successiveLow) {
+        output.push(0xff, 0xda); // SOS marker
+        // Length depends on number of components
+        const length = 6 + componentIds.length * 2;
+        output.push((length >> 8) & 0xff, length & 0xff);
+        output.push(componentIds.length); // Number of components
+        for (const id of componentIds) {
+            output.push(id); // Component ID
+            if (id === 1) {
+                // Y component uses table 0
+                output.push(0x00); // DC table 0, AC table 0
+            }
+            else {
+                // Cb/Cr components use table 1
+                output.push(0x11); // DC table 1, AC table 1
+            }
+        }
+        output.push(spectralStart); // Start of spectral selection (Ss)
+        output.push(spectralEnd); // End of spectral selection (Se)
+        output.push((successiveHigh << 4) | successiveLow); // Successive approximation (Ah, Al)
+    }
+    encodeProgressive(output, width, height, rgba) {
+        // Simplified progressive encoding:
+        // Scan 1: Interleaved DC coefficients for all components (Ss=0, Se=0)
+        // Scans 2-4: Non-interleaved AC coefficients (Ss=1, Se=63) per component.
+        //
+        // Note: Some JPEG readers are picky about interleaved AC scans in
+        // progressive images, so we emit AC scans as single-component for broader
+        // compatibility.
+        // For a more sophisticated progressive JPEG, we would use multiple scans
+        // with different spectral selections and successive approximation values.
+        // This basic implementation provides progressive structure while keeping
+        // complexity manageable.
+        // Pre-process all blocks (DCT + quantization)
+        const mcuWidth = Math.ceil(width / 8);
+        const mcuHeight = Math.ceil(height / 8);
+        const yBlocks = [];
+        const cbBlocks = [];
+        const crBlocks = [];
+        for (let mcuY = 0; mcuY < mcuHeight; mcuY++) {
+            for (let mcuX = 0; mcuX < mcuWidth; mcuX++) {
+                const yBlock = new Float32Array(64);
+                const cbBlock = new Float32Array(64);
+                const crBlock = new Float32Array(64);
+                // Extract 8x8 block and convert RGB to YCbCr
+                for (let y = 0; y < 8; y++) {
+                    for (let x = 0; x < 8; x++) {
+                        const px = mcuX * 8 + x;
+                        const py = mcuY * 8 + y;
+                        if (px < width && py < height) {
+                            const offset = (py * width + px) * 4;
+                            const r = rgba[offset];
+                            const g = rgba[offset + 1];
+                            const b = rgba[offset + 2];
+                            // RGB to YCbCr conversion
+                            const yVal = 0.299 * r + 0.587 * g + 0.114 * b;
+                            const cbVal = -0.168736 * r - 0.331264 * g + 0.5 * b + 128;
+                            const crVal = 0.5 * r - 0.418688 * g - 0.081312 * b + 128;
+                            yBlock[y * 8 + x] = yVal - 128; // Level shift
+                            cbBlock[y * 8 + x] = cbVal - 128;
+                            crBlock[y * 8 + x] = crVal - 128;
+                        }
+                    }
+                }
+                // DCT and quantize
+                yBlocks.push(this.dctAndQuantize(yBlock, this.luminanceQuantTable));
+                cbBlocks.push(this.dctAndQuantize(cbBlock, this.chrominanceQuantTable));
+                crBlocks.push(this.dctAndQuantize(crBlock, this.chrominanceQuantTable));
+            }
+        }
+        // Scan 1: DC-only (interleaved across all components)
+        this.writeProgressiveSOS(output, [1, 2, 3], 0, 0, 0, 0);
+        const dcScanData = this.encodeProgressiveDCScan(yBlocks, cbBlocks, crBlocks);
+        for (let i = 0; i < dcScanData.length; i++) {
+            output.push(dcScanData[i]);
+        }
+        // Scan 2: AC coefficients (Y only)
+        this.writeProgressiveSOS(output, [1], 1, 63, 0, 0);
+        const yAcScanData = this.encodeProgressiveACScanSingle(yBlocks, this.acLuminanceHuffman);
+        for (let i = 0; i < yAcScanData.length; i++) {
+            output.push(yAcScanData[i]);
+        }
+        // Scan 3: AC coefficients (Cb only)
+        this.writeProgressiveSOS(output, [2], 1, 63, 0, 0);
+        const cbAcScanData = this.encodeProgressiveACScanSingle(cbBlocks, this.acChrominanceHuffman);
+        for (let i = 0; i < cbAcScanData.length; i++) {
+            output.push(cbAcScanData[i]);
+        }
+        // Scan 4: AC coefficients (Cr only)
+        this.writeProgressiveSOS(output, [3], 1, 63, 0, 0);
+        const crAcScanData = this.encodeProgressiveACScanSingle(crBlocks, this.acChrominanceHuffman);
+        for (let i = 0; i < crAcScanData.length; i++) {
+            output.push(crAcScanData[i]);
+        }
+    }
+    dctAndQuantize(block, quantTable) {
+        // Perform DCT
+        const dct = this.performDCT2D(block);
+        // Quantize
+        const quantized = new Int32Array(64);
+        for (let i = 0; i < 64; i++) {
+            quantized[i] = Math.round(dct[i] / quantTable[i]);
+        }
+        return quantized;
+    }
+    performDCT2D(block) {
+        const output = new Float32Array(64);
+        for (let v = 0; v < 8; v++) {
+            for (let u = 0; u < 8; u++) {
+                let sum = 0;
+                for (let y = 0; y < 8; y++) {
+                    for (let x = 0; x < 8; x++) {
+                        const cu = u === 0 ? 1 / Math.sqrt(2) : 1;
+                        const cv = v === 0 ? 1 / Math.sqrt(2) : 1;
+                        sum += block[y * 8 + x] *
+                            Math.cos((2 * x + 1) * u * Math.PI / 16) *
+                            Math.cos((2 * y + 1) * v * Math.PI / 16) *
+                            cu * cv;
+                    }
+                }
+                output[v * 8 + u] = sum / 4;
+            }
+        }
+        return output;
+    }
+    encodeProgressiveDCScan(yBlocks, cbBlocks, crBlocks) {
+        // Encode only DC coefficients for progressive JPEG
+        const bitWriter = new BitWriter();
+        let dcY = 0, dcCb = 0, dcCr = 0;
+        for (let i = 0; i < yBlocks.length; i++) {
+            // Encode only DC coefficients
+            dcY = this.encodeOnlyDC(yBlocks[i][0], dcY, this.dcLuminanceHuffman, bitWriter);
+            dcCb = this.encodeOnlyDC(cbBlocks[i][0], dcCb, this.dcChrominanceHuffman, bitWriter);
+            dcCr = this.encodeOnlyDC(crBlocks[i][0], dcCr, this.dcChrominanceHuffman, bitWriter);
+        }
+        bitWriter.flush();
+        return Array.from(bitWriter.getBytes());
+    }
+    encodeProgressiveACScanSingle(blocks, acTable) {
+        // Encode only AC coefficients for progressive JPEG (single component)
+        const bitWriter = new BitWriter();
+        for (let i = 0; i < blocks.length; i++) {
+            this.encodeOnlyAC(blocks[i], acTable, bitWriter);
+        }
+        bitWriter.flush();
+        return Array.from(bitWriter.getBytes());
+    }
+    encodeOnlyDC(dc, prevDC, dcTable, bitWriter) {
+        const dcDiff = dc - prevDC;
+        const clampedDiff = Math.max(-2047, Math.min(2047, dcDiff));
+        const absDiff = Math.abs(clampedDiff);
+        let size = 0;
+        if (absDiff > 0) {
+            size = Math.floor(Math.log2(absDiff)) + 1;
+        }
+        bitWriter.writeBits(dcTable.codes[size], dcTable.sizes[size]);
+        if (size > 0) {
+            const magnitude = clampedDiff < 0 ? clampedDiff + (1 << size) - 1 : clampedDiff;
+            bitWriter.writeBits(magnitude, size);
+        }
+        return dc;
+    }
+    encodeOnlyAC(quantized, acTable, bitWriter) {
+        let zeroCount = 0;
+        // Start from index 1 (skip DC coefficient)
+        for (let i = 1; i < 64; i++) {
+            const coef = quantized[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]);
+        }
+    }
     encodeScan(width, height, rgba) {
         const bitWriter = new BitWriter();
         // Convert RGBA to YCbCr and encode MCUs
@@ -898,9 +1129,9 @@ export class JPEGEncoder {
         const mcuHeight = Math.ceil(height / 8);
         for (let mcuY = 0; mcuY < mcuHeight; mcuY++) {
             for (let mcuX = 0; mcuX < mcuWidth; mcuX++) {
-                const yBlock = new Array(64).fill(0);
-                const cbBlock = new Array(64).fill(0);
-                const crBlock = new Array(64).fill(0);
+                const yBlock = new Float32Array(64);
+                const cbBlock = new Float32Array(64);
+                const crBlock = new Float32Array(64);
                 // Extract 8x8 block and convert RGB to YCbCr
                 for (let y = 0; y < 8; y++) {
                     for (let x = 0; x < 8; x++) {
@@ -934,7 +1165,7 @@ export class JPEGEncoder {
         // Apply DCT
         this.forwardDCT(block);
         // Quantize and reorder to zigzag
-        const quantized = new Array(64);
+        const quantized = new Int32Array(64);
         for (let i = 0; i < 64; i++) {
             const zigzagIndex = ZIGZAG[i];
             quantized[i] = Math.round(block[zigzagIndex] / quantTable[zigzagIndex]);
@@ -948,7 +1179,7 @@ export class JPEGEncoder {
     }
     forwardDCT(block) {
         // Simplified 2D DCT
-        const temp = new Array(64);
+        const temp = new Float32Array(64);
         // 1D DCT on rows
         for (let i = 0; i < 8; i++) {
             const offset = i * 8;
@@ -974,7 +1205,11 @@ export class JPEGEncoder {
         }
     }
     encodeDC(value, huffTable, bitWriter) {
-        const absValue = Math.abs(value);
+        // Clamp DC coefficient to the range supported by standard Huffman tables
+        // Standard DC tables support sizes 0-11, which means values in range [-2047, 2047]
+        const maxDC = 2047;
+        const clampedValue = Math.max(-maxDC, Math.min(maxDC, value));
+        const absValue = Math.abs(clampedValue);
         let size = 0;
         if (absValue > 0) {
             size = Math.floor(Math.log2(absValue)) + 1;
@@ -983,7 +1218,7 @@ export class JPEGEncoder {
         bitWriter.writeBits(huffTable.codes[size], huffTable.sizes[size]);
         // Write magnitude
         if (size > 0) {
-            const magnitude = value < 0 ? value + (1 << size) - 1 : value;
+            const magnitude = clampedValue < 0 ? clampedValue + (1 << size) - 1 : clampedValue;
             bitWriter.writeBits(magnitude, size);
         }
     }
@@ -1000,11 +1235,15 @@ export class JPEGEncoder {
                     bitWriter.writeBits(huffTable.codes[0xf0], huffTable.sizes[0xf0]);
                     zeroCount -= 16;
                 }
-                const absCoef = Math.abs(coef);
+                // Clamp AC coefficient to the range supported by standard Huffman tables
+                // Standard AC tables support sizes 1-10, which means values in range [-1023, 1023]
+                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 = coef < 0 ? coef + (1 << size) - 1 : coef;
+                const magnitude = clampedCoef < 0 ? clampedCoef + (1 << size) - 1 : clampedCoef;
                 bitWriter.writeBits(magnitude, size);
                 zeroCount = 0;
             }

package/esm/src/utils/resize.js

@@ -5,26 +5,55 @@ export function resizeBilinear(src, srcWidth, srcHeight, dstWidth, dstHeight) {
     const dst = new Uint8Array(dstWidth * dstHeight * 4);
     const xRatio = srcWidth / dstWidth;
     const yRatio = srcHeight / dstHeight;
+    const srcWidthMinus1 = srcWidth - 1;
+    const srcHeightMinus1 = srcHeight - 1;
     for (let y = 0; y < dstHeight; y++) {
+        const srcY = y * yRatio;
+        const y1 = srcY | 0; // Fast floor
+        const y2 = y1 < srcHeightMinus1 ? y1 + 1 : srcHeightMinus1;
+        const dy = srcY - y1;
+        const dyInv = 1 - dy;
+        const dstRowOffset = y * dstWidth * 4;
         for (let x = 0; x < dstWidth; x++) {
             const srcX = x * xRatio;
-            const srcY = y * yRatio;
-            const x1 = Math.floor(srcX);
-            const y1 = Math.floor(srcY);
-            const x2 = Math.min(x1 + 1, srcWidth - 1);
-            const y2 = Math.min(y1 + 1, srcHeight - 1);
+            const x1 = srcX | 0; // Fast floor
+            const x2 = x1 < srcWidthMinus1 ? x1 + 1 : srcWidthMinus1;
             const dx = srcX - x1;
-            const dy = srcY - y1;
-            for (let c = 0; c < 4; c++) {
-                const p1 = src[(y1 * srcWidth + x1) * 4 + c];
-                const p2 = src[(y1 * srcWidth + x2) * 4 + c];
-                const p3 = src[(y2 * srcWidth + x1) * 4 + c];
-                const p4 = src[(y2 * srcWidth + x2) * 4 + c];
-                const v1 = p1 * (1 - dx) + p2 * dx;
-                const v2 = p3 * (1 - dx) + p4 * dx;
-                const v = v1 * (1 - dy) + v2 * dy;
-                dst[(y * dstWidth + x) * 4 + c] = Math.round(v);
-            }
+            const dxInv = 1 - dx;
+            const idx1 = (y1 * srcWidth + x1) * 4;
+            const idx2 = (y1 * srcWidth + x2) * 4;
+            const idx3 = (y2 * srcWidth + x1) * 4;
+            const idx4 = (y2 * srcWidth + x2) * 4;
+            const dstIdx = dstRowOffset + x * 4;
+            // Unroll channel loop for better performance
+            const p1_r = src[idx1];
+            const p2_r = src[idx2];
+            const p3_r = src[idx3];
+            const p4_r = src[idx4];
+            const v1_r = p1_r * dxInv + p2_r * dx;
+            const v2_r = p3_r * dxInv + p4_r * dx;
+            dst[dstIdx] = (v1_r * dyInv + v2_r * dy + 0.5) | 0;
+            const p1_g = src[idx1 + 1];
+            const p2_g = src[idx2 + 1];
+            const p3_g = src[idx3 + 1];
+            const p4_g = src[idx4 + 1];
+            const v1_g = p1_g * dxInv + p2_g * dx;
+            const v2_g = p3_g * dxInv + p4_g * dx;
+            dst[dstIdx + 1] = (v1_g * dyInv + v2_g * dy + 0.5) | 0;
+            const p1_b = src[idx1 + 2];
+            const p2_b = src[idx2 + 2];
+            const p3_b = src[idx3 + 2];
+            const p4_b = src[idx4 + 2];
+            const v1_b = p1_b * dxInv + p2_b * dx;
+            const v2_b = p3_b * dxInv + p4_b * dx;
+            dst[dstIdx + 2] = (v1_b * dyInv + v2_b * dy + 0.5) | 0;
+            const p1_a = src[idx1 + 3];
+            const p2_a = src[idx2 + 3];
+            const p3_a = src[idx3 + 3];
+            const p4_a = src[idx4 + 3];
+            const v1_a = p1_a * dxInv + p2_a * dx;
+            const v2_a = p3_a * dxInv + p4_a * dx;
+            dst[dstIdx + 3] = (v1_a * dyInv + v2_a * dy + 0.5) | 0;
         }
     }
     return dst;
@@ -37,11 +66,13 @@ export function resizeNearest(src, srcWidth, srcHeight, dstWidth, dstHeight) {
     const xRatio = srcWidth / dstWidth;
     const yRatio = srcHeight / dstHeight;
     for (let y = 0; y < dstHeight; y++) {
+        const srcY = (y * yRatio) | 0; // Use bitwise OR for fast floor
+        const srcRowOffset = srcY * srcWidth;
+        const dstRowOffset = y * dstWidth;
         for (let x = 0; x < dstWidth; x++) {
-            const srcX = Math.floor(x * xRatio);
-            const srcY = Math.floor(y * yRatio);
-            const srcIdx = (srcY * srcWidth + srcX) * 4;
-            const dstIdx = (y * dstWidth + x) * 4;
+            const srcX = (x * xRatio) | 0; // Use bitwise OR for fast floor
+            const srcIdx = (srcRowOffset + srcX) * 4;
+            const dstIdx = (dstRowOffset + x) * 4;
             dst[dstIdx] = src[srcIdx];
             dst[dstIdx + 1] = src[srcIdx + 1];
             dst[dstIdx + 2] = src[srcIdx + 2];

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

@@ -0,0 +1,18 @@
+/**
+ * Deflate compression/decompression for TIFF
+ * Uses native JavaScript CompressionStream/DecompressionStream APIs
+ * Compression code: 8 (Adobe-style Deflate)
+ */
+/**
+ * Compress data using Deflate
+ * @param data Uncompressed data
+ * @returns Compressed data
+ */
+export declare function deflateCompress(data: Uint8Array): Promise<Uint8Array>;
+/**
+ * Decompress Deflate data
+ * @param data Compressed data
+ * @returns Decompressed data
+ */
+export declare function deflateDecompress(data: Uint8Array): Promise<Uint8Array>;
+//# sourceMappingURL=tiff_deflate.d.ts.map

package/esm/src/utils/tiff_deflate.js

@@ -0,0 +1,27 @@
+/**
+ * Deflate compression/decompression for TIFF
+ * Uses native JavaScript CompressionStream/DecompressionStream APIs
+ * Compression code: 8 (Adobe-style Deflate)
+ */
+/**
+ * Compress data using Deflate
+ * @param data Uncompressed data
+ * @returns Compressed data
+ */
+export async function deflateCompress(data) {
+    const stream = new Response(data).body
+        .pipeThrough(new CompressionStream("deflate"));
+    const compressed = await new Response(stream).arrayBuffer();
+    return new Uint8Array(compressed);
+}
+/**
+ * Decompress Deflate data
+ * @param data Compressed data
+ * @returns Decompressed data
+ */
+export async function deflateDecompress(data) {
+    const stream = new Response(data).body
+        .pipeThrough(new DecompressionStream("deflate"));
+    const decompressed = await new Response(stream).arrayBuffer();
+    return new Uint8Array(decompressed);
+}

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

@@ -0,0 +1,24 @@
+/**
+ * PackBits compression/decompression for TIFF
+ * PackBits is a simple run-length encoding (RLE) scheme used in TIFF images
+ * Compression code: 32773
+ *
+ * Format:
+ * - Header byte n:
+ *   - If n >= 0 and n <= 127: Copy the next n+1 bytes literally
+ *   - If n >= -127 and n <= -1: Repeat the next byte -n+1 times
+ *   - If n = -128: No operation (skip)
+ */
+/**
+ * Compress data using PackBits RLE
+ * @param data Uncompressed data
+ * @returns Compressed data
+ */
+export declare function packBitsCompress(data: Uint8Array): Uint8Array;
+/**
+ * Decompress PackBits RLE data
+ * @param data Compressed data
+ * @returns Decompressed data
+ */
+export declare function packBitsDecompress(data: Uint8Array): Uint8Array;
+//# sourceMappingURL=tiff_packbits.d.ts.map

package/esm/src/utils/tiff_packbits.js

@@ -0,0 +1,90 @@
+/**
+ * PackBits compression/decompression for TIFF
+ * PackBits is a simple run-length encoding (RLE) scheme used in TIFF images
+ * Compression code: 32773
+ *
+ * Format:
+ * - Header byte n:
+ *   - If n >= 0 and n <= 127: Copy the next n+1 bytes literally
+ *   - If n >= -127 and n <= -1: Repeat the next byte -n+1 times
+ *   - If n = -128: No operation (skip)
+ */
+/**
+ * Compress data using PackBits RLE
+ * @param data Uncompressed data
+ * @returns Compressed data
+ */
+export function packBitsCompress(data) {
+    const result = [];
+    let i = 0;
+    while (i < data.length) {
+        // Look for runs (repeated bytes)
+        let runLength = 1;
+        while (i + runLength < data.length &&
+            data[i + runLength] === data[i] &&
+            runLength < 128) {
+            runLength++;
+        }
+        // If we have a run of 2 or more, encode it as a run
+        if (runLength >= 2) {
+            result.push(-(runLength - 1) & 0xff); // Two's complement representation
+            result.push(data[i]);
+            i += runLength;
+        }
+        else {
+            // Look for literals (non-repeating bytes)
+            const literalStart = i;
+            let literalLength = 1;
+            while (i + literalLength < data.length &&
+                literalLength < 128) {
+                // Check if we're starting a run
+                if (i + literalLength + 1 < data.length &&
+                    data[i + literalLength] === data[i + literalLength + 1]) {
+                    // We found a run, stop the literal sequence here
+                    break;
+                }
+                literalLength++;
+            }
+            result.push(literalLength - 1);
+            for (let j = 0; j < literalLength; j++) {
+                result.push(data[literalStart + j]);
+            }
+            i += literalLength;
+        }
+    }
+    return new Uint8Array(result);
+}
+/**
+ * Decompress PackBits RLE data
+ * @param data Compressed data
+ * @returns Decompressed data
+ */
+export function packBitsDecompress(data) {
+    const result = [];
+    let i = 0;
+    while (i < data.length) {
+        const header = data[i++];
+        if (header === 128) {
+            // No operation, skip
+            continue;
+        }
+        else if (header < 128) {
+            // Literal run: copy next (header + 1) bytes
+            const count = header + 1;
+            for (let j = 0; j < count && i < data.length; j++) {
+                result.push(data[i++]);
+            }
+        }
+        else {
+            // Repeated run: repeat next byte (257 - header) times
+            const count = 257 - header;
+            if (i < data.length) {
+                const value = data[i++];
+                for (let j = 0; j < count; j++) {
+                    result.push(value);
+                }
+            }
+        }
+    }
+    return new Uint8Array(result);
+}