cross-image 0.1.4 → 0.2.0

package/script/src/formats/dng.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DNGFormat = void 0;
+const tiff_js_1 = require("./tiff.js");
+/**
+ * DNG format handler
+ * Implements a basic Linear DNG (Digital Negative) writer.
+ * DNG is based on TIFF/EP. This implementation creates a valid DNG
+ * containing uncompressed linear RGB data (demosaiced).
+ */
+class DNGFormat extends tiff_js_1.TIFFFormat {
+    constructor() {
+        super(...arguments);
+        /** Format name identifier */
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "dng"
+        });
+        /** MIME type for DNG images */
+        Object.defineProperty(this, "mimeType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "image/x-adobe-dng"
+        });
+        // Helper methods duplicated from TIFFFormat because they are protected/private there
+        // and we can't easily access them if they are private.
+        // Let's check TIFFFormat visibility.
+        // The read/write helpers were not exported in the previous read_file output.
+    }
+    /**
+     * Check if the given data is a DNG image
+     * @param data Raw image data to check
+     * @returns true if data has DNG signature (TIFF signature + DNGVersion tag)
+     */
+    canDecode(data) {
+        // DNG is a TIFF file, so it must have a TIFF signature
+        if (!super.canDecode(data)) {
+            return false;
+        }
+        // To be strictly a DNG, it should have the DNGVersion tag (0xC612 / 50706)
+        // However, scanning for tags in canDecode might be slow.
+        // For now, we rely on the fact that it's a TIFF-based format.
+        // If we want to be stricter, we would need to parse the IFD here.
+        // Let's do a quick check for the DNGVersion tag in the first few bytes if possible,
+        // but tags are in the IFD which can be anywhere.
+        // So we'll just check if it's a TIFF and maybe rely on extension or user intent.
+        // But wait, if we register both TIFF and DNG, who wins?
+        // The first one in the list.
+        // So we should probably implement a proper check if possible, or just accept that
+        // DNGs are TIFFs.
+        // For this implementation, we'll assume if it's a TIFF, it *could* be a DNG.
+        // But to distinguish, we really should check for DNGVersion.
+        // Let's try to find the DNGVersion tag (50706) in the first IFD.
+        try {
+            const isLittleEndian = data[0] === 0x49;
+            const ifdOffset = this.readUint32(data, 4, isLittleEndian);
+            // Safety check for offset
+            if (ifdOffset >= data.length)
+                return false;
+            const numEntries = this.readUint16(data, ifdOffset, isLittleEndian);
+            for (let i = 0; i < numEntries; i++) {
+                const entryOffset = ifdOffset + 2 + (i * 12);
+                if (entryOffset + 12 > data.length)
+                    break;
+                const tag = this.readUint16(data, entryOffset, isLittleEndian);
+                if (tag === 50706) { // DNGVersion
+                    return true;
+                }
+            }
+        }
+        catch {
+            return false;
+        }
+        return false;
+    }
+    /**
+     * Encode RGBA image data to DNG format (Linear DNG)
+     * @param imageData Image data to encode
+     * @returns Encoded DNG image bytes
+     */
+    async encode(imageData) {
+        const { width, height, data } = imageData;
+        // We'll create a Linear DNG (demosaiced RGB)
+        // This is very similar to a standard TIFF but with specific tags.
+        const result = [];
+        // Header (8 bytes)
+        // Little-endian byte order
+        result.push(0x49, 0x49); // "II"
+        result.push(0x2a, 0x00); // 42
+        // IFD offset (will be after header and pixel data)
+        const ifdOffset = 8 + data.length;
+        this.writeUint32LE(result, ifdOffset);
+        // Pixel data (Uncompressed RGBA)
+        for (let i = 0; i < data.length; i++) {
+            result.push(data[i]);
+        }
+        // IFD (Image File Directory)
+        const ifdStart = result.length;
+        // Tags we need for DNG:
+        // - NewSubfileType (254)
+        // - ImageWidth (256)
+        // - ImageHeight (257)
+        // - BitsPerSample (258)
+        // - Compression (259)
+        // - PhotometricInterpretation (262)
+        // - StripOffsets (273)
+        // - SamplesPerPixel (277)
+        // - RowsPerStrip (278)
+        // - StripByteCounts (279)
+        // - PlanarConfiguration (284)
+        // - ExtraSamples (338) - for Alpha
+        // - DNGVersion (50706)
+        // - UniqueCameraModel (50708)
+        const numEntries = 14;
+        this.writeUint16LE(result, numEntries);
+        // Calculate offsets for variable-length data
+        let dataOffset = ifdStart + 2 + numEntries * 12 + 4; // +4 for next IFD offset (0)
+        // 1. NewSubfileType (0x00FE) - 0 = Full resolution image
+        this.writeIFDEntry(result, 0x00FE, 4, 1, 0);
+        // 2. ImageWidth (0x0100)
+        this.writeIFDEntry(result, 0x0100, 4, 1, width);
+        // 3. ImageHeight (0x0101)
+        this.writeIFDEntry(result, 0x0101, 4, 1, height);
+        // 4. BitsPerSample (0x0102) - 8, 8, 8, 8
+        this.writeIFDEntry(result, 0x0102, 3, 4, dataOffset);
+        // Write the actual values later
+        const bitsPerSampleOffset = dataOffset;
+        dataOffset += 8; // 4 * 2 bytes
+        // 5. Compression (0x0103) - 1 = Uncompressed
+        this.writeIFDEntry(result, 0x0103, 3, 1, 1);
+        // 6. PhotometricInterpretation (0x0106) - 2 = RGB (Linear DNG)
+        // For Raw DNG it would be 32803 (CFA), but we are saving processed RGB data
+        this.writeIFDEntry(result, 0x0106, 3, 1, 2);
+        // 7. StripOffsets (0x0111)
+        this.writeIFDEntry(result, 0x0111, 4, 1, 8); // Pixel data starts at offset 8
+        // 8. SamplesPerPixel (0x0115) - 4 (RGBA)
+        this.writeIFDEntry(result, 0x0115, 3, 1, 4);
+        // 9. RowsPerStrip (0x0116)
+        this.writeIFDEntry(result, 0x0116, 4, 1, height);
+        // 10. StripByteCounts (0x0117)
+        this.writeIFDEntry(result, 0x0117, 4, 1, data.length);
+        // 11. PlanarConfiguration (0x011C) - 1 = Chunky
+        this.writeIFDEntry(result, 0x011C, 3, 1, 1);
+        // 12. ExtraSamples (0x0152) - 2 = Unassociated alpha
+        this.writeIFDEntry(result, 0x0152, 3, 1, 2); // 1 value, fits in offset field? No, it's SHORT (3), count 1. Value 2.
+        // Wait, writeIFDEntry puts value in offset field if count*type_size <= 4.
+        // SHORT is 2 bytes. 1 * 2 = 2 <= 4. So value goes in offset.
+        // 13. DNGVersion (0xC612 / 50706) - 1, 4, 0, 0
+        this.writeIFDEntry(result, 50706, 1, 4, 0x01040000);
+        // BYTE (1) count 4. 1*4=4. Fits.
+        // 1, 4, 0, 0 -> 0x01, 0x04, 0x00, 0x00.
+        // Little endian: 01 04 00 00.
+        // As uint32: 0x00000401? No, bytes are 1, 4, 0, 0.
+        // In file: 01 04 00 00.
+        // readUint32LE would read this as 0x00000401.
+        // So we pass 0x00000401?
+        // Let's verify writeIFDEntry logic in TIFFFormat (I can't see it but I assume it writes value directly if it fits).
+        // Actually, I need to check how writeIFDEntry works.
+        // Assuming it takes a number and writes it.
+        // 14. UniqueCameraModel (0xC614 / 50708) - "Cross Image DNG"
+        const modelName = "Cross Image DNG\0";
+        const modelNameBytes = new TextEncoder().encode(modelName);
+        this.writeIFDEntry(result, 50708, 2, modelNameBytes.length, dataOffset);
+        const modelNameOffset = dataOffset;
+        dataOffset += modelNameBytes.length;
+        // Next IFD offset (0)
+        this.writeUint32LE(result, 0);
+        // Write variable length data
+        // BitsPerSample data (8, 8, 8, 8)
+        // We need to write this at bitsPerSampleOffset
+        // But we are appending to result array.
+        // We calculated dataOffset relative to start of file?
+        // No, dataOffset was initialized to `ifdStart + 2 + numEntries * 12 + 4`.
+        // This is correct absolute offset.
+        // But we need to fill the gap between end of IFD and dataOffset?
+        // No, we are writing sequentially.
+        // Wait, `result` is an array of bytes.
+        // We wrote the IFD entries. Now we are at `ifdStart + 2 + numEntries * 12 + 4`.
+        // This matches `bitsPerSampleOffset`.
+        // Write BitsPerSample (8, 8, 8, 8)
+        this.writeUint16LE(result, 8);
+        this.writeUint16LE(result, 8);
+        this.writeUint16LE(result, 8);
+        this.writeUint16LE(result, 8);
+        // Write UniqueCameraModel string
+        for (let i = 0; i < modelNameBytes.length; i++) {
+            result.push(modelNameBytes[i]);
+        }
+        return new Uint8Array(result);
+    }
+}
+exports.DNGFormat = DNGFormat;

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

