cross-image 0.1.2

package/script/src/utils/lzw.d.ts

@@ -0,0 +1,43 @@
+/**
+ * LZW (Lempel-Ziv-Welch) compression and decompression
+ * Used for GIF image encoding and decoding
+ */
+/**
+ * LZW Decompressor for GIF images
+ */
+export declare class LZWDecoder {
+    private minCodeSize;
+    private clearCode;
+    private endCode;
+    private data;
+    private pos;
+    private bitPos;
+    private codeSize;
+    private maxCode;
+    private dict;
+    private prevCode;
+    private nextCode;
+    constructor(minCodeSize: number, data: Uint8Array);
+    private initDictionary;
+    private readCode;
+    decompress(): Uint8Array;
+}
+/**
+ * LZW Encoder for GIF images
+ */
+export declare class LZWEncoder {
+    private minCodeSize;
+    private clearCode;
+    private endCode;
+    private codeSize;
+    private maxCode;
+    private dict;
+    private output;
+    private bitBuffer;
+    private bitCount;
+    constructor(minCodeSize: number);
+    private initDictionary;
+    private writeCode;
+    compress(data: Uint8Array): Uint8Array;
+}
+//# sourceMappingURL=lzw.d.ts.map

package/script/src/utils/lzw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lzw.d.ts","sourceRoot":"","sources":["../../../src/src/utils/lzw.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,IAAI,CAAa;IACzB,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,IAAI,CAAe;IAC3B,OAAO,CAAC,QAAQ,CAAgB;IAChC,OAAO,CAAC,QAAQ,CAAS;gBAEb,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU;IAejD,OAAO,CAAC,cAAc;IAetB,OAAO,CAAC,QAAQ;IAqBhB,UAAU,IAAI,UAAU;CA0DzB;AAED;;GAEG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,IAAI,CAAsB;IAClC,OAAO,CAAC,MAAM,CAAW;IACzB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAAS;gBAEb,WAAW,EAAE,MAAM;IAa/B,OAAO,CAAC,cAAc;IAUtB,OAAO,CAAC,SAAS;IAWjB,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU;CA4DvC"}

package/script/src/utils/lzw.js

