@aibee/owlly 1.0.25 → 1.0.29

package/lib/owlly/element/gif-kit/Gif.js

@@ -0,0 +1,432 @@
+/* eslint-disable */
+/*!
+ gifken
+ Copyright (c) 2013 aaharu
+ This software is released under the MIT License.
+ https://raw.github.com/aaharu/gifken/master/LICENSE
+
+ This product includes following software:
+ * GifWriter.js
+ - Copyright (c) 2013 NOBUOKA Yu
+ - https://github.com/nobuoka/GifWriter.js
+ - https://raw.github.com/nobuoka/GifWriter.js/master/LICENSE.txt
+ */
+import { GifColor } from './GifColor';
+import { GifParser } from './GifParser';
+import { GifVersion } from './GifVersion';
+import { GifCompressedCodesToByteArrayConverter } from './GifCompressedCodesToByteArrayConverter';
+export class Gif {
+    /**
+     * Gif
+     */
+    constructor(skipDefault) {
+        this.frameIndex1 = 0;
+        this.frameIndex2 = 0;
+        this.frames = [];
+        if (skipDefault) {
+            return;
+        }
+        // default values
+        this._version = GifVersion.GIF89a;
+        this._width = 1;
+        this._height = 1;
+        this.colorResolution = 112; // not supported
+        this.sortFlag = false; // not supported
+        this.bgColorIndex = 1; // ?
+        this.pixelAspectRatio = 0; // not supported
+        this.globalColorTable = GifColor.createColorTable([
+            new GifColor(0, 0, 0),
+            new GifColor(255, 255, 255),
+        ]);
+    }
+    /**
+     * Parse Gif image from ArrayBuffer.
+     *
+     * @return {Gif} parsed gif object
+     */
+    static parse(buffer) {
+        const gif = new Gif(true);
+        const data = new DataView(buffer);
+        let offset = GifParser.readHeader(gif, data);
+        while (true) {
+            offset = GifParser.readBlock(gif, data, offset);
+            if (offset === -1) {
+                break;
+            }
+        }
+        return gif;
+    }
+    versionName() {
+        return GifVersion[this._version];
+    }
+    get version() {
+        return this._version;
+    }
+    set version(v) {
+        this._version = v;
+    }
+    get width() {
+        return this._width;
+    }
+    set width(width) {
+        width = ~~width;
+        if (width > 0xffff || width < 0) {
+            throw new RangeError('width range error: ' + width);
+        }
+        this._width = width;
+    }
+    get height() {
+        return this._height;
+    }
+    set height(height) {
+        height = ~~height;
+        if (height > 0xffff || height < 0) {
+            throw new RangeError('height range error: ' + height);
+        }
+        this._height = height;
+    }
+    get globalColorTable() {
+        return this._globalColorTable;
+    }
+    set globalColorTable(bytes) {
+        this._globalColorTable = bytes;
+        this._globalTableSize = bytes.byteLength / 3;
+        if (this.bgColorIndex === undefined) {
+            this.bgColorIndex = this._globalTableSize - 1;
+        }
+    }
+    get globalTableSize() {
+        return this._globalTableSize;
+    }
+    get loopCount() {
+        return this._loopCount;
+    }
+    set loopCount(loopCount) {
+        loopCount = ~~loopCount;
+        if (loopCount > 0xffff || loopCount < 0) {
+            throw new RangeError('loopCount range error: ' + loopCount);
+        }
+        this._loopCount = loopCount;
+    }
+    writeToArrayBuffer() {
+        return Gif.writeToArrayBuffer(this);
+    }
+    /**
+     * Convert Gif to Uint8Array[].
+     *
+     * @return {Uint8Array[]} array of Uint8Array
+     */
+    static writeToArrayBuffer(gif) {
+        const output = [];
+        // write header
+        const header = new DataView(new ArrayBuffer(13));
+        header.setUint8(0, 71); // G
+        header.setUint8(1, 73); // I
+        header.setUint8(2, 70); // F
+        header.setUint8(3, 56); // 8
+        if (gif.version === GifVersion.GIF89a) {
+            header.setUint8(4, 57); // 9
+        }
+        else {
+            header.setUint8(4, 55); // 7
+        }
+        header.setUint8(5, 97); // a
+        header.setUint16(6, gif.width, true);
+        header.setUint16(8, gif.height, true);
+        let packed = 0;
+        let size = gif.globalTableSize;
+        if (size > 0) {
+            packed |= 128;
+            let count = 0;
+            do {
+                size = size >> 1;
+                ++count;
+            } while (size > 1);
+            packed |= count - 1;
+        }
+        packed |= gif.colorResolution; // not supported
+        if (gif.sortFlag) {
+            // not supported
+            packed |= 8;
+        }
+        header.setUint8(10, packed);
+        header.setUint8(11, gif.bgColorIndex);
+        header.setUint8(12, gif.pixelAspectRatio); // not supported
+        output.push(new Uint8Array(header.buffer));
+        if (gif.globalTableSize > 0) {
+            output.push(gif.globalColorTable);
+        }
+        // write extension
+        if (gif.isLoop) {
+            const appExt = new DataView(new ArrayBuffer(19));
+            appExt.setUint8(0, 0x21);
+            appExt.setUint8(1, 0xff);
+            appExt.setUint8(2, 0x0b);
+            appExt.setUint8(3, 0x4e); // N
+            appExt.setUint8(4, 0x45); // E
+            appExt.setUint8(5, 0x54); // T
+            appExt.setUint8(6, 0x53); // S
+            appExt.setUint8(7, 0x43); // C
+            appExt.setUint8(8, 0x41); // A
+            appExt.setUint8(9, 0x50); // P
+            appExt.setUint8(10, 0x45); // E
+            appExt.setUint8(11, 0x32); // 2
+            appExt.setUint8(12, 0x2e); // .
+            appExt.setUint8(13, 0x30); // 0
+            appExt.setUint8(14, 3);
+            appExt.setUint8(15, 1);
+            appExt.setUint16(16, gif.loopCount, true);
+            appExt.setUint8(18, 0);
+            output.push(new Uint8Array(appExt.buffer));
+        }
+        // write image data
+        gif.frames.forEach((frame) => {
+            const image = new DataView(new ArrayBuffer(18));
+            image.setUint8(0, 0x21);
+            image.setUint8(1, 0xf9);
+            image.setUint8(2, 0x04);
+            if (frame.transparentFlag) {
+                image.setUint8(3, 1);
+            }
+            else {
+                image.setUint8(3, 0);
+            }
+            image.setUint16(4, frame.delayCentiSeconds, true);
+            image.setUint8(6, frame.transparentColorIndex);
+            image.setUint8(7, 0);
+            image.setUint8(8, 0x2c);
+            image.setUint16(9, frame.x, true);
+            image.setUint16(11, frame.y, true);
+            image.setUint16(13, frame.width, true);
+            image.setUint16(15, frame.height, true);
+            if (frame.localTableSize > 0) {
+                let count = 0;
+                let size = frame.localTableSize;
+                do {
+                    size = size >> 1;
+                    ++count;
+                } while (size > 1);
+                image.setUint8(17, 128 | (count - 1));
+            }
+            else {
+                image.setUint8(17, 0);
+            }
+            output.push(new Uint8Array(image.buffer));
+            if (frame.localTableSize > 0) {
+                output.push(frame.localColorTable);
+            }
+            output.push(new Uint8Array([frame.lzwCode]));
+            if (frame.compressedData === undefined && frame.pixelData === undefined) {
+                throw new Error('no image data');
+            }
+            let idx = 0, compressedBytes = frame.compressedData;
+            if (compressedBytes instanceof Array) {
+                compressedBytes = new Uint8Array(compressedBytes);
+            }
+            else {
+                compressedBytes =
+                    compressedBytes ||
+                        new Uint8Array(Gif.compressWithLZW(frame.pixelData, frame.lzwCode));
+            }
+            const l = compressedBytes.length;
+            while (true) {
+                if (l > idx + 255) {
+                    output.push(new Uint8Array([255]));
+                    output.push(compressedBytes.subarray(idx, idx + 255));
+                    idx += 255;
+                    continue;
+                }
+                const bytes = compressedBytes.subarray(idx);
+                output.push(new Uint8Array([bytes.byteLength]));
+                output.push(bytes);
+                break;
+            }
+            output.push(new Uint8Array([0]));
+        });
+        output.push(new Uint8Array([0x3b])); // trailer
+        return output;
+    }
+    /**
+     * TODO
+     **/
+    writeToArray() {
+        const output = Gif.writeToArrayBuffer(this);
+        const arr = [];
+        output.forEach((buffer) => {
+            for (let i = 0, l = buffer.byteLength; i < l; ++i) {
+                arr.push(buffer[i]);
+            }
+        });
+        return arr;
+    }
+    /**
+     * Split the animated GIF image.
+     *
+     * @return {Gif[]} array of Gif object
+     */
+    split(overwrite) {
+        const res = [];
+        if (overwrite) {
+            this.frames.forEach((frame, index) => {
+                const gif = new Gif();
+                gif.version = this._version;
+                gif.width = this._width;
+                gif.height = this._height;
+                gif.colorResolution = this.colorResolution; // not supported
+                gif.sortFlag = this.sortFlag; // not supported
+                gif.bgColorIndex = this.bgColorIndex;
+                gif.pixelAspectRatio = this.pixelAspectRatio; // not supported
+                gif.globalColorTable = this._globalColorTable;
+                // if (index !== 0 && frame.transparentFlag) {
+                //   frame.decompress();
+                // }
+                // if (index !== 0 && frame.transparentFlag) {
+                //   if (frame.pixelData === undefined) {
+                //     frame.decompress();
+                //   }
+                //   if (this.frames[index - 1].pixelData === undefined) {
+                //     this.frames[index - 1].decompress();
+                //   }
+                //   let edited = false;
+                //   for (let i = 0, l = frame.pixelData.length; i < l; ++i) {
+                //     if (frame.pixelData[i] === frame.transparentColorIndex) {
+                //       frame.pixelData[i] = this.frames[index - 1].pixelData[i];
+                //       edited = true;
+                //     }
+                //   }
+                //   if (edited) {
+                //     const compressedBytes = Gif.compressWithLZW(
+                //       frame.pixelData,
+                //       frame.lzwCode
+                //     );
+                //     frame.compressedData = new Uint8Array(compressedBytes);
+                //   }
+                //  delete frame.pixelData;
+                // }
+                gif.frames = [frame];
+                res.push(gif);
+            });
+        }
+        else {
+            this.frames.forEach((frame) => {
+                const gif = new Gif();
+                gif.version = this._version;
+                gif.width = this._width;
+                gif.height = this._height;
+                gif.colorResolution = this.colorResolution; // not supported
+                gif.sortFlag = this.sortFlag; // not supported
+                gif.bgColorIndex = this.bgColorIndex;
+                gif.pixelAspectRatio = this.pixelAspectRatio; // not supported
+                gif.globalColorTable = this._globalColorTable;
+                gif.frames = [frame];
+                res.push(gif);
+            });
+        }
+        return res;
+    }
+    /**
+     * Playback the animated GIF image.
+     *
+     * @return {Gif} Gif object
+     */
+    playback(overwrite) {
+        const res = new Gif();
+        if (overwrite) {
+            this.frames.forEach((frame, index) => {
+                if (index !== 0 && frame.transparentFlag) {
+                    if (frame.pixelData === undefined) {
+                        frame.decompress();
+                    }
+                    if (this.frames[index - 1].pixelData === undefined) {
+                        this.frames[index - 1].decompress();
+                    }
+                    let edited = false;
+                    for (let i = 0, l = frame.pixelData.length; i < l; ++i) {
+                        if (frame.pixelData[i] === frame.transparentColorIndex) {
+                            frame.pixelData[i] = this.frames[index - 1].pixelData[i];
+                            edited = true;
+                        }
+                    }
+                    if (edited) {
+                        const compressedBytes = Gif.compressWithLZW(frame.pixelData, frame.lzwCode);
+                        frame.compressedData = new Uint8Array(compressedBytes);
+                    }
+                    delete frame.pixelData;
+                }
+            });
+        }
+        res.version = this._version;
+        res.width = this._width;
+        res.height = this._height;
+        res.colorResolution = this.colorResolution; // not supported
+        res.sortFlag = this.sortFlag; // not supported
+        res.bgColorIndex = this.bgColorIndex;
+        res.pixelAspectRatio = this.pixelAspectRatio; // not supported
+        res.globalColorTable = this._globalColorTable;
+        res.frames = this.frames.reverse();
+        res.isLoop = this.isLoop;
+        res.loopCount = this._loopCount;
+        return res;
+    }
+    /*
+     ===begin GifWriter.js===
+     */
+    static compressWithLZW(actualCodes, numBits) {
+        // `numBits` is LZW-initial code size, which indicates how many bits are needed
+        // to represents actual code.
+        const bb = new GifCompressedCodesToByteArrayConverter();
+        // GIF spec says: A special Clear code is defined which resets all
+        // compression/decompression parameters and tables to a start-up state.
+        // The value of this code is 2**<code size>. For example if the code size
+        // indicated was 4 (image was 4 bits/pixel) the Clear code value would be 16
+        // (10000 binary). The Clear code can appear at any point in the image data
+        // stream and therefore requires the LZW algorithm to process succeeding
+        // codes as if a new data stream was starting. Encoders should
+        // output a Clear code as the first code of each image data stream.
+        const clearCode = 1 << numBits;
+        // GIF spec says: An End of Information code is defined that explicitly
+        // indicates the end of the image data stream. LZW processing terminates
+        // when this code is encountered. It must be the last code output by the
+        // encoder for an image. The value of this code is <Clear code>+1.
+        const endOfInfoCode = clearCode + 1;
+        let nextCode = endOfInfoCode + 1;
+        let curNumCodeBits = numBits + 1;
+        let dict = Object.create(null);
+        function resetAllParamsAndTablesToStartUpState() {
+            // GIF spec says: The first available compression code value is <Clear code>+2.
+            nextCode = endOfInfoCode + 1;
+            curNumCodeBits = numBits + 1;
+            dict = Object.create(null);
+        }
+        resetAllParamsAndTablesToStartUpState();
+        bb.push(clearCode, curNumCodeBits); // clear code at first
+        let concatedCodesKey = '';
+        for (let i = 0, len = actualCodes.length; i < len; ++i) {
+            const code = actualCodes[i];
+            const dictKey = String.fromCharCode(code);
+            if (!(dictKey in dict))
+                dict[dictKey] = code;
+            const oldKey = concatedCodesKey;
+            concatedCodesKey += dictKey;
+            if (!(concatedCodesKey in dict)) {
+                bb.push(dict[oldKey], curNumCodeBits);
+                // GIF spec defines a maximum code value of 4095 (0xFFF)
+                if (nextCode <= 0xfff) {
+                    dict[concatedCodesKey] = nextCode;
+                    if (nextCode === 1 << curNumCodeBits)
+                        curNumCodeBits++;
+                    nextCode++;
+                }
+                else {
+                    bb.push(clearCode, curNumCodeBits);
+                    resetAllParamsAndTablesToStartUpState();
+                    dict[dictKey] = code;
+                }
+                concatedCodesKey = dictKey;
+            }
+        }
+        bb.push(dict[concatedCodesKey], curNumCodeBits);
+        bb.push(endOfInfoCode, curNumCodeBits);
+        return bb.flush();
+    }
+}

