cross-image 0.1.5 → 0.2.1

package/script/src/utils/image_processing.js

@@ -0,0 +1,242 @@
+"use strict";
+/**
+ * Image processing utilities for common operations like compositing,
+ * level adjustments, and color manipulations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.composite = composite;
+exports.adjustBrightness = adjustBrightness;
+exports.adjustContrast = adjustContrast;
+exports.adjustExposure = adjustExposure;
+exports.adjustSaturation = adjustSaturation;
+exports.invert = invert;
+exports.grayscale = grayscale;
+exports.fillRect = fillRect;
+exports.crop = crop;
+/**
+ * Composite one image on top of another at a specified position
+ * @param base Base image data (RGBA)
+ * @param baseWidth Base image width
+ * @param baseHeight Base image height
+ * @param overlay Overlay image data (RGBA)
+ * @param overlayWidth Overlay image width
+ * @param overlayHeight Overlay image height
+ * @param x X position to place overlay (can be negative)
+ * @param y Y position to place overlay (can be negative)
+ * @param opacity Opacity of overlay (0-1, default: 1)
+ * @returns New image data with overlay composited on base
+ */
+function composite(base, baseWidth, baseHeight, overlay, overlayWidth, overlayHeight, x, y, opacity = 1) {
+    const result = new Uint8Array(base);
+    // Clamp opacity to valid range
+    const finalOpacity = Math.max(0, Math.min(1, opacity));
+    // Calculate the region to composite
+    const startX = Math.max(0, x);
+    const startY = Math.max(0, y);
+    const endX = Math.min(baseWidth, x + overlayWidth);
+    const endY = Math.min(baseHeight, y + overlayHeight);
+    // Iterate over the overlapping region
+    for (let py = startY; py < endY; py++) {
+        for (let px = startX; px < endX; px++) {
+            // Calculate indices
+            const baseIdx = (py * baseWidth + px) * 4;
+            const overlayX = px - x;
+            const overlayY = py - y;
+            const overlayIdx = (overlayY * overlayWidth + overlayX) * 4;
+            // Get overlay pixel with opacity
+            const overlayR = overlay[overlayIdx];
+            const overlayG = overlay[overlayIdx + 1];
+            const overlayB = overlay[overlayIdx + 2];
+            const overlayA = (overlay[overlayIdx + 3] / 255) * finalOpacity;
+            // Get base pixel
+            const baseR = result[baseIdx];
+            const baseG = result[baseIdx + 1];
+            const baseB = result[baseIdx + 2];
+            const baseA = result[baseIdx + 3] / 255;
+            // Alpha compositing using "over" operation
+            const outA = overlayA + baseA * (1 - overlayA);
+            if (outA > 0) {
+                result[baseIdx] = Math.round((overlayR * overlayA + baseR * baseA * (1 - overlayA)) / outA);
+                result[baseIdx + 1] = Math.round((overlayG * overlayA + baseG * baseA * (1 - overlayA)) / outA);
+                result[baseIdx + 2] = Math.round((overlayB * overlayA + baseB * baseA * (1 - overlayA)) / outA);
+                result[baseIdx + 3] = Math.round(outA * 255);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Adjust brightness of an image
+ * @param data Image data (RGBA)
+ * @param amount Brightness adjustment (-1 to 1, where 0 is no change)
+ * @returns New image data with adjusted brightness
+ */
+function adjustBrightness(data, amount) {
+    const result = new Uint8Array(data.length);
+    const adjust = Math.max(-1, Math.min(1, amount)) * 255;
+    for (let i = 0; i < data.length; i += 4) {
+        result[i] = Math.max(0, Math.min(255, data[i] + adjust)); // R
+        result[i + 1] = Math.max(0, Math.min(255, data[i + 1] + adjust)); // G
+        result[i + 2] = Math.max(0, Math.min(255, data[i + 2] + adjust)); // B
+        result[i + 3] = data[i + 3]; // A
+    }
+    return result;
+}
+/**
+ * Adjust contrast of an image
+ * @param data Image data (RGBA)
+ * @param amount Contrast adjustment (-1 to 1, where 0 is no change)
+ * @returns New image data with adjusted contrast
+ */
+function adjustContrast(data, amount) {
+    const result = new Uint8Array(data.length);
+    const contrast = Math.max(-1, Math.min(1, amount));
+    const factor = (259 * (contrast * 255 + 255)) /
+        (255 * (259 - contrast * 255));
+    for (let i = 0; i < data.length; i += 4) {
+        result[i] = Math.max(0, Math.min(255, factor * (data[i] - 128) + 128)); // R
+        result[i + 1] = Math.max(0, Math.min(255, factor * (data[i + 1] - 128) + 128)); // G
+        result[i + 2] = Math.max(0, Math.min(255, factor * (data[i + 2] - 128) + 128)); // B
+        result[i + 3] = data[i + 3]; // A
+    }
+    return result;
+}
+/**
+ * Adjust exposure of an image
+ * @param data Image data (RGBA)
+ * @param amount Exposure adjustment in stops (-3 to 3, where 0 is no change)
+ * @returns New image data with adjusted exposure
+ */
+function adjustExposure(data, amount) {
+    const result = new Uint8Array(data.length);
+    const stops = Math.max(-3, Math.min(3, amount));
+    const multiplier = Math.pow(2, stops);
+    for (let i = 0; i < data.length; i += 4) {
+        result[i] = Math.max(0, Math.min(255, data[i] * multiplier)); // R
+        result[i + 1] = Math.max(0, Math.min(255, data[i + 1] * multiplier)); // G
+        result[i + 2] = Math.max(0, Math.min(255, data[i + 2] * multiplier)); // B
+        result[i + 3] = data[i + 3]; // A
+    }
+    return result;
+}
+/**
+ * Adjust saturation of an image
+ * @param data Image data (RGBA)
+ * @param amount Saturation adjustment (-1 to 1, where 0 is no change)
+ * @returns New image data with adjusted saturation
+ */
+function adjustSaturation(data, amount) {
+    const result = new Uint8Array(data.length);
+    const sat = Math.max(-1, Math.min(1, amount)) + 1; // Convert to 0-2 range
+    for (let i = 0; i < data.length; i += 4) {
+        const r = data[i];
+        const g = data[i + 1];
+        const b = data[i + 2];
+        // Calculate grayscale value using luminosity method
+        const gray = 0.299 * r + 0.587 * g + 0.114 * b;
+        // Interpolate between gray and original color based on saturation
+        result[i] = Math.max(0, Math.min(255, gray + (r - gray) * sat));
+        result[i + 1] = Math.max(0, Math.min(255, gray + (g - gray) * sat));
+        result[i + 2] = Math.max(0, Math.min(255, gray + (b - gray) * sat));
+        result[i + 3] = data[i + 3];
+    }
+    return result;
+}
+/**
+ * Invert colors of an image
+ * @param data Image data (RGBA)
+ * @returns New image data with inverted colors
+ */
+function invert(data) {
+    const result = new Uint8Array(data.length);
+    for (let i = 0; i < data.length; i += 4) {
+        result[i] = 255 - data[i]; // R
+        result[i + 1] = 255 - data[i + 1]; // G
+        result[i + 2] = 255 - data[i + 2]; // B
+        result[i + 3] = data[i + 3]; // A
+    }
+    return result;
+}
+/**
+ * Convert image to grayscale
+ * @param data Image data (RGBA)
+ * @returns New image data in grayscale
+ */
+function grayscale(data) {
+    const result = new Uint8Array(data.length);
+    for (let i = 0; i < data.length; i += 4) {
+        // Using luminosity method for grayscale conversion
+        const gray = Math.round(0.299 * data[i] + 0.587 * data[i + 1] + 0.114 * data[i + 2]);
+        result[i] = gray; // R
+        result[i + 1] = gray; // G
+        result[i + 2] = gray; // B
+        result[i + 3] = data[i + 3]; // A
+    }
+    return result;
+}
+/**
+ * Fill a rectangular region with a color
+ * @param data Image data (RGBA)
+ * @param width Image width
+ * @param height Image height
+ * @param x Starting X position
+ * @param y Starting Y position
+ * @param fillWidth Width of the fill region
+ * @param fillHeight Height of the fill region
+ * @param r Red component (0-255)
+ * @param g Green component (0-255)
+ * @param b Blue component (0-255)
+ * @param a Alpha component (0-255)
+ * @returns Modified image data
+ */
+function fillRect(data, width, height, x, y, fillWidth, fillHeight, r, g, b, a) {
+    const result = new Uint8Array(data);
+    // Calculate bounds
+    const startX = Math.max(0, x);
+    const startY = Math.max(0, y);
+    const endX = Math.min(width, x + fillWidth);
+    const endY = Math.min(height, y + fillHeight);
+    // Fill the region
+    for (let py = startY; py < endY; py++) {
+        for (let px = startX; px < endX; px++) {
+            const idx = (py * width + px) * 4;
+            result[idx] = r;
+            result[idx + 1] = g;
+            result[idx + 2] = b;
+            result[idx + 3] = a;
+        }
+    }
+    return result;
+}
+/**
+ * Crop an image to a rectangular region
+ * @param data Image data (RGBA)
+ * @param width Image width
+ * @param height Image height
+ * @param x Starting X position
+ * @param y Starting Y position
+ * @param cropWidth Width of the crop region
+ * @param cropHeight Height of the crop region
+ * @returns Cropped image data and dimensions
+ */
+function crop(data, width, height, x, y, cropWidth, cropHeight) {
+    // Clamp crop region to image bounds
+    const startX = Math.max(0, x);
+    const startY = Math.max(0, y);
+    const endX = Math.min(width, x + cropWidth);
+    const endY = Math.min(height, y + cropHeight);
+    const actualWidth = endX - startX;
+    const actualHeight = endY - startY;
+    const result = new Uint8Array(actualWidth * actualHeight * 4);
+    for (let py = 0; py < actualHeight; py++) {
+        for (let px = 0; px < actualWidth; px++) {
+            const srcIdx = ((startY + py) * width + (startX + px)) * 4;
+            const dstIdx = (py * actualWidth + px) * 4;
+            result[dstIdx] = data[srcIdx];
+            result[dstIdx + 1] = data[srcIdx + 1];
+            result[dstIdx + 2] = data[srcIdx + 2];
+            result[dstIdx + 3] = data[srcIdx + 3];
+        }
+    }
+    return { data: result, width: actualWidth, height: actualHeight };
+}

package/script/src/utils/webp_decoder.js

@@ -54,6 +54,22 @@ class HuffmanTable {
             this.singleSymbol = symbol;
             return;
         }
+        // Build Huffman tree
+        // Note: WebP uses LSB-first bit packing for the bitstream, but Huffman codes
+        // are typically described MSB-first. However, the spec says:
+        // "The bits of the code are read from the stream LSB first."
+        // This means if code is 01 (binary), we read 1 then 0?
+        // Actually, standard canonical Huffman codes are read MSB to LSB from the stream.
+        // But WebP bit reader reads LSB to MSB from bytes.
+        // Let's check the spec carefully.
+        // "The bits of the code are read from the stream LSB first."
+        // This usually means the bit reader returns bits in order.
+        // If we have code 0x2 (binary 10) with length 2.
+        // If we write it MSB first: 1, then 0.
+        // If we read it: readBits(1) -> 1, readBits(1) -> 0.
+        // This matches how we build the tree (left=0, right=1).
+        // Wait, addCode uses (code >> i) & 1. This is MSB first.
+        // So we expect the first bit read to be the MSB of the code.
         let node = this.root;
         for (let i = codeLength - 1; i >= 0; i--) {
             const bit = (code >> i) & 1;
@@ -80,6 +96,7 @@ class HuffmanTable {
             const bit = reader.readBits(1);
             node = bit === 0 ? node.left : node.right;
             if (!node) {
+                // console.log("Invalid Huffman code - walked off tree");
                 throw new Error("Invalid Huffman code");
             }
         }
@@ -114,21 +131,21 @@ class BitReader {
         });
         this.data = data;
         this.pos = offset;
-        this.bitPos = 0;
+        this.bitPos = 8; // Start at 8 to trigger first byte read
         this.value = 0;
     }
     readBits(numBits) {
         let result = 0;
         for (let i = 0; i < numBits; i++) {
-            if (this.bitPos === 0) {
+            if (this.bitPos === 8) {
                 if (this.pos >= this.data.length) {
                     throw new Error("Unexpected end of data");
                 }
                 this.value = this.data[this.pos++];
-                this.bitPos = 8;
+                this.bitPos = 0;
             }
-            result |= ((this.value >> (this.bitPos - 1)) & 1) << i;
-            this.bitPos--;
+            result |= ((this.value >> this.bitPos) & 1) << i;
+            this.bitPos++;
         }
         return result;
     }
@@ -138,8 +155,8 @@ class BitReader {
     // Read bytes aligned to byte boundary
     readBytes(count) {
         // Align to byte boundary
-        if (this.bitPos !== 0 && this.bitPos !== 8) {
-            this.bitPos = 0;
+        if (this.bitPos !== 8) {
+            this.bitPos = 8; // Skip remaining bits in current byte
         }
         if (this.pos + count > this.data.length) {
             throw new Error("Unexpected end of data");
@@ -337,8 +354,6 @@ class WebPDecoder {
         }
         // Read the main Huffman codes
         // There are 5 Huffman code groups: green, red, blue, alpha, distance
-        // But we read 4 + optional distance code
-        const numCodeGroups = reader.readBits(4) + 4;
         const tables = {
             green: new HuffmanTable(),
             red: new HuffmanTable(),
@@ -353,7 +368,7 @@ class WebPDecoder {
             tables.alpha,
             tables.distance,
         ];
-        for (let i = 0; i < numCodeGroups && i < 5; i++) {
+        for (let i = 0; i < 5; i++) {
             this.readHuffmanCode(reader, tableArray[i], useColorCache, colorCacheBits, i === 0);
         }
         return tables;
@@ -367,8 +382,8 @@ class WebPDecoder {
             const symbols = [];
             for (let i = 0; i < numSymbols; i++) {
                 const symbolBits = isFirstEightBits
-                    ? 1 + reader.readBits(7)
-                    : reader.readBits(8);
+                    ? reader.readBits(8)
+                    : reader.readBits(1);
                 symbols.push(symbolBits);
             }
             // Build simple Huffman table
@@ -420,6 +435,12 @@ class WebPDecoder {
         for (let i = 0; i < numCodeLengthCodes; i++) {
             codeLengthCodeLengths[codeLengthCodeOrder[i]] = reader.readBits(3);
         }
+        // Read max_symbol (trimmed length indicator)
+        // If 1, we read n_bit and then n_bit bits for max_symbol?
+        // Subagent said "write_trimmed_length".
+        // If 0, we don't trim.
+        // We just read 1 bit and ignore it for now (assuming 0).
+        const _trimmed = reader.readBits(1);
         // Build code length Huffman table
         const codeLengthTable = new HuffmanTable();
         this.buildHuffmanTable(codeLengthTable, codeLengthCodeLengths);
@@ -454,6 +475,20 @@ class WebPDecoder {
         return codeLengths;
     }
     buildHuffmanTable(table, codeLengths) {
+        // Check for single symbol optimization (VP8L specific)
+        let nonZeroCount = 0;
+        let singleSymbol = -1;
+        for (let i = 0; i < codeLengths.length; i++) {
+            if (codeLengths[i] > 0) {
+                nonZeroCount++;
+                singleSymbol = i;
+            }
+        }
+        if (nonZeroCount === 1) {
+            // If only one symbol, it has 0 length in the bitstream
+            table.addCode(singleSymbol, 0, 0);
+            return;
+        }
         // Build canonical Huffman codes
         const maxCodeLength = Math.max(...codeLengths);
         const lengthCounts = new Array(maxCodeLength + 1).fill(0);

package/script/src/utils/webp_encoder.js

@@ -58,30 +58,30 @@ class BitWriter {
         });
     }
     writeBits(value, numBits) {
-        // Pack bits to match how the decoder reads them
-        // The decoder reads from MSB to LSB of each byte
-        // So we write from MSB down as well
+        // Pack bits LSB first (standard WebP/VP8L order)
         for (let i = 0; i < numBits; i++) {
             const bit = (value >> i) & 1;
-            // Write bit at the current position (counting from MSB)
-            // bitCount represents how many bits we've written
-            // Position in current byte = 7 - (bitCount % 8)
-            if (this.bitCount % 8 === 0) {
-                this.bits = 0; // Start new byte
+            // If we've filled the current byte, push it and start a new one
+            if (this.bitCount > 0 && this.bitCount % 8 === 0) {
+                this.bytes.push(this.bits);
+                this.bits = 0;
             }
-            const bitPos = 7 - (this.bitCount % 8);
+            const bitPos = this.bitCount % 8;
             this.bits |= bit << bitPos;
             this.bitCount++;
-            if (this.bitCount % 8 === 0) {
-                this.bytes.push(this.bits);
-            }
         }
     }
     flush() {
         if (this.bitCount % 8 !== 0) {
             this.bytes.push(this.bits);
             this.bits = 0;
-            this.bitCount = 0;
+            // Do not reset bitCount here as it tracks total bits written
+        }
+        else if (this.bitCount > 0 && this.bytes.length * 8 < this.bitCount) {
+            // Edge case: if we just finished a byte but haven't pushed it yet
+            // (The loop pushes at the START of the next bit, so we might have a full byte pending)
+            this.bytes.push(this.bits);
+            this.bits = 0;
         }
     }
     getBytes() {
@@ -244,10 +244,6 @@ class WebPEncoder {
         writer.writeBits(0, 1);
         // No meta Huffman codes
         writer.writeBits(0, 1);
-        // Number of code groups: Always 5 (green, red, blue, alpha, distance)
-        // Even without LZ77, we must provide all 5 Huffman codes
-        const numCodeGroups = 5;
-        writer.writeBits(numCodeGroups - 4, 4); // 1 means 5 groups
         // Apply quantization if quality < 100
         const encodingData = this.quantizeImageData();
         // Collect symbol frequencies for each channel
@@ -356,13 +352,13 @@ class WebPEncoder {
         if (symbols.length === 1) {
             // Single symbol
             writer.writeBits(0, 1); // num_symbols = 1 (0 + 1)
-            writer.writeBits(0, 1); // is_first_8bits = 0
+            writer.writeBits(1, 1); // is_first_8bits = 1 (use 8 bits)
             writer.writeBits(symbols[0], 8); // symbol
         }
         else if (symbols.length === 2) {
             // Two symbols
             writer.writeBits(1, 1); // num_symbols = 2 (1 + 1)
-            writer.writeBits(0, 1); // is_first_8bits = 0
+            writer.writeBits(1, 1); // is_first_8bits = 1 (use 8 bits)
             writer.writeBits(symbols[0], 8); // first symbol
             writer.writeBits(symbols[1], 8); // second symbol
         }
@@ -381,9 +377,11 @@ class WebPEncoder {
         const symbols = Array.from(frequencies.keys()).sort((a, b) => a - b);
         if (symbols.length === 0)
             return codeLengths;
-        // For a single symbol, use code length 0
+        // For a single symbol, use code length 1
+        // (Canonical Huffman codes require length >= 1)
         if (symbols.length === 1) {
-            codeLengths[symbols[0]] = 0;
+            // console.log(`Single symbol ${symbols[0]}, forcing length 1`);
+            codeLengths[symbols[0]] = 1;
             return codeLengths;
         }
         // For two symbols, use code length 1 for both
@@ -392,27 +390,64 @@ class WebPEncoder {
             codeLengths[symbols[1]] = 1;
             return codeLengths;
         }
-        const nodes = symbols.map((symbol) => ({
+        let nodes = symbols.map((symbol) => ({
             freq: frequencies.get(symbol),
             symbol,
         }));
-        // Build tree by repeatedly combining two smallest nodes
-        while (nodes.length > 1) {
-            // Sort by frequency (smallest first)
-            nodes.sort((a, b) => a.freq - b.freq);
-            // Take two smallest nodes
-            const left = nodes.shift();
-            const right = nodes.shift();
-            // Create parent node
-            const parent = {
-                freq: left.freq + right.freq,
-                left,
-                right,
-            };
-            nodes.push(parent);
+        // Helper to build tree
+        const buildTree = (leafs) => {
+            const queue = [...leafs];
+            while (queue.length > 1) {
+                queue.sort((a, b) => a.freq - b.freq);
+                const left = queue.shift();
+                const right = queue.shift();
+                queue.push({
+                    freq: left.freq + right.freq,
+                    left,
+                    right,
+                });
+            }
+            return queue[0];
+        };
+        let root = buildTree(nodes);
+        // Check max depth
+        let maxDepth = 0;
+        const checkDepth = (node, depth) => {
+            if (node.symbol !== undefined) {
+                maxDepth = Math.max(maxDepth, depth);
+            }
+            else {
+                if (node.left)
+                    checkDepth(node.left, depth + 1);
+                if (node.right)
+                    checkDepth(node.right, depth + 1);
+            }
+        };
+        checkDepth(root, 0);
+        // If tree is too deep, flatten frequencies and rebuild
+        let attempts = 0;
+        while (maxDepth > maxCodeLength && attempts < 5) {
+            // console.log(`Tree too deep (${maxDepth} > ${maxCodeLength}), flattening...`);
+            attempts++;
+            // Add bias to frequencies to flatten the tree
+            // Increase bias with each attempt
+            const bias = (Math.ceil(root.freq / (symbols.length * 2)) || 1) *
+                attempts;
+            nodes = symbols.map((symbol) => ({
+                freq: frequencies.get(symbol) + bias,
+                symbol,
+            }));
+            root = buildTree(nodes);
+            // Re-check depth
+            maxDepth = 0;
+            checkDepth(root, 0);
+        }
+        if (maxDepth > maxCodeLength) {
+            console.warn(`Failed to reduce Huffman tree depth to ${maxCodeLength} (current: ${maxDepth})`);
+            // Force hard limit by sorting and assigning lengths?
+            // For now, let's just see if this is happening.
         }
         // Calculate code lengths by traversing tree (iterative to avoid deep recursion)
-        const root = nodes[0];
         const stack = [{
                 node: root,
                 depth: 0,
@@ -420,6 +455,7 @@ class WebPEncoder {
         while (stack.length > 0) {
             const { node, depth } = stack.pop();
             if (node.symbol !== undefined) {
+                // Clamp depth to maxCodeLength (should be safe now with flattening heuristic)
                 codeLengths[node.symbol] = Math.min(depth, maxCodeLength);
             }
             else {
@@ -592,13 +628,34 @@ class WebPEncoder {
         }
         numCodeLengthCodes = Math.max(4, numCodeLengthCodes);
         // Write number of code length codes
+        // console.log(`Complex Huffman: numCodeLengthCodes=${numCodeLengthCodes}, rleEncoded.length=${rleEncoded.length}`);
         writer.writeBits(numCodeLengthCodes - 4, 4);
         // Write code length code lengths
         for (let i = 0; i < numCodeLengthCodes; i++) {
             writer.writeBits(codeLengthCodeLengths[codeLengthCodeOrder[i]], 3);
         }
+        // Write max_symbol is encoded? No, it's write_trimmed_length
+        // VP8L spec says: "int max_symbol is read."
+        // Wait, subagent said "write_trimmed_length".
+        // Let's check the spec or libwebp source if possible.
+        // But assuming subagent is correct:
+        writer.writeBits(0, 1); // write_trimmed_length = 0 (no trimming)
         // Build canonical codes for code lengths
         const codeLengthCodes = this.buildCanonicalCodes(codeLengthCodeLengths);
+        // Check for single symbol optimization (VP8L specific)
+        let nonZeroCount = 0;
+        for (const len of codeLengthCodeLengths) {
+            if (len > 0)
+                nonZeroCount++;
+        }
+        if (nonZeroCount === 1) {
+            // If only one symbol is used in the code length alphabet,
+            // we don't write any bits for the code itself in the RLE stream.
+            // The symbol is implicit because it's the only one with non-zero length in the header.
+            for (const [_symbol, info] of codeLengthCodes) {
+                info.length = 0;
+            }
+        }
         // Write RLE-encoded code lengths using code length codes
         for (let i = 0; i < rleEncoded.length; i++) {
             const code = rleEncoded[i];
@@ -608,8 +665,9 @@ class WebPEncoder {
             }
             // Write the Huffman code bits from MSB to LSB
             // This matches how the decoder's addCode builds the tree
-            for (let bit = huffCode.length - 1; bit >= 0; bit--) {
-                writer.writeBits((huffCode.code >> bit) & 1, 1);
+            // (First bit written is MSB, which corresponds to top of tree)
+            for (let i = huffCode.length - 1; i >= 0; i--) {
+                writer.writeBits((huffCode.code >> i) & 1, 1);
             }
             // Write extra bits for special codes
             if (code === 16) {

package/esm/src/formats/raw.d.ts

@@ -1,40 +0,0 @@
-import type { ImageData, ImageFormat } from "../types.js";
-/**
- * RAW format handler
- * Implements a simple uncompressed RGBA format with a minimal header
- *
- * Format structure:
- * - Magic bytes (4 bytes): "RGBA" (0x52 0x47 0x42 0x41)
- * - Width (4 bytes, big-endian)
- * - Height (4 bytes, big-endian)
- * - RGBA pixel data (width * height * 4 bytes)
- */
-export declare class RAWFormat implements ImageFormat {
-    /** Format name identifier */
-    readonly name = "raw";
-    /** MIME type for RAW images */
-    readonly mimeType = "image/raw";
-    private readonly MAGIC_BYTES;
-    private readonly HEADER_SIZE;
-    /**
-     * Check if the given data is a RAW image
-     * @param data Raw image data to check
-     * @returns true if data has RAW signature
-     */
-    canDecode(data: Uint8Array): boolean;
-    /**
-     * Decode RAW image data to RGBA
-     * @param data Raw RAW image data
-     * @returns Decoded image data with RGBA pixels
-     */
-    decode(data: Uint8Array): Promise<ImageData>;
-    /**
-     * Encode RGBA image data to RAW format
-     * @param imageData Image data to encode
-     * @returns Encoded RAW image bytes
-     */
-    encode(imageData: ImageData): Promise<Uint8Array>;
-    private readUint32;
-    private writeUint32;
-}
-//# sourceMappingURL=raw.d.ts.map