cross-image 0.1.2

package/esm/src/formats/webp.d.ts

@@ -0,0 +1,22 @@
+import type { ImageData, ImageFormat, WebPEncodeOptions } from "../types.js";
+/**
+ * WebP format handler
+ * Implements a basic WebP decoder and encoder
+ */
+export declare class WebPFormat implements ImageFormat {
+    readonly name = "webp";
+    readonly mimeType = "image/webp";
+    canDecode(data: Uint8Array): boolean;
+    decode(data: Uint8Array): Promise<ImageData>;
+    encode(imageData: ImageData, options?: WebPEncodeOptions): Promise<Uint8Array>;
+    private readUint32LE;
+    private readUint24LE;
+    private decodeUsingRuntime;
+    private parseEXIF;
+    private parseXMP;
+    private injectMetadata;
+    private createEXIFChunk;
+    private createXMPChunk;
+    private escapeXML;
+}
+//# sourceMappingURL=webp.d.ts.map

package/esm/src/formats/webp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webp.d.ts","sourceRoot":"","sources":["../../../src/src/formats/webp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EACT,WAAW,EAEX,iBAAiB,EAClB,MAAM,aAAa,CAAC;AAKrB;;;GAGG;AACH,qBAAa,UAAW,YAAW,WAAW;IAC5C,QAAQ,CAAC,IAAI,UAAU;IACvB,QAAQ,CAAC,QAAQ,gBAAgB;IAEjC,SAAS,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO;IAS9B,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC;IAmF5C,MAAM,CACV,SAAS,EAAE,SAAS,EACpB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,UAAU,CAAC;IAsDtB,OAAO,CAAC,YAAY;IAKpB,OAAO,CAAC,YAAY;YAIN,kBAAkB;IAiDhC,OAAO,CAAC,SAAS;IA+DjB,OAAO,CAAC,QAAQ;IA6BhB,OAAO,CAAC,cAAc;IAuFtB,OAAO,CAAC,eAAe;IAyDvB,OAAO,CAAC,cAAc;IAoDtB,OAAO,CAAC,SAAS;CAQlB"}

package/esm/src/formats/webp.js

