cross-image 0.2.2 → 0.2.4

package/esm/src/utils/image_processing.js

@@ -131,6 +131,99 @@ export function adjustSaturation(data, amount) {
     }
     return result;
 }
+/**
+ * Convert RGB to HSL color space
+ * @param r Red component (0-255)
+ * @param g Green component (0-255)
+ * @param b Blue component (0-255)
+ * @returns HSL values: [h (0-360), s (0-1), l (0-1)]
+ */
+function rgbToHsl(r, g, b) {
+    r /= 255;
+    g /= 255;
+    b /= 255;
+    const max = Math.max(r, g, b);
+    const min = Math.min(r, g, b);
+    const delta = max - min;
+    let h = 0;
+    let s = 0;
+    const l = (max + min) / 2;
+    if (delta !== 0) {
+        s = l > 0.5 ? delta / (2 - max - min) : delta / (max + min);
+        if (max === r) {
+            h = ((g - b) / delta + (g < b ? 6 : 0)) / 6;
+        }
+        else if (max === g) {
+            h = ((b - r) / delta + 2) / 6;
+        }
+        else {
+            h = ((r - g) / delta + 4) / 6;
+        }
+    }
+    return [h * 360, s, l];
+}
+/**
+ * Convert HSL to RGB color space
+ * @param h Hue (0-360)
+ * @param s Saturation (0-1)
+ * @param l Lightness (0-1)
+ * @returns RGB values: [r (0-255), g (0-255), b (0-255)]
+ */
+function hslToRgb(h, s, l) {
+    h = h / 360;
+    let r, g, b;
+    if (s === 0) {
+        r = g = b = l; // Achromatic
+    }
+    else {
+        const hue2rgb = (p, q, t) => {
+            if (t < 0)
+                t += 1;
+            if (t > 1)
+                t -= 1;
+            if (t < 1 / 6)
+                return p + (q - p) * 6 * t;
+            if (t < 1 / 2)
+                return q;
+            if (t < 2 / 3)
+                return p + (q - p) * (2 / 3 - t) * 6;
+            return p;
+        };
+        const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+        const p = 2 * l - q;
+        r = hue2rgb(p, q, h + 1 / 3);
+        g = hue2rgb(p, q, h);
+        b = hue2rgb(p, q, h - 1 / 3);
+    }
+    return [Math.round(r * 255), Math.round(g * 255), Math.round(b * 255)];
+}
+/**
+ * Adjust hue of an image by rotating the hue wheel
+ * @param data Image data (RGBA)
+ * @param degrees Hue rotation in degrees (any value accepted, wraps at 360)
+ * @returns New image data with adjusted hue
+ */
+export function adjustHue(data, degrees) {
+    const result = new Uint8Array(data.length);
+    // Normalize rotation to -180 to 180 range
+    const rotation = ((degrees % 360) + 360) % 360;
+    for (let i = 0; i < data.length; i += 4) {
+        const r = data[i];
+        const g = data[i + 1];
+        const b = data[i + 2];
+        // Convert to HSL
+        const [h, s, l] = rgbToHsl(r, g, b);
+        // Rotate hue
+        const newH = (h + rotation) % 360;
+        // Convert back to RGB
+        const [newR, newG, newB] = hslToRgb(newH, s, l);
+        result[i] = newR;
+        result[i + 1] = newG;
+        result[i + 2] = newB;
+        result[i + 3] = data[i + 3]; // Preserve alpha
+    }
+    return result;
+}
 /**
  * Invert colors of an image
  * @param data Image data (RGBA)
@@ -459,3 +552,120 @@ export function medianFilter(data, width, height, radius = 1) {
     }
     return result;
 }
+/**
+ * Rotate image 90 degrees clockwise
+ * @param data Image data (RGBA)
+ * @param width Image width
+ * @param height Image height
+ * @returns Rotated image data with swapped dimensions
+ */
+export function rotate90(data, width, height) {
+    const result = new Uint8Array(data.length);
+    const newWidth = height;
+    const newHeight = width;
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const srcIdx = (y * width + x) * 4;
+            const dstX = height - 1 - y;
+            const dstY = x;
+            const dstIdx = (dstY * newWidth + 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 { data: result, width: newWidth, height: newHeight };
+}
+/**
+ * Rotate image 180 degrees
+ * @param data Image data (RGBA)
+ * @param width Image width
+ * @param height Image height
+ * @returns Rotated image data with same dimensions
+ */
+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];
+        }
+    }
+    return result;
+}
+/**
+ * Rotate image 270 degrees clockwise (or 90 degrees counter-clockwise)
+ * @param data Image data (RGBA)
+ * @param width Image width
+ * @param height Image height
+ * @returns Rotated image data with swapped dimensions
+ */
+export function rotate270(data, width, height) {
+    const result = new Uint8Array(data.length);
+    const newWidth = height;
+    const newHeight = width;
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const srcIdx = (y * width + x) * 4;
+            const dstX = y;
+            const dstY = width - 1 - x;
+            const dstIdx = (dstY * newWidth + 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 { data: result, width: newWidth, height: newHeight };
+}
+/**
+ * Flip image horizontally (mirror)
+ * @param data Image data (RGBA)
+ * @param width Image width
+ * @param height Image height
+ * @returns Flipped image data
+ */
+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];
+        }
+    }
+    return result;
+}
+/**
+ * Flip image vertically
+ * @param data Image data (RGBA)
+ * @param width Image width
+ * @param height Image height
+ * @returns Flipped image data
+ */
+export function flipVertical(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 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];
+        }
+    }
+    return result;
+}