@@ -0,0 +1,43 @@
+import type { ImageData, ImageFormat } from "../types.js";
+/**
+ * PAM format handler
+ * Implements the Netpbm PAM (Portable Arbitrary Map) format.
+ * This is a standard uncompressed format supported by GIMP and other tools.
+ *
+ * Format structure:
+ * - Header (text):
+ *   P7
+ *   WIDTH <width>
+ *   HEIGHT <height>
+ *   DEPTH 4
+ *   MAXVAL 255
+ *   TUPLTYPE RGB_ALPHA
+ *   ENDHDR
+ * - Data (binary):
+ *   RGBA pixel data (width * height * 4 bytes)
+ */
+export declare class PAMFormat implements ImageFormat {
+    /** Format name identifier */
+    readonly name = "pam";
+    /** MIME type for PAM images */
+    readonly mimeType = "image/x-portable-arbitrary-map";
+    /**
+     * Check if the given data is a PAM image
+     * @param data Raw image data to check
+     * @returns true if data has PAM signature
+     */
+    canDecode(data: Uint8Array): boolean;
+    /**
+     * Decode PAM image data to RGBA
+     * @param data Raw PAM image data
+     * @returns Decoded image data with RGBA pixels
+     */
+    decode(data: Uint8Array): 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>;
+}
+//# sourceMappingURL=pam.d.ts.map

