cross-image 0.2.2 → 0.2.3

package/esm/src/formats/webp.js

@@ -1,5 +1,6 @@
 import { validateImageDimensions } from "../utils/security.js";
 import { readUint32LE } from "../utils/byte_utils.js";
+import { createXMP, parseXMP } from "../utils/metadata/xmp.js";
 // Default quality for WebP encoding when not specified
 const DEFAULT_WEBP_QUALITY = 90;
 /**
@@ -219,6 +220,7 @@ export class WebPFormat {
             const numEntries = littleEndian
                 ? data[ifd0Offset] | (data[ifd0Offset + 1] << 8)
                 : (data[ifd0Offset] << 8) | data[ifd0Offset + 1];
+            let gpsIfdOffset = 0;
             // Parse basic EXIF tags (simplified version)
             for (let i = 0; i < numEntries && i < 50; i++) {
                 const entryOffset = ifd0Offset + 2 + i * 12;
@@ -245,32 +247,103 @@ export class WebPFormat {
                         }
                     }
                 }
+                // GPS IFD Pointer tag (0x8825)
+                if (tag === 0x8825) {
+                    gpsIfdOffset = 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];
+                }
+            }
+            // Parse GPS IFD if present
+            if (gpsIfdOffset > 0 && gpsIfdOffset + 2 <= data.length) {
+                this.parseGPSIFD(data, gpsIfdOffset, littleEndian, metadata);
             }
         }
         catch (_e) {
             // Ignore EXIF parsing errors
         }
     }
+    parseGPSIFD(data, gpsIfdOffset, littleEndian, metadata) {
+        try {
+            const numEntries = littleEndian
+                ? data[gpsIfdOffset] | (data[gpsIfdOffset + 1] << 8)
+                : (data[gpsIfdOffset] << 8) | data[gpsIfdOffset + 1];
+            let latRef = "";
+            let lonRef = "";
+            let latitude;
+            let longitude;
+            for (let i = 0; i < numEntries; i++) {
+                const entryOffset = gpsIfdOffset + 2 + i * 12;
+                if (entryOffset + 12 > data.length)
+                    break;
+                const tag = littleEndian
+                    ? data[entryOffset] | (data[entryOffset + 1] << 8)
+                    : (data[entryOffset] << 8) | data[entryOffset + 1];
+                const type = littleEndian
+                    ? data[entryOffset + 2] | (data[entryOffset + 3] << 8)
+                    : (data[entryOffset + 2] << 8) | data[entryOffset + 3];
+                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];
+                // GPSLatitudeRef (0x0001)
+                if (tag === 0x0001 && type === 2) {
+                    latRef = String.fromCharCode(data[entryOffset + 8]);
+                }
+                // GPSLatitude (0x0002)
+                if (tag === 0x0002 && type === 5 && valueOffset + 24 <= data.length) {
+                    const degrees = this.readRational(data, valueOffset, littleEndian);
+                    const minutes = this.readRational(data, valueOffset + 8, littleEndian);
+                    const seconds = this.readRational(data, valueOffset + 16, littleEndian);
+                    latitude = degrees + minutes / 60 + seconds / 3600;
+                }
+                // GPSLongitudeRef (0x0003)
+                if (tag === 0x0003 && type === 2) {
+                    lonRef = String.fromCharCode(data[entryOffset + 8]);
+                }
+                // GPSLongitude (0x0004)
+                if (tag === 0x0004 && type === 5 && valueOffset + 24 <= data.length) {
+                    const degrees = this.readRational(data, valueOffset, littleEndian);
+                    const minutes = this.readRational(data, valueOffset + 8, littleEndian);
+                    const seconds = this.readRational(data, valueOffset + 16, littleEndian);
+                    longitude = degrees + minutes / 60 + seconds / 3600;
+                }
+            }
+            // Apply hemisphere references
+            if (latitude !== undefined && latRef) {
+                metadata.latitude = latRef === "S" ? -latitude : latitude;
+            }
+            if (longitude !== undefined && lonRef) {
+                metadata.longitude = lonRef === "W" ? -longitude : longitude;
+            }
+        }
+        catch (_e) {
+            // Ignore GPS parsing errors
+        }
+    }
+    readRational(data, offset, littleEndian) {
+        const numerator = littleEndian
+            ? data[offset] | (data[offset + 1] << 8) | (data[offset + 2] << 16) |
+                (data[offset + 3] << 24)
+            : (data[offset] << 24) | (data[offset + 1] << 16) |
+                (data[offset + 2] << 8) | data[offset + 3];
+        const denominator = littleEndian
+            ? data[offset + 4] | (data[offset + 5] << 8) | (data[offset + 6] << 16) |
+                (data[offset + 7] << 24)
+            : (data[offset + 4] << 24) | (data[offset + 5] << 16) |
+                (data[offset + 6] << 8) | data[offset + 7];
+        return denominator !== 0 ? numerator / denominator : 0;
+    }
     parseXMP(data, metadata) {
-        // XMP is XML-based metadata - simple parsing for common fields
+        // Parse XMP using the centralized utility
         try {
             const xmpStr = new TextDecoder().decode(data);
-            // Extract title
-            const titleMatch = xmpStr.match(/<dc:title[^>]*>([^<]+)<\/dc:title>/);
-            if (titleMatch)
-                metadata.title = titleMatch[1].trim();
-            // Extract description
-            const descMatch = xmpStr.match(/<dc:description[^>]*>([^<]+)<\/dc:description>/);
-            if (descMatch)
-                metadata.description = descMatch[1].trim();
-            // Extract creator/author
-            const creatorMatch = xmpStr.match(/<dc:creator[^>]*>([^<]+)<\/dc:creator>/);
-            if (creatorMatch)
-                metadata.author = creatorMatch[1].trim();
-            // Extract rights/copyright
-            const rightsMatch = xmpStr.match(/<dc:rights[^>]*>([^<]+)<\/dc:rights>/);
-            if (rightsMatch)
-                metadata.copyright = rightsMatch[1].trim();
+            const parsedMetadata = parseXMP(xmpStr);
+            // Merge parsed metadata into the existing metadata object
+            Object.assign(metadata, parsedMetadata);
         }
         catch (_e) {
             // Ignore XMP parsing errors
@@ -284,8 +357,9 @@ export class WebPFormat {
         chunks.push(webpData.slice(0, 12));
         // Create metadata chunks
         const metadataChunks = [];
-        // Create EXIF chunk if we have date or other EXIF data
-        if (metadata.creationDate) {
+        // Create EXIF chunk if we have date or GPS data
+        if (metadata.creationDate ||
+            (metadata.latitude !== undefined && metadata.longitude !== undefined)) {
             const exifData = this.createEXIFChunk(metadata);
             if (exifData) {
                 metadataChunks.push(exifData);
@@ -341,7 +415,10 @@ export class WebPFormat {
         return finalData;
     }
     createEXIFChunk(metadata) {
-        if (!metadata.creationDate)
+        const hasDate = metadata.creationDate !== undefined;
+        const hasGPS = metadata.latitude !== undefined &&
+            metadata.longitude !== undefined;
+        if (!hasDate && !hasGPS)
             return null;
         const exifData = [];
         // Byte order marker (little endian)
@@ -349,21 +426,47 @@ export class WebPFormat {
         exifData.push(0x2a, 0x00); // 42
         // IFD0 offset
         exifData.push(0x08, 0x00, 0x00, 0x00);
-        // Number of entries
-        exifData.push(0x01, 0x00);
-        // DateTime entry
-        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`;
-        const dateBytes = new TextEncoder().encode(dateStr);
-        // Tag 0x0132, Type 2 (ASCII), Count, Offset
-        exifData.push(0x32, 0x01, 0x02, 0x00);
-        exifData.push(dateBytes.length & 0xff, (dateBytes.length >> 8) & 0xff, (dateBytes.length >> 16) & 0xff, (dateBytes.length >> 24) & 0xff);
-        exifData.push(0x12, 0x00, 0x00, 0x00); // Offset to data
+        // Number of entries (DateTime + GPS IFD pointer if needed)
+        const numEntries = (hasDate ? 1 : 0) + (hasGPS ? 1 : 0);
+        exifData.push(numEntries & 0xff, (numEntries >> 8) & 0xff);
+        let dataOffset = 8 + 2 + numEntries * 12 + 4;
+        // DateTime entry (if present)
+        if (hasDate) {
+            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`;
+            const dateBytes = new TextEncoder().encode(dateStr);
+            // Tag 0x0132, Type 2 (ASCII), Count, Offset
+            exifData.push(0x32, 0x01, 0x02, 0x00);
+            exifData.push(dateBytes.length & 0xff, (dateBytes.length >> 8) & 0xff, (dateBytes.length >> 16) & 0xff, (dateBytes.length >> 24) & 0xff);
+            exifData.push(dataOffset & 0xff, (dataOffset >> 8) & 0xff, (dataOffset >> 16) & 0xff, (dataOffset >> 24) & 0xff);
+            dataOffset += dateBytes.length;
+        }
+        // GPS IFD pointer (if present)
+        let gpsIfdOffset = 0;
+        if (hasGPS) {
+            gpsIfdOffset = dataOffset;
+            exifData.push(0x25, 0x88); // Tag 0x8825
+            exifData.push(0x04, 0x00); // Type LONG
+            exifData.push(0x01, 0x00, 0x00, 0x00); // Count 1
+            exifData.push(gpsIfdOffset & 0xff, (gpsIfdOffset >> 8) & 0xff, (gpsIfdOffset >> 16) & 0xff, (gpsIfdOffset >> 24) & 0xff);
+        }
         // Next IFD
         exifData.push(0x00, 0x00, 0x00, 0x00);
-        // Date string data
-        for (const byte of dateBytes) {
-            exifData.push(byte);
+        // Date string data (if present)
+        if (hasDate) {
+            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`;
+            const dateBytes = new TextEncoder().encode(dateStr);
+            for (const byte of dateBytes) {
+                exifData.push(byte);
+            }
+        }
+        // GPS IFD data (if present)
+        if (hasGPS) {
+            const gpsIfd = this.createGPSIFD(metadata, gpsIfdOffset);
+            for (const byte of gpsIfd) {
+                exifData.push(byte);
+            }
         }
         // Create chunk header
         const chunkData = new Uint8Array(exifData);
@@ -376,29 +479,59 @@ export class WebPFormat {
         chunk.set(chunkData, 8);
         return chunk;
     }
+    createGPSIFD(metadata, gpsIfdStart) {
+        const gps = [];
+        const numEntries = 4;
+        gps.push(numEntries & 0xff, (numEntries >> 8) & 0xff);
+        const latitude = metadata.latitude;
+        const longitude = metadata.longitude;
+        const absLat = Math.abs(latitude);
+        const absLon = Math.abs(longitude);
+        const latDeg = Math.floor(absLat);
+        const latMin = Math.floor((absLat - latDeg) * 60);
+        const latSec = ((absLat - latDeg) * 60 - latMin) * 60;
+        const lonDeg = Math.floor(absLon);
+        const lonMin = Math.floor((absLon - lonDeg) * 60);
+        const lonSec = ((absLon - lonDeg) * 60 - lonMin) * 60;
+        let dataOffset = gpsIfdStart + 2 + numEntries * 12 + 4;
+        // GPSLatitudeRef
+        gps.push(0x01, 0x00);
+        gps.push(0x02, 0x00);
+        gps.push(0x02, 0x00, 0x00, 0x00);
+        gps.push(latitude >= 0 ? 78 : 83, 0x00, 0x00, 0x00);
+        // GPSLatitude
+        gps.push(0x02, 0x00);
+        gps.push(0x05, 0x00);
+        gps.push(0x03, 0x00, 0x00, 0x00);
+        gps.push(dataOffset & 0xff, (dataOffset >> 8) & 0xff, (dataOffset >> 16) & 0xff, (dataOffset >> 24) & 0xff);
+        dataOffset += 24;
+        // GPSLongitudeRef
+        gps.push(0x03, 0x00);
+        gps.push(0x02, 0x00);
+        gps.push(0x02, 0x00, 0x00, 0x00);
+        gps.push(longitude >= 0 ? 69 : 87, 0x00, 0x00, 0x00);
+        // GPSLongitude
+        gps.push(0x04, 0x00);
+        gps.push(0x05, 0x00);
+        gps.push(0x03, 0x00, 0x00, 0x00);
+        gps.push(dataOffset & 0xff, (dataOffset >> 8) & 0xff, (dataOffset >> 16) & 0xff, (dataOffset >> 24) & 0xff);
+        gps.push(0x00, 0x00, 0x00, 0x00);
+        // Write rationals
+        this.writeRational(gps, latDeg, 1);
+        this.writeRational(gps, latMin, 1);
+        this.writeRational(gps, Math.round(latSec * 1000000), 1000000);
+        this.writeRational(gps, lonDeg, 1);
+        this.writeRational(gps, lonMin, 1);
+        this.writeRational(gps, Math.round(lonSec * 1000000), 1000000);
+        return gps;
+    }
+    writeRational(output, numerator, denominator) {
+        output.push(numerator & 0xff, (numerator >> 8) & 0xff, (numerator >> 16) & 0xff, (numerator >> 24) & 0xff);
+        output.push(denominator & 0xff, (denominator >> 8) & 0xff, (denominator >> 16) & 0xff, (denominator >> 24) & 0xff);
+    }
     createXMPChunk(metadata) {
-        const xmpParts = [];
-        xmpParts.push('<?xpacket begin="" id="W5M0MpCehiHzreSzNTczkc9d"?>');
-        xmpParts.push('<x:xmpmeta xmlns:x="adobe:ns:meta/">');
-        xmpParts.push('<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">');
-        xmpParts.push('<rdf:Description xmlns:dc="http://purl.org/dc/elements/1.1/">');
-        if (metadata.title) {
-            xmpParts.push(`<dc:title>${this.escapeXML(metadata.title)}</dc:title>`);
-        }
-        if (metadata.description) {
-            xmpParts.push(`<dc:description>${this.escapeXML(metadata.description)}</dc:description>`);
-        }
-        if (metadata.author) {
-            xmpParts.push(`<dc:creator>${this.escapeXML(metadata.author)}</dc:creator>`);
-        }
-        if (metadata.copyright) {
-            xmpParts.push(`<dc:rights>${this.escapeXML(metadata.copyright)}</dc:rights>`);
-        }
-        xmpParts.push("</rdf:Description>");
-        xmpParts.push("</rdf:RDF>");
-        xmpParts.push("</x:xmpmeta>");
-        xmpParts.push('<?xpacket end="w"?>');
-        const xmpStr = xmpParts.join("\n");
+        // Use the centralized XMP utility to create the XMP packet
+        const xmpStr = createXMP(metadata);
         const xmpData = new TextEncoder().encode(xmpStr);
         // Create chunk
         const chunk = new Uint8Array(8 + xmpData.length);
@@ -410,12 +543,28 @@ export class WebPFormat {
         chunk.set(xmpData, 8);
         return chunk;
     }
-    escapeXML(str) {
-        return str
-            .replace(/&/g, "&amp;")
-            .replace(/</g, "&lt;")
-            .replace(/>/g, "&gt;")
-            .replace(/"/g, "&quot;")
-            .replace(/'/g, "&apos;");
+    /**
+     * Get the list of metadata fields supported by WebP format
+     */
+    getSupportedMetadata() {
+        return [
+            // EXIF chunk
+            "creationDate",
+            "latitude",
+            "longitude",
+            // XMP chunk (enhanced support)
+            "title",
+            "description",
+            "author",
+            "copyright",
+            "cameraMake",
+            "cameraModel",
+            "orientation",
+            "software",
+            "iso",
+            "exposureTime",
+            "fNumber",
+            "focalLength",
+        ];
     }
 }