@@ -0,0 +1,403 @@
+// Default quality for WebP encoding when not specified
+const DEFAULT_WEBP_QUALITY = 90;
+/**
+ * WebP format handler
+ * Implements a basic WebP decoder and encoder
+ */
+export class WebPFormat {
+    constructor() {
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "webp"
+        });
+        Object.defineProperty(this, "mimeType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "image/webp"
+        });
+    }
+    canDecode(data) {
+        // WebP signature: "RIFF" + size + "WEBP"
+        return data.length >= 12 &&
+            data[0] === 0x52 && data[1] === 0x49 && // "RI"
+            data[2] === 0x46 && data[3] === 0x46 && // "FF"
+            data[8] === 0x57 && data[9] === 0x45 && // "WE"
+            data[10] === 0x42 && data[11] === 0x50; // "BP"
+    }
+    async decode(data) {
+        if (!this.canDecode(data)) {
+            throw new Error("Invalid WebP signature");
+        }
+        // Parse WebP structure
+        let pos = 12; // Skip RIFF header
+        let width = 0;
+        let height = 0;
+        const metadata = {};
+        // Read all chunks to extract metadata
+        while (pos + 8 <= data.length) {
+            const chunkType = String.fromCharCode(data[pos], data[pos + 1], data[pos + 2], data[pos + 3]);
+            const chunkSize = this.readUint32LE(data, pos + 4);
+            pos += 8;
+            // Stop if we've gone past the end
+            if (pos + chunkSize > data.length)
+                break;
+            const chunkData = data.slice(pos, pos + chunkSize);
+            if (chunkType === "VP8 ") {
+                // Lossy format - extract dimensions
+                if (chunkData.length >= 10) {
+                    const frameTag = chunkData[0] | (chunkData[1] << 8) |
+                        (chunkData[2] << 16);
+                    const keyFrame = (frameTag & 1) === 0;
+                    if (keyFrame && chunkData[3] === 0x9d && chunkData[4] === 0x01 &&
+                        chunkData[5] === 0x2a) {
+                        width = chunkData[6] | ((chunkData[7] & 0x3f) << 8);
+                        height = chunkData[8] | ((chunkData[9] & 0x3f) << 8);
+                    }
+                }
+            }
+            else if (chunkType === "VP8L") {
+                // Lossless format - extract dimensions
+                if (chunkData.length >= 5 && chunkData[0] === 0x2f) {
+                    const bits = this.readUint32LE(chunkData, 1);
+                    width = (bits & 0x3fff) + 1;
+                    height = ((bits >> 14) & 0x3fff) + 1;
+                }
+            }
+            else if (chunkType === "VP8X") {
+                // Extended format - extract dimensions
+                if (chunkData.length >= 10) {
+                    width = this.readUint24LE(chunkData, 4) + 1;
+                    height = this.readUint24LE(chunkData, 7) + 1;
+                }
+            }
+            else if (chunkType === "EXIF") {
+                // EXIF metadata chunk
+                this.parseEXIF(chunkData, metadata);
+            }
+            else if (chunkType === "XMP ") {
+                // XMP metadata chunk
+                this.parseXMP(chunkData, metadata);
+            }
+            pos += chunkSize;
+            // Chunks are padded to even length
+            if (chunkSize % 2 === 1)
+                pos++;
+        }
+        if (width === 0 || height === 0) {
+            throw new Error("Could not determine WebP dimensions");
+        }
+        // For a pure JS implementation, we'd need to implement full WebP decoding
+        // which is very complex. Instead, we'll use the browser/runtime's decoder.
+        const rgba = await this.decodeUsingRuntime(data, width, height);
+        return {
+            width,
+            height,
+            data: rgba,
+            metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+        };
+    }
+    async encode(imageData, options) {
+        const { width, height, data, metadata } = imageData;
+        const quality = options?.quality ?? DEFAULT_WEBP_QUALITY;
+        const forceLossless = options?.lossless ?? false;
+        // Determine if we should use lossless encoding
+        // Use lossless if: quality is 100, or lossless flag is set
+        const useLossless = quality === 100 || forceLossless;
+        // Try to use runtime encoding if available (better quality and compression)
+        if (typeof OffscreenCanvas !== "undefined") {
+            try {
+                const canvas = new OffscreenCanvas(width, height);
+                const ctx = canvas.getContext("2d");
+                if (ctx) {
+                    const imgData = ctx.createImageData(width, height);
+                    const imgDataData = new Uint8ClampedArray(data);
+                    imgData.data.set(imgDataData);
+                    ctx.putImageData(imgData, 0, 0);
+                    const blob = await canvas.convertToBlob({
+                        type: "image/webp",
+                        quality: quality / 100, // Convert 1-100 to 0-1
+                    });
+                    const arrayBuffer = await blob.arrayBuffer();
+                    const encoded = new Uint8Array(arrayBuffer);
+                    // Inject metadata if present
+                    if (metadata && Object.keys(metadata).length > 0) {
+                        const injected = this.injectMetadata(encoded, metadata);
+                        return injected;
+                    }
+                    return encoded;
+                }
+            }
+            catch (_error) {
+                // Fall through to pure JS encoder
+            }
+        }
+        // Fallback to pure JavaScript encoder
+        // VP8L (lossless) encoder with optional quality-based quantization
+        const { WebPEncoder } = await import("../utils/webp_encoder.js");
+        const encoder = new WebPEncoder(width, height, data);
+        const encoded = encoder.encode(useLossless ? 100 : quality);
+        // Inject metadata if present
+        if (metadata && Object.keys(metadata).length > 0) {
+            return this.injectMetadata(encoded, metadata);
+        }
+        return encoded;
+    }
+    readUint32LE(data, offset) {
+        return data[offset] | (data[offset + 1] << 8) |
+            (data[offset + 2] << 16) | (data[offset + 3] << 24);
+    }
+    readUint24LE(data, offset) {
+        return data[offset] | (data[offset + 1] << 8) | (data[offset + 2] << 16);
+    }
+    async decodeUsingRuntime(data, _width, _height) {
+        // Try to use ImageDecoder API if available (Deno, modern browsers)
+        if (typeof ImageDecoder !== "undefined") {
+            try {
+                const decoder = new ImageDecoder({ data, type: "image/webp" });
+                const result = await decoder.decode();
+                const bitmap = result.image;
+                // Create a canvas to extract pixel data
+                const canvas = new OffscreenCanvas(bitmap.displayWidth, bitmap.displayHeight);
+                const ctx = canvas.getContext("2d");
+                if (!ctx)
+                    throw new Error("Could not get canvas context");
+                ctx.drawImage(bitmap, 0, 0);
+                const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+                bitmap.close();
+                return new Uint8Array(imageData.data.buffer);
+            }
+            catch (error) {
+                // ImageDecoder API failed, fall through to pure JS decoder
+                console.warn("WebP decoding with ImageDecoder failed, using pure JS decoder:", error);
+            }
+        }
+        // Fallback to pure JavaScript decoder (VP8L lossless only)
+        try {
+            const { WebPDecoder } = await import("../utils/webp_decoder.js");
+            const decoder = new WebPDecoder(data);
+            const result = decoder.decode();
+            return result.data;
+        }
+        catch (error) {
+            throw new Error(`WebP decoding failed: ${error}`);
+        }
+    }
+    // Metadata parsing and injection methods
+    parseEXIF(data, metadata) {
+        // EXIF data parsing (similar to JPEG/PNG EXIF parsing)
+        if (data.length < 8)
+            return;
+        try {
+            const byteOrder = String.fromCharCode(data[0], data[1]);
+            const littleEndian = byteOrder === "II";
+            const ifd0Offset = littleEndian
+                ? data[4] | (data[5] << 8) | (data[6] << 16) | (data[7] << 24)
+                : (data[4] << 24) | (data[5] << 16) | (data[6] << 8) | data[7];
+            if (ifd0Offset + 2 > data.length)
+                return;
+            const numEntries = littleEndian
+                ? data[ifd0Offset] | (data[ifd0Offset + 1] << 8)
+                : (data[ifd0Offset] << 8) | data[ifd0Offset + 1];
+            // Parse basic EXIF tags (simplified version)
+            for (let i = 0; i < numEntries && i < 50; i++) {
+                const entryOffset = ifd0Offset + 2 + i * 12;
+                if (entryOffset + 12 > data.length)
+                    break;
+                const tag = littleEndian
+                    ? data[entryOffset] | (data[entryOffset + 1] << 8)
+                    : (data[entryOffset] << 8) | data[entryOffset + 1];
+                // DateTime tag
+                if (tag === 0x0132) {
+                    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];
+                    if (valueOffset < data.length) {
+                        const endIndex = data.indexOf(0, valueOffset);
+                        if (endIndex > valueOffset) {
+                            const dateStr = new TextDecoder().decode(data.slice(valueOffset, endIndex));
+                            const match = dateStr.match(/^(\d{4}):(\d{2}):(\d{2}) (\d{2}):(\d{2}):(\d{2})$/);
+                            if (match) {
+                                metadata.creationDate = new Date(parseInt(match[1]), parseInt(match[2]) - 1, parseInt(match[3]), parseInt(match[4]), parseInt(match[5]), parseInt(match[6]));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (_e) {
+            // Ignore EXIF parsing errors
+        }
+    }
+    parseXMP(data, metadata) {
+        // XMP is XML-based metadata - simple parsing for common fields
+        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();
+        }
+        catch (_e) {
+            // Ignore XMP parsing errors
+        }
+    }
+    injectMetadata(webpData, metadata) {
+        // WebP files are RIFF containers: RIFF + size + WEBP + chunks
+        // We need to inject EXIF and/or XMP chunks before the image data
+        const chunks = [];
+        // Copy RIFF header (12 bytes)
+        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) {
+            const exifData = this.createEXIFChunk(metadata);
+            if (exifData) {
+                metadataChunks.push(exifData);
+            }
+        }
+        // Create XMP chunk if we have text metadata
+        if (metadata.title || metadata.description || metadata.author ||
+            metadata.copyright) {
+            const xmpData = this.createXMPChunk(metadata);
+            if (xmpData) {
+                metadataChunks.push(xmpData);
+            }
+        }
+        // Copy original chunks (skip header)
+        let pos = 12;
+        while (pos + 8 <= webpData.length) {
+            const chunkType = String.fromCharCode(webpData[pos], webpData[pos + 1], webpData[pos + 2], webpData[pos + 3]);
+            const chunkSize = this.readUint32LE(webpData, pos + 4);
+            // Don't copy existing EXIF/XMP chunks (we'll add new ones)
+            if (chunkType !== "EXIF" && chunkType !== "XMP ") {
+                const chunkEnd = pos + 8 + chunkSize + (chunkSize % 2);
+                chunks.push(webpData.slice(pos, chunkEnd));
+            }
+            pos += 8 + chunkSize;
+            if (chunkSize % 2 === 1)
+                pos++; // Padding
+        }
+        // Insert metadata chunks after VP8/VP8L/VP8X chunk
+        const result = [chunks[0]]; // RIFF header
+        if (chunks.length > 1) {
+            result.push(chunks[1]); // First chunk (VP8/VP8L/VP8X)
+        }
+        result.push(...metadataChunks);
+        for (let i = 2; i < chunks.length; i++) {
+            result.push(chunks[i]);
+        }
+        // Recalculate total size
+        const totalSize = result.reduce((sum, chunk) => sum + chunk.length, 0) - 8;
+        const finalData = new Uint8Array(totalSize + 8);
+        // Write RIFF header with updated size
+        finalData.set(new TextEncoder().encode("RIFF"), 0);
+        finalData[4] = totalSize & 0xff;
+        finalData[5] = (totalSize >> 8) & 0xff;
+        finalData[6] = (totalSize >> 16) & 0xff;
+        finalData[7] = (totalSize >> 24) & 0xff;
+        finalData.set(new TextEncoder().encode("WEBP"), 8);
+        // Copy all chunks
+        let offset = 12;
+        for (let i = 1; i < result.length; i++) {
+            finalData.set(result[i], offset);
+            offset += result[i].length;
+        }
+        return finalData;
+    }
+    createEXIFChunk(metadata) {
+        if (!metadata.creationDate)
+            return null;
+        const exifData = [];
+        // Byte order marker (little endian)
+        exifData.push(0x49, 0x49); // "II"
+        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
+        // Next IFD
+        exifData.push(0x00, 0x00, 0x00, 0x00);
+        // Date string data
+        for (const byte of dateBytes) {
+            exifData.push(byte);
+        }
+        // Create chunk header
+        const chunkData = new Uint8Array(exifData);
+        const chunk = new Uint8Array(8 + chunkData.length);
+        chunk.set(new TextEncoder().encode("EXIF"), 0);
+        chunk[4] = chunkData.length & 0xff;
+        chunk[5] = (chunkData.length >> 8) & 0xff;
+        chunk[6] = (chunkData.length >> 16) & 0xff;
+        chunk[7] = (chunkData.length >> 24) & 0xff;
+        chunk.set(chunkData, 8);
+        return chunk;
+    }
+    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");
+        const xmpData = new TextEncoder().encode(xmpStr);
+        // Create chunk
+        const chunk = new Uint8Array(8 + xmpData.length);
+        chunk.set(new TextEncoder().encode("XMP "), 0);
+        chunk[4] = xmpData.length & 0xff;
+        chunk[5] = (xmpData.length >> 8) & 0xff;
+        chunk[6] = (xmpData.length >> 16) & 0xff;
+        chunk[7] = (xmpData.length >> 24) & 0xff;
+        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;");
+    }
+}

package/esm/src/image.d.ts

@@ -0,0 +1,124 @@
+import type { ImageFormat, ImageMetadata, MultiFrameImageData, ResizeOptions } from "./types.js";
+/**
+ * Main Image class for reading, manipulating, and saving images
+ */
+export declare class Image {
+    private imageData;
+    private static formats;
+    /**
+     * Get the current image width
+     */
+    get width(): number;
+    /**
+     * Get the current image height
+     */
+    get height(): number;
+    /**
+     * Get the current image data
+     */
+    get data(): Uint8Array;
+    /**
+     * Get the current image metadata
+     */
+    get metadata(): ImageMetadata | undefined;
+    /**
+     * Set or update image metadata
+     * @param metadata Metadata to set or merge
+     * @param merge If true, merges with existing metadata. If false, replaces it. Default: true
+     */
+    setMetadata(metadata: ImageMetadata, merge?: boolean): this;
+    /**
+     * Get a specific metadata field
+     * @param key The metadata field to retrieve
+     * @returns The metadata value or undefined
+     */
+    getMetadataField<K extends keyof ImageMetadata>(key: K): ImageMetadata[K] | undefined;
+    /**
+     * Get position (latitude, longitude) from metadata
+     * @returns Object with latitude and longitude, or undefined if not available
+     */
+    getPosition(): {
+        latitude: number;
+        longitude: number;
+    } | undefined;
+    /**
+     * Set position (latitude, longitude) in metadata
+     * @param latitude GPS latitude
+     * @param longitude GPS longitude
+     */
+    setPosition(latitude: number, longitude: number): this;
+    /**
+     * Get physical dimensions from metadata
+     * @returns Object with DPI and physical dimensions, or undefined if not available
+     */
+    getDimensions(): {
+        dpiX?: number;
+        dpiY?: number;
+        physicalWidth?: number;
+        physicalHeight?: number;
+    } | undefined;
+    /**
+     * Set physical dimensions in metadata
+     * @param dpiX Dots per inch (horizontal)
+     * @param dpiY Dots per inch (vertical), defaults to dpiX if not provided
+     */
+    setDPI(dpiX: number, dpiY?: number): this;
+    /**
+     * Register a custom image format
+     * @param format Custom format implementation
+     */
+    static registerFormat(format: ImageFormat): void;
+    /**
+     * Get all registered formats
+     */
+    static getFormats(): readonly ImageFormat[];
+    /**
+     * Read an image from bytes
+     * @param data Raw image data
+     * @param format Optional format hint (e.g., "png", "jpeg", "webp")
+     * @returns Image instance
+     */
+    static read(data: Uint8Array, format?: string): Promise<Image>;
+    /**
+     * Read all frames from a multi-frame image (GIF animation, multi-page TIFF)
+     * @param data Raw image data
+     * @param format Optional format hint (e.g., "gif", "tiff")
+     * @returns MultiFrameImageData with all frames
+     */
+    static readFrames(data: Uint8Array, format?: string): Promise<MultiFrameImageData>;
+    /**
+     * Save multi-frame image data to bytes in the specified format
+     * @param format Format name (e.g., "gif", "tiff")
+     * @param imageData Multi-frame image data to save
+     * @param options Optional format-specific encoding options
+     * @returns Encoded image bytes
+     */
+    static saveFrames(format: string, imageData: MultiFrameImageData, options?: unknown): Promise<Uint8Array>;
+    /**
+     * Create an image from raw RGBA data
+     * @param width Image width
+     * @param height Image height
+     * @param data Raw RGBA pixel data (4 bytes per pixel)
+     * @returns Image instance
+     */
+    static fromRGBA(width: number, height: number, data: Uint8Array): Image;
+    /**
+     * Resize the image
+     * @param options Resize options
+     * @returns This image instance for chaining
+     */
+    resize(options: ResizeOptions): this;
+    /**
+     * Save the image to bytes in the specified format
+     * @param format Format name (e.g., "png", "jpeg", "webp", "ascii")
+     * @param options Optional format-specific encoding options
+     * @returns Encoded image bytes
+     */
+    save(format: string, options?: unknown): Promise<Uint8Array>;
+    /**
+     * Clone this image
+     * @returns New image instance with copied data and metadata
+     */
+    clone(): Image;
+}
+//# sourceMappingURL=image.d.ts.map

package/esm/src/image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../../src/src/image.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,WAAW,EACX,aAAa,EACb,mBAAmB,EACnB,aAAa,EACd,MAAM,YAAY,CAAC;AAWpB;;GAEG;AACH,qBAAa,KAAK;IAChB,OAAO,CAAC,SAAS,CAA0B;IAC3C,OAAO,CAAC,MAAM,CAAC,OAAO,CASpB;IAEF;;OAEG;IACH,IAAI,KAAK,IAAI,MAAM,CAGlB;IAED;;OAEG;IACH,IAAI,MAAM,IAAI,MAAM,CAGnB;IAED;;OAEG;IACH,IAAI,IAAI,IAAI,UAAU,CAGrB;IAED;;OAEG;IACH,IAAI,QAAQ,IAAI,aAAa,GAAG,SAAS,CAGxC;IAED;;;;OAIG;IACH,WAAW,CAAC,QAAQ,EAAE,aAAa,EAAE,KAAK,UAAO,GAAG,IAAI;IAmBxD;;;;OAIG;IACH,gBAAgB,CAAC,CAAC,SAAS,MAAM,aAAa,EAC5C,GAAG,EAAE,CAAC,GACL,aAAa,CAAC,CAAC,CAAC,GAAG,SAAS;IAK/B;;;OAGG;IACH,WAAW,IAAI;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS;IAWlE;;;;OAIG;IACH,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAItD;;;OAGG;IACH,aAAa,IAAI;QACf,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB,GAAG,SAAS;IAgBb;;;;OAIG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI;IAezC;;;OAGG;IACH,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI;IAIhD;;OAEG;IACH,MAAM,CAAC,UAAU,IAAI,SAAS,WAAW,EAAE;IAI3C;;;;;OAKG;WACU,IAAI,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAuBpE;;;;;OAKG;WACU,UAAU,CACrB,IAAI,EAAE,UAAU,EAChB,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,mBAAmB,CAAC;IAqB/B;;;;;;OAMG;WACU,UAAU,CACrB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,mBAAmB,EAC9B,OAAO,CAAC,EAAE,OAAO,GAChB,OAAO,CAAC,UAAU,CAAC;IAgBtB;;;;;;OAMG;IACH,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,KAAK;IAcvE;;;;OAIG;IACH,MAAM,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI;IAqCpC;;;;;OAKG;IACG,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC;IAWlE;;;OAGG;IACH,KAAK,IAAI,KAAK;CAmBf"}