cross-image 0.1.5 → 0.2.0

package/script/src/formats/pcx.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PCXFormat = void 0;
+/**
+ * PCX format handler
+ * Implements PCX decoder and encoder
+ */
+class PCXFormat {
+    constructor() {
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "pcx"
+        });
+        Object.defineProperty(this, "mimeType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "image/x-pcx"
+        });
+    }
+    canDecode(data) {
+        // PCX header check
+        // Byte 0: Manufacturer (must be 0x0A)
+        // Byte 1: Version (0, 2, 3, 4, 5)
+        // Byte 2: Encoding (1 = RLE)
+        return data.length >= 128 &&
+            data[0] === 0x0A &&
+            (data[1] === 0 || data[1] === 2 || data[1] === 3 || data[1] === 4 ||
+                data[1] === 5) &&
+            data[2] === 1;
+    }
+    decode(data) {
+        if (!this.canDecode(data)) {
+            return Promise.reject(new Error("Invalid PCX data"));
+        }
+        const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        // Parse header
+        // const manufacturer = view.getUint8(0);
+        // const version = view.getUint8(1);
+        // const encoding = view.getUint8(2);
+        const bitsPerPixel = view.getUint8(3);
+        const xMin = view.getUint16(4, true);
+        const yMin = view.getUint16(6, true);
+        const xMax = view.getUint16(8, true);
+        const yMax = view.getUint16(10, true);
+        // const hDpi = view.getUint16(12, true);
+        // const vDpi = view.getUint16(14, true);
+        // const colormap = data.slice(16, 64);
+        // const reserved = view.getUint8(64);
+        const nPlanes = view.getUint8(65);
+        const bytesPerLine = view.getUint16(66, true);
+        // const paletteInfo = view.getUint16(68, true);
+        // const hScreenSize = view.getUint16(70, true);
+        // const vScreenSize = view.getUint16(72, true);
+        const width = xMax - xMin + 1;
+        const height = yMax - yMin + 1;
+        if (width <= 0 || height <= 0) {
+            return Promise.reject(new Error("Invalid PCX dimensions"));
+        }
+        // Decode RLE data
+        let offset = 128;
+        const scanlineLength = nPlanes * bytesPerLine;
+        const rawData = new Uint8Array(height * scanlineLength);
+        let ptr = 0;
+        // Decode all scanlines
+        for (let y = 0; y < height; y++) {
+            let x = 0;
+            while (x < scanlineLength) {
+                if (offset >= data.length)
+                    break;
+                let byte = data[offset++];
+                let count = 1;
+                if ((byte & 0xC0) === 0xC0) {
+                    count = byte & 0x3F;
+                    if (offset >= data.length)
+                        break;
+                    byte = data[offset++];
+                }
+                for (let i = 0; i < count; i++) {
+                    if (ptr < rawData.length) {
+                        rawData[ptr++] = byte;
+                    }
+                    x++;
+                }
+            }
+        }
+        const rgba = new Uint8Array(width * height * 4);
+        if (nPlanes === 3 && bitsPerPixel === 8) {
+            // 24-bit RGB
+            for (let y = 0; y < height; y++) {
+                for (let x = 0; x < width; x++) {
+                    const r = rawData[y * scanlineLength + x];
+                    const g = rawData[y * scanlineLength + bytesPerLine + x];
+                    const b = rawData[y * scanlineLength + 2 * bytesPerLine + x];
+                    const idx = (y * width + x) * 4;
+                    rgba[idx] = r;
+                    rgba[idx + 1] = g;
+                    rgba[idx + 2] = b;
+                    rgba[idx + 3] = 255;
+                }
+            }
+        }
+        else if (nPlanes === 1 && bitsPerPixel === 8) {
+            // 8-bit palette
+            // Check for palette at end of file
+            let palette;
+            if (data[data.length - 769] === 0x0C) {
+                palette = data.slice(data.length - 768);
+            }
+            else {
+                // Fallback or error?
+                // Some old PCX might use header palette but that's only 16 colors.
+                // For 8bpp we expect 256 color palette at end.
+                return Promise.reject(new Error("Missing PCX palette"));
+            }
+            for (let y = 0; y < height; y++) {
+                for (let x = 0; x < width; x++) {
+                    const colorIndex = rawData[y * scanlineLength + x];
+                    const idx = (y * width + x) * 4;
+                    rgba[idx] = palette[colorIndex * 3];
+                    rgba[idx + 1] = palette[colorIndex * 3 + 1];
+                    rgba[idx + 2] = palette[colorIndex * 3 + 2];
+                    rgba[idx + 3] = 255;
+                }
+            }
+        }
+        else {
+            // Unsupported PCX format (e.g. 1-bit, 4-bit)
+            // For now only supporting 24-bit and 8-bit
+            return Promise.reject(new Error("Unsupported PCX format"));
+        }
+        return Promise.resolve({
+            width,
+            height,
+            data: rgba,
+        });
+    }
+    encode(image) {
+        const width = image.width;
+        const height = image.height;
+        const data = image.data;
+        // We will encode as 24-bit RGB (3 planes)
+        const header = new Uint8Array(128);
+        const view = new DataView(header.buffer);
+        view.setUint8(0, 0x0A); // Manufacturer
+        view.setUint8(1, 5); // Version 3.0+
+        view.setUint8(2, 1); // Encoding RLE
+        view.setUint8(3, 8); // Bits per pixel (8 per plane)
+        view.setUint16(4, 0, true); // XMin
+        view.setUint16(6, 0, true); // YMin
+        view.setUint16(8, width - 1, true); // XMax
+        view.setUint16(10, height - 1, true); // YMax
+        view.setUint16(12, 72, true); // HDpi
+        view.setUint16(14, 72, true); // VDpi
+        view.setUint8(65, 3); // NPlanes (3 for RGB)
+        view.setUint16(66, width + (width % 2), true); // BytesPerLine (must be even)
+        view.setUint16(68, 1, true); // PaletteInfo (Color/BW)
+        const bytesPerLine = width + (width % 2);
+        const scanlineLength = bytesPerLine * 3;
+        const rleData = [];
+        // Helper to write RLE
+        const writeRLE = (byte, count) => {
+            if ((byte & 0xC0) === 0xC0 || count > 1) {
+                rleData.push(0xC0 | count);
+                rleData.push(byte);
+            }
+            else {
+                rleData.push(byte);
+            }
+        };
+        for (let y = 0; y < height; y++) {
+            // Prepare scanline planes
+            const lineR = new Uint8Array(bytesPerLine);
+            const lineG = new Uint8Array(bytesPerLine);
+            const lineB = new Uint8Array(bytesPerLine);
+            for (let x = 0; x < width; x++) {
+                const idx = (y * width + x) * 4;
+                lineR[x] = data[idx];
+                lineG[x] = data[idx + 1];
+                lineB[x] = data[idx + 2];
+            }
+            // Compress each plane
+            for (const plane of [lineR, lineG, lineB]) {
+                let currentByte = plane[0];
+                let runLength = 1;
+                for (let x = 1; x < bytesPerLine; x++) {
+                    const byte = plane[x];
+                    if (byte === currentByte && runLength < 63) {
+                        runLength++;
+                    }
+                    else {
+                        writeRLE(currentByte, runLength);
+                        currentByte = byte;
+                        runLength = 1;
+                    }
+                }
+                writeRLE(currentByte, runLength);
+            }
+        }
+        const result = new Uint8Array(header.length + rleData.length);
+        result.set(header);
+        result.set(rleData, header.length);
+        return Promise.resolve(result);
+    }
+}
+exports.PCXFormat = PCXFormat;