package/esm/src/utils/metadata/xmp.d.ts

@@ -0,0 +1,52 @@
+/**
+ * XMP (Extensible Metadata Platform) parsing and writing utilities
+ *
+ * This module provides utilities for reading and writing XMP metadata in image files.
+ * It supports Dublin Core, EXIF, and Photoshop namespaces.
+ */
+import type { ImageMetadata } from "../../types.js";
+/**
+ * XMP namespace URIs
+ */
+export declare const XMP_NAMESPACES: {
+    readonly RDF: "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
+    readonly DC: "http://purl.org/dc/elements/1.1/";
+    readonly XMP: "http://ns.adobe.com/xap/1.0/";
+    readonly EXIF: "http://ns.adobe.com/exif/1.0/";
+    readonly TIFF: "http://ns.adobe.com/tiff/1.0/";
+    readonly PHOTOSHOP: "http://ns.adobe.com/photoshop/1.0/";
+    readonly XMP_RIGHTS: "http://ns.adobe.com/xap/1.0/rights/";
+};
+/**
+ * XMP Dublin Core field mapping to ImageMetadata
+ */
+export interface XMPFieldMapping {
+    xmpPath: string;
+    metadataKey: keyof ImageMetadata;
+    namespace: string;
+}
+/**
+ * Supported XMP fields and their mappings
+ */
+export declare const XMP_FIELD_MAPPINGS: XMPFieldMapping[];
+/**
+ * Escape XML special characters
+ */
+export declare function escapeXML(str: string): string;
+/**
+ * Unescape XML special characters
+ */
+export declare function unescapeXML(str: string): string;
+/**
+ * Parse XMP metadata from XML string
+ */
+export declare function parseXMP(xmpStr: string): Partial<ImageMetadata>;
+/**
+ * Create XMP packet from metadata
+ */
+export declare function createXMP(metadata: Partial<ImageMetadata>): string;
+/**
+ * Get list of supported XMP metadata fields
+ */
+export declare function getSupportedXMPFields(): Array<keyof ImageMetadata>;
+//# sourceMappingURL=xmp.d.ts.map

package/esm/src/utils/metadata/xmp.js

