cross-image 0.2.4 → 0.4.0

package/esm/src/types.d.ts

@@ -138,7 +138,7 @@ export interface ResizeOptions {
 /**
  * Options for ASCII art encoding
  */
-export interface ASCIIOptions {
+export interface ASCIIEncoderOptions {
     /** Target width in characters (default: 80) */
     width?: number;
     /** Character set to use (default: "simple") */
@@ -148,10 +148,21 @@ export interface ASCIIOptions {
     /** Whether to invert brightness (default: false) */
     invert?: boolean;
 }
+/**
+ * Options for TIFF encoding.
+ */
+export interface TIFFEncoderOptions {
+    /** Compression method: "none" (default), "lzw", "packbits", or "deflate" */
+    compression?: "none" | "lzw" | "packbits" | "deflate";
+    /** Encode as grayscale instead of RGB/RGBA (default: false) */
+    grayscale?: boolean;
+    /** Encode as RGB without alpha channel (default: false, ignored if grayscale is true) */
+    rgb?: boolean;
+}
 /**
  * Options for WebP encoding
  */
-export interface WebPEncodeOptions {
+export interface WebPEncoderOptions {
     /**
      * Encoding quality (1-100, default: 90)
      * - 100 = lossless (VP8L)
@@ -164,6 +175,47 @@ export interface WebPEncodeOptions {
      */
     lossless?: boolean;
 }
+/**
+ * Options for JPEG encoding.
+ */
+export interface JPEGEncoderOptions {
+    /**
+     * Encoding quality (1-100, default depends on encoder backend).
+     */
+    quality?: number;
+    /**
+     * Enable progressive JPEG output when using the pure-JS encoder.
+     * Runtime encoders do not currently expose a progressive toggle.
+     */
+    progressive?: boolean;
+}
+/**
+ * Common options for decode APIs.
+ *
+ * These options are runtime-agnostic and can be passed to `Image.decode()` and
+ * `Image.decodeFrames()`.
+ */
+export interface ImageDecoderOptions {
+    /**
+     * Controls tolerant decoding in the pure-JS decoders.
+     *
+     * - true (default): try to recover from corruption and continue
+     * - false: strict mode (fail fast)
+     */
+    tolerantDecoding?: boolean;
+    /**
+     * Optional warning callback used by pure-JS decoders when non-fatal issues are
+     * encountered.
+     */
+    onWarning?: (message: string, details?: unknown) => void;
+    /**
+     * Runtime decoder strategy.
+     *
+     * - "prefer" (default): try runtime decoders first (ImageDecoder/Canvas), then fall back to pure JS
+     * - "never": skip runtime decoders and use pure JS when available
+     */
+    runtimeDecoding?: "prefer" | "never";
+}
 /**
  * Image format handler interface
  */
@@ -177,7 +229,7 @@ export interface ImageFormat {
      * @param data Raw image data
      * @returns Decoded image data
      */
-    decode(data: Uint8Array): Promise<ImageData>;
+    decode(data: Uint8Array, options?: ImageDecoderOptions): Promise<ImageData>;
     /**
      * Encode image data to bytes
      * @param imageData Image data to encode
@@ -196,7 +248,7 @@ export interface ImageFormat {
      * @param data Raw image data
      * @returns Decoded multi-frame image data
      */
-    decodeFrames?(data: Uint8Array): Promise<MultiFrameImageData>;
+    decodeFrames?(data: Uint8Array, options?: ImageDecoderOptions): Promise<MultiFrameImageData>;
     /**
      * Encode multi-frame image data to bytes (optional)
      * @param imageData Multi-frame image data to encode

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

@@ -2,6 +2,7 @@
  * Pure JavaScript GIF decoder implementation
  * Supports GIF87a and GIF89a formats with LZW decompression
  */
+import type { ImageDecoderOptions } from "../types.js";
 interface GIFImage {
     width: number;
     height: number;
@@ -19,7 +20,8 @@ interface GIFFrame {
 export declare class GIFDecoder {
     private data;
     private pos;
-    constructor(data: Uint8Array);
+    private options;
+    constructor(data: Uint8Array, settings?: ImageDecoderOptions);
     private readByte;
     private readUint16LE;
     private readBytes;
@@ -36,6 +38,7 @@ export declare class GIFDecoder {
         frames: GIFFrame[];
     };
     private indexedToRGBA;
+    private decodeFrame;
     private deinterlace;
 }
 export {};

package/esm/src/utils/gif_decoder.js

@@ -4,7 +4,7 @@
  */
 import { LZWDecoder } from "./lzw.js";
 export class GIFDecoder {
-    constructor(data) {
+    constructor(data, settings = {}) {
         Object.defineProperty(this, "data", {
             enumerable: true,
             configurable: true,
@@ -17,8 +17,18 @@ export class GIFDecoder {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.data = data;
         this.pos = 0;
+        this.options = {
+            tolerantDecoding: settings.tolerantDecoding ?? true,
+            onWarning: settings.onWarning,
+        };
     }
     readByte() {
         if (this.pos >= this.data.length) {
@@ -207,72 +217,20 @@ export class GIFDecoder {
             }
             else if (separator === 0x2c) {
                 // Image Descriptor
-                const imageLeft = this.readUint16LE();
-                const imageTop = this.readUint16LE();
-                const imageWidth = this.readUint16LE();
-                const imageHeight = this.readUint16LE();
-                const packed = this.readByte();
-                const hasLocalColorTable = (packed & 0x80) !== 0;
-                const interlaced = (packed & 0x40) !== 0;
-                // Color table size: 2^(n+1) where n is the 3 least significant bits
-                const localColorTableSize = 2 << (packed & 0x07);
-                let localColorTable = null;
-                if (hasLocalColorTable) {
-                    localColorTable = this.readColorTable(localColorTableSize);
-                }
-                // Read image data
-                const minCodeSize = this.readByte();
-                const compressedData = this.readDataSubBlocks();
-                // Decompress using LZW
-                const decoder = new LZWDecoder(minCodeSize, compressedData);
-                const indexedData = decoder.decompress();
-                // Convert indexed to RGBA
-                const colorTable = localColorTable || globalColorTable;
-                if (!colorTable) {
-                    throw new Error("No color table available");
-                }
-                // Deinterlace if necessary
-                const deinterlaced = interlaced
-                    ? this.deinterlace(indexedData, imageWidth, imageHeight)
-                    : indexedData;
-                // Create frame with just the image data (not full canvas)
-                const frameData = new Uint8Array(imageWidth * imageHeight * 4);
-                for (let y = 0; y < imageHeight; y++) {
-                    for (let x = 0; x < imageWidth; x++) {
-                        const srcIdx = y * imageWidth + x;
-                        if (srcIdx >= deinterlaced.length)
-                            continue;
-                        const colorIndex = deinterlaced[srcIdx];
-                        const dstIdx = (y * imageWidth + x) * 4;
-                        if (transparentColorIndex !== null &&
-                            colorIndex === transparentColorIndex) {
-                            // Transparent pixel
-                            frameData[dstIdx] = 0;
-                            frameData[dstIdx + 1] = 0;
-                            frameData[dstIdx + 2] = 0;
-                            frameData[dstIdx + 3] = 0;
-                        }
-                        else {
-                            // Copy color from color table
-                            const colorOffset = colorIndex * 3;
-                            if (colorOffset + 2 < colorTable.length) {
-                                frameData[dstIdx] = colorTable[colorOffset];
-                                frameData[dstIdx + 1] = colorTable[colorOffset + 1];
-                                frameData[dstIdx + 2] = colorTable[colorOffset + 2];
-                                frameData[dstIdx + 3] = 255;
-                            }
-                        }
+                if (this.options.tolerantDecoding) {
+                    try {
+                        this.decodeFrame(frames, globalColorTable, transparentColorIndex, delayTime, disposalMethod);
+                    }
+                    catch (e) {
+                        // Tolerant decoding: skip corrupted frames and continue
+                        // This allows partial decoding of multi-frame GIFs with some bad frames
+                        this.options.onWarning?.("GIF: Skipping corrupted frame", e);
                     }
                 }
-                frames.push({
-                    width: imageWidth,
-                    height: imageHeight,
-                    left: imageLeft,
-                    top: imageTop,
-                    data: frameData,
-                    delay: delayTime,
-                    disposal: disposalMethod,
-                });
+                else {
+                    // Non-tolerant mode: throw on first error
+                    this.decodeFrame(frames, globalColorTable, transparentColorIndex, delayTime, disposalMethod);
+                }
                 // Reset graphic control extension state
                 transparentColorIndex = null;
                 delayTime = 0;
@@ -350,6 +308,74 @@ export class GIFDecoder {
             data: rgba,
         };
     }
+    decodeFrame(frames, globalColorTable, transparentColorIndex, delayTime, disposalMethod) {
+        const imageLeft = this.readUint16LE();
+        const imageTop = this.readUint16LE();
+        const imageWidth = this.readUint16LE();
+        const imageHeight = this.readUint16LE();
+        const packed = this.readByte();
+        const hasLocalColorTable = (packed & 0x80) !== 0;
+        const interlaced = (packed & 0x40) !== 0;
+        // Color table size: 2^(n+1) where n is the 3 least significant bits
+        const localColorTableSize = 2 << (packed & 0x07);
+        let localColorTable = null;
+        if (hasLocalColorTable) {
+            localColorTable = this.readColorTable(localColorTableSize);
+        }
+        // Read image data
+        const minCodeSize = this.readByte();
+        const compressedData = this.readDataSubBlocks();
+        // Decompress using LZW
+        const decoder = new LZWDecoder(minCodeSize, compressedData);
+        const indexedData = decoder.decompress();
+        // Convert indexed to RGBA
+        const colorTable = localColorTable || globalColorTable;
+        if (!colorTable) {
+            throw new Error("No color table available");
+        }
+        // Deinterlace if necessary
+        const deinterlaced = interlaced
+            ? this.deinterlace(indexedData, imageWidth, imageHeight)
+            : indexedData;
+        // Create frame with just the image data (not full canvas)
+        const frameData = new Uint8Array(imageWidth * imageHeight * 4);
+        for (let y = 0; y < imageHeight; y++) {
+            for (let x = 0; x < imageWidth; x++) {
+                const srcIdx = y * imageWidth + x;
+                if (srcIdx >= deinterlaced.length)
+                    continue;
+                const colorIndex = deinterlaced[srcIdx];
+                const dstIdx = (y * imageWidth + x) * 4;
+                if (transparentColorIndex !== null &&
+                    colorIndex === transparentColorIndex) {
+                    // Transparent pixel
+                    frameData[dstIdx] = 0;
+                    frameData[dstIdx + 1] = 0;
+                    frameData[dstIdx + 2] = 0;
+                    frameData[dstIdx + 3] = 0;
+                }
+                else {
+                    // Copy color from color table
+                    const colorOffset = colorIndex * 3;
+                    if (colorOffset + 2 < colorTable.length) {
+                        frameData[dstIdx] = colorTable[colorOffset];
+                        frameData[dstIdx + 1] = colorTable[colorOffset + 1];
+                        frameData[dstIdx + 2] = colorTable[colorOffset + 2];
+                        frameData[dstIdx + 3] = 255;
+                    }
+                }
+            }
+        }
+        frames.push({
+            width: imageWidth,
+            height: imageHeight,
+            left: imageLeft,
+            top: imageTop,
+            data: frameData,
+            delay: delayTime,
+            disposal: disposalMethod,
+        });
+    }
     deinterlace(data, width, height) {
         const deinterlaced = new Uint8Array(data.length);
         const passes = [

package/esm/src/utils/image_processing.js

@@ -2,6 +2,19 @@
  * Image processing utilities for common operations like compositing,
  * level adjustments, and color manipulations.
  */
+/**
+ * Detect system endianness
+ * Returns true if little-endian (most common), false if big-endian
+ */
+function isLittleEndian() {
+    const buffer = new ArrayBuffer(4);
+    const uint32View = new Uint32Array(buffer);
+    const uint8View = new Uint8Array(buffer);
+    uint32View[0] = 0x01020304;
+    return uint8View[0] === 0x04;
+}
+// Cache the endianness check result
+const IS_LITTLE_ENDIAN = isLittleEndian();
 /**
  * Composite one image on top of another at a specified position
  * @param base Base image data (RGBA)
@@ -26,17 +39,20 @@ export function composite(base, baseWidth, baseHeight, overlay, overlayWidth, ov
     const endY = Math.min(baseHeight, y + overlayHeight);
     // Iterate over the overlapping region
     for (let py = startY; py < endY; py++) {
+        const baseRowOffset = py * baseWidth * 4;
+        const overlayRowOffset = (py - y) * overlayWidth * 4;
         for (let px = startX; px < endX; px++) {
-            // Calculate indices
-            const baseIdx = (py * baseWidth + px) * 4;
-            const overlayX = px - x;
-            const overlayY = py - y;
-            const overlayIdx = (overlayY * overlayWidth + overlayX) * 4;
+            // Calculate indices with pre-computed offsets
+            const baseIdx = baseRowOffset + px * 4;
+            const overlayIdx = overlayRowOffset + (px - x) * 4;
             // Get overlay pixel with opacity
             const overlayR = overlay[overlayIdx];
             const overlayG = overlay[overlayIdx + 1];
             const overlayB = overlay[overlayIdx + 2];
             const overlayA = (overlay[overlayIdx + 3] / 255) * finalOpacity;
+            // Skip if overlay is fully transparent
+            if (overlayA === 0)
+                continue;
             // Get base pixel
             const baseR = result[baseIdx];
             const baseG = result[baseIdx + 1];
@@ -44,11 +60,14 @@ export function composite(base, baseWidth, baseHeight, overlay, overlayWidth, ov
             const baseA = result[baseIdx + 3] / 255;
             // Alpha compositing using "over" operation
             const outA = overlayA + baseA * (1 - overlayA);
-            if (outA > 0) {
-                result[baseIdx] = Math.round((overlayR * overlayA + baseR * baseA * (1 - overlayA)) / outA);
-                result[baseIdx + 1] = Math.round((overlayG * overlayA + baseG * baseA * (1 - overlayA)) / outA);
-                result[baseIdx + 2] = Math.round((overlayB * overlayA + baseB * baseA * (1 - overlayA)) / outA);
-                result[baseIdx + 3] = Math.round(outA * 255);
+            if (outA > 0.001) {
+                const invOverlayA = 1 - overlayA;
+                const baseWeight = baseA * invOverlayA;
+                const invOutA = 1 / outA;
+                result[baseIdx] = ((overlayR * overlayA + baseR * baseWeight) * invOutA + 0.5) | 0;
+                result[baseIdx + 1] = ((overlayG * overlayA + baseG * baseWeight) * invOutA + 0.5) | 0;
+                result[baseIdx + 2] = ((overlayB * overlayA + baseB * baseWeight) * invOutA + 0.5) | 0;
+                result[baseIdx + 3] = (outA * 255 + 0.5) | 0;
             }
         }
     }
@@ -62,11 +81,23 @@ export function composite(base, baseWidth, baseHeight, overlay, overlayWidth, ov
  */
 export function adjustBrightness(data, amount) {
     const result = new Uint8Array(data.length);
-    const adjust = Math.max(-1, Math.min(1, amount)) * 255;
+    const clampedAmount = Math.max(-1, Math.min(1, amount));
+    const adjust = clampedAmount * 255;
+    // Pre-compute lookup table for clamping
+    // Range: -255 to 511 (data value 0-255 + adjust -255 to 255), offset by 255 for zero-based index
+    const LUT_SIZE = 767;
+    const LUT_OFFSET = 255;
+    const lut = new Uint8Array(LUT_SIZE);
+    for (let i = 0; i < LUT_SIZE; i++) {
+        const value = i - LUT_OFFSET;
+        lut[i] = value < 0 ? 0 : (value > 255 ? 255 : value);
+    }
+    // Use bitwise OR for fast rounding (equivalent to Math.round for positive numbers)
+    const adjustInt = (adjust + 0.5) | 0;
     for (let i = 0; i < data.length; i += 4) {
-        result[i] = Math.max(0, Math.min(255, data[i] + adjust)); // R
-        result[i + 1] = Math.max(0, Math.min(255, data[i + 1] + adjust)); // G
-        result[i + 2] = Math.max(0, Math.min(255, data[i + 2] + adjust)); // B
+        result[i] = lut[data[i] + adjustInt + LUT_OFFSET]; // R
+        result[i + 1] = lut[data[i + 1] + adjustInt + LUT_OFFSET]; // G
+        result[i + 2] = lut[data[i + 2] + adjustInt + LUT_OFFSET]; // B
         result[i + 3] = data[i + 3]; // A
     }
     return result;
@@ -82,10 +113,16 @@ export function adjustContrast(data, amount) {
     const contrast = Math.max(-1, Math.min(1, amount));
     const factor = (259 * (contrast * 255 + 255)) /
         (255 * (259 - contrast * 255));
+    // Pre-compute lookup table for all possible pixel values
+    const lut = new Uint8Array(256);
+    for (let i = 0; i < 256; i++) {
+        const val = factor * (i - 128) + 128;
+        lut[i] = val < 0 ? 0 : (val > 255 ? 255 : Math.round(val));
+    }
     for (let i = 0; i < data.length; i += 4) {
-        result[i] = Math.max(0, Math.min(255, factor * (data[i] - 128) + 128)); // R
-        result[i + 1] = Math.max(0, Math.min(255, factor * (data[i + 1] - 128) + 128)); // G
-        result[i + 2] = Math.max(0, Math.min(255, factor * (data[i + 2] - 128) + 128)); // B
+        result[i] = lut[data[i]]; // R
+        result[i + 1] = lut[data[i + 1]]; // G
+        result[i + 2] = lut[data[i + 2]]; // B
         result[i + 3] = data[i + 3]; // A
     }
     return result;
@@ -100,10 +137,16 @@ export function adjustExposure(data, amount) {
     const result = new Uint8Array(data.length);
     const stops = Math.max(-3, Math.min(3, amount));
     const multiplier = Math.pow(2, stops);
+    // Pre-compute lookup table for all possible pixel values
+    const lut = new Uint8Array(256);
+    for (let i = 0; i < 256; i++) {
+        const val = i * multiplier;
+        lut[i] = val > 255 ? 255 : (val + 0.5) | 0;
+    }
     for (let i = 0; i < data.length; i += 4) {
-        result[i] = Math.max(0, Math.min(255, data[i] * multiplier)); // R
-        result[i + 1] = Math.max(0, Math.min(255, data[i + 1] * multiplier)); // G
-        result[i + 2] = Math.max(0, Math.min(255, data[i + 2] * multiplier)); // B
+        result[i] = lut[data[i]]; // R
+        result[i + 1] = lut[data[i + 1]]; // G
+        result[i + 2] = lut[data[i + 2]]; // B
         result[i + 3] = data[i + 3]; // A
     }
     return result;
@@ -310,15 +353,12 @@ export function crop(data, width, height, x, y, cropWidth, cropHeight) {
     const actualWidth = endX - startX;
     const actualHeight = endY - startY;
     const result = new Uint8Array(actualWidth * actualHeight * 4);
+    const rowBytes = actualWidth * 4;
+    // Copy entire rows at once for better performance
     for (let py = 0; py < actualHeight; py++) {
-        for (let px = 0; px < actualWidth; px++) {
-            const srcIdx = ((startY + py) * width + (startX + px)) * 4;
-            const dstIdx = (py * actualWidth + px) * 4;
-            result[dstIdx] = data[srcIdx];
-            result[dstIdx + 1] = data[srcIdx + 1];
-            result[dstIdx + 2] = data[srcIdx + 2];
-            result[dstIdx + 3] = data[srcIdx + 3];
-        }
+        const srcOffset = ((startY + py) * width + startX) * 4;
+        const dstOffset = py * rowBytes;
+        result.set(data.subarray(srcOffset, srcOffset + rowBytes), dstOffset);
     }
     return { data: result, width: actualWidth, height: actualHeight };
 }
@@ -397,46 +437,52 @@ function generateGaussianKernel(radius, sigma) {
 export function gaussianBlur(data, width, height, radius = 1, sigma) {
     const clampedRadius = Math.max(1, Math.floor(radius));
     const kernel = generateGaussianKernel(clampedRadius, sigma);
+    const widthMinus1 = width - 1;
+    const heightMinus1 = height - 1;
     // Apply horizontal pass
     const temp = new Uint8Array(data.length);
     for (let y = 0; y < height; y++) {
+        const rowOffset = y * width * 4;
         for (let x = 0; x < width; x++) {
             let r = 0, g = 0, b = 0, a = 0;
             for (let kx = -clampedRadius; kx <= clampedRadius; kx++) {
-                const px = Math.max(0, Math.min(width - 1, x + kx));
-                const idx = (y * width + px) * 4;
+                const px = x + kx;
+                const clampedPx = px < 0 ? 0 : (px > widthMinus1 ? widthMinus1 : px);
+                const idx = rowOffset + clampedPx * 4;
                 const weight = kernel[kx + clampedRadius];
                 r += data[idx] * weight;
                 g += data[idx + 1] * weight;
                 b += data[idx + 2] * weight;
                 a += data[idx + 3] * weight;
             }
-            const outIdx = (y * width + x) * 4;
-            temp[outIdx] = Math.round(r);
-            temp[outIdx + 1] = Math.round(g);
-            temp[outIdx + 2] = Math.round(b);
-            temp[outIdx + 3] = Math.round(a);
+            const outIdx = rowOffset + x * 4;
+            temp[outIdx] = (r + 0.5) | 0;
+            temp[outIdx + 1] = (g + 0.5) | 0;
+            temp[outIdx + 2] = (b + 0.5) | 0;
+            temp[outIdx + 3] = (a + 0.5) | 0;
         }
     }
     // Apply vertical pass
     const result = new Uint8Array(data.length);
     for (let y = 0; y < height; y++) {
+        const rowOffset = y * width * 4;
         for (let x = 0; x < width; x++) {
             let r = 0, g = 0, b = 0, a = 0;
             for (let ky = -clampedRadius; ky <= clampedRadius; ky++) {
-                const py = Math.max(0, Math.min(height - 1, y + ky));
-                const idx = (py * width + x) * 4;
+                const py = y + ky;
+                const clampedPy = py < 0 ? 0 : (py > heightMinus1 ? heightMinus1 : py);
+                const idx = clampedPy * width * 4 + x * 4;
                 const weight = kernel[ky + clampedRadius];
                 r += temp[idx] * weight;
                 g += temp[idx + 1] * weight;
                 b += temp[idx + 2] * weight;
                 a += temp[idx + 3] * weight;
             }
-            const outIdx = (y * width + x) * 4;
-            result[outIdx] = Math.round(r);
-            result[outIdx + 1] = Math.round(g);
-            result[outIdx + 2] = Math.round(b);
-            result[outIdx + 3] = Math.round(a);
+            const outIdx = rowOffset + x * 4;
+            result[outIdx] = (r + 0.5) | 0;
+            result[outIdx + 1] = (g + 0.5) | 0;
+            result[outIdx + 2] = (b + 0.5) | 0;
+            result[outIdx + 3] = (a + 0.5) | 0;
         }
     }
     return result;
@@ -586,16 +632,30 @@ export function rotate90(data, width, height) {
  */
 export function rotate180(data, width, height) {
     const result = new Uint8Array(data.length);
-    for (let y = 0; y < height; y++) {
-        for (let x = 0; x < width; x++) {
-            const srcIdx = (y * width + x) * 4;
-            const dstX = width - 1 - x;
-            const dstY = height - 1 - y;
-            const dstIdx = (dstY * width + dstX) * 4;
-            result[dstIdx] = data[srcIdx];
-            result[dstIdx + 1] = data[srcIdx + 1];
-            result[dstIdx + 2] = data[srcIdx + 2];
-            result[dstIdx + 3] = data[srcIdx + 3];
+    // Only use Uint32Array optimization on little-endian systems to avoid byte order issues
+    if (IS_LITTLE_ENDIAN) {
+        // Use Uint32Array view for faster 4-byte (pixel) copying
+        // Note: Uint8Array buffers are guaranteed to be aligned for any TypedArray view
+        const src32 = new Uint32Array(data.buffer, data.byteOffset, width * height);
+        const dst32 = new Uint32Array(result.buffer, result.byteOffset, width * height);
+        const totalPixels = width * height;
+        for (let i = 0; i < totalPixels; i++) {
+            dst32[totalPixels - 1 - i] = src32[i];
+        }
+    }
+    else {
+        // Fallback for big-endian systems - byte-by-byte copying
+        for (let y = 0; y < height; y++) {
+            for (let x = 0; x < width; x++) {
+                const srcIdx = (y * width + x) * 4;
+                const dstX = width - 1 - x;
+                const dstY = height - 1 - y;
+                const dstIdx = (dstY * width + dstX) * 4;
+                result[dstIdx] = data[srcIdx];
+                result[dstIdx + 1] = data[srcIdx + 1];
+                result[dstIdx + 2] = data[srcIdx + 2];
+                result[dstIdx + 3] = data[srcIdx + 3];
+            }
         }
     }
     return result;
@@ -634,15 +694,33 @@ export function rotate270(data, width, height) {
  */
 export function flipHorizontal(data, width, height) {
     const result = new Uint8Array(data.length);
-    for (let y = 0; y < height; y++) {
-        for (let x = 0; x < width; x++) {
-            const srcIdx = (y * width + x) * 4;
-            const dstX = width - 1 - x;
-            const dstIdx = (y * width + dstX) * 4;
-            result[dstIdx] = data[srcIdx];
-            result[dstIdx + 1] = data[srcIdx + 1];
-            result[dstIdx + 2] = data[srcIdx + 2];
-            result[dstIdx + 3] = data[srcIdx + 3];
+    // Only use Uint32Array optimization on little-endian systems to avoid byte order issues
+    if (IS_LITTLE_ENDIAN) {
+        // Use Uint32Array view for faster 4-byte (pixel) copying
+        // Note: Uint8Array buffers are guaranteed to be aligned for any TypedArray view
+        const src32 = new Uint32Array(data.buffer, data.byteOffset, width * height);
+        const dst32 = new Uint32Array(result.buffer, result.byteOffset, width * height);
+        for (let y = 0; y < height; y++) {
+            const rowStart = y * width;
+            for (let x = 0; x < width; x++) {
+                const srcIdx = rowStart + x;
+                const dstIdx = rowStart + (width - 1 - x);
+                dst32[dstIdx] = src32[srcIdx];
+            }
+        }
+    }
+    else {
+        // Fallback for big-endian systems - byte-by-byte copying
+        for (let y = 0; y < height; y++) {
+            for (let x = 0; x < width; x++) {
+                const srcIdx = (y * width + x) * 4;
+                const dstX = width - 1 - x;
+                const dstIdx = (y * width + dstX) * 4;
+                result[dstIdx] = data[srcIdx];
+                result[dstIdx + 1] = data[srcIdx + 1];
+                result[dstIdx + 2] = data[srcIdx + 2];
+                result[dstIdx + 3] = data[srcIdx + 3];
+            }
         }
     }
     return result;
@@ -656,16 +734,12 @@ export function flipHorizontal(data, width, height) {
  */
 export function flipVertical(data, width, height) {
     const result = new Uint8Array(data.length);
+    const rowBytes = width * 4;
+    // Copy entire rows at once for better performance
     for (let y = 0; y < height; y++) {
-        for (let x = 0; x < width; x++) {
-            const srcIdx = (y * width + x) * 4;
-            const dstY = height - 1 - y;
-            const dstIdx = (dstY * width + x) * 4;
-            result[dstIdx] = data[srcIdx];
-            result[dstIdx + 1] = data[srcIdx + 1];
-            result[dstIdx + 2] = data[srcIdx + 2];
-            result[dstIdx + 3] = data[srcIdx + 3];
-        }
+        const srcOffset = y * rowBytes;
+        const dstOffset = (height - 1 - y) * rowBytes;
+        result.set(data.subarray(srcOffset, srcOffset + rowBytes), dstOffset);
     }
     return result;
 }