cross-image 0.1.5 → 0.2.1

package/esm/src/image.js

@@ -1,11 +1,16 @@
 import { resizeBilinear, resizeNearest } from "./utils/resize.js";
+import { adjustBrightness, adjustContrast, adjustExposure, adjustSaturation, composite, crop, fillRect, grayscale, invert, } from "./utils/image_processing.js";
 import { PNGFormat } from "./formats/png.js";
+import { APNGFormat } from "./formats/apng.js";
 import { JPEGFormat } from "./formats/jpeg.js";
 import { WebPFormat } from "./formats/webp.js";
 import { GIFFormat } from "./formats/gif.js";
 import { TIFFFormat } from "./formats/tiff.js";
 import { BMPFormat } from "./formats/bmp.js";
-import { RAWFormat } from "./formats/raw.js";
+import { ICOFormat } from "./formats/ico.js";
+import { DNGFormat } from "./formats/dng.js";
+import { PAMFormat } from "./formats/pam.js";
+import { PCXFormat } from "./formats/pcx.js";
 import { ASCIIFormat } from "./formats/ascii.js";
 import { validateImageDimensions } from "./utils/security.js";
 /**
@@ -262,6 +267,31 @@ export 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)
+        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
@@ -348,6 +378,174 @@ export 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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;
+    }
 }
 Object.defineProperty(Image, "formats", {
     enumerable: true,
@@ -355,12 +553,16 @@ Object.defineProperty(Image, "formats", {
     writable: true,
     value: [
         new PNGFormat(),
+        new APNGFormat(),
         new JPEGFormat(),
         new WebPFormat(),
         new GIFFormat(),
         new TIFFFormat(),
         new BMPFormat(),
-        new RAWFormat(),
+        new ICOFormat(),
+        new DNGFormat(),
+        new PAMFormat(),
+        new PCXFormat(),
         new ASCIIFormat(),
     ]
 });

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

@@ -0,0 +1,30 @@
+/**
+ * Shared byte-level read/write utilities for image formats
+ * These functions handle reading and writing multi-byte integers
+ * in little-endian byte order, commonly used in BMP, ICO, GIF, and other formats.
+ */
+/**
+ * Read a 16-bit unsigned integer in little-endian format
+ */
+export declare function readUint16LE(data: Uint8Array, offset: number): number;
+/**
+ * Read a 32-bit unsigned integer in little-endian format
+ */
+export declare function readUint32LE(data: Uint8Array, offset: number): number;
+/**
+ * Read a 32-bit signed integer in little-endian format
+ */
+export declare function readInt32LE(data: Uint8Array, offset: number): number;
+/**
+ * Write a 16-bit unsigned integer in little-endian format
+ */
+export declare function writeUint16LE(data: Uint8Array, offset: number, value: number): void;
+/**
+ * Write a 32-bit unsigned integer in little-endian format
+ */
+export declare function writeUint32LE(data: Uint8Array, offset: number, value: number): void;
+/**
+ * Write a 32-bit signed integer in little-endian format
+ */
+export declare function writeInt32LE(data: Uint8Array, offset: number, value: number): void;
+//# sourceMappingURL=byte_utils.d.ts.map

package/esm/src/utils/byte_utils.js

@@ -0,0 +1,50 @@
+/**
+ * Shared byte-level read/write utilities for image formats
+ * These functions handle reading and writing multi-byte integers
+ * in little-endian byte order, commonly used in BMP, ICO, GIF, and other formats.
+ */
+// Constants for signed/unsigned integer conversion
+const INT32_MAX = 0x7fffffff;
+const UINT32_RANGE = 0x100000000;
+/**
+ * Read a 16-bit unsigned integer in little-endian format
+ */
+export function readUint16LE(data, offset) {
+    return data[offset] | (data[offset + 1] << 8);
+}
+/**
+ * Read a 32-bit unsigned integer in little-endian format
+ */
+export function readUint32LE(data, offset) {
+    return data[offset] | (data[offset + 1] << 8) |
+        (data[offset + 2] << 16) | (data[offset + 3] << 24);
+}
+/**
+ * Read a 32-bit signed integer in little-endian format
+ */
+export function readInt32LE(data, offset) {
+    const value = readUint32LE(data, offset);
+    return value > INT32_MAX ? value - UINT32_RANGE : value;
+}
+/**
+ * Write a 16-bit unsigned integer in little-endian format
+ */
+export function writeUint16LE(data, offset, value) {
+    data[offset] = value & 0xff;
+    data[offset + 1] = (value >>> 8) & 0xff;
+}
+/**
+ * Write a 32-bit unsigned integer in little-endian format
+ */
+export function writeUint32LE(data, offset, value) {
+    data[offset] = value & 0xff;
+    data[offset + 1] = (value >>> 8) & 0xff;
+    data[offset + 2] = (value >>> 16) & 0xff;
+    data[offset + 3] = (value >>> 24) & 0xff;
+}
+/**
+ * Write a 32-bit signed integer in little-endian format
+ */
+export function writeInt32LE(data, offset, value) {
+    writeUint32LE(data, offset, value < 0 ? value + UINT32_RANGE : value);
+}

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