@@ -0,0 +1,325 @@
+/**
+ * XMP (Extensible Metadata Platform) parsing and writing utilities
+ *
+ * This module provides utilities for reading and writing XMP metadata in image files.
+ * It supports Dublin Core, EXIF, and Photoshop namespaces.
+ */
+/**
+ * XMP namespace URIs
+ */
+export const XMP_NAMESPACES = {
+    RDF: "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+    DC: "http://purl.org/dc/elements/1.1/",
+    XMP: "http://ns.adobe.com/xap/1.0/",
+    EXIF: "http://ns.adobe.com/exif/1.0/",
+    TIFF: "http://ns.adobe.com/tiff/1.0/",
+    PHOTOSHOP: "http://ns.adobe.com/photoshop/1.0/",
+    XMP_RIGHTS: "http://ns.adobe.com/xap/1.0/rights/",
+};
+/**
+ * Supported XMP fields and their mappings
+ */
+export const XMP_FIELD_MAPPINGS = [
+    // Dublin Core
+    { xmpPath: "dc:title", metadataKey: "title", namespace: XMP_NAMESPACES.DC },
+    {
+        xmpPath: "dc:description",
+        metadataKey: "description",
+        namespace: XMP_NAMESPACES.DC,
+    },
+    {
+        xmpPath: "dc:creator",
+        metadataKey: "author",
+        namespace: XMP_NAMESPACES.DC,
+    },
+    {
+        xmpPath: "dc:rights",
+        metadataKey: "copyright",
+        namespace: XMP_NAMESPACES.DC,
+    },
+    // EXIF namespace
+    {
+        xmpPath: "exif:DateTimeOriginal",
+        metadataKey: "creationDate",
+        namespace: XMP_NAMESPACES.EXIF,
+    },
+    {
+        xmpPath: "exif:ISOSpeedRatings",
+        metadataKey: "iso",
+        namespace: XMP_NAMESPACES.EXIF,
+    },
+    {
+        xmpPath: "exif:ExposureTime",
+        metadataKey: "exposureTime",
+        namespace: XMP_NAMESPACES.EXIF,
+    },
+    {
+        xmpPath: "exif:FNumber",
+        metadataKey: "fNumber",
+        namespace: XMP_NAMESPACES.EXIF,
+    },
+    {
+        xmpPath: "exif:FocalLength",
+        metadataKey: "focalLength",
+        namespace: XMP_NAMESPACES.EXIF,
+    },
+    {
+        xmpPath: "exif:Flash",
+        metadataKey: "flash",
+        namespace: XMP_NAMESPACES.EXIF,
+    },
+    {
+        xmpPath: "exif:WhiteBalance",
+        metadataKey: "whiteBalance",
+        namespace: XMP_NAMESPACES.EXIF,
+    },
+    {
+        xmpPath: "exif:UserComment",
+        metadataKey: "userComment",
+        namespace: XMP_NAMESPACES.EXIF,
+    },
+    // TIFF namespace
+    {
+        xmpPath: "tiff:Make",
+        metadataKey: "cameraMake",
+        namespace: XMP_NAMESPACES.TIFF,
+    },
+    {
+        xmpPath: "tiff:Model",
+        metadataKey: "cameraModel",
+        namespace: XMP_NAMESPACES.TIFF,
+    },
+    {
+        xmpPath: "tiff:Orientation",
+        metadataKey: "orientation",
+        namespace: XMP_NAMESPACES.TIFF,
+    },
+    {
+        xmpPath: "tiff:Software",
+        metadataKey: "software",
+        namespace: XMP_NAMESPACES.TIFF,
+    },
+    // Photoshop namespace
+    {
+        xmpPath: "photoshop:Credit",
+        metadataKey: "author",
+        namespace: XMP_NAMESPACES.PHOTOSHOP,
+    },
+];
+/**
+ * Escape XML special characters
+ */
+export function escapeXML(str) {
+    return str
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}
+/**
+ * Unescape XML special characters
+ */
+export function unescapeXML(str) {
+    return str
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&apos;/g, "'")
+        .replace(/&amp;/g, "&");
+}
+/**
+ * Parse XMP metadata from XML string
+ */
+export function parseXMP(xmpStr) {
+    const metadata = {};
+    try {
+        // Simple regex-based parsing for common fields
+        // Dublin Core - title (with dotall flag 's')
+        const titleMatch = xmpStr.match(/<dc:title[\s\S]*?<rdf:li[^>]*>([^<]+)<\/rdf:li>/);
+        if (titleMatch && titleMatch[1].trim()) {
+            metadata.title = unescapeXML(titleMatch[1].trim());
+        }
+        // Dublin Core - description
+        const descMatch = xmpStr.match(/<dc:description[\s\S]*?<rdf:li[^>]*>([^<]+)<\/rdf:li>/);
+        if (descMatch && descMatch[1].trim()) {
+            metadata.description = unescapeXML(descMatch[1].trim());
+        }
+        // Dublin Core - creator
+        const creatorMatch = xmpStr.match(/<dc:creator[\s\S]*?<rdf:li[^>]*>([^<]+)<\/rdf:li>/);
+        if (creatorMatch && creatorMatch[1].trim()) {
+            metadata.author = unescapeXML(creatorMatch[1].trim());
+        }
+        // Dublin Core - rights
+        const rightsMatch = xmpStr.match(/<dc:rights[\s\S]*?<rdf:li[^>]*>([^<]+)<\/rdf:li>/);
+        if (rightsMatch && rightsMatch[1].trim()) {
+            metadata.copyright = unescapeXML(rightsMatch[1].trim());
+        }
+        // EXIF - DateTimeOriginal
+        const dateMatch = xmpStr.match(/<exif:DateTimeOriginal>([^<]+)<\/exif:DateTimeOriginal>/);
+        if (dateMatch) {
+            try {
+                metadata.creationDate = new Date(dateMatch[1]);
+            }
+            catch (_e) {
+                // Ignore date parse errors
+            }
+        }
+        // TIFF - Make and Model
+        const makeMatch = xmpStr.match(/<tiff:Make>([^<]+)<\/tiff:Make>/);
+        if (makeMatch) {
+            metadata.cameraMake = unescapeXML(makeMatch[1]);
+        }
+        const modelMatch = xmpStr.match(/<tiff:Model>([^<]+)<\/tiff:Model>/);
+        if (modelMatch) {
+            metadata.cameraModel = unescapeXML(modelMatch[1]);
+        }
+        const softwareMatch = xmpStr.match(/<tiff:Software>([^<]+)<\/tiff:Software>/);
+        if (softwareMatch) {
+            metadata.software = unescapeXML(softwareMatch[1]);
+        }
+        const orientationMatch = xmpStr.match(/<tiff:Orientation>([^<]+)<\/tiff:Orientation>/);
+        if (orientationMatch) {
+            metadata.orientation = parseInt(orientationMatch[1]);
+        }
+        // EXIF - Camera settings
+        const isoMatch = xmpStr.match(/<exif:ISOSpeedRatings>(?:<rdf:Seq[^>]*><rdf:li>)?([^<]+)/);
+        if (isoMatch) {
+            metadata.iso = parseInt(isoMatch[1]);
+        }
+        const exposureMatch = xmpStr.match(/<exif:ExposureTime>([^<]+)<\/exif:ExposureTime>/);
+        if (exposureMatch) {
+            // Handle rational format (e.g., "1/250")
+            if (exposureMatch[1].includes("/")) {
+                const [num, den] = exposureMatch[1].split("/").map(Number);
+                metadata.exposureTime = num / den;
+            }
+            else {
+                metadata.exposureTime = parseFloat(exposureMatch[1]);
+            }
+        }
+        const fNumberMatch = xmpStr.match(/<exif:FNumber>([^<]+)<\/exif:FNumber>/);
+        if (fNumberMatch) {
+            metadata.fNumber = parseFloat(fNumberMatch[1]);
+        }
+        const focalLengthMatch = xmpStr.match(/<exif:FocalLength>([^<]+)<\/exif:FocalLength>/);
+        if (focalLengthMatch) {
+            metadata.focalLength = parseFloat(focalLengthMatch[1]);
+        }
+    }
+    catch (_e) {
+        // Ignore XMP parsing errors
+    }
+    return metadata;
+}
+/**
+ * Create XMP packet from metadata
+ */
+export function createXMP(metadata) {
+    const parts = [];
+    parts.push('<?xpacket begin="\ufeff" id="W5M0MpCehiHzreSzNTczkc9d"?>');
+    parts.push('<x:xmpmeta xmlns:x="adobe:ns:meta/" x:xmptk="@cross/image">');
+    parts.push('<rdf:RDF xmlns:rdf="' + XMP_NAMESPACES.RDF + '">');
+    parts.push('<rdf:Description rdf:about=""');
+    parts.push('  xmlns:dc="' + XMP_NAMESPACES.DC + '"');
+    parts.push('  xmlns:xmp="' + XMP_NAMESPACES.XMP + '"');
+    parts.push('  xmlns:exif="' + XMP_NAMESPACES.EXIF + '"');
+    parts.push('  xmlns:tiff="' + XMP_NAMESPACES.TIFF + '"');
+    parts.push('  xmlns:photoshop="' + XMP_NAMESPACES.PHOTOSHOP + '"');
+    parts.push('  xmlns:xmpRights="' + XMP_NAMESPACES.XMP_RIGHTS + '">');
+    // Dublin Core - title
+    if (metadata.title) {
+        parts.push("  <dc:title>");
+        parts.push("    <rdf:Alt>");
+        parts.push('      <rdf:li xml:lang="x-default">' + escapeXML(metadata.title) +
+            "</rdf:li>");
+        parts.push("    </rdf:Alt>");
+        parts.push("  </dc:title>");
+    }
+    // Dublin Core - description
+    if (metadata.description) {
+        parts.push("  <dc:description>");
+        parts.push("    <rdf:Alt>");
+        parts.push('      <rdf:li xml:lang="x-default">' + escapeXML(metadata.description) +
+            "</rdf:li>");
+        parts.push("    </rdf:Alt>");
+        parts.push("  </dc:description>");
+    }
+    // Dublin Core - creator
+    if (metadata.author) {
+        parts.push("  <dc:creator>");
+        parts.push("    <rdf:Seq>");
+        parts.push("      <rdf:li>" + escapeXML(metadata.author) + "</rdf:li>");
+        parts.push("    </rdf:Seq>");
+        parts.push("  </dc:creator>");
+    }
+    // Dublin Core - rights
+    if (metadata.copyright) {
+        parts.push("  <dc:rights>");
+        parts.push("    <rdf:Alt>");
+        parts.push('      <rdf:li xml:lang="x-default">' + escapeXML(metadata.copyright) +
+            "</rdf:li>");
+        parts.push("    </rdf:Alt>");
+        parts.push("  </dc:rights>");
+    }
+    // EXIF - DateTimeOriginal
+    if (metadata.creationDate) {
+        const isoDate = metadata.creationDate.toISOString();
+        parts.push("  <exif:DateTimeOriginal>" + isoDate + "</exif:DateTimeOriginal>");
+    }
+    // TIFF - Make and Model
+    if (metadata.cameraMake) {
+        parts.push("  <tiff:Make>" + escapeXML(metadata.cameraMake) + "</tiff:Make>");
+    }
+    if (metadata.cameraModel) {
+        parts.push("  <tiff:Model>" + escapeXML(metadata.cameraModel) + "</tiff:Model>");
+    }
+    if (metadata.software) {
+        parts.push("  <tiff:Software>" + escapeXML(metadata.software) + "</tiff:Software>");
+    }
+    if (metadata.orientation !== undefined) {
+        parts.push("  <tiff:Orientation>" + metadata.orientation + "</tiff:Orientation>");
+    }
+    // EXIF - Camera settings
+    if (metadata.iso !== undefined) {
+        parts.push("  <exif:ISOSpeedRatings>");
+        parts.push("    <rdf:Seq>");
+        parts.push("      <rdf:li>" + metadata.iso + "</rdf:li>");
+        parts.push("    </rdf:Seq>");
+        parts.push("  </exif:ISOSpeedRatings>");
+    }
+    if (metadata.exposureTime !== undefined) {
+        parts.push("  <exif:ExposureTime>" + metadata.exposureTime + "</exif:ExposureTime>");
+    }
+    if (metadata.fNumber !== undefined) {
+        parts.push("  <exif:FNumber>" + metadata.fNumber + "</exif:FNumber>");
+    }
+    if (metadata.focalLength !== undefined) {
+        parts.push("  <exif:FocalLength>" + metadata.focalLength + "</exif:FocalLength>");
+    }
+    parts.push("</rdf:Description>");
+    parts.push("</rdf:RDF>");
+    parts.push("</x:xmpmeta>");
+    parts.push('<?xpacket end="w"?>');
+    return parts.join("\n");
+}
+/**
+ * Get list of supported XMP metadata fields
+ */
+export function getSupportedXMPFields() {
+    return [
+        "title",
+        "description",
+        "author",
+        "copyright",
+        "creationDate",
+        "cameraMake",
+        "cameraModel",
+        "orientation",
+        "software",
+        "iso",
+        "exposureTime",
+        "fNumber",
+        "focalLength",
+    ];
+}

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

