cross-image 0.2.0 → 0.2.2

package/esm/src/formats/ppm.js

@@ -0,0 +1,242 @@
+import { validateImageDimensions } from "../utils/security.js";
+/**
+ * PPM format handler
+ * Implements the Netpbm PPM (Portable PixMap) format.
+ * This is a simple uncompressed RGB format supported by many image tools.
+ *
+ * Format structure:
+ * - P3 (ASCII format):
+ *   P3
+ *   <width> <height>
+ *   <maxval>
+ *   R G B R G B ... (space-separated decimal values)
+ *
+ * - P6 (Binary format):
+ *   P6
+ *   <width> <height>
+ *   <maxval>
+ *   RGB RGB RGB ... (binary byte data)
+ */
+export class PPMFormat {
+    constructor() {
+        /** Format name identifier */
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "ppm"
+        });
+        /** MIME type for PPM images */
+        Object.defineProperty(this, "mimeType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "image/x-portable-pixmap"
+        });
+    }
+    /**
+     * Check if the given data is a PPM image
+     * @param data Raw image data to check
+     * @returns true if data has PPM signature (P3 or P6)
+     */
+    canDecode(data) {
+        // Check if data has at least magic bytes
+        if (data.length < 3) {
+            return false;
+        }
+        // Check for P3 or P6 followed by whitespace
+        return data[0] === 0x50 && // P
+            (data[1] === 0x33 || data[1] === 0x36) && // 3 or 6
+            (data[2] === 0x0a || data[2] === 0x0d || data[2] === 0x20 ||
+                data[2] === 0x09); // \n, \r, space, or tab
+    }
+    /**
+     * Decode PPM image data to RGBA
+     * Supports both P3 (ASCII) and P6 (binary) formats
+     * @param data Raw PPM image data
+     * @returns Decoded image data with RGBA pixels
+     */
+    decode(data) {
+        if (!this.canDecode(data)) {
+            throw new Error("Invalid PPM signature");
+        }
+        const isBinary = data[1] === 0x36; // P6
+        // Parse header
+        let offset = 0;
+        let width = 0;
+        let height = 0;
+        let maxval = 0;
+        let headerValues = 0; // Track how many values we've parsed (need 3: width, height, maxval)
+        // Skip magic number and whitespace
+        offset = 2;
+        while (offset < data.length && this.isWhitespace(data[offset])) {
+            offset++;
+        }
+        // Parse header values (width, height, maxval)
+        while (headerValues < 3 && offset < data.length) {
+            // Skip comments (lines starting with #)
+            if (data[offset] === 0x23) { // #
+                // Skip until newline
+                while (offset < data.length && data[offset] !== 0x0a) {
+                    offset++;
+                }
+                if (offset < data.length)
+                    offset++; // Skip the newline
+                continue;
+            }
+            // Skip whitespace
+            while (offset < data.length && this.isWhitespace(data[offset])) {
+                offset++;
+            }
+            // Read number
+            let numStr = "";
+            while (offset < data.length &&
+                !this.isWhitespace(data[offset]) &&
+                data[offset] !== 0x23) {
+                numStr += String.fromCharCode(data[offset]);
+                offset++;
+            }
+            if (numStr) {
+                const num = parseInt(numStr, 10);
+                if (isNaN(num) || num <= 0) {
+                    throw new Error(`Invalid PPM header value: ${numStr}`);
+                }
+                if (headerValues === 0) {
+                    width = num;
+                }
+                else if (headerValues === 1) {
+                    height = num;
+                }
+                else if (headerValues === 2) {
+                    maxval = num;
+                }
+                headerValues++;
+            }
+        }
+        if (headerValues < 3) {
+            throw new Error("Incomplete PPM header");
+        }
+        // Skip single whitespace character after maxval (required by spec)
+        if (offset < data.length && this.isWhitespace(data[offset])) {
+            offset++;
+        }
+        // Validate dimensions
+        validateImageDimensions(width, height);
+        // Validate maxval
+        if (maxval > 255) {
+            throw new Error(`Unsupported PPM maxval: ${maxval}. Only maxval <= 255 is supported.`);
+        }
+        const pixelCount = width * height;
+        const rgba = new Uint8Array(pixelCount * 4);
+        if (isBinary) {
+            // P6: Binary format
+            const expectedDataLength = pixelCount * 3;
+            const actualDataLength = data.length - offset;
+            if (actualDataLength < expectedDataLength) {
+                throw new Error(`Invalid PPM data length: expected ${expectedDataLength}, got ${actualDataLength}`);
+            }
+            // Read RGB data and convert to RGBA
+            for (let i = 0; i < pixelCount; i++) {
+                const srcIndex = offset + i * 3;
+                const dstIndex = i * 4;
+                rgba[dstIndex] = data[srcIndex]; // R
+                rgba[dstIndex + 1] = data[srcIndex + 1]; // G
+                rgba[dstIndex + 2] = data[srcIndex + 2]; // B
+                rgba[dstIndex + 3] = 255; // A (fully opaque)
+            }
+        }
+        else {
+            // P3: ASCII format
+            let pixelIndex = 0;
+            while (pixelIndex < pixelCount * 3 && offset < data.length) {
+                // Skip whitespace and comments
+                while (offset < data.length) {
+                    if (data[offset] === 0x23) { // #
+                        // Skip comment
+                        while (offset < data.length && data[offset] !== 0x0a) {
+                            offset++;
+                        }
+                        if (offset < data.length)
+                            offset++;
+                    }
+                    else if (this.isWhitespace(data[offset])) {
+                        offset++;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                // Read number
+                let numStr = "";
+                while (offset < data.length &&
+                    !this.isWhitespace(data[offset]) &&
+                    data[offset] !== 0x23) {
+                    numStr += String.fromCharCode(data[offset]);
+                    offset++;
+                }
+                if (numStr) {
+                    const value = parseInt(numStr, 10);
+                    if (isNaN(value) || value < 0 || value > maxval) {
+                        throw new Error(`Invalid PPM pixel value: ${numStr}`);
+                    }
+                    // Scale to 0-255 if needed
+                    const scaledValue = maxval === 255 ? value : Math.round((value * 255) / maxval);
+                    const component = pixelIndex % 3;
+                    const rgbaIndex = Math.floor(pixelIndex / 3) * 4;
+                    if (component === 0) {
+                        rgba[rgbaIndex] = scaledValue; // R
+                    }
+                    else if (component === 1) {
+                        rgba[rgbaIndex + 1] = scaledValue; // G
+                    }
+                    else {
+                        rgba[rgbaIndex + 2] = scaledValue; // B
+                        rgba[rgbaIndex + 3] = 255; // A
+                    }
+                    pixelIndex++;
+                }
+            }
+            if (pixelIndex < pixelCount * 3) {
+                throw new Error(`Incomplete PPM pixel data: expected ${pixelCount * 3} values, got ${pixelIndex}`);
+            }
+        }
+        return Promise.resolve({ width, height, data: rgba });
+    }
+    /**
+     * Encode RGBA image data to PPM format (P6 binary)
+     * Note: Alpha channel is ignored as PPM doesn't support transparency
+     * @param imageData Image data to encode
+     * @returns Encoded PPM image bytes
+     */
+    encode(imageData) {
+        const { width, height, data } = imageData;
+        // Validate input
+        if (data.length !== width * height * 4) {
+            throw new Error(`Data length mismatch: expected ${width * height * 4}, got ${data.length}`);
+        }
+        // Create header
+        const header = `P6\n${width} ${height}\n255\n`;
+        const encoder = new TextEncoder();
+        const headerBytes = encoder.encode(header);
+        // Create output buffer (header + RGB data)
+        const pixelCount = width * height;
+        const output = new Uint8Array(headerBytes.length + pixelCount * 3);
+        // Write header
+        output.set(headerBytes, 0);
+        // Write RGB pixel data (discard alpha channel)
+        let outputOffset = headerBytes.length;
+        for (let i = 0; i < pixelCount; i++) {
+            const srcIndex = i * 4;
+            output[outputOffset++] = data[srcIndex]; // R
+            output[outputOffset++] = data[srcIndex + 1]; // G
+            output[outputOffset++] = data[srcIndex + 2]; // B
+        }
+        return Promise.resolve(output);
+    }
+    /**
+     * Check if a byte is whitespace (space, tab, CR, LF)
+     */
+    isWhitespace(byte) {
+        return byte === 0x20 || byte === 0x09 || byte === 0x0a || byte === 0x0d;
+    }
+}

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

@@ -5,6 +5,10 @@ import type { ImageData, ImageFormat, MultiFrameImageData } from "../types.js";
 export interface TIFFEncodeOptions {
     /** Compression method: "none" for uncompressed (default), "lzw" for LZW compression */
     compression?: "none" | "lzw";
+    /** Encode as grayscale instead of RGB/RGBA */
+    grayscale?: boolean;
+    /** Encode as RGB without alpha channel (ignored if grayscale is true) */
+    rgb?: boolean;
 }
 /**
  * TIFF format handler

package/esm/src/formats/tiff.js

@@ -132,18 +132,49 @@ export class TIFFFormat {
         const { width, height, data, metadata } = imageData;
         const opts = options;
         const compression = opts?.compression ?? "none";
+        const grayscale = opts?.grayscale ?? false;
+        const rgb = opts?.rgb ?? false;
+        // Convert RGBA to grayscale if requested
+        let sourceData;
+        let samplesPerPixel;
+        if (grayscale) {
+            sourceData = new Uint8Array(width * height);
+            samplesPerPixel = 1;
+            for (let i = 0; i < width * height; i++) {
+                const r = data[i * 4];
+                const g = data[i * 4 + 1];
+                const b = data[i * 4 + 2];
+                // Use standard luminance formula
+                sourceData[i] = Math.round(0.299 * r + 0.587 * g + 0.114 * b);
+            }
+        }
+        else if (rgb) {
+            // Convert RGBA to RGB (strip alpha channel)
+            sourceData = new Uint8Array(width * height * 3);
+            samplesPerPixel = 3;
+            for (let i = 0; i < width * height; i++) {
+                sourceData[i * 3] = data[i * 4]; // R
+                sourceData[i * 3 + 1] = data[i * 4 + 1]; // G
+                sourceData[i * 3 + 2] = data[i * 4 + 2]; // B
+            }
+        }
+        else {
+            // Keep as RGBA
+            sourceData = data;
+            samplesPerPixel = 4;
+        }
         // Prepare pixel data (compress if needed)
         let pixelData;
         let compressionCode;
         if (compression === "lzw") {
             // LZW compress the pixel data
             const encoder = new TIFFLZWEncoder();
-            pixelData = encoder.compress(data);
+            pixelData = encoder.compress(sourceData);
             compressionCode = 5;
         }
         else {
             // Uncompressed
-            pixelData = data;
+            pixelData = sourceData;
             compressionCode = 1;
         }
         const result = [];
@@ -161,7 +192,10 @@ export class TIFFFormat {
         // IFD (Image File Directory)
         const ifdStart = result.length;
         // Count number of entries (including metadata)
-        let numEntries = 12; // Base entries (including ExtraSamples)
+        // Grayscale: 10 entries (no ExtraSamples)
+        // RGB: 11 entries (no ExtraSamples)
+        // RGBA: 12 entries (includes ExtraSamples)
+        let numEntries = grayscale ? 10 : (rgb ? 11 : 12);
         if (metadata?.description)
             numEntries++;
         if (metadata?.author)
@@ -179,16 +213,28 @@ export class TIFFFormat {
         // ImageHeight (0x0101)
         this.writeIFDEntry(result, 0x0101, 4, 1, height);
         // BitsPerSample (0x0102) - 8 bits per channel
-        this.writeIFDEntry(result, 0x0102, 3, 4, dataOffset);
-        dataOffset += 8; // 4 x 2-byte values
+        if (grayscale) {
+            // Single value for grayscale
+            this.writeIFDEntry(result, 0x0102, 3, 1, 8);
+        }
+        else if (rgb) {
+            // 3 values for RGB
+            this.writeIFDEntry(result, 0x0102, 3, 3, dataOffset);
+            dataOffset += 6; // 3 x 2-byte values
+        }
+        else {
+            // 4 values for RGBA
+            this.writeIFDEntry(result, 0x0102, 3, 4, dataOffset);
+            dataOffset += 8; // 4 x 2-byte values
+        }
         // Compression (0x0103) - 1 = uncompressed, 5 = LZW
         this.writeIFDEntry(result, 0x0103, 3, 1, compressionCode);
-        // PhotometricInterpretation (0x0106) - 2 = RGB
-        this.writeIFDEntry(result, 0x0106, 3, 1, 2);
+        // PhotometricInterpretation (0x0106) - 1 = BlackIsZero (grayscale), 2 = RGB
+        this.writeIFDEntry(result, 0x0106, 3, 1, grayscale ? 1 : 2);
         // StripOffsets (0x0111)
         this.writeIFDEntry(result, 0x0111, 4, 1, 8);
-        // SamplesPerPixel (0x0115) - 4 (RGBA)
-        this.writeIFDEntry(result, 0x0115, 3, 1, 4);
+        // SamplesPerPixel (0x0115) - 1 for grayscale, 3 for RGB, 4 for RGBA
+        this.writeIFDEntry(result, 0x0115, 3, 1, samplesPerPixel);
         // RowsPerStrip (0x0116)
         this.writeIFDEntry(result, 0x0116, 4, 1, height);
         // StripByteCounts (0x0117)
@@ -201,8 +247,10 @@ export class TIFFFormat {
         const yResOffset = dataOffset;
         this.writeIFDEntry(result, 0x011b, 5, 1, yResOffset);
         dataOffset += 8;
-        // ExtraSamples (0x0152) - 2 = unassociated alpha
-        this.writeIFDEntry(result, 0x0152, 3, 1, 2);
+        // ExtraSamples (0x0152) - 2 = unassociated alpha (only for RGBA)
+        if (!grayscale && !rgb) {
+            this.writeIFDEntry(result, 0x0152, 3, 1, 2);
+        }
         // Optional metadata entries
         if (metadata?.description) {
             const descBytes = new TextEncoder().encode(metadata.description + "\0");
@@ -229,11 +277,18 @@ export class TIFFFormat {
         // Next IFD offset (0 = no more IFDs)
         this.writeUint32LE(result, 0);
         // Write variable-length data
-        // BitsPerSample values (must be written first to match offset calculation)
-        this.writeUint16LE(result, 8);
-        this.writeUint16LE(result, 8);
-        this.writeUint16LE(result, 8);
-        this.writeUint16LE(result, 8);
+        // BitsPerSample values (only for RGB and RGBA, not for grayscale)
+        if (rgb) {
+            this.writeUint16LE(result, 8);
+            this.writeUint16LE(result, 8);
+            this.writeUint16LE(result, 8);
+        }
+        else if (!grayscale) {
+            this.writeUint16LE(result, 8);
+            this.writeUint16LE(result, 8);
+            this.writeUint16LE(result, 8);
+            this.writeUint16LE(result, 8);
+        }
         // XResolution value (rational)
         const dpiX = metadata?.dpiX ?? DEFAULT_DPI;
         this.writeUint32LE(result, dpiX);
@@ -696,14 +751,23 @@ export class TIFFFormat {
         }
         // Check photometric interpretation
         const photometric = this.getIFDValue(data, ifdOffset, 0x0106, isLittleEndian);
-        if (photometric !== 2) {
-            // Only support RGB (photometric = 2)
+        if (photometric !== 0 && photometric !== 1 && photometric !== 2) {
+            // Support: 0 = WhiteIsZero, 1 = BlackIsZero, 2 = RGB
             return null;
         }
         // Get samples per pixel
         const samplesPerPixel = this.getIFDValue(data, ifdOffset, 0x0115, isLittleEndian);
-        if (!samplesPerPixel || (samplesPerPixel !== 3 && samplesPerPixel !== 4)) {
-            // Only support RGB (3) or RGBA (4)
+        // For grayscale (photometric 0 or 1), expect 1 sample per pixel
+        // For RGB, expect 3 or 4 samples per pixel
+        if (!samplesPerPixel) {
+            return null;
+        }
+        if ((photometric === 0 || photometric === 1) && samplesPerPixel !== 1) {
+            // Grayscale requires 1 sample per pixel
+            return null;
+        }
+        if (photometric === 2 && samplesPerPixel !== 3 && samplesPerPixel !== 4) {
+            // RGB requires 3 or 4 samples per pixel
             return null;
         }
         // Get strip offset
@@ -733,17 +797,40 @@ export class TIFFFormat {
         // Convert to RGBA
         const rgba = new Uint8Array(width * height * 4);
         let srcPos = 0;
-        for (let y = 0; y < height; y++) {
-            for (let x = 0; x < width; x++) {
-                const dstIdx = (y * width + x) * 4;
-                if (srcPos + samplesPerPixel > pixelData.length) {
-                    return null; // Not enough data
+        if (photometric === 0 || photometric === 1) {
+            // Grayscale image
+            for (let y = 0; y < height; y++) {
+                for (let x = 0; x < width; x++) {
+                    const dstIdx = (y * width + x) * 4;
+                    if (srcPos >= pixelData.length) {
+                        return null; // Not enough data
+                    }
+                    let gray = pixelData[srcPos++];
+                    // WhiteIsZero (0) means 0=white, 255=black, so invert
+                    if (photometric === 0) {
+                        gray = 255 - gray;
+                    }
+                    rgba[dstIdx] = gray; // R
+                    rgba[dstIdx + 1] = gray; // G
+                    rgba[dstIdx + 2] = gray; // B
+                    rgba[dstIdx + 3] = 255; // A (opaque)
+                }
+            }
+        }
+        else {
+            // RGB/RGBA image
+            for (let y = 0; y < height; y++) {
+                for (let x = 0; x < width; x++) {
+                    const dstIdx = (y * width + x) * 4;
+                    if (srcPos + samplesPerPixel > pixelData.length) {
+                        return null; // Not enough data
+                    }
+                    // TIFF stores RGB(A) in order
+                    rgba[dstIdx] = pixelData[srcPos++]; // R
+                    rgba[dstIdx + 1] = pixelData[srcPos++]; // G
+                    rgba[dstIdx + 2] = pixelData[srcPos++]; // B
+                    rgba[dstIdx + 3] = samplesPerPixel === 4 ? pixelData[srcPos++] : 255; // A
                 }
-                // TIFF stores RGB(A) in order
-                rgba[dstIdx] = pixelData[srcPos++]; // R
-                rgba[dstIdx + 1] = pixelData[srcPos++]; // G
-                rgba[dstIdx + 2] = pixelData[srcPos++]; // B
-                rgba[dstIdx + 3] = samplesPerPixel === 4 ? pixelData[srcPos++] : 255; // A
             }
         }
         return rgba;
@@ -761,14 +848,23 @@ export class TIFFFormat {
         }
         // Check photometric interpretation
         const photometric = this.getIFDValue(data, ifdOffset, 0x0106, isLittleEndian);
-        if (photometric !== 2) {
-            // Only support RGB (photometric = 2)
+        if (photometric !== 0 && photometric !== 1 && photometric !== 2) {
+            // Support: 0 = WhiteIsZero, 1 = BlackIsZero, 2 = RGB
             return null;
         }
         // Get samples per pixel
         const samplesPerPixel = this.getIFDValue(data, ifdOffset, 0x0115, isLittleEndian);
-        if (!samplesPerPixel || (samplesPerPixel !== 3 && samplesPerPixel !== 4)) {
-            // Only support RGB (3) or RGBA (4)
+        // For grayscale (photometric 0 or 1), expect 1 sample per pixel
+        // For RGB, expect 3 or 4 samples per pixel
+        if (!samplesPerPixel) {
+            return null;
+        }
+        if ((photometric === 0 || photometric === 1) && samplesPerPixel !== 1) {
+            // Grayscale requires 1 sample per pixel
+            return null;
+        }
+        if (photometric === 2 && samplesPerPixel !== 3 && samplesPerPixel !== 4) {
+            // RGB requires 3 or 4 samples per pixel
             return null;
         }
         // Get strip offset
@@ -798,17 +894,40 @@ export class TIFFFormat {
         // Convert to RGBA
         const rgba = new Uint8Array(width * height * 4);
         let srcPos = 0;
-        for (let y = 0; y < height; y++) {
-            for (let x = 0; x < width; x++) {
-                const dstIdx = (y * width + x) * 4;
-                if (srcPos + samplesPerPixel > pixelData.length) {
-                    return null; // Not enough data
+        if (photometric === 0 || photometric === 1) {
+            // Grayscale image
+            for (let y = 0; y < height; y++) {
+                for (let x = 0; x < width; x++) {
+                    const dstIdx = (y * width + x) * 4;
+                    if (srcPos >= pixelData.length) {
+                        return null; // Not enough data
+                    }
+                    let gray = pixelData[srcPos++];
+                    // WhiteIsZero (0) means 0=white, 255=black, so invert
+                    if (photometric === 0) {
+                        gray = 255 - gray;
+                    }
+                    rgba[dstIdx] = gray; // R
+                    rgba[dstIdx + 1] = gray; // G
+                    rgba[dstIdx + 2] = gray; // B
+                    rgba[dstIdx + 3] = 255; // A (opaque)
+                }
+            }
+        }
+        else {
+            // RGB/RGBA image
+            for (let y = 0; y < height; y++) {
+                for (let x = 0; x < width; x++) {
+                    const dstIdx = (y * width + x) * 4;
+                    if (srcPos + samplesPerPixel > pixelData.length) {
+                        return null; // Not enough data
+                    }
+                    // TIFF stores RGB(A) in order
+                    rgba[dstIdx] = pixelData[srcPos++]; // R
+                    rgba[dstIdx + 1] = pixelData[srcPos++]; // G
+                    rgba[dstIdx + 2] = pixelData[srcPos++]; // B
+                    rgba[dstIdx + 3] = samplesPerPixel === 4 ? pixelData[srcPos++] : 255; // A
                 }
-                // TIFF stores RGB(A) in order
-                rgba[dstIdx] = pixelData[srcPos++]; // R
-                rgba[dstIdx + 1] = pixelData[srcPos++]; // G
-                rgba[dstIdx + 2] = pixelData[srcPos++]; // B
-                rgba[dstIdx + 3] = samplesPerPixel === 4 ? pixelData[srcPos++] : 255; // A
             }
         }
         return rgba;

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

@@ -27,7 +27,6 @@ export declare class WebPFormat implements ImageFormat {
      * @returns Encoded WebP image bytes
      */
     encode(imageData: ImageData, options?: WebPEncodeOptions): Promise<Uint8Array>;
-    private readUint32LE;
     private readUint24LE;
     private decodeUsingRuntime;
     private parseEXIF;

package/esm/src/formats/webp.js

@@ -1,4 +1,5 @@
 import { validateImageDimensions } from "../utils/security.js";
+import { readUint32LE } from "../utils/byte_utils.js";
 // Default quality for WebP encoding when not specified
 const DEFAULT_WEBP_QUALITY = 90;
 /**
@@ -52,7 +53,7 @@ export class WebPFormat {
         // Read all chunks to extract metadata
         while (pos + 8 <= data.length) {
             const chunkType = String.fromCharCode(data[pos], data[pos + 1], data[pos + 2], data[pos + 3]);
-            const chunkSize = this.readUint32LE(data, pos + 4);
+            const chunkSize = readUint32LE(data, pos + 4);
             pos += 8;
             // Stop if we've gone past the end
             if (pos + chunkSize > data.length)
@@ -74,7 +75,7 @@ export class WebPFormat {
             else if (chunkType === "VP8L") {
                 // Lossless format - extract dimensions
                 if (chunkData.length >= 5 && chunkData[0] === 0x2f) {
-                    const bits = this.readUint32LE(chunkData, 1);
+                    const bits = readUint32LE(chunkData, 1);
                     width = (bits & 0x3fff) + 1;
                     height = ((bits >> 14) & 0x3fff) + 1;
                 }
@@ -166,10 +167,6 @@ export class WebPFormat {
         }
         return encoded;
     }
-    readUint32LE(data, offset) {
-        return data[offset] | (data[offset + 1] << 8) |
-            (data[offset + 2] << 16) | (data[offset + 3] << 24);
-    }
     readUint24LE(data, offset) {
         return data[offset] | (data[offset + 1] << 8) | (data[offset + 2] << 16);
     }
@@ -306,7 +303,7 @@ export class WebPFormat {
         let pos = 12;
         while (pos + 8 <= webpData.length) {
             const chunkType = String.fromCharCode(webpData[pos], webpData[pos + 1], webpData[pos + 2], webpData[pos + 3]);
-            const chunkSize = this.readUint32LE(webpData, pos + 4);
+            const chunkSize = readUint32LE(webpData, pos + 4);
             // Don't copy existing EXIF/XMP chunks (we'll add new ones)
             if (chunkType !== "EXIF" && chunkType !== "XMP ") {
                 const chunkEnd = pos + 8 + chunkSize + (chunkSize % 2);

package/esm/src/image.d.ts

@@ -207,6 +207,36 @@ export declare class Image {
      * @returns This image instance for chaining
      */
     grayscale(): this;
+    /**
+     * Apply sepia tone effect to the image
+     * @returns This image instance for chaining
+     */
+    sepia(): this;
+    /**
+     * Apply box blur filter to the image
+     * @param radius Blur radius (default: 1)
+     * @returns This image instance for chaining
+     */
+    blur(radius?: number): this;
+    /**
+     * Apply Gaussian blur filter to the image
+     * @param radius Blur radius (default: 1)
+     * @param sigma Optional standard deviation (if not provided, calculated from radius)
+     * @returns This image instance for chaining
+     */
+    gaussianBlur(radius?: number, sigma?: number): this;
+    /**
+     * Apply sharpen filter to the image
+     * @param amount Sharpening amount (0-1, default: 0.5)
+     * @returns This image instance for chaining
+     */
+    sharpen(amount?: number): this;
+    /**
+     * Apply median filter to reduce noise
+     * @param radius Filter radius (default: 1)
+     * @returns This image instance for chaining
+     */
+    medianFilter(radius?: number): this;
     /**
      * Fill a rectangular region with a color
      * @param x Starting X position