package/script/src/formats/pam.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PAMFormat = void 0;
+const security_js_1 = require("../utils/security.js");
+/**
+ * PAM format handler
+ * Implements the Netpbm PAM (Portable Arbitrary Map) format.
+ * This is a standard uncompressed format supported by GIMP and other tools.
+ *
+ * Format structure:
+ * - Header (text):
+ *   P7
+ *   WIDTH <width>
+ *   HEIGHT <height>
+ *   DEPTH 4
+ *   MAXVAL 255
+ *   TUPLTYPE RGB_ALPHA
+ *   ENDHDR
+ * - Data (binary):
+ *   RGBA pixel data (width * height * 4 bytes)
+ */
+class PAMFormat {
+    constructor() {
+        /** Format name identifier */
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "pam"
+        });
+        /** MIME type for PAM images */
+        Object.defineProperty(this, "mimeType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "image/x-portable-arbitrary-map"
+        });
+    }
+    /**
+     * Check if the given data is a PAM image
+     * @param data Raw image data to check
+     * @returns true if data has PAM signature
+     */
+    canDecode(data) {
+        // Check if data has at least magic bytes
+        if (data.length < 3) {
+            return false;
+        }
+        // Check for P7 followed by whitespace (usually newline)
+        return data[0] === 0x50 && // P
+            data[1] === 0x37 && // 7
+            (data[2] === 0x0a || data[2] === 0x0d || data[2] === 0x20); // \n, \r, or space
+    }
+    /**
+     * Decode PAM image data to RGBA
+     * @param data Raw PAM image data
+     * @returns Decoded image data with RGBA pixels
+     */
+    decode(data) {
+        if (!this.canDecode(data)) {
+            throw new Error("Invalid PAM signature");
+        }
+        // Parse header
+        let offset = 0;
+        let width = 0;
+        let height = 0;
+        let depth = 0;
+        let maxval = 0;
+        let headerDone = false;
+        const decoder = new TextDecoder();
+        // Find end of header
+        // We need to read line by line.
+        // Since we have the full buffer, we can just scan for newlines.
+        let lineStart = 0;
+        while (!headerDone && offset < data.length) {
+            // Find next newline
+            let lineEnd = -1;
+            for (let i = offset; i < data.length; i++) {
+                if (data[i] === 0x0a) {
+                    lineEnd = i;
+                    break;
+                }
+            }
+            if (lineEnd === -1) {
+                throw new Error("Unexpected end of file in header");
+            }
+            const line = decoder.decode(data.subarray(lineStart, lineEnd)).trim();
+            offset = lineEnd + 1; // Skip newline
+            lineStart = offset;
+            // Skip comments
+            if (line.startsWith("#"))
+                continue;
+            if (line === "")
+                continue;
+            if (line === "P7")
+                continue;
+            if (line === "ENDHDR") {
+                headerDone = true;
+                break;
+            }
+            // Parse fields
+            const parts = line.split(/\s+/);
+            if (parts.length >= 2) {
+                const key = parts[0];
+                const value = parts[1];
+                switch (key) {
+                    case "WIDTH":
+                        width = parseInt(value, 10);
+                        break;
+                    case "HEIGHT":
+                        height = parseInt(value, 10);
+                        break;
+                    case "DEPTH":
+                        depth = parseInt(value, 10);
+                        break;
+                    case "MAXVAL":
+                        maxval = parseInt(value, 10);
+                        break;
+                    case "TUPLTYPE":
+                        // Optional check
+                        break;
+                }
+            }
+        }
+        if (!headerDone) {
+            throw new Error("Invalid PAM header: missing ENDHDR");
+        }
+        // Validate dimensions
+        if (width <= 0 || height <= 0) {
+            throw new Error(`Invalid PAM dimensions: ${width}x${height}`);
+        }
+        // Validate dimensions for security
+        (0, security_js_1.validateImageDimensions)(width, height);
+        // We only support DEPTH 4 (RGBA) and MAXVAL 255 for now
+        if (depth !== 4) {
+            throw new Error(`Unsupported PAM depth: ${depth}. Only depth 4 (RGBA) is supported.`);
+        }
+        if (maxval !== 255) {
+            throw new Error(`Unsupported PAM maxval: ${maxval}. Only maxval 255 is supported.`);
+        }
+        const expectedDataLength = width * height * 4;
+        const actualDataLength = data.length - offset;
+        if (actualDataLength < expectedDataLength) {
+            throw new Error(`Invalid PAM data length: expected ${expectedDataLength}, got ${actualDataLength}`);
+        }
+        // Extract pixel data
+        const pixelData = new Uint8Array(expectedDataLength);
+        pixelData.set(data.subarray(offset, offset + expectedDataLength));
+        return Promise.resolve({ width, height, data: pixelData });
+    }
+    /**
+     * Encode RGBA image data to PAM format
+     * @param imageData Image data to encode
+     * @returns Encoded PAM image bytes
+     */
+    encode(imageData) {
+        const { width, height, data } = imageData;
+        // Validate input
+        if (data.length !== width * height * 4) {
+            throw new Error(`Data length mismatch: expected ${width * height * 4}, got ${data.length}`);
+        }
+        // Create header
+        const header = `P7\n` +
+            `WIDTH ${width}\n` +
+            `HEIGHT ${height}\n` +
+            `DEPTH 4\n` +
+            `MAXVAL 255\n` +
+            `TUPLTYPE RGB_ALPHA\n` +
+            `ENDHDR\n`;
+        const encoder = new TextEncoder();
+        const headerBytes = encoder.encode(header);
+        // Create output buffer
+        const output = new Uint8Array(headerBytes.length + data.length);
+        // Write header
+        output.set(headerBytes, 0);
+        // Write pixel data
+        output.set(data, headerBytes.length);
+        return Promise.resolve(output);
+    }
+}
+exports.PAMFormat = PAMFormat;

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

