cross-image 0.1.5 → 0.2.1

package/esm/src/formats/png_base.js

@@ -0,0 +1,487 @@
+// Constants for unit conversions
+const INCHES_PER_METER = 39.3701;
+/**
+ * Base class for PNG and APNG format handlers
+ * Contains shared utility methods for PNG chunk manipulation and metadata parsing
+ */
+export class PNGBase {
+    /**
+     * Read a 32-bit unsigned integer (big-endian)
+     */
+    readUint32(data, offset) {
+        return (data[offset] << 24) | (data[offset + 1] << 16) |
+            (data[offset + 2] << 8) | data[offset + 3];
+    }
+    /**
+     * Read a 16-bit unsigned integer (big-endian)
+     */
+    readUint16(data, offset) {
+        return (data[offset] << 8) | data[offset + 1];
+    }
+    /**
+     * Write a 32-bit unsigned integer (big-endian)
+     */
+    writeUint32(data, offset, value) {
+        data[offset] = (value >>> 24) & 0xff;
+        data[offset + 1] = (value >>> 16) & 0xff;
+        data[offset + 2] = (value >>> 8) & 0xff;
+        data[offset + 3] = value & 0xff;
+    }
+    /**
+     * Write a 16-bit unsigned integer (big-endian)
+     */
+    writeUint16(data, offset, value) {
+        data[offset] = (value >>> 8) & 0xff;
+        data[offset + 1] = value & 0xff;
+    }
+    /**
+     * Decompress PNG data using deflate
+     */
+    async inflate(data) {
+        const stream = new Response(data).body
+            .pipeThrough(new DecompressionStream("deflate"));
+        const decompressed = await new Response(stream).arrayBuffer();
+        return new Uint8Array(decompressed);
+    }
+    /**
+     * Compress PNG data using deflate
+     */
+    async deflate(data) {
+        const stream = new Response(data).body
+            .pipeThrough(new CompressionStream("deflate"));
+        const compressed = await new Response(stream).arrayBuffer();
+        return new Uint8Array(compressed);
+    }
+    /**
+     * Unfilter PNG scanlines and convert to RGBA
+     */
+    unfilterAndConvert(data, width, height, bitDepth, colorType) {
+        const rgba = new Uint8Array(width * height * 4);
+        const bytesPerPixel = this.getBytesPerPixel(colorType, bitDepth);
+        const scanlineLength = width * bytesPerPixel;
+        let dataPos = 0;
+        const scanlines = [];
+        for (let y = 0; y < height; y++) {
+            const filterType = data[dataPos++];
+            const scanline = new Uint8Array(scanlineLength);
+            for (let x = 0; x < scanlineLength; x++) {
+                scanline[x] = data[dataPos++];
+            }
+            this.unfilterScanline(scanline, y > 0 ? scanlines[y - 1] : null, filterType, bytesPerPixel);
+            scanlines.push(scanline);
+            // Convert to RGBA
+            for (let x = 0; x < width; x++) {
+                const outIdx = (y * width + x) * 4;
+                if (colorType === 6) { // RGBA
+                    rgba[outIdx] = scanline[x * 4];
+                    rgba[outIdx + 1] = scanline[x * 4 + 1];
+                    rgba[outIdx + 2] = scanline[x * 4 + 2];
+                    rgba[outIdx + 3] = scanline[x * 4 + 3];
+                }
+                else if (colorType === 2) { // RGB
+                    rgba[outIdx] = scanline[x * 3];
+                    rgba[outIdx + 1] = scanline[x * 3 + 1];
+                    rgba[outIdx + 2] = scanline[x * 3 + 2];
+                    rgba[outIdx + 3] = 255;
+                }
+                else if (colorType === 0) { // Grayscale
+                    const gray = scanline[x];
+                    rgba[outIdx] = gray;
+                    rgba[outIdx + 1] = gray;
+                    rgba[outIdx + 2] = gray;
+                    rgba[outIdx + 3] = 255;
+                }
+                else {
+                    throw new Error(`Unsupported PNG color type: ${colorType}`);
+                }
+            }
+        }
+        return rgba;
+    }
+    /**
+     * Unfilter a single PNG scanline
+     */
+    unfilterScanline(scanline, prevLine, filterType, bytesPerPixel) {
+        for (let x = 0; x < scanline.length; x++) {
+            const left = x >= bytesPerPixel ? scanline[x - bytesPerPixel] : 0;
+            const above = prevLine ? prevLine[x] : 0;
+            const upperLeft = (x >= bytesPerPixel && prevLine)
+                ? prevLine[x - bytesPerPixel]
+                : 0;
+            switch (filterType) {
+                case 0: // None
+                    break;
+                case 1: // Sub
+                    scanline[x] = (scanline[x] + left) & 0xff;
+                    break;
+                case 2: // Up
+                    scanline[x] = (scanline[x] + above) & 0xff;
+                    break;
+                case 3: // Average
+                    scanline[x] = (scanline[x] + Math.floor((left + above) / 2)) & 0xff;
+                    break;
+                case 4: // Paeth
+                    scanline[x] =
+                        (scanline[x] + this.paethPredictor(left, above, upperLeft)) & 0xff;
+                    break;
+            }
+        }
+    }
+    /**
+     * Paeth predictor for PNG filtering
+     */
+    paethPredictor(a, b, c) {
+        const p = a + b - c;
+        const pa = Math.abs(p - a);
+        const pb = Math.abs(p - b);
+        const pc = Math.abs(p - c);
+        if (pa <= pb && pa <= pc)
+            return a;
+        if (pb <= pc)
+            return b;
+        return c;
+    }
+    /**
+     * Filter PNG data for encoding (using filter type 0 - None)
+     */
+    filterData(data, width, height) {
+        // Use filter type 0 (None) for simplicity
+        const filtered = new Uint8Array(height * (1 + width * 4));
+        let pos = 0;
+        for (let y = 0; y < height; y++) {
+            filtered[pos++] = 0; // Filter type: None
+            for (let x = 0; x < width * 4; x++) {
+                filtered[pos++] = data[y * width * 4 + x];
+            }
+        }
+        return filtered;
+    }
+    /**
+     * Get bytes per pixel for a given color type and bit depth
+     */
+    getBytesPerPixel(colorType, bitDepth) {
+        const bitsPerPixel = this.getBitsPerPixel(colorType, bitDepth);
+        return Math.ceil(bitsPerPixel / 8);
+    }
+    /**
+     * Get bits per pixel for a given color type and bit depth
+     */
+    getBitsPerPixel(colorType, bitDepth) {
+        switch (colorType) {
+            case 0: // Grayscale
+                return bitDepth;
+            case 2: // RGB
+                return bitDepth * 3;
+            case 3: // Palette
+                return bitDepth;
+            case 4: // Grayscale + Alpha
+                return bitDepth * 2;
+            case 6: // RGBA
+                return bitDepth * 4;
+            default:
+                throw new Error(`Unknown color type: ${colorType}`);
+        }
+    }
+    /**
+     * Create a PNG chunk with length, type, data, and CRC
+     */
+    createChunk(type, data) {
+        const chunk = new Uint8Array(12 + data.length);
+        this.writeUint32(chunk, 0, data.length);
+        chunk[4] = type.charCodeAt(0);
+        chunk[5] = type.charCodeAt(1);
+        chunk[6] = type.charCodeAt(2);
+        chunk[7] = type.charCodeAt(3);
+        chunk.set(data, 8);
+        const crc = this.crc32(chunk.slice(4, 8 + data.length));
+        this.writeUint32(chunk, 8 + data.length, crc);
+        return chunk;
+    }
+    /**
+     * Calculate CRC32 checksum
+     */
+    crc32(data) {
+        let crc = 0xffffffff;
+        for (let i = 0; i < data.length; i++) {
+            crc ^= data[i];
+            for (let j = 0; j < 8; j++) {
+                crc = (crc & 1) ? (crc >>> 1) ^ 0xedb88320 : crc >>> 1;
+            }
+        }
+        return (crc ^ 0xffffffff) >>> 0;
+    }
+    // Metadata parsing methods
+    /**
+     * Parse pHYs (physical pixel dimensions) chunk
+     */
+    parsePhysChunk(data, metadata, width, height) {
+        if (data.length < 9)
+            return;
+        const pixelsPerUnitX = this.readUint32(data, 0);
+        const pixelsPerUnitY = this.readUint32(data, 4);
+        const unit = data[8];
+        if (unit === 1 && pixelsPerUnitX > 0 && pixelsPerUnitY > 0) {
+            metadata.dpiX = Math.round(pixelsPerUnitX / INCHES_PER_METER);
+            metadata.dpiY = Math.round(pixelsPerUnitY / INCHES_PER_METER);
+            metadata.physicalWidth = width / metadata.dpiX;
+            metadata.physicalHeight = height / metadata.dpiY;
+        }
+    }
+    /**
+     * Parse tEXt (text) chunk
+     */
+    parseTextChunk(data, metadata) {
+        const nullIndex = data.indexOf(0);
+        if (nullIndex === -1)
+            return;
+        const keyword = new TextDecoder().decode(data.slice(0, nullIndex));
+        const text = new TextDecoder().decode(data.slice(nullIndex + 1));
+        switch (keyword.toLowerCase()) {
+            case "title":
+                metadata.title = text;
+                break;
+            case "author":
+                metadata.author = text;
+                break;
+            case "description":
+                metadata.description = text;
+                break;
+            case "copyright":
+                metadata.copyright = text;
+                break;
+            default:
+                if (!metadata.custom)
+                    metadata.custom = {};
+                metadata.custom[keyword] = text;
+        }
+    }
+    /**
+     * Parse iTXt (international text) chunk
+     */
+    parseITxtChunk(data, metadata) {
+        let pos = 0;
+        const nullIndex = data.indexOf(0, pos);
+        if (nullIndex === -1 || pos >= data.length)
+            return;
+        const keyword = new TextDecoder().decode(data.slice(pos, nullIndex));
+        pos = nullIndex + 1;
+        if (pos + 2 > data.length)
+            return;
+        pos += 2; // Skip compression flag and method
+        const languageNullIndex = data.indexOf(0, pos);
+        if (languageNullIndex === -1 || pos >= data.length)
+            return;
+        pos = languageNullIndex + 1;
+        const translatedKeywordNullIndex = data.indexOf(0, pos);
+        if (translatedKeywordNullIndex === -1 || pos >= data.length)
+            return;
+        pos = translatedKeywordNullIndex + 1;
+        if (pos >= data.length)
+            return;
+        const text = new TextDecoder("utf-8").decode(data.slice(pos));
+        switch (keyword.toLowerCase()) {
+            case "title":
+                metadata.title = text;
+                break;
+            case "author":
+                metadata.author = text;
+                break;
+            case "description":
+                metadata.description = text;
+                break;
+            case "copyright":
+                metadata.copyright = text;
+                break;
+            default:
+                if (!metadata.custom)
+                    metadata.custom = {};
+                metadata.custom[keyword] = text;
+        }
+    }
+    /**
+     * Parse eXIf (EXIF) chunk
+     */
+    parseExifChunk(data, metadata) {
+        if (data.length < 8)
+            return;
+        try {
+            const byteOrder = String.fromCharCode(data[0], data[1]);
+            const littleEndian = byteOrder === "II";
+            const ifd0Offset = littleEndian
+                ? data[4] | (data[5] << 8) | (data[6] << 16) | (data[7] << 24)
+                : (data[4] << 24) | (data[5] << 16) | (data[6] << 8) | data[7];
+            if (ifd0Offset + 2 > data.length)
+                return;
+            const numEntries = littleEndian
+                ? data[ifd0Offset] | (data[ifd0Offset + 1] << 8)
+                : (data[ifd0Offset] << 8) | data[ifd0Offset + 1];
+            for (let i = 0; i < numEntries; i++) {
+                const entryOffset = ifd0Offset + 2 + i * 12;
+                if (entryOffset + 12 > data.length)
+                    break;
+                const tag = littleEndian
+                    ? data[entryOffset] | (data[entryOffset + 1] << 8)
+                    : (data[entryOffset] << 8) | data[entryOffset + 1];
+                if (tag === 0x0132) {
+                    const valueOffset = littleEndian
+                        ? data[entryOffset + 8] | (data[entryOffset + 9] << 8) |
+                            (data[entryOffset + 10] << 16) | (data[entryOffset + 11] << 24)
+                        : (data[entryOffset + 8] << 24) | (data[entryOffset + 9] << 16) |
+                            (data[entryOffset + 10] << 8) | data[entryOffset + 11];
+                    if (valueOffset < data.length) {
+                        const nullIndex = data.indexOf(0, valueOffset);
+                        if (nullIndex > valueOffset) {
+                            const dateStr = new TextDecoder().decode(data.slice(valueOffset, nullIndex));
+                            const match = dateStr.match(/^(\d{4}):(\d{2}):(\d{2}) (\d{2}):(\d{2}):(\d{2})$/);
+                            if (match) {
+                                metadata.creationDate = new Date(parseInt(match[1]), parseInt(match[2]) - 1, parseInt(match[3]), parseInt(match[4]), parseInt(match[5]), parseInt(match[6]));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (_e) {
+            // Ignore EXIF parsing errors
+        }
+    }
+    /**
+     * Create pHYs (physical pixel dimensions) chunk
+     */
+    createPhysChunk(metadata) {
+        const chunk = new Uint8Array(9);
+        const dpiX = metadata.dpiX ?? 72;
+        const dpiY = metadata.dpiY ?? 72;
+        const pixelsPerMeterX = Math.round(dpiX * INCHES_PER_METER);
+        const pixelsPerMeterY = Math.round(dpiY * INCHES_PER_METER);
+        this.writeUint32(chunk, 0, pixelsPerMeterX);
+        this.writeUint32(chunk, 4, pixelsPerMeterY);
+        chunk[8] = 1;
+        return chunk;
+    }
+    /**
+     * Create tEXt (text) chunk
+     */
+    createTextChunk(keyword, text) {
+        const keywordBytes = new TextEncoder().encode(keyword);
+        const textBytes = new TextEncoder().encode(text);
+        const chunk = new Uint8Array(keywordBytes.length + 1 + textBytes.length);
+        chunk.set(keywordBytes, 0);
+        chunk[keywordBytes.length] = 0;
+        chunk.set(textBytes, keywordBytes.length + 1);
+        return chunk;
+    }
+    /**
+     * Create eXIf (EXIF) chunk
+     */
+    createExifChunk(metadata) {
+        const entries = [];
+        if (metadata.creationDate) {
+            const date = metadata.creationDate;
+            const dateStr = `${date.getFullYear()}:${String(date.getMonth() + 1).padStart(2, "0")}:${String(date.getDate()).padStart(2, "0")} ${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}:${String(date.getSeconds()).padStart(2, "0")}\0`;
+            entries.push({
+                tag: 0x0132,
+                type: 2,
+                value: new TextEncoder().encode(dateStr),
+            });
+        }
+        if (entries.length === 0)
+            return null;
+        const exif = [];
+        exif.push(0x49, 0x49); // "II"
+        exif.push(0x2a, 0x00); // 42
+        exif.push(0x08, 0x00, 0x00, 0x00);
+        exif.push(entries.length & 0xff, (entries.length >> 8) & 0xff);
+        let dataOffset = 8 + 2 + entries.length * 12 + 4;
+        for (const entry of entries) {
+            exif.push(entry.tag & 0xff, (entry.tag >> 8) & 0xff);
+            exif.push(entry.type & 0xff, (entry.type >> 8) & 0xff);
+            const count = entry.value.length;
+            exif.push(count & 0xff, (count >> 8) & 0xff, (count >> 16) & 0xff, (count >> 24) & 0xff);
+            if (entry.value.length <= 4) {
+                for (let i = 0; i < 4; i++) {
+                    exif.push(i < entry.value.length ? entry.value[i] : 0);
+                }
+            }
+            else {
+                exif.push(dataOffset & 0xff, (dataOffset >> 8) & 0xff, (dataOffset >> 16) & 0xff, (dataOffset >> 24) & 0xff);
+                dataOffset += entry.value.length;
+            }
+        }
+        exif.push(0x00, 0x00, 0x00, 0x00);
+        for (const entry of entries) {
+            if (entry.value.length > 4) {
+                for (const byte of entry.value) {
+                    exif.push(byte);
+                }
+            }
+        }
+        return new Uint8Array(exif);
+    }
+    /**
+     * Concatenate multiple byte arrays into a single Uint8Array
+     */
+    concatenateChunks(chunks) {
+        const totalLength = chunks.reduce((sum, chunk) => sum + chunk.data.length, 0);
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+            result.set(chunk.data, offset);
+            offset += chunk.data.length;
+        }
+        return result;
+    }
+    /**
+     * Concatenate multiple Uint8Arrays into a single Uint8Array
+     */
+    concatenateArrays(arrays) {
+        const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const arr of arrays) {
+            result.set(arr, offset);
+            offset += arr.length;
+        }
+        return result;
+    }
+    /**
+     * Add metadata chunks to the chunks array
+     * Shared method to avoid duplication between PNG and APNG encoding
+     */
+    addMetadataChunks(chunks, metadata) {
+        if (!metadata)
+            return;
+        // Add pHYs chunk for DPI information
+        if (metadata.dpiX !== undefined || metadata.dpiY !== undefined) {
+            const physChunk = this.createPhysChunk(metadata);
+            chunks.push(this.createChunk("pHYs", physChunk));
+        }
+        // Add tEXt chunks for standard metadata
+        if (metadata.title !== undefined) {
+            chunks.push(this.createChunk("tEXt", this.createTextChunk("Title", metadata.title)));
+        }
+        if (metadata.author !== undefined) {
+            chunks.push(this.createChunk("tEXt", this.createTextChunk("Author", metadata.author)));
+        }
+        if (metadata.description !== undefined) {
+            chunks.push(this.createChunk("tEXt", this.createTextChunk("Description", metadata.description)));
+        }
+        if (metadata.copyright !== undefined) {
+            chunks.push(this.createChunk("tEXt", this.createTextChunk("Copyright", metadata.copyright)));
+        }
+        // Add custom metadata fields
+        if (metadata.custom) {
+            for (const [key, value] of Object.entries(metadata.custom)) {
+                chunks.push(this.createChunk("tEXt", this.createTextChunk(key, String(value))));
+            }
+        }
+        // Add EXIF chunk for GPS data and creation date
+        if (metadata.latitude !== undefined || metadata.longitude !== undefined ||
+            metadata.creationDate !== undefined) {
+            const exifChunk = this.createExifChunk(metadata);
+            if (exifChunk) {
+                chunks.push(this.createChunk("eXIf", exifChunk));
+            }
+        }
+    }
+}

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

@@ -15,9 +15,9 @@ export interface TIFFEncodeOptions {
  */
 export declare class TIFFFormat implements ImageFormat {
     /** Format name identifier */
-    readonly name = "tiff";
+    readonly name: string;
     /** MIME type for TIFF images */
-    readonly mimeType = "image/tiff";
+    readonly mimeType: string;
     /**
      * Check if this format supports multiple frames (pages)
      * @returns true for TIFF format
@@ -52,11 +52,11 @@ export declare class TIFFFormat implements ImageFormat {
      * Extract metadata from an IFD
      */
     private extractMetadataFromIFD;
-    private readUint16;
-    private readUint32;
-    private writeUint16LE;
-    private writeUint32LE;
-    private writeIFDEntry;
+    protected readUint16(data: Uint8Array, offset: number, isLittleEndian: boolean): number;
+    protected readUint32(data: Uint8Array, offset: number, isLittleEndian: boolean): number;
+    protected writeUint16LE(result: number[], value: number): void;
+    protected writeUint32LE(result: number[], value: number): void;
+    protected writeIFDEntry(result: number[], tag: number, type: number, count: number, valueOrOffset: number): void;
     private getIFDValue;
     private decodeUsingRuntime;
     private readString;

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

@@ -127,6 +127,17 @@ export declare class Image {
      * @returns Image instance
      */
     static fromRGBA(width: number, height: number, data: Uint8Array): Image;
+    /**
+     * Create a blank image with the specified dimensions and color
+     * @param width Image width
+     * @param height Image height
+     * @param r Red component (0-255, default: 0)
+     * @param g Green component (0-255, default: 0)
+     * @param b Blue component (0-255, default: 0)
+     * @param a Alpha component (0-255, default: 255)
+     * @returns Image instance
+     */
+    static create(width: number, height: number, r?: number, g?: number, b?: number, a?: number): Image;
     /**
      * Resize the image
      * @param options Resize options
@@ -153,5 +164,93 @@ export declare class Image {
      * @returns New image instance with copied data and metadata
      */
     clone(): Image;
+    /**
+     * Composite another image on top of this image at the specified position
+     * @param overlay Image to place on top
+     * @param x X position (can be negative)
+     * @param y Y position (can be negative)
+     * @param opacity Opacity of overlay (0-1, default: 1)
+     * @returns This image instance for chaining
+     */
+    composite(overlay: Image, x: number, y: number, opacity?: number): this;
+    /**
+     * Adjust brightness of the image
+     * @param amount Brightness adjustment (-1 to 1, where 0 is no change)
+     * @returns This image instance for chaining
+     */
+    brightness(amount: number): this;
+    /**
+     * Adjust contrast of the image
+     * @param amount Contrast adjustment (-1 to 1, where 0 is no change)
+     * @returns This image instance for chaining
+     */
+    contrast(amount: number): this;
+    /**
+     * Adjust exposure of the image
+     * @param amount Exposure adjustment in stops (-3 to 3, where 0 is no change)
+     * @returns This image instance for chaining
+     */
+    exposure(amount: number): this;
+    /**
+     * Adjust saturation of the image
+     * @param amount Saturation adjustment (-1 to 1, where 0 is no change)
+     * @returns This image instance for chaining
+     */
+    saturation(amount: number): this;
+    /**
+     * Invert colors of the image
+     * @returns This image instance for chaining
+     */
+    invert(): this;
+    /**
+     * Convert the image to grayscale
+     * @returns This image instance for chaining
+     */
+    grayscale(): this;
+    /**
+     * Fill a rectangular region with a color
+     * @param x Starting X position
+     * @param y Starting Y position
+     * @param width Width of the fill region
+     * @param height 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, default: 255)
+     * @returns This image instance for chaining
+     */
+    fillRect(x: number, y: number, width: number, height: number, r: number, g: number, b: number, a?: number): this;
+    /**
+     * Crop the image to a rectangular region
+     * @param x Starting X position
+     * @param y Starting Y position
+     * @param width Width of the crop region
+     * @param height Height of the crop region
+     * @returns This image instance for chaining
+     */
+    crop(x: number, y: number, width: number, height: number): this;
+    /**
+     * Get the pixel color at the specified position
+     * @param x X position
+     * @param y Y position
+     * @returns Object with r, g, b, a components (0-255) or undefined if out of bounds
+     */
+    getPixel(x: number, y: number): {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    } | undefined;
+    /**
+     * Set the pixel color at the specified position
+     * @param x X position
+     * @param y Y position
+     * @param r Red component (0-255)
+     * @param g Green component (0-255)
+     * @param b Blue component (0-255)
+     * @param a Alpha component (0-255, default: 255)
+     * @returns This image instance for chaining
+     */
+    setPixel(x: number, y: number, r: number, g: number, b: number, a?: number): this;
 }
 //# sourceMappingURL=image.d.ts.map