package/esm/src/image.d.ts

@@ -79,6 +79,12 @@ export declare class Image {
      * @returns Image instance
      */
     static decode(data: Uint8Array, format?: string): Promise<Image>;
+    /**
+     * Get supported metadata fields for a specific format
+     * @param format Format name (e.g., "jpeg", "png", "webp")
+     * @returns Array of supported metadata field names, or undefined if format doesn't support metadata
+     */
+    static getSupportedMetadata(format: string): Array<keyof ImageMetadata> | undefined;
     /**
      * Read an image from bytes
      * @deprecated Use `decode()` instead. This method will be removed in a future version.
@@ -197,6 +203,12 @@ export declare class Image {
      * @returns This image instance for chaining
      */
     saturation(amount: number): this;
+    /**
+     * Adjust hue of the image by rotating the color wheel
+     * @param degrees Hue rotation in degrees (any value accepted, wraps at 360)
+     * @returns This image instance for chaining
+     */
+    hue(degrees: number): this;
     /**
      * Invert colors of the image
      * @returns This image instance for chaining
@@ -282,5 +294,44 @@ export declare class Image {
      * @returns This image instance for chaining
      */
     setPixel(x: number, y: number, r: number, g: number, b: number, a?: number): this;
+    /**
+     * Rotate the image 90 degrees clockwise
+     * @returns This image instance for chaining
+     */
+    rotate90(): this;
+    /**
+     * Rotate the image 180 degrees
+     * @returns This image instance for chaining
+     */
+    rotate180(): this;
+    /**
+     * Rotate the image 270 degrees clockwise (or 90 degrees counter-clockwise)
+     * @returns This image instance for chaining
+     */
+    rotate270(): this;
+    /**
+     * Rotate the image by the specified angle in degrees
+     * @param degrees Rotation angle in degrees (positive = clockwise, negative = counter-clockwise)
+     * @returns This image instance for chaining
+     *
+     * @example
+     * ```ts
+     * image.rotate(90);   // Rotate 90° clockwise
+     * image.rotate(-90);  // Rotate 90° counter-clockwise
+     * image.rotate(180);  // Rotate 180°
+     * image.rotate(45);   // Rotate 45° clockwise (rounded to nearest 90°)
+     * ```
+     */
+    rotate(degrees: number): this;
+    /**
+     * Flip the image horizontally (mirror)
+     * @returns This image instance for chaining
+     */
+    flipHorizontal(): this;
+    /**
+     * Flip the image vertically
+     * @returns This image instance for chaining
+     */
+    flipVertical(): this;
 }
 //# sourceMappingURL=image.d.ts.map