@@ -0,0 +1,13 @@
+import type { ImageData, ImageFormat } from "../types.js";
+/**
+ * PCX format handler
+ * Implements PCX decoder and encoder
+ */
+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>;
+}
+//# sourceMappingURL=pcx.d.ts.map

package/script/src/formats/pcx.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PCXFormat = void 0;
+/**
+ * PCX format handler
+ * Implements PCX decoder and encoder
+ */
+class PCXFormat {
+    constructor() {
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "pcx"
+        });
+        Object.defineProperty(this, "mimeType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "image/x-pcx"
+        });
+    }
+    canDecode(data) {
+        // PCX header check
+        // Byte 0: Manufacturer (must be 0x0A)
+        // Byte 1: Version (0, 2, 3, 4, 5)
+        // Byte 2: Encoding (1 = RLE)
+        return data.length >= 128 &&
+            data[0] === 0x0A &&
+            (data[1] === 0 || data[1] === 2 || data[1] === 3 || data[1] === 4 ||
+                data[1] === 5) &&
+            data[2] === 1;
+    }
+    decode(data) {
+        if (!this.canDecode(data)) {
+            return Promise.reject(new Error("Invalid PCX data"));
+        }
+        const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        // Parse header
+        // const manufacturer = view.getUint8(0);
+        // const version = view.getUint8(1);
+        // const encoding = view.getUint8(2);
+        const bitsPerPixel = view.getUint8(3);
+        const xMin = view.getUint16(4, true);
+        const yMin = view.getUint16(6, true);
+        const xMax = view.getUint16(8, true);
+        const yMax = view.getUint16(10, true);
+        // const hDpi = view.getUint16(12, true);
+        // const vDpi = view.getUint16(14, true);
+        // const colormap = data.slice(16, 64);
+        // const reserved = view.getUint8(64);
+        const nPlanes = view.getUint8(65);
+        const bytesPerLine = view.getUint16(66, true);
+        // const paletteInfo = view.getUint16(68, true);
+        // const hScreenSize = view.getUint16(70, true);
+        // const vScreenSize = view.getUint16(72, true);
+        const width = xMax - xMin + 1;
+        const height = yMax - yMin + 1;
+        if (width <= 0 || height <= 0) {
+            return Promise.reject(new Error("Invalid PCX dimensions"));
+        }
+        // Decode RLE data
+        let offset = 128;
+        const scanlineLength = nPlanes * bytesPerLine;
+        const rawData = new Uint8Array(height * scanlineLength);
+        let ptr = 0;
+        // Decode all scanlines
+        for (let y = 0; y < height; y++) {
+            let x = 0;
+            while (x < scanlineLength) {
+                if (offset >= data.length)
+                    break;
+                let byte = data[offset++];
+                let count = 1;
+                if ((byte & 0xC0) === 0xC0) {
+                    count = byte & 0x3F;
+                    if (offset >= data.length)
+                        break;
+                    byte = data[offset++];
+                }
+                for (let i = 0; i < count; i++) {
+                    if (ptr < rawData.length) {
+                        rawData[ptr++] = byte;
+                    }
+                    x++;
+                }
+            }
+        }
+        const rgba = new Uint8Array(width * height * 4);
+        if (nPlanes === 3 && bitsPerPixel === 8) {
+            // 24-bit RGB
+            for (let y = 0; y < height; y++) {
+                for (let x = 0; x < width; x++) {
+                    const r = rawData[y * scanlineLength + x];
+                    const g = rawData[y * scanlineLength + bytesPerLine + x];
+                    const b = rawData[y * scanlineLength + 2 * bytesPerLine + x];
+                    const idx = (y * width + x) * 4;
+                    rgba[idx] = r;
+                    rgba[idx + 1] = g;
+                    rgba[idx + 2] = b;
+                    rgba[idx + 3] = 255;
+                }
+            }
+        }
+        else if (nPlanes === 1 && bitsPerPixel === 8) {
+            // 8-bit palette
+            // Check for palette at end of file
+            let palette;
+            if (data[data.length - 769] === 0x0C) {
+                palette = data.slice(data.length - 768);
+            }
+            else {
+                // Fallback or error?
+                // Some old PCX might use header palette but that's only 16 colors.
+                // For 8bpp we expect 256 color palette at end.
+                return Promise.reject(new Error("Missing PCX palette"));
+            }
+            for (let y = 0; y < height; y++) {
+                for (let x = 0; x < width; x++) {
+                    const colorIndex = rawData[y * scanlineLength + x];
+                    const idx = (y * width + x) * 4;
+                    rgba[idx] = palette[colorIndex * 3];
+                    rgba[idx + 1] = palette[colorIndex * 3 + 1];
+                    rgba[idx + 2] = palette[colorIndex * 3 + 2];
+                    rgba[idx + 3] = 255;
+                }
+            }
+        }
+        else {
+            // Unsupported PCX format (e.g. 1-bit, 4-bit)
+            // For now only supporting 24-bit and 8-bit
+            return Promise.reject(new Error("Unsupported PCX format"));
+        }
+        return Promise.resolve({
+            width,
+            height,
+            data: rgba,
+        });
+    }
+    encode(image) {
+        const width = image.width;
+        const height = image.height;
+        const data = image.data;
+        // We will encode as 24-bit RGB (3 planes)
+        const header = new Uint8Array(128);
+        const view = new DataView(header.buffer);
+        view.setUint8(0, 0x0A); // Manufacturer
+        view.setUint8(1, 5); // Version 3.0+
+        view.setUint8(2, 1); // Encoding RLE
+        view.setUint8(3, 8); // Bits per pixel (8 per plane)
+        view.setUint16(4, 0, true); // XMin
+        view.setUint16(6, 0, true); // YMin
+        view.setUint16(8, width - 1, true); // XMax
+        view.setUint16(10, height - 1, true); // YMax
+        view.setUint16(12, 72, true); // HDpi
+        view.setUint16(14, 72, true); // VDpi
+        view.setUint8(65, 3); // NPlanes (3 for RGB)
+        view.setUint16(66, width + (width % 2), true); // BytesPerLine (must be even)
+        view.setUint16(68, 1, true); // PaletteInfo (Color/BW)
+        const bytesPerLine = width + (width % 2);
+        const scanlineLength = bytesPerLine * 3;
+        const rleData = [];
+        // Helper to write RLE
+        const writeRLE = (byte, count) => {
+            if ((byte & 0xC0) === 0xC0 || count > 1) {
+                rleData.push(0xC0 | count);
+                rleData.push(byte);
+            }
+            else {
+                rleData.push(byte);
+            }
+        };
+        for (let y = 0; y < height; y++) {
+            // Prepare scanline planes
+            const lineR = new Uint8Array(bytesPerLine);
+            const lineG = new Uint8Array(bytesPerLine);
+            const lineB = new Uint8Array(bytesPerLine);
+            for (let x = 0; x < width; x++) {
+                const idx = (y * width + x) * 4;
+                lineR[x] = data[idx];
+                lineG[x] = data[idx + 1];
+                lineB[x] = data[idx + 2];
+            }
+            // Compress each plane
+            for (const plane of [lineR, lineG, lineB]) {
+                let currentByte = plane[0];
+                let runLength = 1;
+                for (let x = 1; x < bytesPerLine; x++) {
+                    const byte = plane[x];
+                    if (byte === currentByte && runLength < 63) {
+                        runLength++;
+                    }
+                    else {
+                        writeRLE(currentByte, runLength);
+                        currentByte = byte;
+                        runLength = 1;
+                    }
+                }
+                writeRLE(currentByte, runLength);
+            }
+        }
+        const result = new Uint8Array(header.length + rleData.length);
+        result.set(header);
+        result.set(rleData, header.length);
+        return Promise.resolve(result);
+    }
+}
+exports.PCXFormat = PCXFormat;