@@ -0,0 +1,314 @@
+"use strict";
+/**
+ * LZW (Lempel-Ziv-Welch) compression and decompression
+ * Used for GIF image encoding and decoding
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LZWEncoder = exports.LZWDecoder = void 0;
+/**
+ * LZW Decompressor for GIF images
+ */
+class LZWDecoder {
+    constructor(minCodeSize, data) {
+        Object.defineProperty(this, "minCodeSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "clearCode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "endCode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "data", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "pos", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "bitPos", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "codeSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "maxCode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "dict", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "prevCode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "nextCode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.minCodeSize = minCodeSize;
+        this.clearCode = 1 << minCodeSize;
+        this.endCode = this.clearCode + 1;
+        this.data = data;
+        this.pos = 0;
+        this.bitPos = 0;
+        this.codeSize = minCodeSize + 1;
+        this.maxCode = (1 << this.codeSize) - 1;
+        this.dict = [];
+        this.prevCode = null;
+        this.nextCode = this.endCode + 1;
+        this.initDictionary();
+    }
+    initDictionary() {
+        this.dict = [];
+        // Initialize dictionary with single-byte entries
+        for (let i = 0; i < this.clearCode; i++) {
+            this.dict[i] = new Uint8Array([i]);
+        }
+        // Reserve clear code and end code positions
+        this.dict[this.clearCode] = new Uint8Array(0);
+        this.dict[this.endCode] = new Uint8Array(0);
+        this.codeSize = this.minCodeSize + 1;
+        this.maxCode = (1 << this.codeSize) - 1;
+        this.prevCode = null;
+        this.nextCode = this.endCode + 1;
+    }
+    readCode() {
+        let code = 0;
+        for (let i = 0; i < this.codeSize; i++) {
+            if (this.bitPos === 0) {
+                // Need to read a new byte
+                if (this.pos >= this.data.length) {
+                    return null;
+                }
+            }
+            const byte = this.data[this.pos];
+            const bit = (byte >> this.bitPos) & 1;
+            code |= bit << i;
+            this.bitPos++;
+            if (this.bitPos === 8) {
+                this.bitPos = 0;
+                this.pos++;
+            }
+        }
+        return code;
+    }
+    decompress() {
+        const output = [];
+        while (true) {
+            // Check if we need to increase code size for this read
+            // This happens when we're about to add an entry at nextCode and it exceeds maxCode
+            if (this.prevCode !== null && this.nextCode > this.maxCode &&
+                this.codeSize < 12) {
+                this.maxCode = this.maxCode * 2 + 1;
+                this.codeSize++;
+            }
+            const code = this.readCode();
+            if (code === null || code === this.endCode) {
+                break;
+            }
+            if (code === this.clearCode) {
+                this.initDictionary();
+                continue;
+            }
+            if (code < this.dict.length && this.dict[code]) {
+                const entry = this.dict[code];
+                output.push(...entry);
+                if (this.prevCode !== null && this.prevCode < this.dict.length) {
+                    const prevEntry = this.dict[this.prevCode];
+                    if (prevEntry && this.nextCode < 4096) {
+                        const newEntry = new Uint8Array(prevEntry.length + 1);
+                        newEntry.set(prevEntry);
+                        newEntry[prevEntry.length] = entry[0];
+                        this.dict[this.nextCode] = newEntry;
+                        this.nextCode++;
+                    }
+                }
+            }
+            else if (this.prevCode !== null && this.prevCode < this.dict.length) {
+                // Special case: code not in dictionary yet
+                const prevEntry = this.dict[this.prevCode];
+                if (prevEntry && this.nextCode < 4096) {
+                    const newEntry = new Uint8Array(prevEntry.length + 1);
+                    newEntry.set(prevEntry);
+                    newEntry[prevEntry.length] = prevEntry[0];
+                    this.dict[this.nextCode] = newEntry;
+                    this.nextCode++;
+                    output.push(...newEntry);
+                }
+            }
+            this.prevCode = code;
+        }
+        return new Uint8Array(output);
+    }
+}
+exports.LZWDecoder = LZWDecoder;
+/**
+ * LZW Encoder for GIF images
+ */
+class LZWEncoder {
+    constructor(minCodeSize) {
+        Object.defineProperty(this, "minCodeSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "clearCode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "endCode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "codeSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "maxCode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "dict", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "output", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "bitBuffer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "bitCount", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.minCodeSize = minCodeSize;
+        this.clearCode = 1 << minCodeSize;
+        this.endCode = this.clearCode + 1;
+        this.codeSize = minCodeSize + 1;
+        this.maxCode = (1 << this.codeSize) - 1;
+        this.dict = new Map();
+        this.output = [];
+        this.bitBuffer = 0;
+        this.bitCount = 0;
+        this.initDictionary();
+    }
+    initDictionary() {
+        this.dict.clear();
+        // Initialize dictionary with single-byte entries
+        for (let i = 0; i < this.clearCode; i++) {
+            this.dict.set(String.fromCharCode(i), i);
+        }
+        this.codeSize = this.minCodeSize + 1;
+        this.maxCode = (1 << this.codeSize) - 1;
+    }
+    writeCode(code) {
+        this.bitBuffer |= code << this.bitCount;
+        this.bitCount += this.codeSize;
+        while (this.bitCount >= 8) {
+            this.output.push(this.bitBuffer & 0xff);
+            this.bitBuffer >>= 8;
+            this.bitCount -= 8;
+        }
+    }
+    compress(data) {
+        this.initDictionary();
+        this.output = [];
+        this.bitBuffer = 0;
+        this.bitCount = 0;
+        // Write clear code
+        this.writeCode(this.clearCode);
+        let buffer = "";
+        let nextCode = this.endCode + 1;
+        for (let i = 0; i < data.length; i++) {
+            const k = String.fromCharCode(data[i]);
+            const bufferK = buffer + k;
+            if (this.dict.has(bufferK)) {
+                buffer = bufferK;
+            }
+            else {
+                // Output code for buffer
+                const code = this.dict.get(buffer);
+                if (code !== undefined) {
+                    this.writeCode(code);
+                }
+                // Add new entry to dictionary
+                if (nextCode < 4096) {
+                    this.dict.set(bufferK, nextCode);
+                    // Increase code size when needed (check BEFORE incrementing nextCode)
+                    if (nextCode > this.maxCode && this.codeSize < 12) {
+                        this.maxCode = this.maxCode * 2 + 1;
+                        this.codeSize++;
+                    }
+                    nextCode++;
+                }
+                buffer = k;
+            }
+        }
+        // Output final code
+        if (buffer.length > 0) {
+            const code = this.dict.get(buffer);
+            if (code !== undefined) {
+                this.writeCode(code);
+            }
+        }
+        // Write end code
+        this.writeCode(this.endCode);
+        // Flush remaining bits
+        if (this.bitCount > 0) {
+            this.output.push(this.bitBuffer & 0xff);
+        }
+        return new Uint8Array(this.output);
+    }
+}
+exports.LZWEncoder = LZWEncoder;

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

@@ -0,0 +1,9 @@
+/**
+ * Bilinear interpolation resize
+ */
+export declare function resizeBilinear(src: Uint8Array, srcWidth: number, srcHeight: number, dstWidth: number, dstHeight: number): Uint8Array;
+/**
+ * Nearest neighbor resize
+ */
+export declare function resizeNearest(src: Uint8Array, srcWidth: number, srcHeight: number, dstWidth: number, dstHeight: number): Uint8Array;
+//# sourceMappingURL=resize.d.ts.map

package/script/src/utils/resize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resize.d.ts","sourceRoot":"","sources":["../../../src/src/utils/resize.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,UAAU,EACf,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAChB,UAAU,CAgCZ;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,UAAU,EACf,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAChB,UAAU,CAoBZ"}

package/script/src/utils/resize.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resizeBilinear = resizeBilinear;
+exports.resizeNearest = resizeNearest;
+/**
+ * Bilinear interpolation resize
+ */
+function resizeBilinear(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 x1 = Math.floor(srcX);
+            const y1 = Math.floor(srcY);
+            const x2 = Math.min(x1 + 1, srcWidth - 1);
+            const y2 = Math.min(y1 + 1, srcHeight - 1);
+            const dx = srcX - x1;
+            const dy = srcY - y1;
+            for (let c = 0; c < 4; c++) {
+                const p1 = src[(y1 * srcWidth + x1) * 4 + c];
+                const p2 = src[(y1 * srcWidth + x2) * 4 + c];
+                const p3 = src[(y2 * srcWidth + x1) * 4 + c];
+                const p4 = src[(y2 * srcWidth + x2) * 4 + c];
+                const v1 = p1 * (1 - dx) + p2 * dx;
+                const v2 = p3 * (1 - dx) + p4 * dx;
+                const v = v1 * (1 - dy) + v2 * dy;
+                dst[(y * dstWidth + x) * 4 + c] = Math.round(v);
+            }
+        }
+    }
+    return dst;
+}
+/**
+ * Nearest neighbor resize
+ */
+function resizeNearest(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 = Math.floor(x * xRatio);
+            const srcY = Math.floor(y * yRatio);
+            const srcIdx = (srcY * srcWidth + srcX) * 4;
+            const dstIdx = (y * dstWidth + x) * 4;
+            dst[dstIdx] = src[srcIdx];
+            dst[dstIdx + 1] = src[srcIdx + 1];
+            dst[dstIdx + 2] = src[srcIdx + 2];
+            dst[dstIdx + 3] = src[srcIdx + 3];
+        }
+    }
+    return dst;
+}