package/lib/owlly/element/gif-kit/GifColor.d.ts

@@ -0,0 +1,21 @@
+/*!
+ gifken
+ Copyright (c) 2013 aaharu
+ This software is released under the MIT License.
+ https://raw.github.com/aaharu/gifken/master/LICENSE
+ */
+export declare class GifColor {
+    r: number;
+    g: number;
+    b: number;
+    /**
+     * GifColor
+     */
+    constructor(r: number, g: number, b: number);
+    /**
+     * TODO:
+    static valueOf(color:string) {
+    }
+     */
+    static createColorTable(colors: GifColor[]): Uint8Array;
+}

package/lib/owlly/element/gif-kit/GifColor.js

@@ -0,0 +1,37 @@
+/* eslint-disable */
+/*!
+ gifken
+ Copyright (c) 2013 aaharu
+ This software is released under the MIT License.
+ https://raw.github.com/aaharu/gifken/master/LICENSE
+ */
+export class GifColor {
+    /**
+     * GifColor
+     */
+    constructor(r, g, b) {
+        this.r = r;
+        this.g = g;
+        this.b = b;
+    }
+    /**
+     * TODO:
+    static valueOf(color:string) {
+    }
+     */
+    static createColorTable(colors) {
+        const numbers = [];
+        for (let i = 1; i <= 8; ++i) {
+            const d = (i << 1) - colors.length;
+            for (let j = 0; j < d; ++j) {
+                colors.push(new GifColor(255, 255, 255));
+            }
+        }
+        colors.forEach((color) => {
+            numbers.push(color.r);
+            numbers.push(color.g);
+            numbers.push(color.b);
+        });
+        return new Uint8Array(numbers);
+    }
+}