package/script/src/formats/tiff.d.ts

@@ -15,9 +15,9 @@ export interface TIFFEncodeOptions {
  */
 export declare class TIFFFormat implements ImageFormat {
     /** Format name identifier */
-    readonly name = "tiff";
+    readonly name: string;
     /** MIME type for TIFF images */
-    readonly mimeType = "image/tiff";
+    readonly mimeType: string;
     /**
      * Check if this format supports multiple frames (pages)
      * @returns true for TIFF format
@@ -52,11 +52,11 @@ export declare class TIFFFormat implements ImageFormat {
      * Extract metadata from an IFD
      */
     private extractMetadataFromIFD;
-    private readUint16;
-    private readUint32;
-    private writeUint16LE;
-    private writeUint32LE;
-    private writeIFDEntry;
+    protected readUint16(data: Uint8Array, offset: number, isLittleEndian: boolean): number;
+    protected readUint32(data: Uint8Array, offset: number, isLittleEndian: boolean): number;
+    protected writeUint16LE(result: number[], value: number): void;
+    protected writeUint32LE(result: number[], value: number): void;
+    protected writeIFDEntry(result: number[], tag: number, type: number, count: number, valueOrOffset: number): void;
     private getIFDValue;
     private decodeUsingRuntime;
     private readString;