@@ -6,4 +6,8 @@ export declare function resizeBilinear(src: Uint8Array, srcWidth: number, srcHei
  * Nearest neighbor resize
  */
 export declare function resizeNearest(src: Uint8Array, srcWidth: number, srcHeight: number, dstWidth: number, dstHeight: number): Uint8Array;
+/**
+ * Bicubic interpolation resize (Catmull-Rom)
+ */
+export declare function resizeBicubic(src: Uint8Array, srcWidth: number, srcHeight: number, dstWidth: number, dstHeight: number): Uint8Array;
 //# sourceMappingURL=resize.d.ts.map

package/esm/src/utils/resize.js

@@ -50,3 +50,77 @@ export function resizeNearest(src, srcWidth, srcHeight, dstWidth, dstHeight) {
     }
     return dst;
 }
+/**
+ * Cubic interpolation kernel (Catmull-Rom)
+ *
+ * The Catmull-Rom spline provides smooth interpolation through control points.
+ * It's a special case of the cubic Hermite spline with specific tangent values.
+ *
+ * @param x Distance from the sample point
+ * @returns Weight for the sample at distance x
+ */
+function cubicKernel(x) {
+    const absX = Math.abs(x);
+    if (absX <= 1) {
+        return 1.5 * absX * absX * absX - 2.5 * absX * absX + 1;
+    }
+    else if (absX < 2) {
+        return -0.5 * absX * absX * absX + 2.5 * absX * absX - 4 * absX + 2;
+    }
+    return 0;
+}
+/**
+ * Get pixel value with bounds checking
+ *
+ * Clamps coordinates to valid image bounds to prevent out-of-bounds access.
+ * This ensures that edge pixels are repeated when sampling outside the image.
+ *
+ * @param src Source image data
+ * @param x X coordinate (may be outside bounds)
+ * @param y Y coordinate (may be outside bounds)
+ * @param width Image width
+ * @param height Image height
+ * @param channel Channel index (0=R, 1=G, 2=B, 3=A)
+ * @returns Pixel value at the clamped coordinates
+ */
+function getPixel(src, x, y, width, height, channel) {
+    const clampedX = Math.max(0, Math.min(width - 1, x));
+    const clampedY = Math.max(0, Math.min(height - 1, y));
+    return src[(clampedY * width + clampedX) * 4 + channel];
+}
+/**
+ * Bicubic interpolation resize (Catmull-Rom)
+ */
+export function resizeBicubic(src, srcWidth, srcHeight, dstWidth, dstHeight) {
+    const dst = new Uint8Array(dstWidth * dstHeight * 4);
+    const xRatio = srcWidth / dstWidth;
+    const yRatio = srcHeight / dstHeight;
+    for (let y = 0; y < dstHeight; y++) {
+        for (let x = 0; x < dstWidth; x++) {
+            const srcX = x * xRatio;
+            const srcY = y * yRatio;
+            const x0 = Math.floor(srcX);
+            const y0 = Math.floor(srcY);
+            const dx = srcX - x0;
+            const dy = srcY - y0;
+            // Process each channel separately
+            for (let c = 0; c < 4; c++) {
+                let value = 0;
+                // Sample 4x4 neighborhood
+                for (let j = -1; j <= 2; j++) {
+                    for (let i = -1; i <= 2; i++) {
+                        const px = x0 + i;
+                        const py = y0 + j;
+                        const pixelValue = getPixel(src, px, py, srcWidth, srcHeight, c);
+                        const weight = cubicKernel(i - dx) * cubicKernel(j - dy);
+                        value += pixelValue * weight;
+                    }
+                }
+                // Clamp to valid range
+                const dstIdx = (y * dstWidth + x) * 4 + c;
+                dst[dstIdx] = Math.max(0, Math.min(255, Math.round(value)));
+            }
+        }
+    }
+    return dst;
+}