cross-image 0.1.2

package/esm/src/utils/gif_decoder.js

@@ -0,0 +1,374 @@
+/**
+ * Pure JavaScript GIF decoder implementation
+ * Supports GIF87a and GIF89a formats with LZW decompression
+ */
+import { LZWDecoder } from "./lzw.js";
+export class GIFDecoder {
+    constructor(data) {
+        Object.defineProperty(this, "data", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "pos", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.data = data;
+        this.pos = 0;
+    }
+    readByte() {
+        if (this.pos >= this.data.length) {
+            throw new Error("Unexpected end of GIF data");
+        }
+        return this.data[this.pos++];
+    }
+    readUint16LE() {
+        const low = this.readByte();
+        const high = this.readByte();
+        return low | (high << 8);
+    }
+    readBytes(count) {
+        if (this.pos + count > this.data.length) {
+            throw new Error("Unexpected end of GIF data");
+        }
+        const result = this.data.slice(this.pos, this.pos + count);
+        this.pos += count;
+        return result;
+    }
+    readColorTable(size) {
+        // Each color is 3 bytes (RGB)
+        return this.readBytes(size * 3);
+    }
+    readDataSubBlocks() {
+        const blocks = [];
+        while (true) {
+            const blockSize = this.readByte();
+            if (blockSize === 0)
+                break;
+            const blockData = this.readBytes(blockSize);
+            blocks.push(...blockData);
+        }
+        return new Uint8Array(blocks);
+    }
+    decode() {
+        // Verify GIF signature
+        const signature = this.readBytes(3);
+        const version = this.readBytes(3);
+        if (signature[0] !== 0x47 || signature[1] !== 0x49 || signature[2] !== 0x46 ||
+            (version[0] !== 0x38) ||
+            (version[1] !== 0x37 && version[1] !== 0x39) ||
+            (version[2] !== 0x61)) {
+            throw new Error("Invalid GIF signature");
+        }
+        // Read Logical Screen Descriptor
+        const width = this.readUint16LE();
+        const height = this.readUint16LE();
+        const packed = this.readByte();
+        const backgroundColorIndex = this.readByte();
+        const _aspectRatio = this.readByte();
+        const hasGlobalColorTable = (packed & 0x80) !== 0;
+        const _colorResolution = ((packed & 0x70) >> 4) + 1;
+        const _sortFlag = (packed & 0x08) !== 0;
+        const globalColorTableSize = 2 << (packed & 0x07);
+        let globalColorTable = null;
+        if (hasGlobalColorTable) {
+            globalColorTable = this.readColorTable(globalColorTableSize);
+        }
+        // Parse data stream
+        let imageWidth = 0;
+        let imageHeight = 0;
+        let imageLeft = 0;
+        let imageTop = 0;
+        let localColorTable = null;
+        let transparentColorIndex = null;
+        let interlaced = false;
+        while (this.pos < this.data.length) {
+            const separator = this.readByte();
+            if (separator === 0x21) {
+                // Extension
+                const label = this.readByte();
+                if (label === 0xf9) {
+                    // Graphic Control Extension
+                    const _blockSize = this.readByte();
+                    const packed = this.readByte();
+                    const hasTransparent = (packed & 0x01) !== 0;
+                    const _delayTime = this.readUint16LE();
+                    const transparentIndex = this.readByte();
+                    const _terminator = this.readByte();
+                    if (hasTransparent) {
+                        transparentColorIndex = transparentIndex;
+                    }
+                }
+                else {
+                    // Skip other extensions
+                    this.readDataSubBlocks();
+                }
+            }
+            else if (separator === 0x2c) {
+                // Image Descriptor
+                imageLeft = this.readUint16LE();
+                imageTop = this.readUint16LE();
+                imageWidth = this.readUint16LE();
+                imageHeight = this.readUint16LE();
+                const packed = this.readByte();
+                const hasLocalColorTable = (packed & 0x80) !== 0;
+                interlaced = (packed & 0x40) !== 0;
+                const localColorTableSize = 2 << (packed & 0x07);
+                if (hasLocalColorTable) {
+                    localColorTable = this.readColorTable(localColorTableSize);
+                }
+                // Read image data
+                const minCodeSize = this.readByte();
+                const compressedData = this.readDataSubBlocks();
+                // Decompress using LZW
+                const decoder = new LZWDecoder(minCodeSize, compressedData);
+                const indexedData = decoder.decompress();
+                // Convert indexed to RGBA
+                const colorTable = localColorTable || globalColorTable;
+                if (!colorTable) {
+                    throw new Error("No color table available");
+                }
+                return this.indexedToRGBA(indexedData, imageWidth, imageHeight, colorTable, transparentColorIndex, interlaced, width, height, imageLeft, imageTop, backgroundColorIndex);
+            }
+            else if (separator === 0x3b) {
+                // Trailer - end of GIF
+                break;
+            }
+            else if (separator === 0x00) {
+                // Skip null bytes
+                continue;
+            }
+            else {
+                throw new Error(`Unknown separator: 0x${separator.toString(16)}`);
+            }
+        }
+        throw new Error("No image data found in GIF");
+    }
+    /**
+     * Decode all frames from an animated GIF
+     * @returns Object with canvas dimensions and array of frames
+     */
+    decodeAllFrames() {
+        // Reset position
+        this.pos = 0;
+        // Verify GIF signature
+        const signature = this.readBytes(3);
+        const version = this.readBytes(3);
+        if (signature[0] !== 0x47 || signature[1] !== 0x49 || signature[2] !== 0x46 ||
+            (version[0] !== 0x38) ||
+            (version[1] !== 0x37 && version[1] !== 0x39) ||
+            (version[2] !== 0x61)) {
+            throw new Error("Invalid GIF signature");
+        }
+        // Read Logical Screen Descriptor
+        const width = this.readUint16LE();
+        const height = this.readUint16LE();
+        const packed = this.readByte();
+        const _backgroundColorIndex = this.readByte();
+        const _aspectRatio = this.readByte();
+        const hasGlobalColorTable = (packed & 0x80) !== 0;
+        // Color table size: 2^(n+1) where n is the 3 least significant bits
+        const globalColorTableSize = 2 << (packed & 0x07);
+        let globalColorTable = null;
+        if (hasGlobalColorTable) {
+            globalColorTable = this.readColorTable(globalColorTableSize);
+        }
+        const frames = [];
+        // Parse data stream for all frames
+        let transparentColorIndex = null;
+        let delayTime = 0;
+        let disposalMethod = 0;
+        while (this.pos < this.data.length) {
+            const separator = this.readByte();
+            if (separator === 0x21) {
+                // Extension
+                const label = this.readByte();
+                if (label === 0xf9) {
+                    // Graphic Control Extension
+                    const _blockSize = this.readByte();
+                    const packed = this.readByte();
+                    disposalMethod = (packed >> 2) & 0x07;
+                    const hasTransparent = (packed & 0x01) !== 0;
+                    delayTime = this.readUint16LE();
+                    const transparentIndex = this.readByte();
+                    const _terminator = this.readByte();
+                    if (hasTransparent) {
+                        transparentColorIndex = transparentIndex;
+                    }
+                }
+                else {
+                    // Skip other extensions
+                    this.readDataSubBlocks();
+                }
+            }
+            else if (separator === 0x2c) {
+                // Image Descriptor
+                const imageLeft = this.readUint16LE();
+                const imageTop = this.readUint16LE();
+                const imageWidth = this.readUint16LE();
+                const imageHeight = this.readUint16LE();
+                const packed = this.readByte();
+                const hasLocalColorTable = (packed & 0x80) !== 0;
+                const interlaced = (packed & 0x40) !== 0;
+                // Color table size: 2^(n+1) where n is the 3 least significant bits
+                const localColorTableSize = 2 << (packed & 0x07);
+                let localColorTable = null;
+                if (hasLocalColorTable) {
+                    localColorTable = this.readColorTable(localColorTableSize);
+                }
+                // Read image data
+                const minCodeSize = this.readByte();
+                const compressedData = this.readDataSubBlocks();
+                // Decompress using LZW
+                const decoder = new LZWDecoder(minCodeSize, compressedData);
+                const indexedData = decoder.decompress();
+                // Convert indexed to RGBA
+                const colorTable = localColorTable || globalColorTable;
+                if (!colorTable) {
+                    throw new Error("No color table available");
+                }
+                // Deinterlace if necessary
+                const deinterlaced = interlaced
+                    ? this.deinterlace(indexedData, imageWidth, imageHeight)
+                    : indexedData;
+                // Create frame with just the image data (not full canvas)
+                const frameData = new Uint8Array(imageWidth * imageHeight * 4);
+                for (let y = 0; y < imageHeight; y++) {
+                    for (let x = 0; x < imageWidth; x++) {
+                        const srcIdx = y * imageWidth + x;
+                        if (srcIdx >= deinterlaced.length)
+                            continue;
+                        const colorIndex = deinterlaced[srcIdx];
+                        const dstIdx = (y * imageWidth + x) * 4;
+                        if (transparentColorIndex !== null &&
+                            colorIndex === transparentColorIndex) {
+                            // Transparent pixel
+                            frameData[dstIdx] = 0;
+                            frameData[dstIdx + 1] = 0;
+                            frameData[dstIdx + 2] = 0;
+                            frameData[dstIdx + 3] = 0;
+                        }
+                        else {
+                            // Copy color from color table
+                            const colorOffset = colorIndex * 3;
+                            if (colorOffset + 2 < colorTable.length) {
+                                frameData[dstIdx] = colorTable[colorOffset];
+                                frameData[dstIdx + 1] = colorTable[colorOffset + 1];
+                                frameData[dstIdx + 2] = colorTable[colorOffset + 2];
+                                frameData[dstIdx + 3] = 255;
+                            }
+                        }
+                    }
+                }
+                frames.push({
+                    width: imageWidth,
+                    height: imageHeight,
+                    left: imageLeft,
+                    top: imageTop,
+                    data: frameData,
+                    delay: delayTime,
+                    disposal: disposalMethod,
+                });
+                // Reset graphic control extension state
+                transparentColorIndex = null;
+                delayTime = 0;
+                disposalMethod = 0;
+            }
+            else if (separator === 0x3b) {
+                // Trailer - end of GIF
+                break;
+            }
+            else if (separator === 0x00) {
+                // Skip null bytes
+                continue;
+            }
+            else {
+                throw new Error(`Unknown separator: 0x${separator.toString(16)}`);
+            }
+        }
+        if (frames.length === 0) {
+            throw new Error("No image data found in GIF");
+        }
+        return {
+            width,
+            height,
+            frames,
+        };
+    }
+    indexedToRGBA(indexedData, imageWidth, imageHeight, colorTable, transparentColorIndex, interlaced, canvasWidth, canvasHeight, imageLeft, imageTop, backgroundColorIndex) {
+        // Create RGBA buffer for full canvas
+        const rgba = new Uint8Array(canvasWidth * canvasHeight * 4);
+        // Fill with background color
+        const bgR = colorTable[backgroundColorIndex * 3] || 0;
+        const bgG = colorTable[backgroundColorIndex * 3 + 1] || 0;
+        const bgB = colorTable[backgroundColorIndex * 3 + 2] || 0;
+        for (let i = 0; i < rgba.length; i += 4) {
+            rgba[i] = bgR;
+            rgba[i + 1] = bgG;
+            rgba[i + 2] = bgB;
+            rgba[i + 3] = 255;
+        }
+        // Deinterlace if necessary
+        const deinterlaced = interlaced
+            ? this.deinterlace(indexedData, imageWidth, imageHeight)
+            : indexedData;
+        // Copy image data to canvas
+        for (let y = 0; y < imageHeight; y++) {
+            for (let x = 0; x < imageWidth; x++) {
+                const srcIdx = y * imageWidth + x;
+                if (srcIdx >= deinterlaced.length)
+                    continue;
+                const colorIndex = deinterlaced[srcIdx];
+                const canvasX = imageLeft + x;
+                const canvasY = imageTop + y;
+                if (canvasX >= canvasWidth || canvasY >= canvasHeight)
+                    continue;
+                const dstIdx = (canvasY * canvasWidth + canvasX) * 4;
+                if (transparentColorIndex !== null && colorIndex === transparentColorIndex) {
+                    // Transparent pixel
+                    rgba[dstIdx + 3] = 0;
+                }
+                else {
+                    // Copy color from color table
+                    const colorOffset = colorIndex * 3;
+                    if (colorOffset + 2 < colorTable.length) {
+                        rgba[dstIdx] = colorTable[colorOffset];
+                        rgba[dstIdx + 1] = colorTable[colorOffset + 1];
+                        rgba[dstIdx + 2] = colorTable[colorOffset + 2];
+                        rgba[dstIdx + 3] = 255;
+                    }
+                }
+            }
+        }
+        return {
+            width: canvasWidth,
+            height: canvasHeight,
+            data: rgba,
+        };
+    }
+    deinterlace(data, width, height) {
+        const deinterlaced = new Uint8Array(data.length);
+        const passes = [
+            { start: 0, step: 8 }, // Pass 1: every 8th row, starting with row 0
+            { start: 4, step: 8 }, // Pass 2: every 8th row, starting with row 4
+            { start: 2, step: 4 }, // Pass 3: every 4th row, starting with row 2
+            { start: 1, step: 2 }, // Pass 4: every 2nd row, starting with row 1
+        ];
+        let srcIdx = 0;
+        for (const pass of passes) {
+            for (let y = pass.start; y < height; y += pass.step) {
+                for (let x = 0; x < width; x++) {
+                    if (srcIdx >= data.length)
+                        break;
+                    const dstIdx = y * width + x;
+                    deinterlaced[dstIdx] = data[srcIdx++];
+                }
+            }
+        }
+        return deinterlaced;
+    }
+}

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

@@ -0,0 +1,29 @@
+/**
+ * Pure JavaScript GIF encoder implementation
+ * Supports GIF89a format with LZW compression
+ */
+export declare class GIFEncoder {
+    private width;
+    private height;
+    private data;
+    constructor(width: number, height: number, data: Uint8Array);
+    private writeBytes;
+    private writeUint16LE;
+    private writeString;
+    /**
+     * Quantize a color channel value to a specified number of levels
+     * @param value - The input color channel value (0-255)
+     * @param levels - Number of quantization levels minus 1 (e.g., 7 for 8 levels)
+     * @param step - Step size for quantization (e.g., 255/7)
+     * @returns Quantized integer value
+     */
+    private quantizeChannel;
+    /**
+     * Quantize RGBA image to 256 colors using median cut algorithm
+     */
+    private quantize;
+    private nextPowerOf2;
+    private getBitsPerColor;
+    encode(): Uint8Array;
+}
+//# sourceMappingURL=gif_encoder.d.ts.map

package/esm/src/utils/gif_encoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gif_encoder.d.ts","sourceRoot":"","sources":["../../../src/src/utils/gif_encoder.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAUH,qBAAa,UAAU;IACrB,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,IAAI,CAAa;gBAEb,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU;IAM3D,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,aAAa;IAKrB,OAAO,CAAC,WAAW;IAMnB;;;;;;OAMG;IACH,OAAO,CAAC,eAAe;IAMvB;;OAEG;IACH,OAAO,CAAC,QAAQ;IA6GhB,OAAO,CAAC,YAAY;IAQpB,OAAO,CAAC,eAAe;IAQvB,MAAM,IAAI,UAAU;CA+ErB"}

package/esm/src/utils/gif_encoder.js

@@ -0,0 +1,226 @@
+/**
+ * Pure JavaScript GIF encoder implementation
+ * Supports GIF89a format with LZW compression
+ */
+import { LZWEncoder } from "./lzw.js";
+export class GIFEncoder {
+    constructor(width, height, data) {
+        Object.defineProperty(this, "width", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "height", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "data", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.width = width;
+        this.height = height;
+        this.data = data;
+    }
+    writeBytes(output, bytes) {
+        output.push(...bytes);
+    }
+    writeUint16LE(output, value) {
+        output.push(value & 0xff);
+        output.push((value >> 8) & 0xff);
+    }
+    writeString(output, str) {
+        for (let i = 0; i < str.length; i++) {
+            output.push(str.charCodeAt(i));
+        }
+    }
+    /**
+     * Quantize a color channel value to a specified number of levels
+     * @param value - The input color channel value (0-255)
+     * @param levels - Number of quantization levels minus 1 (e.g., 7 for 8 levels)
+     * @param step - Step size for quantization (e.g., 255/7)
+     * @returns Quantized integer value
+     */
+    quantizeChannel(value, levels, step) {
+        // First round to get quantization level (0-levels)
+        // Then multiply by step size and round to ensure integer result
+        return Math.round(Math.round(value * levels / 255) * step);
+    }
+    /**
+     * Quantize RGBA image to 256 colors using median cut algorithm
+     */
+    quantize() {
+        // Simple quantization: collect unique colors and build palette
+        const colorMap = new Map();
+        const colors = [];
+        // Color quantization parameters for 8-bit palette (256 colors)
+        // R/G: 8 levels (0-7) using 3 bits, B: 4 levels (0-3) using 2 bits (8*8*4=256)
+        const RG_LEVELS = 7; // Max level for R/G (8 total levels: 0-7)
+        const B_LEVELS = 3; // Max level for B (4 total levels: 0-3)
+        const rgStep = 255 / RG_LEVELS; // Step size for R/G quantization
+        const bStep = 255 / B_LEVELS; // Step size for B quantization
+        // Collect unique colors
+        for (let i = 0; i < this.data.length; i += 4) {
+            const r = this.data[i];
+            const g = this.data[i + 1];
+            const b = this.data[i + 2];
+            const key = `${r},${g},${b}`;
+            if (!colorMap.has(key) && colors.length < 256) {
+                colorMap.set(key, colors.length);
+                colors.push({ r, g, b });
+            }
+        }
+        // Track if color reduction was applied
+        let useColorReduction = false;
+        // If we have too many colors, use simple color reduction
+        if (colors.length >= 256) {
+            // Downsample colors to 256 by reducing color depth
+            colorMap.clear();
+            colors.length = 0;
+            useColorReduction = true;
+            for (let i = 0; i < this.data.length; i += 4) {
+                // Reduce color depth: 3 bits for R/G channels, 2 bits for B channel
+                // This gives us 8 bits total = 256 possible colors
+                const r = this.quantizeChannel(this.data[i], RG_LEVELS, rgStep);
+                const g = this.quantizeChannel(this.data[i + 1], RG_LEVELS, rgStep);
+                const b = this.quantizeChannel(this.data[i + 2], B_LEVELS, bStep);
+                const key = `${r},${g},${b}`;
+                if (!colorMap.has(key)) {
+                    if (colors.length < 256) {
+                        colorMap.set(key, colors.length);
+                        colors.push({ r, g, b });
+                    }
+                }
+            }
+        }
+        // Pad to power of 2
+        const paletteSize = Math.max(2, this.nextPowerOf2(colors.length));
+        while (colors.length < paletteSize) {
+            colors.push({ r: 0, g: 0, b: 0 });
+        }
+        // Create palette
+        const palette = new Uint8Array(colors.length * 3);
+        for (let i = 0; i < colors.length; i++) {
+            palette[i * 3] = colors[i].r;
+            palette[i * 3 + 1] = colors[i].g;
+            palette[i * 3 + 2] = colors[i].b;
+        }
+        // Create indexed data
+        const indexed = new Uint8Array(this.width * this.height);
+        for (let i = 0, j = 0; i < this.data.length; i += 4, j++) {
+            let r = this.data[i];
+            let g = this.data[i + 1];
+            let b = this.data[i + 2];
+            // Apply color reduction if it was used for building the palette
+            if (useColorReduction) {
+                r = this.quantizeChannel(r, RG_LEVELS, rgStep);
+                g = this.quantizeChannel(g, RG_LEVELS, rgStep);
+                b = this.quantizeChannel(b, B_LEVELS, bStep);
+            }
+            const key = `${r},${g},${b}`;
+            // Try fast O(1) lookup first
+            if (colorMap.has(key)) {
+                indexed[j] = colorMap.get(key);
+            }
+            else {
+                // Fallback: find closest color in palette (shouldn't happen often)
+                let minDist = Infinity;
+                let bestIdx = 0;
+                for (let k = 0; k < colors.length; k++) {
+                    const dr = r - colors[k].r;
+                    const dg = g - colors[k].g;
+                    const db = b - colors[k].b;
+                    const dist = dr * dr + dg * dg + db * db;
+                    if (dist < minDist) {
+                        minDist = dist;
+                        bestIdx = k;
+                    }
+                }
+                indexed[j] = bestIdx;
+            }
+        }
+        return { palette, indexed };
+    }
+    nextPowerOf2(n) {
+        let power = 1;
+        while (power < n) {
+            power *= 2;
+        }
+        return power;
+    }
+    getBitsPerColor(paletteSize) {
+        let bits = 1;
+        while ((1 << bits) < paletteSize) {
+            bits++;
+        }
+        return Math.max(2, bits);
+    }
+    encode() {
+        const output = [];
+        // Quantize image
+        const { palette, indexed } = this.quantize();
+        const paletteSize = palette.length / 3;
+        const bitsPerColor = this.getBitsPerColor(paletteSize);
+        // Header
+        this.writeString(output, "GIF89a");
+        // Logical Screen Descriptor
+        this.writeUint16LE(output, this.width);
+        this.writeUint16LE(output, this.height);
+        // Packed field:
+        // - Global Color Table Flag (1 bit): 1
+        // - Color Resolution (3 bits): bitsPerColor - 1
+        // - Sort Flag (1 bit): 0
+        // - Size of Global Color Table (3 bits): bitsPerColor - 1
+        const packed = 0x80 | ((bitsPerColor - 1) << 4) | (bitsPerColor - 1);
+        output.push(packed);
+        // Background Color Index
+        output.push(0);
+        // Pixel Aspect Ratio
+        output.push(0);
+        // Global Color Table
+        // The GCT size is 2^(n+1) where n is the value in the packed field
+        // So we need to write that many colors, padding if necessary
+        const gctSize = 1 << bitsPerColor;
+        const paddedPalette = new Uint8Array(gctSize * 3);
+        paddedPalette.set(palette);
+        this.writeBytes(output, paddedPalette);
+        // Image Descriptor
+        output.push(0x2c); // Image Separator
+        // Image position and dimensions
+        this.writeUint16LE(output, 0); // Left
+        this.writeUint16LE(output, 0); // Top
+        this.writeUint16LE(output, this.width);
+        this.writeUint16LE(output, this.height);
+        // Packed field:
+        // - Local Color Table Flag (1 bit): 0
+        // - Interlace Flag (1 bit): 0
+        // - Sort Flag (1 bit): 0
+        // - Reserved (2 bits): 0
+        // - Size of Local Color Table (3 bits): 0
+        output.push(0);
+        // LZW Minimum Code Size
+        const minCodeSize = Math.max(2, bitsPerColor);
+        output.push(minCodeSize);
+        // Compress image data with LZW
+        const encoder = new LZWEncoder(minCodeSize);
+        const compressed = encoder.compress(indexed);
+        // Write compressed data in sub-blocks (max 255 bytes per block)
+        for (let i = 0; i < compressed.length; i += 255) {
+            const blockSize = Math.min(255, compressed.length - i);
+            output.push(blockSize);
+            for (let j = 0; j < blockSize; j++) {
+                output.push(compressed[i + j]);
+            }
+        }
+        // Block Terminator
+        output.push(0);
+        // Trailer
+        output.push(0x3b);
+        return new Uint8Array(output);
+    }
+}

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

@@ -0,0 +1,39 @@
+/**
+ * Basic baseline JPEG decoder implementation
+ * Supports baseline DCT JPEG images (the most common format)
+ *
+ * This is a simplified implementation that handles common JPEG files.
+ * For complex or non-standard JPEGs, the ImageDecoder API fallback is preferred.
+ */
+export declare class JPEGDecoder {
+    private data;
+    private pos;
+    private width;
+    private height;
+    private components;
+    private qTables;
+    private dcTables;
+    private acTables;
+    private restartInterval;
+    private bitBuffer;
+    private bitCount;
+    constructor(data: Uint8Array);
+    decode(): Uint8Array;
+    private readMarker;
+    private readUint16;
+    private skipSegment;
+    private parseDQT;
+    private parseDHT;
+    private buildHuffmanTable;
+    private parseSOF;
+    private parseSOS;
+    private parseDRI;
+    private decodeScan;
+    private decodeBlock;
+    private decodeHuffman;
+    private readBit;
+    private receiveBits;
+    private idct;
+    private convertToRGB;
+}
+//# sourceMappingURL=jpeg_decoder.d.ts.map

package/esm/src/utils/jpeg_decoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jpeg_decoder.d.ts","sourceRoot":"","sources":["../../../src/src/utils/jpeg_decoder.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAkGH,qBAAa,WAAW;IACtB,OAAO,CAAC,IAAI,CAAa;IACzB,OAAO,CAAC,GAAG,CAAa;IACxB,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,UAAU,CAAuB;IACzC,OAAO,CAAC,OAAO,CAAkB;IACjC,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,eAAe,CAAa;IACpC,OAAO,CAAC,SAAS,CAAa;IAC9B,OAAO,CAAC,QAAQ,CAAa;gBAEjB,IAAI,EAAE,UAAU;IAI5B,MAAM,IAAI,UAAU;IAwDpB,OAAO,CAAC,UAAU;IAoBlB,OAAO,CAAC,UAAU;IAMlB,OAAO,CAAC,WAAW;IAKnB,OAAO,CAAC,QAAQ;IAsBhB,OAAO,CAAC,QAAQ;IAgChB,OAAO,CAAC,iBAAiB;IA8BzB,OAAO,CAAC,QAAQ;IAmChB,OAAO,CAAC,QAAQ;IAkBhB,OAAO,CAAC,QAAQ;IAKhB,OAAO,CAAC,UAAU;IAiDlB,OAAO,CAAC,WAAW;IAiDnB,OAAO,CAAC,aAAa;IAerB,OAAO,CAAC,OAAO;IA2Bf,OAAO,CAAC,WAAW;IAcnB,OAAO,CAAC,IAAI;IAqCZ,OAAO,CAAC,YAAY;CAsGrB"}