package/esm/src/image.js

@@ -1,5 +1,5 @@
-import { resizeBilinear, resizeNearest } from "./utils/resize.js";
-import { adjustBrightness, adjustContrast, adjustExposure, adjustSaturation, boxBlur, composite, crop, fillRect, gaussianBlur, grayscale, invert, medianFilter, sepia, sharpen, } from "./utils/image_processing.js";
+import { resizeBicubic, resizeBilinear, resizeNearest, } from "./utils/resize.js";
+import { adjustBrightness, adjustContrast, adjustExposure, adjustHue, adjustSaturation, boxBlur, composite, crop, fillRect, flipHorizontal, flipVertical, gaussianBlur, grayscale, invert, medianFilter, rotate180, rotate270, rotate90, sepia, sharpen, } from "./utils/image_processing.js";
 import { PNGFormat } from "./formats/png.js";
 import { APNGFormat } from "./formats/apng.js";
 import { JPEGFormat } from "./formats/jpeg.js";
@@ -181,6 +181,18 @@ export class Image {
         }
         throw new Error("Unsupported or unrecognized image format");
     }
+    /**
+     * Get supported metadata fields for a specific format
+     * @param format Format name (e.g., "jpeg", "png", "webp")
+     * @returns Array of supported metadata field names, or undefined if format doesn't support metadata
+     */
+    static getSupportedMetadata(format) {
+        const formatHandler = Image.formats.find((f) => f.name === format.toLowerCase());
+        if (!formatHandler) {
+            throw new Error(`Unknown image format: ${format}`);
+        }
+        return formatHandler.getSupportedMetadata?.();
+    }
     /**
      * Read an image from bytes
      * @deprecated Use `decode()` instead. This method will be removed in a future version.
@@ -301,19 +313,98 @@ export class Image {
     resize(options) {
         if (!this.imageData)
             throw new Error("No image loaded");
-        const { width, height, method = "bilinear" } = options;
+        const { width, height, method = "bilinear", fit = "stretch" } = options;
         // Validate new dimensions for security (prevent integer overflow and heap exhaustion)
         validateImageDimensions(width, height);
         const { data: srcData, width: srcWidth, height: srcHeight } = this.imageData;
+        // Handle fitting modes
+        let targetWidth = width;
+        let targetHeight = height;
+        let shouldCenter = false;
+        const fitMode = fit === "contain" ? "fit" : fit === "cover" ? "fill" : fit;
+        if (fitMode === "fit" || fitMode === "fill") {
+            const srcAspect = srcWidth / srcHeight;
+            const targetAspect = width / height;
+            if (fitMode === "fit") {
+                // Fit within dimensions (letterbox)
+                if (srcAspect > targetAspect) {
+                    // Source is wider - fit to width
+                    targetWidth = width;
+                    targetHeight = Math.round(width / srcAspect);
+                }
+                else {
+                    // Source is taller - fit to height
+                    targetWidth = Math.round(height * srcAspect);
+                    targetHeight = height;
+                }
+                shouldCenter = true;
+            }
+            else {
+                // Fill dimensions (crop)
+                if (srcAspect > targetAspect) {
+                    // Source is wider - fit to height and crop width
+                    targetWidth = Math.round(height * srcAspect);
+                    targetHeight = height;
+                }
+                else {
+                    // Source is taller - fit to width and crop height
+                    targetWidth = width;
+                    targetHeight = Math.round(width / srcAspect);
+                }
+                shouldCenter = true;
+            }
+        }
+        // Perform the resize
         let resizedData;
         if (method === "nearest") {
-            resizedData = resizeNearest(srcData, srcWidth, srcHeight, width, height);
+            resizedData = resizeNearest(srcData, srcWidth, srcHeight, targetWidth, targetHeight);
+        }
+        else if (method === "bicubic") {
+            resizedData = resizeBicubic(srcData, srcWidth, srcHeight, targetWidth, targetHeight);
         }
         else {
-            resizedData = resizeBilinear(srcData, srcWidth, srcHeight, width, height);
+            resizedData = resizeBilinear(srcData, srcWidth, srcHeight, targetWidth, targetHeight);
         }
         // Preserve metadata when resizing
         const metadata = this.imageData.metadata;
+        // If we need to center (fit mode) or crop (fill mode), create a canvas
+        if (shouldCenter && (targetWidth !== width || targetHeight !== height)) {
+            const canvas = new Uint8Array(width * height * 4);
+            // Fill with transparent black by default
+            canvas.fill(0);
+            if (fitMode === "fit") {
+                // Center the resized image (letterbox)
+                const offsetX = Math.floor((width - targetWidth) / 2);
+                const offsetY = Math.floor((height - targetHeight) / 2);
+                for (let y = 0; y < targetHeight; y++) {
+                    for (let x = 0; x < targetWidth; x++) {
+                        const srcIdx = (y * targetWidth + x) * 4;
+                        const dstIdx = ((y + offsetY) * width + (x + offsetX)) * 4;
+                        canvas[dstIdx] = resizedData[srcIdx];
+                        canvas[dstIdx + 1] = resizedData[srcIdx + 1];
+                        canvas[dstIdx + 2] = resizedData[srcIdx + 2];
+                        canvas[dstIdx + 3] = resizedData[srcIdx + 3];
+                    }
+                }
+                resizedData = canvas;
+            }
+            else {
+                // Crop to fill (center crop)
+                const offsetX = Math.floor((targetWidth - width) / 2);
+                const offsetY = Math.floor((targetHeight - height) / 2);
+                for (let y = 0; y < height; y++) {
+                    for (let x = 0; x < width; x++) {
+                        const srcIdx = ((y + offsetY) * targetWidth + (x + offsetX)) * 4;
+                        const dstIdx = (y * width + x) * 4;
+                        canvas[dstIdx] = resizedData[srcIdx];
+                        canvas[dstIdx + 1] = resizedData[srcIdx + 1];
+                        canvas[dstIdx + 2] = resizedData[srcIdx + 2];
+                        canvas[dstIdx + 3] = resizedData[srcIdx + 3];
+                    }
+                }
+                resizedData = canvas;
+            }
+        }
         this.imageData = {
             width,
             height,
@@ -439,6 +530,17 @@ export class Image {
         this.imageData.data = adjustSaturation(this.imageData.data, amount);
         return this;
     }
+    /**
+     * Adjust hue of the image by rotating the color wheel
+     * @param degrees Hue rotation in degrees (any value accepted, wraps at 360)
+     * @returns This image instance for chaining
+     */
+    hue(degrees) {
+        if (!this.imageData)
+            throw new Error("No image loaded");
+        this.imageData.data = adjustHue(this.imageData.data, degrees);
+        return this;
+    }
     /**
      * Invert colors of the image
      * @returns This image instance for chaining
@@ -602,6 +704,124 @@ export class Image {
         this.imageData.data[idx + 3] = a;
         return this;
     }
+    /**
+     * Rotate the image 90 degrees clockwise
+     * @returns This image instance for chaining
+     */
+    rotate90() {
+        if (!this.imageData)
+            throw new Error("No image loaded");
+        const result = rotate90(this.imageData.data, this.imageData.width, this.imageData.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 && metadata.dpiY) {
+                // Swap physical dimensions
+                const tempPhysical = metadata.physicalWidth;
+                this.imageData.metadata.physicalWidth = metadata.physicalHeight;
+                this.imageData.metadata.physicalHeight = tempPhysical;
+                // Swap DPI
+                const tempDpi = metadata.dpiX;
+                this.imageData.metadata.dpiX = metadata.dpiY;
+                this.imageData.metadata.dpiY = tempDpi;
+            }
+        }
+        return this;
+    }
+    /**
+     * Rotate the image 180 degrees
+     * @returns This image instance for chaining
+     */
+    rotate180() {
+        if (!this.imageData)
+            throw new Error("No image loaded");
+        this.imageData.data = rotate180(this.imageData.data, this.imageData.width, this.imageData.height);
+        return this;
+    }
+    /**
+     * Rotate the image 270 degrees clockwise (or 90 degrees counter-clockwise)
+     * @returns This image instance for chaining
+     */
+    rotate270() {
+        if (!this.imageData)
+            throw new Error("No image loaded");
+        const result = rotate270(this.imageData.data, this.imageData.width, this.imageData.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 && metadata.dpiY) {
+                // Swap physical dimensions
+                const tempPhysical = metadata.physicalWidth;
+                this.imageData.metadata.physicalWidth = metadata.physicalHeight;
+                this.imageData.metadata.physicalHeight = tempPhysical;
+                // Swap DPI
+                const tempDpi = metadata.dpiX;
+                this.imageData.metadata.dpiX = metadata.dpiY;
+                this.imageData.metadata.dpiY = tempDpi;
+            }
+        }
+        return this;
+    }
+    /**
+     * Rotate the image by the specified angle in degrees
+     * @param degrees Rotation angle in degrees (positive = clockwise, negative = counter-clockwise)
+     * @returns This image instance for chaining
+     *
+     * @example
+     * ```ts
+     * image.rotate(90);   // Rotate 90° clockwise
+     * image.rotate(-90);  // Rotate 90° counter-clockwise
+     * image.rotate(180);  // Rotate 180°
+     * image.rotate(45);   // Rotate 45° clockwise (rounded to nearest 90°)
+     * ```
+     */
+    rotate(degrees) {
+        // Normalize to 0-360 range
+        let normalizedDegrees = degrees % 360;
+        if (normalizedDegrees < 0) {
+            normalizedDegrees += 360;
+        }
+        // Round to nearest 90 degrees
+        const rounded = Math.round(normalizedDegrees / 90) * 90;
+        // Apply rotation based on rounded value
+        switch (rounded % 360) {
+            case 90:
+                return this.rotate90();
+            case 180:
+                return this.rotate180();
+            case 270:
+                return this.rotate270();
+            default:
+                // 0 or 360 degrees - no rotation needed
+                return this;
+        }
+    }
+    /**
+     * Flip the image horizontally (mirror)
+     * @returns This image instance for chaining
+     */
+    flipHorizontal() {
+        if (!this.imageData)
+            throw new Error("No image loaded");
+        this.imageData.data = flipHorizontal(this.imageData.data, this.imageData.width, this.imageData.height);
+        return this;
+    }
+    /**
+     * Flip the image vertically
+     * @returns This image instance for chaining
+     */
+    flipVertical() {
+        if (!this.imageData)
+            throw new Error("No image loaded");
+        this.imageData.data = flipVertical(this.imageData.data, this.imageData.width, this.imageData.height);
+        return this;
+    }
 }
 Object.defineProperty(Image, "formats", {
     enumerable: true,