package/lib/owlly/element/gif-kit/GifCompressedCodesToByteArrayConverter.d.ts

@@ -0,0 +1,20 @@
+/*!
+ gifken
+ Copyright (c) 2013 aaharu
+ This software is released under the MIT License.
+ https://raw.github.com/aaharu/gifken/master/LICENSE
+
+ This product includes following software:
+ * GifWriter.js
+ - Copyright (c) 2013 NOBUOKA Yu
+ - https://github.com/nobuoka/GifWriter.js
+ - https://raw.github.com/nobuoka/GifWriter.js/master/LICENSE.txt
+ */
+export declare class GifCompressedCodesToByteArrayConverter {
+    private __out;
+    private __remNumBits;
+    private __remVal;
+    constructor();
+    push(code: number, numBits: number): void;
+    flush(): number[];
+}

package/lib/owlly/element/gif-kit/GifCompressedCodesToByteArrayConverter.js

@@ -0,0 +1,50 @@
+/* eslint-disable */
+/*!
+ gifken
+ Copyright (c) 2013 aaharu
+ This software is released under the MIT License.
+ https://raw.github.com/aaharu/gifken/master/LICENSE
+
+ This product includes following software:
+ * GifWriter.js
+ - Copyright (c) 2013 NOBUOKA Yu
+ - https://github.com/nobuoka/GifWriter.js
+ - https://raw.github.com/nobuoka/GifWriter.js/master/LICENSE.txt
+ */
+/*
+ ===begin GifWriter.js===
+ */
+export class GifCompressedCodesToByteArrayConverter {
+    constructor() {
+        this.__out = [];
+        this.__remNumBits = 0;
+        this.__remVal = 0;
+    }
+    push(code, numBits) {
+        while (numBits > 0) {
+            this.__remVal = ((code << this.__remNumBits) & 0xff) + this.__remVal;
+            if (numBits + this.__remNumBits >= 8) {
+                this.__out.push(this.__remVal);
+                numBits = numBits - (8 - this.__remNumBits);
+                code = code >> (8 - this.__remNumBits);
+                this.__remVal = 0;
+                this.__remNumBits = 0;
+            }
+            else {
+                this.__remNumBits = numBits + this.__remNumBits;
+                numBits = 0;
+            }
+        }
+    }
+    flush() {
+        this.push(0, 8);
+        this.__remNumBits = 0;
+        this.__remVal = 0;
+        const out = this.__out;
+        this.__out = [];
+        return out;
+    }
+}
+/*
+ ===end GifWriter.js===
+ */

