cross-image 0.2.3 → 0.4.0

package/esm/src/formats/ico.js

@@ -49,7 +49,7 @@ export class ICOFormat {
      * @param data Raw ICO image data
      * @returns Decoded image data with RGBA pixels
      */
-    async decode(data) {
+    async decode(data, options) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid ICO signature");
         }
@@ -100,7 +100,7 @@ export class ICOFormat {
             imageData[2] === 0x4e &&
             imageData[3] === 0x47) {
             // It's a PNG, decode it
-            return await this.pngFormat.decode(imageData);
+            return await this.pngFormat.decode(imageData, options);
         }
         // Otherwise, it's a BMP without the file header (DIB format)
         return this.decodeDIB(imageData);
@@ -182,10 +182,10 @@ export class ICOFormat {
      * @param imageData Image data to encode
      * @returns Encoded ICO image bytes
      */
-    async encode(imageData) {
+    async encode(imageData, _options) {
         const { width, height } = imageData;
         // Encode the image as PNG
-        const pngData = await this.pngFormat.encode(imageData);
+        const pngData = await this.pngFormat.encode(imageData, undefined);
         // Create ICO file structure
         // ICONDIR (6 bytes) + ICONDIRENTRY (16 bytes) + PNG data
         const icoSize = 6 + 16 + pngData.length;
@@ -211,4 +211,32 @@ export class ICOFormat {
         result.set(pngData, 22);
         return result;
     }
+    /**
+     * Get the list of metadata fields supported by ICO format
+     */
+    getSupportedMetadata() {
+        return [
+            "frameCount", // Number of images in ICO file
+        ];
+    }
+    /**
+     * Extract metadata from ICO data without fully decoding the pixel data
+     * @param data Raw ICO data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data) {
+        if (!this.canDecode(data)) {
+            return Promise.resolve(undefined);
+        }
+        // ICO files can contain multiple images, count them
+        const count = readUint16LE(data, 4);
+        const metadata = {
+            format: "ico",
+            compression: "none", // ICO typically contains uncompressed PNG or BMP
+            frameCount: count,
+            bitDepth: 32, // Most modern ICOs use 32-bit RGBA
+            colorType: "rgba",
+        };
+        return Promise.resolve(metadata);
+    }
 }

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, ImageMetadata } from "../types.js";
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata, JPEGEncoderOptions } from "../types.js";
 /**
  * JPEG format handler
  * Implements a basic JPEG decoder and encoder
@@ -19,13 +19,13 @@ export declare class JPEGFormat implements ImageFormat {
      * @param data Raw JPEG image data
      * @returns Decoded image data with RGBA pixels
      */
-    decode(data: Uint8Array): Promise<ImageData>;
+    decode(data: Uint8Array, settings?: ImageDecoderOptions): Promise<ImageData>;
     /**
      * Encode RGBA image data to JPEG format
      * @param imageData Image data to encode
      * @returns Encoded JPEG image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, options?: JPEGEncoderOptions): Promise<Uint8Array>;
     private injectMetadata;
     private decodeUsingRuntime;
     private parseJFIF;
@@ -42,5 +42,12 @@ export declare class JPEGFormat implements ImageFormat {
      * Get the list of metadata fields supported by JPEG format
      */
     getSupportedMetadata(): Array<keyof ImageMetadata>;
+    /**
+     * Extract metadata from JPEG data without fully decoding the pixel data
+     * This quickly parses JFIF and EXIF markers to extract metadata
+     * @param data Raw JPEG data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data: Uint8Array): Promise<ImageMetadata | undefined>;
 }
 //# sourceMappingURL=jpeg.d.ts.map

package/esm/src/formats/jpeg.js

@@ -37,7 +37,7 @@ export class JPEGFormat {
      * @param data Raw JPEG image data
      * @returns Decoded image data with RGBA pixels
      */
-    async decode(data) {
+    async decode(data, settings) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid JPEG signature");
         }
@@ -95,7 +95,7 @@ export class JPEGFormat {
         validateImageDimensions(width, height);
         // For a pure JS implementation, we'd need to implement full JPEG decoding
         // which is very complex. Instead, we'll use the browser/runtime's decoder.
-        const rgba = await this.decodeUsingRuntime(data, width, height);
+        const rgba = await this.decodeUsingRuntime(data, width, height, settings);
         return {
             width,
             height,
@@ -108,10 +108,13 @@ export class JPEGFormat {
      * @param imageData Image data to encode
      * @returns Encoded JPEG image bytes
      */
-    async encode(imageData) {
+    async encode(imageData, options) {
         const { width, height, data, metadata } = imageData;
+        const requestedQuality = options?.quality;
+        const requestedProgressive = options?.progressive;
         // Try to use runtime encoding if available (better quality)
-        if (typeof OffscreenCanvas !== "undefined") {
+        // Note: progressive output is only supported by the pure-JS encoder.
+        if (!requestedProgressive && typeof OffscreenCanvas !== "undefined") {
             try {
                 const canvas = new OffscreenCanvas(width, height);
                 const ctx = canvas.getContext("2d");
@@ -120,9 +123,12 @@ export class JPEGFormat {
                     const imgDataData = new Uint8ClampedArray(data);
                     imgData.data.set(imgDataData);
                     ctx.putImageData(imgData, 0, 0);
+                    const quality = requestedQuality === undefined
+                        ? 0.9
+                        : Math.max(1, Math.min(100, requestedQuality)) / 100;
                     const blob = await canvas.convertToBlob({
                         type: "image/jpeg",
-                        quality: 0.9,
+                        quality,
                     });
                     const arrayBuffer = await blob.arrayBuffer();
                     const encoded = new Uint8Array(arrayBuffer);
@@ -141,7 +147,10 @@ export class JPEGFormat {
         const { JPEGEncoder } = await import("../utils/jpeg_encoder.js");
         const dpiX = metadata?.dpiX ?? 72;
         const dpiY = metadata?.dpiY ?? 72;
-        const encoder = new JPEGEncoder(85); // Quality 85
+        const encoder = new JPEGEncoder({
+            quality: requestedQuality,
+            progressive: requestedProgressive,
+        });
         const encoded = encoder.encode(width, height, data, dpiX, dpiY);
         // Add EXIF metadata if present
         if (metadata && Object.keys(metadata).length > 0) {
@@ -185,9 +194,10 @@ export class JPEGFormat {
         result.set(encoded.slice(pos), pos + app1.length);
         return result;
     }
-    async decodeUsingRuntime(data, _width, _height) {
+    async decodeUsingRuntime(data, _width, _height, settings) {
         // Try to use ImageDecoder API if available (Deno, modern browsers)
-        if (typeof ImageDecoder !== "undefined") {
+        if (settings?.runtimeDecoding !== "never" &&
+            typeof ImageDecoder !== "undefined") {
             try {
                 const decoder = new ImageDecoder({ data, type: "image/jpeg" });
                 const result = await decoder.decode();
@@ -202,15 +212,17 @@ export class JPEGFormat {
                 bitmap.close();
                 return new Uint8Array(imageData.data.buffer);
             }
-            catch (error) {
+            catch (_error) {
                 // ImageDecoder API failed, fall through to pure JS decoder
-                console.warn("JPEG decoding with ImageDecoder failed, using pure JS decoder:", error);
             }
         }
         // Fallback to pure JavaScript decoder
         try {
             const { JPEGDecoder } = await import("../utils/jpeg_decoder.js");
-            const decoder = new JPEGDecoder(data);
+            const decoder = new JPEGDecoder(data, {
+                tolerantDecoding: settings?.tolerantDecoding ?? true,
+                onWarning: settings?.onWarning,
+            });
             return decoder.decode();
         }
         catch (error) {
@@ -1060,4 +1072,80 @@ export class JPEGFormat {
             "dpiY",
         ];
     }
+    /**
+     * Extract metadata from JPEG data without fully decoding the pixel data
+     * This quickly parses JFIF and EXIF markers to extract metadata
+     * @param data Raw JPEG data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data) {
+        if (!this.canDecode(data)) {
+            return Promise.resolve(undefined);
+        }
+        // Parse JPEG structure to extract metadata
+        let pos = 2; // Skip initial FF D8
+        const metadata = {
+            format: "jpeg",
+            compression: "dct",
+            frameCount: 1,
+            bitDepth: 8,
+            colorType: "rgb",
+        };
+        let width = 0;
+        let height = 0;
+        while (pos < data.length - 1) {
+            if (data[pos] !== 0xff) {
+                pos++;
+                continue;
+            }
+            const marker = data[pos + 1];
+            pos += 2;
+            // SOF markers (Start of Frame) - get dimensions for DPI calculation
+            if (marker >= 0xc0 && marker <= 0xcf &&
+                marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc) {
+                const length = (data[pos] << 8) | data[pos + 1];
+                // precision at pos+2
+                const precision = data[pos + 2];
+                if (precision && precision !== 8) {
+                    metadata.bitDepth = precision;
+                }
+                height = (data[pos + 3] << 8) | data[pos + 4];
+                width = (data[pos + 5] << 8) | data[pos + 6];
+                // Check number of components
+                const numComponents = data[pos + 7];
+                if (numComponents === 1) {
+                    metadata.colorType = "grayscale";
+                }
+                // Don't break - continue parsing for metadata
+                pos += length;
+                continue;
+            }
+            // APP0 marker (JFIF)
+            if (marker === 0xe0) {
+                const length = (data[pos] << 8) | data[pos + 1];
+                const appData = data.slice(pos + 2, pos + length);
+                this.parseJFIF(appData, metadata, width, height);
+                pos += length;
+                continue;
+            }
+            // APP1 marker (EXIF)
+            if (marker === 0xe1) {
+                const length = (data[pos] << 8) | data[pos + 1];
+                const appData = data.slice(pos + 2, pos + length);
+                this.parseEXIF(appData, metadata);
+                pos += length;
+                continue;
+            }
+            // Skip other markers
+            if (marker === 0xd9 || marker === 0xda)
+                break; // EOI or SOS
+            if (marker >= 0xd0 && marker <= 0xd8)
+                continue; // RST markers have no length
+            if (marker === 0x01)
+                continue; // TEM has no length
+            const length = (data[pos] << 8) | data[pos + 1];
+            pos += length;
+        }
+        return Promise.resolve(Object.keys(metadata).length > 0 ? metadata : undefined);
+    }
 }

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat } from "../types.js";
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata } from "../types.js";
 /**
  * PAM format handler
  * Implements the Netpbm PAM (Portable Arbitrary Map) format.
@@ -32,12 +32,22 @@ export declare class PAMFormat implements ImageFormat {
      * @param data Raw PAM image data
      * @returns Decoded image data with RGBA pixels
      */
-    decode(data: Uint8Array): Promise<ImageData>;
+    decode(data: Uint8Array, _options?: ImageDecoderOptions): Promise<ImageData>;
     /**
      * Encode RGBA image data to PAM format
      * @param imageData Image data to encode
      * @returns Encoded PAM image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, _options?: unknown): Promise<Uint8Array>;
+    /**
+     * Get the list of metadata fields supported by PAM format
+     */
+    getSupportedMetadata(): Array<keyof ImageMetadata>;
+    /**
+     * Extract metadata from PAM data without fully decoding the pixel data
+     * @param data Raw PAM data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data: Uint8Array): Promise<ImageMetadata | undefined>;
 }
 //# sourceMappingURL=pam.d.ts.map

package/esm/src/formats/pam.js

@@ -53,7 +53,7 @@ export class PAMFormat {
      * @param data Raw PAM image data
      * @returns Decoded image data with RGBA pixels
      */
-    decode(data) {
+    decode(data, _options) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid PAM signature");
         }
@@ -150,7 +150,7 @@ export class PAMFormat {
      * @param imageData Image data to encode
      * @returns Encoded PAM image bytes
      */
-    encode(imageData) {
+    encode(imageData, _options) {
         const { width, height, data } = imageData;
         // Validate input
         if (data.length !== width * height * 4) {
@@ -174,4 +174,70 @@ export class PAMFormat {
         output.set(data, headerBytes.length);
         return Promise.resolve(output);
     }
+    /**
+     * Get the list of metadata fields supported by PAM format
+     */
+    getSupportedMetadata() {
+        return []; // PAM format doesn't support metadata preservation
+    }
+    /**
+     * Extract metadata from PAM data without fully decoding the pixel data
+     * @param data Raw PAM data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data) {
+        if (!this.canDecode(data)) {
+            return Promise.resolve(undefined);
+        }
+        const metadata = {
+            format: "pam",
+            compression: "none",
+            frameCount: 1,
+            bitDepth: 8, // PAM typically uses 8 bits per channel
+            colorType: "rgba",
+        };
+        // Try to parse the header to get actual color type
+        const decoder = new TextDecoder();
+        const headerText = decoder.decode(data.slice(0, Math.min(200, data.length)));
+        // Look for TUPLTYPE to determine color type
+        const tupltypeMatch = headerText.match(/TUPLTYPE\s+(\S+)/);
+        if (tupltypeMatch) {
+            const tupltype = tupltypeMatch[1];
+            if (tupltype === "GRAYSCALE") {
+                metadata.colorType = "grayscale";
+            }
+            else if (tupltype === "RGB") {
+                metadata.colorType = "rgb";
+            }
+            else if (tupltype === "RGB_ALPHA") {
+                metadata.colorType = "rgba";
+            }
+        }
+        // Look for DEPTH to determine number of channels
+        const depthMatch = headerText.match(/DEPTH\s+(\d+)/);
+        if (depthMatch) {
+            const depth = parseInt(depthMatch[1]);
+            if (depth === 1) {
+                metadata.colorType = "grayscale";
+            }
+            else if (depth === 3) {
+                metadata.colorType = "rgb";
+            }
+            else if (depth === 4) {
+                metadata.colorType = "rgba";
+            }
+        }
+        // Look for MAXVAL to determine bit depth
+        const maxvalMatch = headerText.match(/MAXVAL\s+(\d+)/);
+        if (maxvalMatch) {
+            const maxval = parseInt(maxvalMatch[1]);
+            if (maxval === 255) {
+                metadata.bitDepth = 8;
+            }
+            else if (maxval === 65535) {
+                metadata.bitDepth = 16;
+            }
+        }
+        return Promise.resolve(metadata);
+    }
 }

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat } from "../types.js";
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata } from "../types.js";
 /**
  * PCX format handler
  * Implements PCX decoder and encoder
@@ -7,7 +7,17 @@ export declare class PCXFormat implements ImageFormat {
     readonly name = "pcx";
     readonly mimeType = "image/x-pcx";
     canDecode(data: Uint8Array): boolean;
-    decode(data: Uint8Array): Promise<ImageData>;
-    encode(image: ImageData): Promise<Uint8Array>;
+    decode(data: Uint8Array, _options?: ImageDecoderOptions): Promise<ImageData>;
+    encode(image: ImageData, _options?: unknown): Promise<Uint8Array>;
+    /**
+     * Get the list of metadata fields supported by PCX format
+     */
+    getSupportedMetadata(): Array<keyof ImageMetadata>;
+    /**
+     * Extract metadata from PCX data without fully decoding the pixel data
+     * @param data Raw PCX data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data: Uint8Array): Promise<ImageMetadata | undefined>;
 }
 //# sourceMappingURL=pcx.d.ts.map

package/esm/src/formats/pcx.js

@@ -28,7 +28,7 @@ export class PCXFormat {
                 data[1] === 5) &&
             data[2] === 1;
     }
-    decode(data) {
+    decode(data, _options) {
         if (!this.canDecode(data)) {
             return Promise.reject(new Error("Invalid PCX data"));
         }
@@ -134,7 +134,7 @@ export class PCXFormat {
             data: rgba,
         });
     }
-    encode(image) {
+    encode(image, _options) {
         const width = image.width;
         const height = image.height;
         const data = image.data;
@@ -201,4 +201,49 @@ export class PCXFormat {
         result.set(rleData, header.length);
         return Promise.resolve(result);
     }
+    /**
+     * Get the list of metadata fields supported by PCX format
+     */
+    getSupportedMetadata() {
+        return [
+            "dpiX", // DPI in header
+            "dpiY", // DPI in header
+        ];
+    }
+    /**
+     * Extract metadata from PCX data without fully decoding the pixel data
+     * @param data Raw PCX data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data) {
+        if (!this.canDecode(data)) {
+            return Promise.resolve(undefined);
+        }
+        const metadata = {
+            format: "pcx",
+            compression: "rle",
+            frameCount: 1,
+            bitDepth: data[3], // Bits per pixel per plane
+            colorType: "rgb",
+        };
+        // Check number of planes to determine color type
+        const numPlanes = data[65];
+        if (numPlanes === 1) {
+            metadata.colorType = "indexed";
+        }
+        else if (numPlanes === 3) {
+            metadata.colorType = "rgb";
+        }
+        else if (numPlanes === 4) {
+            metadata.colorType = "rgba";
+        }
+        // DPI information
+        const dpiX = data[12] | (data[13] << 8);
+        const dpiY = data[14] | (data[15] << 8);
+        if (dpiX > 0)
+            metadata.dpiX = dpiX;
+        if (dpiY > 0)
+            metadata.dpiY = dpiY;
+        return Promise.resolve(metadata);
+    }
 }

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

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat } from "../types.js";
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata } from "../types.js";
 import { PNGBase } from "./png_base.js";
 /**
  * PNG format handler
@@ -20,12 +20,24 @@ export declare class PNGFormat extends PNGBase implements ImageFormat {
      * @param data Raw PNG image data
      * @returns Decoded image data with RGBA pixels
      */
-    decode(data: Uint8Array): Promise<ImageData>;
+    decode(data: Uint8Array, _options?: ImageDecoderOptions): Promise<ImageData>;
     /**
      * Encode RGBA image data to PNG format
      * @param imageData Image data to encode
      * @returns Encoded PNG image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, _options?: unknown): Promise<Uint8Array>;
+    /**
+     * Get the list of metadata fields supported by PNG format
+     * Delegates to PNGBase implementation
+     */
+    getSupportedMetadata(): Array<keyof ImageMetadata>;
+    /**
+     * Extract metadata from PNG data without fully decoding the pixel data
+     * This quickly parses PNG chunks to extract metadata
+     * @param data Raw PNG data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data: Uint8Array): Promise<ImageMetadata | undefined>;
 }
 //# sourceMappingURL=png.d.ts.map

package/esm/src/formats/png.js

@@ -40,7 +40,7 @@ export class PNGFormat extends PNGBase {
      * @param data Raw PNG image data
      * @returns Decoded image data with RGBA pixels
      */
-    async decode(data) {
+    async decode(data, _options) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid PNG signature");
         }
@@ -112,7 +112,7 @@ export class PNGFormat extends PNGBase {
      * @param imageData Image data to encode
      * @returns Encoded PNG image bytes
      */
-    async encode(imageData) {
+    async encode(imageData, _options) {
         const { width, height, data, metadata } = imageData;
         // Prepare IHDR chunk
         const ihdr = new Uint8Array(13);
@@ -137,4 +137,91 @@ export class PNGFormat extends PNGBase {
         // Concatenate all chunks
         return this.concatenateArrays(chunks);
     }
+    /**
+     * Get the list of metadata fields supported by PNG format
+     * Delegates to PNGBase implementation
+     */
+    getSupportedMetadata() {
+        return super.getSupportedMetadata();
+    }
+    /**
+     * Extract metadata from PNG data without fully decoding the pixel data
+     * This quickly parses PNG chunks to extract metadata
+     * @param data Raw PNG data
+     * @returns Extracted metadata or undefined
+     */
+    extractMetadata(data) {
+        if (!this.canDecode(data)) {
+            return Promise.resolve(undefined);
+        }
+        let pos = 8; // Skip PNG signature
+        let width = 0;
+        let height = 0;
+        const metadata = {
+            format: "png",
+            compression: "deflate",
+            frameCount: 1,
+        };
+        // Parse chunks for metadata only
+        while (pos < data.length) {
+            if (pos + 8 > data.length)
+                break;
+            const length = this.readUint32(data, pos);
+            pos += 4;
+            const type = String.fromCharCode(data[pos], data[pos + 1], data[pos + 2], data[pos + 3]);
+            pos += 4;
+            if (pos + length + 4 > data.length)
+                break;
+            const chunkData = data.slice(pos, pos + length);
+            pos += length;
+            pos += 4; // Skip CRC
+            if (type === "IHDR") {
+                width = this.readUint32(chunkData, 0);
+                height = this.readUint32(chunkData, 4);
+                // Parse bit depth and color type from IHDR
+                if (chunkData.length >= 9) {
+                    metadata.bitDepth = chunkData[8];
+                    const colorTypeCode = chunkData[9];
+                    // PNG color types: 0=grayscale, 2=rgb, 3=indexed, 4=grayscale+alpha, 6=rgba
+                    switch (colorTypeCode) {
+                        case 0:
+                            metadata.colorType = "grayscale";
+                            break;
+                        case 2:
+                            metadata.colorType = "rgb";
+                            break;
+                        case 3:
+                            metadata.colorType = "indexed";
+                            break;
+                        case 4:
+                            metadata.colorType = "grayscale-alpha";
+                            break;
+                        case 6:
+                            metadata.colorType = "rgba";
+                            break;
+                    }
+                }
+            }
+            else if (type === "pHYs") {
+                // Physical pixel dimensions
+                this.parsePhysChunk(chunkData, metadata, width, height);
+            }
+            else if (type === "tEXt") {
+                // Text chunk
+                this.parseTextChunk(chunkData, metadata);
+            }
+            else if (type === "iTXt") {
+                // International text chunk
+                this.parseITxtChunk(chunkData, metadata);
+            }
+            else if (type === "eXIf") {
+                // EXIF chunk
+                this.parseExifChunk(chunkData, metadata);
+            }
+            else if (type === "IEND") {
+                break;
+            }
+        }
+        return Promise.resolve(Object.keys(metadata).length > 0 ? metadata : undefined);
+    }
 }

package/esm/src/formats/png_base.js

@@ -105,9 +105,7 @@ export class PNGBase {
         for (let x = 0; x < scanline.length; x++) {
             const left = x >= bytesPerPixel ? scanline[x - bytesPerPixel] : 0;
             const above = prevLine ? prevLine[x] : 0;
-            const upperLeft = (x >= bytesPerPixel && prevLine)
-                ? prevLine[x - bytesPerPixel]
-                : 0;
+            const upperLeft = (x >= bytesPerPixel && prevLine) ? prevLine[x - bytesPerPixel] : 0;
             switch (filterType) {
                 case 0: // None
                     break;
@@ -121,8 +119,7 @@ export class PNGBase {
                     scanline[x] = (scanline[x] + Math.floor((left + above) / 2)) & 0xff;
                     break;
                 case 4: // Paeth
-                    scanline[x] =
-                        (scanline[x] + this.paethPredictor(left, above, upperLeft)) & 0xff;
+                    scanline[x] = (scanline[x] + this.paethPredictor(left, above, upperLeft)) & 0xff;
                     break;
             }
         }