package/script/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/script/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

package/script/src/image.js

@@ -2,13 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Image = void 0;
 const resize_js_1 = require("./utils/resize.js");
+const image_processing_js_1 = require("./utils/image_processing.js");
 const png_js_1 = require("./formats/png.js");
 const jpeg_js_1 = require("./formats/jpeg.js");
 const webp_js_1 = require("./formats/webp.js");
 const gif_js_1 = require("./formats/gif.js");
 const tiff_js_1 = require("./formats/tiff.js");
 const bmp_js_1 = require("./formats/bmp.js");
-const raw_js_1 = require("./formats/raw.js");
+const dng_js_1 = require("./formats/dng.js");
+const pam_js_1 = require("./formats/pam.js");
+const pcx_js_1 = require("./formats/pcx.js");
 const ascii_js_1 = require("./formats/ascii.js");
 const security_js_1 = require("./utils/security.js");
 /**
@@ -265,6 +268,31 @@ class Image {
         image.imageData = { width, height, data: new Uint8Array(data) };
         return 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, height, r = 0, g = 0, b = 0, a = 255) {
+        // Validate dimensions for security (prevent integer overflow and heap exhaustion)
+        (0, security_js_1.validateImageDimensions)(width, height);
+        const data = new Uint8Array(width * height * 4);
+        // Fill with the specified color
+        for (let i = 0; i < data.length; i += 4) {
+            data[i] = r;
+            data[i + 1] = g;
+            data[i + 2] = b;
+            data[i + 3] = a;
+        }
+        const image = new Image();
+        image.imageData = { width, height, data };
+        return image;
+    }
     /**
      * Resize the image
      * @param options Resize options
@@ -351,6 +379,174 @@ class Image {
         };
         return 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, x, y, opacity = 1) {
+        if (!this.imageData)
+            throw new Error("No image loaded");
+        if (!overlay.imageData)
+            throw new Error("Overlay has no image loaded");
+        this.imageData.data = (0, image_processing_js_1.composite)(this.imageData.data, this.imageData.width, this.imageData.height, overlay.imageData.data, overlay.imageData.width, overlay.imageData.height, x, y, opacity);
+        return 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) {
+        if (!this.imageData)
+            throw new Error("No image loaded");
+        this.imageData.data = (0, image_processing_js_1.adjustBrightness)(this.imageData.data, amount);
+        return 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) {
+        if (!this.imageData)
+            throw new Error("No image loaded");
+        this.imageData.data = (0, image_processing_js_1.adjustContrast)(this.imageData.data, amount);
+        return 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) {
+        if (!this.imageData)
+            throw new Error("No image loaded");
+        this.imageData.data = (0, image_processing_js_1.adjustExposure)(this.imageData.data, amount);
+        return 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) {
+        if (!this.imageData)
+            throw new Error("No image loaded");
+        this.imageData.data = (0, image_processing_js_1.adjustSaturation)(this.imageData.data, amount);
+        return this;
+    }
+    /**
+     * Invert colors of the image
+     * @returns This image instance for chaining
+     */
+    invert() {
+        if (!this.imageData)
+            throw new Error("No image loaded");
+        this.imageData.data = (0, image_processing_js_1.invert)(this.imageData.data);
+        return this;
+    }
+    /**
+     * Convert the image to grayscale
+     * @returns This image instance for chaining
+     */
+    grayscale() {
+        if (!this.imageData)
+            throw new Error("No image loaded");
+        this.imageData.data = (0, image_processing_js_1.grayscale)(this.imageData.data);
+        return 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, y, width, height, r, g, b, a = 255) {
+        if (!this.imageData)
+            throw new Error("No image loaded");
+        this.imageData.data = (0, image_processing_js_1.fillRect)(this.imageData.data, this.imageData.width, this.imageData.height, x, y, width, height, r, g, b, a);
+        return 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, y, width, height) {
+        if (!this.imageData)
+            throw new Error("No image loaded");
+        const result = (0, image_processing_js_1.crop)(this.imageData.data, this.imageData.width, this.imageData.height, x, y, width, height);
+        this.imageData.width = result.width;
+        this.imageData.height = result.height;
+        this.imageData.data = result.data;
+        // Update physical dimensions if DPI is set
+        if (this.imageData.metadata) {
+            const metadata = this.imageData.metadata;
+            if (metadata.dpiX) {
+                this.imageData.metadata.physicalWidth = result.width / metadata.dpiX;
+            }
+            if (metadata.dpiY) {
+                this.imageData.metadata.physicalHeight = result.height / metadata.dpiY;
+            }
+        }
+        return 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, y) {
+        if (!this.imageData)
+            throw new Error("No image loaded");
+        if (x < 0 || x >= this.imageData.width || y < 0 || y >= this.imageData.height) {
+            return undefined;
+        }
+        const idx = (y * this.imageData.width + x) * 4;
+        return {
+            r: this.imageData.data[idx],
+            g: this.imageData.data[idx + 1],
+            b: this.imageData.data[idx + 2],
+            a: this.imageData.data[idx + 3],
+        };
+    }
+    /**
+     * 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, y, r, g, b, a = 255) {
+        if (!this.imageData)
+            throw new Error("No image loaded");
+        if (x < 0 || x >= this.imageData.width || y < 0 || y >= this.imageData.height) {
+            return this;
+        }
+        const idx = (y * this.imageData.width + x) * 4;
+        this.imageData.data[idx] = r;
+        this.imageData.data[idx + 1] = g;
+        this.imageData.data[idx + 2] = b;
+        this.imageData.data[idx + 3] = a;
+        return this;
+    }
 }
 exports.Image = Image;
 Object.defineProperty(Image, "formats", {
@@ -364,7 +560,9 @@ Object.defineProperty(Image, "formats", {
         new gif_js_1.GIFFormat(),
         new tiff_js_1.TIFFFormat(),
         new bmp_js_1.BMPFormat(),
-        new raw_js_1.RAWFormat(),
+        new dng_js_1.DNGFormat(),
+        new pam_js_1.PAMFormat(),
+        new pcx_js_1.PCXFormat(),
         new ascii_js_1.ASCIIFormat(),
     ]
 });

package/script/src/utils/image_processing.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Image processing utilities for common operations like compositing,
+ * level adjustments, and color manipulations.
+ */
+/**
+ * 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
+ */
+export declare function composite(base: Uint8Array, baseWidth: number, baseHeight: number, overlay: Uint8Array, overlayWidth: number, overlayHeight: number, x: number, y: number, opacity?: number): Uint8Array;
+/**
+ * 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
+ */
+export declare function adjustBrightness(data: Uint8Array, amount: number): Uint8Array;
+/**
+ * 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
+ */
+export declare function adjustContrast(data: Uint8Array, amount: number): Uint8Array;
+/**
+ * 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
+ */
+export declare function adjustExposure(data: Uint8Array, amount: number): Uint8Array;
+/**
+ * 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
+ */
+export declare function adjustSaturation(data: Uint8Array, amount: number): Uint8Array;
+/**
+ * Invert colors of an image
+ * @param data Image data (RGBA)
+ * @returns New image data with inverted colors
+ */
+export declare function invert(data: Uint8Array): Uint8Array;
+/**
+ * Convert image to grayscale
+ * @param data Image data (RGBA)
+ * @returns New image data in grayscale
+ */
+export declare function grayscale(data: Uint8Array): Uint8Array;
+/**
+ * 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
+ */
+export declare function fillRect(data: Uint8Array, width: number, height: number, x: number, y: number, fillWidth: number, fillHeight: number, r: number, g: number, b: number, a: number): Uint8Array;
+/**
+ * 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
+ */
+export declare function crop(data: Uint8Array, width: number, height: number, x: number, y: number, cropWidth: number, cropHeight: number): {
+    data: Uint8Array;
+    width: number;
+    height: number;
+};
+//# sourceMappingURL=image_processing.d.ts.map