package/lib/owlly/element/gif-kit/GifFrame.d.ts

@@ -0,0 +1,31 @@
+/*!
+ gifken
+ Copyright (c) 2013 aaharu
+ This software is released under the MIT License.
+ https://raw.github.com/aaharu/gifken/master/LICENSE
+
+ This product includes following software:
+ * jsgif
+ - Copyright (c) 2011 Shachaf Ben-Kiki
+ - https://github.com/shachaf/jsgif
+ - https://raw.github.com/shachaf/jsgif/master/LICENSE
+ */
+export declare class GifFrame {
+    transparentFlag: boolean;
+    delayCentiSeconds: number;
+    transparentColorIndex: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    localTableSize: number;
+    lzwCode: number;
+    localColorTable: Uint8Array;
+    compressedData: Uint8Array;
+    pixelData: Uint8Array;
+    orgpixelData: any;
+    pixels: Array<any>;
+    static init(width: number, height: number): GifFrame;
+    decompress(): void;
+    private lzwDecode;
+}

package/lib/owlly/element/gif-kit/GifFrame.js

@@ -0,0 +1,96 @@
+/* eslint-disable */
+/*!
+ gifken
+ Copyright (c) 2013 aaharu
+ This software is released under the MIT License.
+ https://raw.github.com/aaharu/gifken/master/LICENSE
+
+ This product includes following software:
+ * jsgif
+ - Copyright (c) 2011 Shachaf Ben-Kiki
+ - https://github.com/shachaf/jsgif
+ - https://raw.github.com/shachaf/jsgif/master/LICENSE
+ */
+export class GifFrame {
+    static init(width, height) {
+        const frame = new GifFrame();
+        frame.transparentFlag = false;
+        frame.delayCentiSeconds = 0;
+        frame.transparentColorIndex = 0;
+        frame.x = 0;
+        frame.y = 0;
+        frame.width = width || 1;
+        frame.height = height || 1;
+        frame.localTableSize = 0;
+        frame.lzwCode = 4; // ?
+        frame.pixelData = new Uint8Array(frame.width * frame.height);
+        return frame;
+    }
+    decompress() {
+        // console.log('000000000000000',this.lzwCode,
+        // this.compressedData,
+        // this.width ,this.height);
+        // this.pixels = this.lzwDecode2(this.lzwCode,this.orgpixelData);
+        // console.log('this.pixels: ',this.width,this.height,this.pixels);
+        this.pixelData = this.lzwDecode(this.lzwCode, this.compressedData, this.width * this.height);
+    }
+    /*
+     ===begin jsgif===
+     */
+    lzwDecode(minCodeSize, data, len) {
+        let pos = 0; // Maybe this streaming thing should be merged with the Stream?
+        const readCode = function (size) {
+            let code = 0;
+            for (let i = 0; i < size; ++i) {
+                if (data[pos >> 3] & (1 << (pos & 7))) {
+                    code |= 1 << i;
+                }
+                ++pos;
+            }
+            return code;
+        };
+        const output = new Uint8Array(len);
+        const clearCode = 1 << minCodeSize;
+        const eoiCode = clearCode + 1;
+        let codeSize = minCodeSize + 1;
+        let dict = [];
+        const clear = () => {
+            dict = [];
+            codeSize = minCodeSize + 1;
+            for (let i = 0; i < clearCode; ++i) {
+                dict[i] = [i];
+            }
+            dict[clearCode] = [];
+        };
+        let code = 0;
+        let last;
+        let offset = 0;
+        while (true) {
+            last = code;
+            code = readCode(codeSize);
+            if (code === clearCode) {
+                clear();
+                continue;
+            }
+            if (code === eoiCode)
+                break;
+            if (code < dict.length) {
+                if (last !== clearCode) {
+                    dict.push(dict[last].concat(dict[code][0]));
+                }
+            }
+            else {
+                if (code !== dict.length)
+                    throw new Error("Invalid LZW code.");
+                dict.push(dict[last].concat(dict[last][0]));
+            }
+            output.set(dict[code], offset);
+            offset += dict[code].length;
+            if (dict.length === 1 << codeSize && codeSize < 12) {
+                // If we're at the last code and codeSize is 12, the next code will be a clearCode, and it'll be 12 bits long.
+                codeSize++;
+            }
+        }
+        return output;
+    }
+}