package/script/src/utils/tiff_lzw.d.ts

@@ -0,0 +1,44 @@
+/**
+ * LZW compression and decompression for TIFF images
+ *
+ * TIFF LZW differs from GIF LZW in several ways:
+ * - Uses MSB-first bit ordering (big-endian bits)
+ * - Typically starts with 9-bit codes
+ * - Uses code 256 as clear code, code 257 as end-of-information (EOI)
+ * - Variable code size from 9 to 12 bits
+ */
+/**
+ * LZW Decompressor for TIFF images
+ */
+export declare class TIFFLZWDecoder {
+    private data;
+    private pos;
+    private bitPos;
+    private codeSize;
+    private dict;
+    private clearCode;
+    private eoiCode;
+    private nextCode;
+    constructor(data: Uint8Array);
+    private initDictionary;
+    private readCode;
+    decompress(): Uint8Array;
+}
+/**
+ * LZW Encoder for TIFF images
+ */
+export declare class TIFFLZWEncoder {
+    private codeSize;
+    private dict;
+    private output;
+    private bitBuffer;
+    private bitCount;
+    private clearCode;
+    private eoiCode;
+    private nextCode;
+    constructor();
+    private initDictionary;
+    private writeCode;
+    compress(data: Uint8Array): Uint8Array;
+}
+//# sourceMappingURL=tiff_lzw.d.ts.map

package/script/src/utils/tiff_lzw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiff_lzw.d.ts","sourceRoot":"","sources":["../../../src/src/utils/tiff_lzw.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;GAEG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,IAAI,CAAa;IACzB,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,IAAI,CAAe;IAC3B,OAAO,CAAC,SAAS,CAAO;IACxB,OAAO,CAAC,OAAO,CAAO;IACtB,OAAO,CAAC,QAAQ,CAAO;gBAEX,IAAI,EAAE,UAAU;IAS5B,OAAO,CAAC,cAAc;IAUtB,OAAO,CAAC,QAAQ;IA2BhB,UAAU,IAAI,UAAU;CA2EzB;AAED;;GAEG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,IAAI,CAAsB;IAClC,OAAO,CAAC,MAAM,CAAW;IACzB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,SAAS,CAAO;IACxB,OAAO,CAAC,OAAO,CAAO;IACtB,OAAO,CAAC,QAAQ,CAAO;;IAWvB,OAAO,CAAC,cAAc;IAUtB,OAAO,CAAC,SAAS;IAejB,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU;CAoEvC"}