@@ -5,8 +5,9 @@
 export declare class GIFEncoder {
     private width;
     private height;
-    private data;
-    constructor(width: number, height: number, data: Uint8Array);
+    private frames;
+    constructor(width: number, height: number, data?: Uint8Array);
+    addFrame(data: Uint8Array, delay?: number): void;
     private writeBytes;
     private writeUint16LE;
     private writeString;

package/esm/src/utils/gif_encoder.js

@@ -17,15 +17,20 @@ export class GIFEncoder {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "data", {
+        Object.defineProperty(this, "frames", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: []
         });
         this.width = width;
         this.height = height;
-        this.data = data;
+        if (data) {
+            this.addFrame(data);
+        }
+    }
+    addFrame(data, delay = 0) {
+        this.frames.push({ data, delay });
     }
     writeBytes(output, bytes) {
         output.push(...bytes);
@@ -54,7 +59,7 @@ export class GIFEncoder {
     /**
      * Quantize RGBA image to 256 colors using median cut algorithm
      */
-    quantize() {
+    quantize(data) {
         // Simple quantization: collect unique colors and build palette
         const colorMap = new Map();
         const colors = [];
@@ -65,10 +70,10 @@ export class GIFEncoder {
         const rgStep = 255 / RG_LEVELS; // Step size for R/G quantization
         const bStep = 255 / B_LEVELS; // Step size for B quantization
         // Collect unique colors
-        for (let i = 0; i < this.data.length; i += 4) {
-            const r = this.data[i];
-            const g = this.data[i + 1];
-            const b = this.data[i + 2];
+        for (let i = 0; i < data.length; i += 4) {
+            const r = data[i];
+            const g = data[i + 1];
+            const b = data[i + 2];
             const key = `${r},${g},${b}`;
             if (!colorMap.has(key) && colors.length < 256) {
                 colorMap.set(key, colors.length);
@@ -83,12 +88,12 @@ export class GIFEncoder {
             colorMap.clear();
             colors.length = 0;
             useColorReduction = true;
-            for (let i = 0; i < this.data.length; i += 4) {
+            for (let i = 0; i < data.length; i += 4) {
                 // Reduce color depth: 3 bits for R/G channels, 2 bits for B channel
                 // This gives us 8 bits total = 256 possible colors
-                const r = this.quantizeChannel(this.data[i], RG_LEVELS, rgStep);
-                const g = this.quantizeChannel(this.data[i + 1], RG_LEVELS, rgStep);
-                const b = this.quantizeChannel(this.data[i + 2], B_LEVELS, bStep);
+                const r = this.quantizeChannel(data[i], RG_LEVELS, rgStep);
+                const g = this.quantizeChannel(data[i + 1], RG_LEVELS, rgStep);
+                const b = this.quantizeChannel(data[i + 2], B_LEVELS, bStep);
                 const key = `${r},${g},${b}`;
                 if (!colorMap.has(key)) {
                     if (colors.length < 256) {
@@ -112,10 +117,10 @@ export class GIFEncoder {
         }
         // Create indexed data
         const indexed = new Uint8Array(this.width * this.height);
-        for (let i = 0, j = 0; i < this.data.length; i += 4, j++) {
-            let r = this.data[i];
-            let g = this.data[i + 1];
-            let b = this.data[i + 2];
+        for (let i = 0, j = 0; i < data.length; i += 4, j++) {
+            let r = data[i];
+            let g = data[i + 1];
+            let b = data[i + 2];
             // Apply color reduction if it was used for building the palette
             if (useColorReduction) {
                 r = this.quantizeChannel(r, RG_LEVELS, rgStep);
@@ -161,10 +166,14 @@ export class GIFEncoder {
         return Math.max(2, bits);
     }
     encode() {
+        if (this.frames.length === 0) {
+            throw new Error("No frames to encode");
+        }
         const output = [];
-        // Quantize image
-        const { palette, indexed } = this.quantize();
-        const paletteSize = palette.length / 3;
+        // Quantize first frame for Global Color Table
+        const firstFrame = this.frames[0];
+        const { palette: globalPalette, indexed: firstIndexed } = this.quantize(firstFrame.data);
+        const paletteSize = globalPalette.length / 3;
         const bitsPerColor = this.getBitsPerColor(paletteSize);
         // Header
         this.writeString(output, "GIF89a");
@@ -187,38 +196,96 @@ export class GIFEncoder {
         // So we need to write that many colors, padding if necessary
         const gctSize = 1 << bitsPerColor;
         const paddedPalette = new Uint8Array(gctSize * 3);
-        paddedPalette.set(palette);
+        paddedPalette.set(globalPalette);
         this.writeBytes(output, paddedPalette);
-        // Image Descriptor
-        output.push(0x2c); // Image Separator
-        // Image position and dimensions
-        this.writeUint16LE(output, 0); // Left
-        this.writeUint16LE(output, 0); // Top
-        this.writeUint16LE(output, this.width);
-        this.writeUint16LE(output, this.height);
-        // Packed field:
-        // - Local Color Table Flag (1 bit): 0
-        // - Interlace Flag (1 bit): 0
-        // - Sort Flag (1 bit): 0
-        // - Reserved (2 bits): 0
-        // - Size of Local Color Table (3 bits): 0
-        output.push(0);
-        // LZW Minimum Code Size
-        const minCodeSize = Math.max(2, bitsPerColor);
-        output.push(minCodeSize);
-        // Compress image data with LZW
-        const encoder = new LZWEncoder(minCodeSize);
-        const compressed = encoder.compress(indexed);
-        // Write compressed data in sub-blocks (max 255 bytes per block)
-        for (let i = 0; i < compressed.length; i += 255) {
-            const blockSize = Math.min(255, compressed.length - i);
-            output.push(blockSize);
-            for (let j = 0; j < blockSize; j++) {
-                output.push(compressed[i + j]);
+        // Netscape Application Extension (Looping)
+        if (this.frames.length > 1) {
+            output.push(0x21); // Extension Introducer
+            output.push(0xff); // Application Extension Label
+            output.push(11); // Block Size
+            this.writeString(output, "NETSCAPE2.0");
+            output.push(3); // Sub-block Size
+            output.push(1); // Loop Indicator (1 = loop)
+            this.writeUint16LE(output, 0); // Loop Count (0 = infinite)
+            output.push(0); // Block Terminator
+        }
+        // Encode frames
+        for (let i = 0; i < this.frames.length; i++) {
+            const frame = this.frames[i];
+            let indexed;
+            let useLocalPalette = false;
+            let localPalette = null;
+            let localBitsPerColor = bitsPerColor;
+            if (i === 0) {
+                indexed = firstIndexed;
+            }
+            else {
+                // Quantize subsequent frames
+                // For simplicity, we use a Local Color Table for each frame to ensure colors are correct
+                const result = this.quantize(frame.data);
+                indexed = result.indexed;
+                localPalette = result.palette;
+                useLocalPalette = true;
+                const localPaletteSize = localPalette.length / 3;
+                localBitsPerColor = this.getBitsPerColor(localPaletteSize);
             }
+            // Graphic Control Extension
+            output.push(0x21); // Extension Introducer
+            output.push(0xf9); // Graphic Control Label
+            output.push(4); // Byte Size
+            // Packed Field
+            // Reserved (3 bits)
+            // Disposal Method (3 bits): 2 (Restore to background) - usually safe for animation
+            // User Input Flag (1 bit): 0
+            // Transparent Color Flag (1 bit): 0
+            output.push(0x08); // Disposal method 2 (Restore to background)
+            // Delay Time (1/100ths of a second)
+            // Default to 10 (100ms) if not specified
+            const delay = frame.delay > 0 ? Math.round(frame.delay / 10) : 10;
+            this.writeUint16LE(output, delay);
+            // Transparent Color Index
+            output.push(0);
+            output.push(0); // Block Terminator
+            // Image Descriptor
+            output.push(0x2c); // Image Separator
+            this.writeUint16LE(output, 0); // Left
+            this.writeUint16LE(output, 0); // Top
+            this.writeUint16LE(output, this.width);
+            this.writeUint16LE(output, this.height);
+            // Packed Field
+            if (useLocalPalette && localPalette) {
+                // LCT Flag: 1
+                // Interlace: 0
+                // Sort: 0
+                // Reserved: 0
+                // Size of LCT: localBitsPerColor - 1
+                const lctPacked = 0x80 | (localBitsPerColor - 1);
+                output.push(lctPacked);
+                // Write Local Color Table
+                const lctSize = 1 << localBitsPerColor;
+                const paddedLct = new Uint8Array(lctSize * 3);
+                paddedLct.set(localPalette);
+                this.writeBytes(output, paddedLct);
+            }
+            else {
+                output.push(0); // No LCT
+            }
+            // LZW Minimum Code Size
+            const minCodeSize = Math.max(2, useLocalPalette ? localBitsPerColor : bitsPerColor);
+            output.push(minCodeSize);
+            // Compress image data with LZW
+            const encoder = new LZWEncoder(minCodeSize);
+            const compressed = encoder.compress(indexed);
+            // Write compressed data in sub-blocks (max 255 bytes per block)
+            for (let k = 0; k < compressed.length; k += 255) {
+                const blockSize = Math.min(255, compressed.length - k);
+                output.push(blockSize);
+                for (let j = 0; j < blockSize; j++) {
+                    output.push(compressed[k + j]);
+                }
+            }
+            output.push(0); // Block Terminator
         }
-        // Block Terminator
-        output.push(0);
         // Trailer
         output.push(0x3b);
         return new Uint8Array(output);

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