@twin.org/image 0.0.1-next.1

package/dist/esm/index.mjs

@@ -0,0 +1,1896 @@
+import { Guards, GeneralError, Is, Compression } from '@twin.org/core';
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/* eslint-disable no-bitwise */
+/**
+ * Class to represent a color.
+ */
+class Color {
+    /**
+     * Runtime name for the class.
+     * @internal
+     */
+    static _CLASS_NAME = "Color";
+    /**
+     * @internal
+     */
+    _alpha;
+    /**
+     * @internal
+     */
+    _red;
+    /**
+     * @internal
+     */
+    _green;
+    /**
+     * @internal
+     */
+    _blue;
+    /**
+     * Create a new instance of color.
+     * @param alpha The alpha element of the color.
+     * @param red The red element of the color.
+     * @param green The green element of the color.
+     * @param blue The blue element of the color.
+     */
+    constructor(alpha, red, green, blue) {
+        Guards.number(Color._CLASS_NAME, "alpha", alpha);
+        Guards.number(Color._CLASS_NAME, "red", red);
+        Guards.number(Color._CLASS_NAME, "green", green);
+        Guards.number(Color._CLASS_NAME, "blue", blue);
+        if (alpha < 0 || alpha > 255) {
+            throw new GeneralError(Color._CLASS_NAME, "range", {
+                prop: "alpha",
+                value: alpha
+            });
+        }
+        if (red < 0 || red > 255) {
+            throw new GeneralError(Color._CLASS_NAME, "range", {
+                prop: "red",
+                value: red
+            });
+        }
+        if (green < 0 || green > 255) {
+            throw new GeneralError(Color._CLASS_NAME, "range", {
+                prop: "green",
+                value: green
+            });
+        }
+        if (blue < 0 || blue > 255) {
+            throw new GeneralError(Color._CLASS_NAME, "range", {
+                prop: "blue",
+                value: blue
+            });
+        }
+        this._alpha = alpha;
+        this._red = red;
+        this._green = green;
+        this._blue = blue;
+    }
+    /**
+     * Construct a color from a hex string.
+     * @param hex The hex string to parse.
+     * @returns The color.
+     * @throws Error if the format is incorrect.
+     */
+    static fromHex(hex) {
+        Guards.stringValue(Color._CLASS_NAME, "hex", hex);
+        let alpha;
+        let red;
+        let green;
+        let blue;
+        if (/^#[\dA-Fa-f]{3}$/.test(hex)) {
+            // #RGB
+            alpha = "0xFF";
+            red = hex.slice(1, 2).repeat(2);
+            green = hex.slice(2, 3).repeat(2);
+            blue = hex.slice(3, 4).repeat(2);
+        }
+        else if (/^#[\dA-Fa-f]{4}$/.test(hex)) {
+            // #ARGB
+            alpha = hex.slice(1, 2).repeat(2);
+            red = hex.slice(2, 3).repeat(2);
+            green = hex.slice(3, 4).repeat(2);
+            blue = hex.slice(4, 5).repeat(2);
+        }
+        else if (/^#[\dA-Fa-f]{6}$/.test(hex)) {
+            // #RRGGBB
+            alpha = "0xFF";
+            red = hex.slice(1, 3);
+            green = hex.slice(3, 5);
+            blue = hex.slice(5, 7);
+        }
+        else if (/^#[\dA-Fa-f]{8}$/.test(hex)) {
+            // #AARRGGBB
+            alpha = hex.slice(1, 3);
+            red = hex.slice(3, 5);
+            green = hex.slice(5, 7);
+            blue = hex.slice(7, 9);
+        }
+        else {
+            throw new GeneralError(Color._CLASS_NAME, "hex");
+        }
+        return new Color(Number.parseInt(alpha, 16), Number.parseInt(red, 16), Number.parseInt(green, 16), Number.parseInt(blue, 16));
+    }
+    /**
+     * Coerce an unknown type to a color.
+     * @param value The value to try and convert.
+     * @returns The color if one can be created.
+     */
+    static coerce(value) {
+        if (Is.object(value) &&
+            Is.number(value._alpha) &&
+            Is.number(value._red) &&
+            Is.number(value._green) &&
+            Is.number(value._blue)) {
+            return new Color(value._alpha, value._red, value._green, value._blue);
+        }
+        else if (Is.stringValue(value) && value.startsWith("#")) {
+            try {
+                return Color.fromHex(value);
+            }
+            catch { }
+        }
+    }
+    /**
+     * Get the alpha element.
+     * @returns The alpha element.
+     */
+    alpha() {
+        return this._alpha;
+    }
+    /**
+     * Get the red element.
+     * @returns The red element.
+     */
+    red() {
+        return this._red;
+    }
+    /**
+     * Get the green element.
+     * @returns The green element.
+     */
+    green() {
+        return this._green;
+    }
+    /**
+     * Get the blue element.
+     * @returns The blue element.
+     */
+    blue() {
+        return this._blue;
+    }
+    /**
+     * Get color as argb.
+     * @returns The color as argb.
+     */
+    argb() {
+        return ((this._alpha << 24) | (this._red << 16) | (this._green << 8) | this._blue) >>> 0;
+    }
+    /**
+     * Get color as rgba.
+     * @returns The color as rgba.
+     */
+    rgba() {
+        return ((this._red << 24) | (this._green << 16) | (this._blue << 8) | this._alpha) >>> 0;
+    }
+    /**
+     * Get color as rgb text.
+     * @returns The color as rgb.
+     */
+    rgbText() {
+        return `rgb(${this._red},${this._green},${this._blue})`;
+    }
+    /**
+     * Get color as rgba text.
+     * @returns The color as rgba.
+     */
+    rgbaText() {
+        return `rgba(${this._red},${this._green},${this._blue},${Math.round((this._alpha / 255) * 100) / 100})`;
+    }
+    /**
+     * Get color as hex no alpha.
+     * @returns The color as hex with no alpha component.
+     */
+    hex() {
+        const red = `00${this._red.toString(16)}`.slice(-2);
+        const green = `00${this._green.toString(16)}`.slice(-2);
+        const blue = `00${this._blue.toString(16)}`.slice(-2);
+        return `#${red}${green}${blue}`.toUpperCase();
+    }
+    /**
+     * Get color as hex with alpha.
+     * @returns The color as hex with with alpha component.
+     */
+    hexWithAlpha() {
+        const alpha = `00${this._alpha.toString(16)}`.slice(-2);
+        const red = `00${this._red.toString(16)}`.slice(-2);
+        const green = `00${this._green.toString(16)}`.slice(-2);
+        const blue = `00${this._blue.toString(16)}`.slice(-2);
+        return `#${alpha}${red}${green}${blue}`.toUpperCase();
+    }
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/* eslint-disable no-bitwise */
+/* eslint-disable no-mixed-operators */
+/* eslint-disable array-bracket-newline */
+/**
+ * JPEG Encoder.
+ * Based on JPEG encoder ported to JavaScript and optimized by Andreas Ritter.
+ */
+class JpegEncoder {
+    /**
+     * Runtime name for the class.
+     * @internal
+     */
+    static _CLASS_NAME = "JpegEncoder";
+    /**
+     * @internal
+     */
+    static _STD_DC_LUMINANCE_NR_CODES = [
+        0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0
+    ];
+    /**
+     * @internal
+     */
+    static _STD_DC_LUMINANCE_VALUES = [
+        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
+    ];
+    /**
+     * @internal
+     */
+    static _STD_AC_LUMINANCE_NR_CODES = [
+        0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d
+    ];
+    /**
+     * @internal
+     */
+    static _STD_AC_LUMINANCE_VALUES = [
+        0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
+        0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08, 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
+        0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
+        0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
+        0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+        0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
+        0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
+        0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
+        0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
+        0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
+        0xf9, 0xfa
+    ];
+    /**
+     * @internal
+     */
+    static _STD_DC_CHROMINANCE_NR_CODES = [
+        0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0
+    ];
+    /**
+     * @internal
+     */
+    static _STD_DC_CHROMINANCE_VALUES = [
+        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
+    ];
+    /**
+     * @internal
+     */
+    static _STD_AC_CHROMINANCE_NR_CODES = [
+        0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77
+    ];
+    /**
+     * @internal
+     */
+    static _STD_AC_CHROMINANCE_VALUES = [
+        0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
+        0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
+        0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34, 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
+        0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
+        0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
+        0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+        0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
+        0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
+        0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
+        0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
+        0xf9, 0xfa
+    ];
+    /** @internal */
+    static _SIG_ZAG = [
+        0, 1, 5, 6, 14, 15, 27, 28, 2, 4, 7, 13, 16, 26, 29, 42, 3, 8, 12, 17, 25, 30, 41, 43, 9, 11,
+        18, 24, 31, 40, 44, 53, 10, 19, 23, 32, 39, 45, 52, 54, 20, 22, 33, 38, 46, 51, 55, 60, 21, 34,
+        37, 47, 50, 56, 59, 61, 35, 36, 48, 49, 57, 58, 62, 63
+    ];
+    /**
+     * @internal
+     */
+    _yTable;
+    /**
+     * @internal
+     */
+    _uvTable;
+    /**
+     * @internal
+     */
+    _fdTblY;
+    /**
+     * @internal
+     */
+    _fdTblUV;
+    /**
+     * @internal
+     */
+    _ydcHashTable;
+    /**
+     * @internal
+     */
+    _uVdcHashTable;
+    /**
+     * @internal
+     */
+    _yacHashTable;
+    /**
+     * @internal
+     */
+    _uVacHashTable;
+    /**
+     * @internal
+     */
+    _bitCode;
+    /**
+     * @internal
+     */
+    _category;
+    /**
+     * @internal
+     */
+    _outputFDctQuant;
+    /**
+     * @internal
+     */
+    _du;
+    /**
+     * @internal
+     */
+    _byteOut;
+    /**
+     * @internal
+     */
+    _byteNew;
+    /**
+     * @internal
+     */
+    _bytePos;
+    /**
+     * @internal
+     */
+    _ydu;
+    /**
+     * @internal
+     */
+    _udu;
+    /**
+     * @internal
+     */
+    _vdu;
+    /**
+     * @internal
+     */
+    _rgbYuvTable;
+    /**
+     * Create a new instance of JpegEncoder.
+     */
+    constructor() {
+        this._yTable = Array.from({ length: 64 });
+        this._uvTable = Array.from({ length: 64 });
+        this._fdTblY = Array.from({ length: 64 });
+        this._fdTblUV = Array.from({ length: 64 });
+        this._bitCode = Array.from({ length: 65535 });
+        this._category = Array.from({ length: 65535 });
+        this._outputFDctQuant = Array.from({ length: 64 });
+        this._du = Array.from({ length: 64 });
+        this._byteOut = [];
+        this._byteNew = 0;
+        this._bytePos = 7;
+        this._ydu = Array.from({ length: 64 });
+        this._udu = Array.from({ length: 64 });
+        this._vdu = Array.from({ length: 64 });
+        this._rgbYuvTable = Array.from({ length: 2048 });
+        this.initHuffmanTbl();
+        this.initCategoryNumber();
+        this.initRGBYUVTable();
+    }
+    /**
+     * Encode the image with the given quality.
+     * @param width The width of the image to encode.
+     * @param height The height of the image to encode.
+     * @param imageData The data for the image.
+     * @param quality The quality to encode the image at.
+     * @returns The data for the encoded image.
+     */
+    encode(width, height, imageData, quality) {
+        this.setQuality(quality);
+        // Initialize bit writer
+        this._byteOut = [];
+        this._byteNew = 0;
+        this._bytePos = 7;
+        // Add JPEG headers
+        this.writeWord(0xffd8); // SOI
+        this.writeAPP0();
+        this.writeDQT();
+        this.writeSOF0(width, height);
+        this.writeDHT();
+        this.writeSOS();
+        // Encode 8x8 macro blocks
+        let DCY = 0;
+        let DCU = 0;
+        let DCV = 0;
+        this._byteNew = 0;
+        this._bytePos = 7;
+        const quadWidth = width * 4;
+        let x;
+        let y = 0;
+        let r;
+        let g;
+        let b;
+        let start;
+        let p;
+        let col;
+        let row;
+        let pos;
+        while (y < height) {
+            x = 0;
+            while (x < quadWidth) {
+                start = quadWidth * y + x;
+                p = start;
+                col = -1;
+                row = 0;
+                for (pos = 0; pos < 64; pos++) {
+                    row = pos >> 3; // /8
+                    col = (pos & 7) * 4; // %8
+                    p = start + row * quadWidth + col;
+                    if (y + row >= height) {
+                        // padding bottom
+                        p -= quadWidth * (y + 1 + row - height);
+                    }
+                    if (x + col >= quadWidth) {
+                        // padding right
+                        p -= x + col - quadWidth + 4;
+                    }
+                    r = imageData[p++];
+                    g = imageData[p++];
+                    b = imageData[p++];
+                    // use lookup table (slightly faster)
+                    this._ydu[pos] =
+                        ((this._rgbYuvTable[r] +
+                            this._rgbYuvTable[Math.trunc(g + 256)] +
+                            this._rgbYuvTable[Math.trunc(b + 512)]) >>
+                            16) -
+                            128;
+                    this._udu[pos] =
+                        ((this._rgbYuvTable[Math.trunc(r + 768)] +
+                            this._rgbYuvTable[Math.trunc(g + 1024)] +
+                            this._rgbYuvTable[Math.trunc(b + 1280)]) >>
+                            16) -
+                            128;
+                    this._vdu[pos] =
+                        ((this._rgbYuvTable[Math.trunc(r + 1280)] +
+                            this._rgbYuvTable[Math.trunc(g + 1536)] +
+                            this._rgbYuvTable[Math.trunc(b + 1792)]) >>
+                            16) -
+                            128;
+                }
+                if (this._ydcHashTable && this._yacHashTable) {
+                    DCY = this.processDU(this._ydu, this._fdTblY, DCY, this._ydcHashTable, this._yacHashTable);
+                }
+                if (this._uVdcHashTable && this._uVacHashTable) {
+                    DCU = this.processDU(this._udu, this._fdTblUV, DCU, this._uVdcHashTable, this._uVacHashTable);
+                }
+                if (this._uVdcHashTable && this._uVacHashTable) {
+                    DCV = this.processDU(this._vdu, this._fdTblUV, DCV, this._uVdcHashTable, this._uVacHashTable);
+                }
+                x += 32;
+            }
+            y += 8;
+        }
+        // Do the bit alignment of the EOI marker
+        if (this._bytePos >= 0) {
+            const fillBits = [];
+            fillBits[1] = this._bytePos + 1;
+            fillBits[0] = (1 << (this._bytePos + 1)) - 1;
+            this.writeBits(fillBits);
+        }
+        this.writeWord(0xffd9); // EOI
+        return new Uint8Array(this._byteOut);
+    }
+    /**
+     * @internal
+     */
+    setQuality(quality) {
+        if (quality <= 0 || quality > 100) {
+            throw new GeneralError(JpegEncoder._CLASS_NAME, "invalidQuality", { value: quality });
+        }
+        let sf = 0;
+        if (quality < 50) {
+            sf = Math.floor(5000 / quality);
+        }
+        else {
+            sf = Math.floor(200 - quality * 2);
+        }
+        this.initQuantTables(sf);
+    }
+    /**
+     * @internal
+     */
+    initQuantTables(sf) {
+        const YQT = [
+            16, 11, 10, 16, 24, 40, 51, 61, 12, 12, 14, 19, 26, 58, 60, 55, 14, 13, 16, 24, 40, 57, 69,
+            56, 14, 17, 22, 29, 51, 87, 80, 62, 18, 22, 37, 56, 68, 109, 103, 77, 24, 35, 55, 64, 81, 104,
+            113, 92, 49, 64, 78, 87, 103, 121, 120, 101, 72, 92, 95, 98, 112, 100, 103, 99
+        ];
+        for (let i = 0; i < 64; i++) {
+            let t = Math.floor((YQT[i] * sf + 50) / 100);
+            if (t < 1) {
+                t = 1;
+            }
+            else if (t > 255) {
+                t = 255;
+            }
+            this._yTable[JpegEncoder._SIG_ZAG[i]] = t;
+        }
+        const UVQT = [
+            17, 18, 24, 47, 99, 99, 99, 99, 18, 21, 26, 66, 99, 99, 99, 99, 24, 26, 56, 99, 99, 99, 99,
+            99, 47, 66, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
+            99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99
+        ];
+        for (let j = 0; j < 64; j++) {
+            let u = Math.floor((UVQT[j] * sf + 50) / 100);
+            if (u < 1) {
+                u = 1;
+            }
+            else if (u > 255) {
+                u = 255;
+            }
+            this._uvTable[JpegEncoder._SIG_ZAG[j]] = u;
+        }
+        const aAsf = [1, 1.387039845, 1.306562965, 1.175875602, 1, 0.785694958, 0.5411961, 0.275899379];
+        let k = 0;
+        for (let row = 0; row < 8; row++) {
+            for (let col = 0; col < 8; col++) {
+                this._fdTblY[k] = 1 / (this._yTable[JpegEncoder._SIG_ZAG[k]] * aAsf[row] * aAsf[col] * 8);
+                this._fdTblUV[k] = 1 / (this._uvTable[JpegEncoder._SIG_ZAG[k]] * aAsf[row] * aAsf[col] * 8);
+                k++;
+            }
+        }
+    }
+    /**
+     * @internal
+     */
+    computeHuffmanTbl(nrCodes, stdTable) {
+        let codeValue = 0;
+        let posInTable = 0;
+        const HT = [];
+        for (let k = 1; k <= 16; k++) {
+            for (let j = 1; j <= nrCodes[k]; j++) {
+                HT[stdTable[posInTable]] = [];
+                HT[stdTable[posInTable]][0] = codeValue;
+                HT[stdTable[posInTable]][1] = k;
+                posInTable++;
+                codeValue++;
+            }
+            codeValue *= 2;
+        }
+        return HT;
+    }
+    /**
+     * @internal
+     */
+    initHuffmanTbl() {
+        this._ydcHashTable = this.computeHuffmanTbl(JpegEncoder._STD_DC_LUMINANCE_NR_CODES, JpegEncoder._STD_DC_LUMINANCE_VALUES);
+        this._uVdcHashTable = this.computeHuffmanTbl(JpegEncoder._STD_DC_CHROMINANCE_NR_CODES, JpegEncoder._STD_DC_CHROMINANCE_VALUES);
+        this._yacHashTable = this.computeHuffmanTbl(JpegEncoder._STD_AC_LUMINANCE_NR_CODES, JpegEncoder._STD_AC_LUMINANCE_VALUES);
+        this._uVacHashTable = this.computeHuffmanTbl(JpegEncoder._STD_AC_CHROMINANCE_NR_CODES, JpegEncoder._STD_AC_CHROMINANCE_VALUES);
+    }
+    /**
+     * @internal
+     */
+    initCategoryNumber() {
+        let nrLower = 1;
+        let nrUpper = 2;
+        for (let cat = 1; cat <= 15; cat++) {
+            // Positive numbers
+            for (let nr = nrLower; nr < nrUpper; nr++) {
+                this._category[32767 + nr] = cat;
+                this._bitCode[32767 + nr] = [];
+                this._bitCode[32767 + nr][1] = cat;
+                this._bitCode[32767 + nr][0] = nr;
+            }
+            // Negative numbers
+            for (let nrNeg = -(nrUpper - 1); nrNeg <= -nrLower; nrNeg++) {
+                this._category[32767 + nrNeg] = cat;
+                this._bitCode[32767 + nrNeg] = [];
+                this._bitCode[32767 + nrNeg][1] = cat;
+                this._bitCode[32767 + nrNeg][0] = nrUpper - 1 + nrNeg;
+            }
+            nrLower <<= 1;
+            nrUpper <<= 1;
+        }
+    }
+    /**
+     * @internal
+     */
+    initRGBYUVTable() {
+        for (let i = 0; i < 256; i++) {
+            this._rgbYuvTable[i] = 19595 * i;
+            this._rgbYuvTable[Math.trunc(i + 256)] = 38470 * i;
+            this._rgbYuvTable[Math.trunc(i + 512)] = 7471 * i + 0x8000;
+            this._rgbYuvTable[Math.trunc(i + 768)] = -11059 * i;
+            this._rgbYuvTable[Math.trunc(i + 1024)] = -21709 * i;
+            this._rgbYuvTable[Math.trunc(i + 1280)] = 32768 * i + 0x807fff;
+            this._rgbYuvTable[Math.trunc(i + 1536)] = -27439 * i;
+            this._rgbYuvTable[Math.trunc(i + 1792)] = -5329 * i;
+        }
+    }
+    /**
+     * @internal
+     */
+    writeBits(bs) {
+        const value = bs[0];
+        let posVal = bs[1] - 1;
+        while (posVal >= 0) {
+            if (value & (1 << posVal)) {
+                this._byteNew |= 1 << this._bytePos;
+            }
+            posVal--;
+            this._bytePos--;
+            if (this._bytePos < 0) {
+                if (this._byteNew === 0xff) {
+                    this.writeByte(0xff);
+                    this.writeByte(0);
+                }
+                else {
+                    this.writeByte(this._byteNew);
+                }
+                this._bytePos = 7;
+                this._byteNew = 0;
+            }
+        }
+    }
+    /**
+     * @internal
+     */
+    writeByte(value) {
+        this._byteOut.push(value);
+    }
+    /**
+     * @internal
+     */
+    writeWord(value) {
+        this.writeByte((value >> 8) & 0xff);
+        this.writeByte(value & 0xff);
+    }
+    /**
+     * @internal
+     */
+    fDCTQuant(data, fdTbl) {
+        let d0;
+        let d1;
+        let d2;
+        let d3;
+        let d4;
+        let d5;
+        let d6;
+        let d7;
+        /* Pass 1: process rows. */
+        let dataOff = 0;
+        let i;
+        const I8 = 8;
+        const I64 = 64;
+        for (i = 0; i < I8; ++i) {
+            d0 = data[dataOff];
+            d1 = data[dataOff + 1];
+            d2 = data[dataOff + 2];
+            d3 = data[dataOff + 3];
+            d4 = data[dataOff + 4];
+            d5 = data[dataOff + 5];
+            d6 = data[dataOff + 6];
+            d7 = data[dataOff + 7];
+            const tmp0 = d0 + d7;
+            const tmp7 = d0 - d7;
+            const tmp1 = d1 + d6;
+            const tmp6 = d1 - d6;
+            const tmp2 = d2 + d5;
+            const tmp5 = d2 - d5;
+            const tmp3 = d3 + d4;
+            const tmp4 = d3 - d4;
+            /* Even part */
+            let tmp10 = tmp0 + tmp3; /* phase 2 */
+            const tmp13 = tmp0 - tmp3;
+            let tmp11 = tmp1 + tmp2;
+            let tmp12 = tmp1 - tmp2;
+            data[dataOff] = tmp10 + tmp11; /* phase 3 */
+            data[dataOff + 4] = tmp10 - tmp11;
+            const z1 = (tmp12 + tmp13) * 0.707106781; /* c4 */
+            data[dataOff + 2] = tmp13 + z1; /* phase 5 */
+            data[dataOff + 6] = tmp13 - z1;
+            /* Odd part */
+            tmp10 = tmp4 + tmp5; /* phase 2 */
+            tmp11 = tmp5 + tmp6;
+            tmp12 = tmp6 + tmp7;
+            /* The rotator is modified from fig 4-8 to avoid extra negations. */
+            const z5 = (tmp10 - tmp12) * 0.382683433; /* c6 */
+            const z2 = 0.5411961 * tmp10 + z5; /* c2-c6 */
+            const z4 = 1.306562965 * tmp12 + z5; /* c2+c6 */
+            const z3 = tmp11 * 0.707106781; /* c4 */
+            const z11 = tmp7 + z3; /* phase 5 */
+            const z13 = tmp7 - z3;
+            data[dataOff + 5] = z13 + z2; /* phase 6 */
+            data[dataOff + 3] = z13 - z2;
+            data[dataOff + 1] = z11 + z4;
+            data[dataOff + 7] = z11 - z4;
+            dataOff += 8; /* advance pointer to next row */
+        }
+        /* Pass 2: process columns. */
+        dataOff = 0;
+        for (i = 0; i < I8; ++i) {
+            d0 = data[dataOff];
+            d1 = data[dataOff + 8];
+            d2 = data[dataOff + 16];
+            d3 = data[dataOff + 24];
+            d4 = data[dataOff + 32];
+            d5 = data[dataOff + 40];
+            d6 = data[dataOff + 48];
+            d7 = data[dataOff + 56];
+            const tmp0p2 = d0 + d7;
+            const tmp7p2 = d0 - d7;
+            const tmp1p2 = d1 + d6;
+            const tmp6p2 = d1 - d6;
+            const tmp2p2 = d2 + d5;
+            const tmp5p2 = d2 - d5;
+            const tmp3p2 = d3 + d4;
+            const tmp4p2 = d3 - d4;
+            /* Even part */
+            let tmp10p2 = tmp0p2 + tmp3p2; /* phase 2 */
+            const tmp13p2 = tmp0p2 - tmp3p2;
+            let tmp11p2 = tmp1p2 + tmp2p2;
+            let tmp12p2 = tmp1p2 - tmp2p2;
+            data[dataOff] = tmp10p2 + tmp11p2; /* phase 3 */
+            data[dataOff + 32] = tmp10p2 - tmp11p2;
+            const z1p2 = (tmp12p2 + tmp13p2) * 0.707106781; /* c4 */
+            data[dataOff + 16] = tmp13p2 + z1p2; /* phase 5 */
+            data[dataOff + 48] = tmp13p2 - z1p2;
+            /* Odd part */
+            tmp10p2 = tmp4p2 + tmp5p2; /* phase 2 */
+            tmp11p2 = tmp5p2 + tmp6p2;
+            tmp12p2 = tmp6p2 + tmp7p2;
+            /* The rotator is modified from fig 4-8 to avoid extra negations. */
+            const z5p2 = (tmp10p2 - tmp12p2) * 0.382683433; /* c6 */
+            const z2p2 = 0.5411961 * tmp10p2 + z5p2; /* c2-c6 */
+            const z4p2 = 1.306562965 * tmp12p2 + z5p2; /* c2+c6 */
+            const z3p2 = tmp11p2 * 0.707106781; /* c4 */
+            const z11p2 = tmp7p2 + z3p2; /* phase 5 */
+            const z13p2 = tmp7p2 - z3p2;
+            data[dataOff + 40] = z13p2 + z2p2; /* phase 6 */
+            data[dataOff + 24] = z13p2 - z2p2;
+            data[dataOff + 8] = z11p2 + z4p2;
+            data[dataOff + 56] = z11p2 - z4p2;
+            dataOff++; /* advance pointer to next column */
+        }
+        // Quantize/descale the coefficients
+        let fDCTQuant;
+        for (i = 0; i < I64; ++i) {
+            // Apply the quantization and scaling factor & Round to nearest integer
+            fDCTQuant = data[i] * fdTbl[i];
+            this._outputFDctQuant[i] =
+                fDCTQuant > 0 ? Math.trunc(fDCTQuant + 0.5) : Math.trunc(fDCTQuant - 0.5);
+        }
+        return this._outputFDctQuant;
+    }
+    /**
+     * @internal
+     */
+    writeAPP0() {
+        this.writeWord(0xffe0); // marker
+        this.writeWord(16); // length
+        this.writeByte(0x4a); // J
+        this.writeByte(0x46); // F
+        this.writeByte(0x49); // I
+        this.writeByte(0x46); // F
+        // cspell:disable-next-line
+        this.writeByte(0); // = "JFIF",'\0'
+        this.writeByte(1); // version hi
+        this.writeByte(1); // version lo
+        this.writeByte(0); // xy units
+        this.writeWord(1); // x density
+        this.writeWord(1); // y density
+        this.writeByte(0); // thumb n width
+        this.writeByte(0); // thumb n height
+    }
+    /**
+     * @internal
+     */
+    writeSOF0(width, height) {
+        this.writeWord(0xffc0); // marker
+        this.writeWord(17); // length, true color YUV JPG
+        this.writeByte(8); // precision
+        this.writeWord(height);
+        this.writeWord(width);
+        this.writeByte(3); // nr of components
+        this.writeByte(1); // IdY
+        this.writeByte(0x11); // HVY
+        this.writeByte(0); // QTY
+        this.writeByte(2); // IdU
+        this.writeByte(0x11); // HVU
+        this.writeByte(1); // QTU
+        this.writeByte(3); // IdV
+        this.writeByte(0x11); // HVV
+        this.writeByte(1); // QTV
+    }
+    /**
+     * @internal
+     */
+    writeDQT() {
+        this.writeWord(0xffdb); // marker
+        this.writeWord(132); // length
+        this.writeByte(0);
+        for (let i = 0; i < 64; i++) {
+            this.writeByte(this._yTable[i]);
+        }
+        this.writeByte(1);
+        for (let j = 0; j < 64; j++) {
+            this.writeByte(this._uvTable[j]);
+        }
+    }
+    /**
+     * @internal
+     */
+    writeDHT() {
+        this.writeWord(0xffc4); // marker
+        this.writeWord(0x01a2); // length
+        this.writeByte(0); // HTYDc info
+        for (let i = 0; i < 16; i++) {
+            this.writeByte(JpegEncoder._STD_DC_LUMINANCE_NR_CODES[i + 1]);
+        }
+        for (let j = 0; j <= 11; j++) {
+            this.writeByte(JpegEncoder._STD_DC_LUMINANCE_VALUES[j]);
+        }
+        this.writeByte(0x10); // HTYAc info
+        for (let k = 0; k < 16; k++) {
+            this.writeByte(JpegEncoder._STD_AC_LUMINANCE_NR_CODES[k + 1]);
+        }
+        for (let l = 0; l <= 161; l++) {
+            this.writeByte(JpegEncoder._STD_AC_LUMINANCE_VALUES[l]);
+        }
+        this.writeByte(1); // HTUDc info
+        for (let m = 0; m < 16; m++) {
+            this.writeByte(JpegEncoder._STD_DC_CHROMINANCE_NR_CODES[m + 1]);
+        }
+        for (let n = 0; n <= 11; n++) {
+            this.writeByte(JpegEncoder._STD_DC_CHROMINANCE_VALUES[n]);
+        }
+        this.writeByte(0x11); // HTUAc info
+        for (let o = 0; o < 16; o++) {
+            this.writeByte(JpegEncoder._STD_AC_CHROMINANCE_NR_CODES[o + 1]);
+        }
+        for (let p = 0; p <= 161; p++) {
+            this.writeByte(JpegEncoder._STD_AC_CHROMINANCE_VALUES[p]);
+        }
+    }
+    /**
+     * @internal
+     */
+    writeSOS() {
+        this.writeWord(0xffda); // marker
+        this.writeWord(12); // length
+        this.writeByte(3); // nr of components
+        this.writeByte(1); // IdY
+        this.writeByte(0); // HTY
+        this.writeByte(2); // IdU
+        this.writeByte(0x11); // HTU
+        this.writeByte(3); // IdV
+        this.writeByte(0x11); // HTV
+        this.writeByte(0); // Ss
+        this.writeByte(0x3f); // Se
+        this.writeByte(0); // Bf
+    }
+    /**
+     * @internal
+     */
+    processDU(CDU, fdTbl, passedDC, HTDc, HTAc) {
+        let DC = passedDC;
+        const EOB = HTAc[0x00];
+        const m16zeroes = HTAc[0xf0];
+        let pos;
+        const I16 = 16;
+        const I63 = 63;
+        const I64 = 64;
+        const DU_DCT = this.fDCTQuant(CDU, fdTbl);
+        // ZigZag reorder
+        for (let j = 0; j < I64; ++j) {
+            this._du[JpegEncoder._SIG_ZAG[j]] = DU_DCT[j];
+        }
+        const diff = this._du[0] - DC;
+        DC = this._du[0];
+        // Encode DC
+        if (diff === 0) {
+            this.writeBits(HTDc[0]); // Diff might be 0
+        }
+        else {
+            pos = 32767 + diff;
+            this.writeBits(HTDc[this._category[pos]]);
+            this.writeBits(this._bitCode[pos]);
+        }
+        // Encode ACs
+        let end0pos = 63; // was const... which is crazy
+        for (; end0pos > 0 && this._du[end0pos] === 0; end0pos--) { }
+        // end0pos = first element in reverse order !=0
+        if (end0pos === 0) {
+            this.writeBits(EOB);
+            return DC;
+        }
+        let i = 1;
+        let lng;
+        while (i <= end0pos) {
+            const startPos = i;
+            for (; this._du[i] === 0 && i <= end0pos; ++i) { }
+            let nrZeroes = i - startPos;
+            if (nrZeroes >= I16) {
+                lng = nrZeroes >> 4;
+                for (let nrMarker = 1; nrMarker <= lng; ++nrMarker) {
+                    this.writeBits(m16zeroes);
+                }
+                nrZeroes &= 0xf;
+            }
+            pos = 32767 + this._du[i];
+            this.writeBits(HTAc[(nrZeroes << 4) + this._category[pos]]);
+            this.writeBits(this._bitCode[pos]);
+            i++;
+        }
+        if (end0pos !== I63) {
+            this.writeBits(EOB);
+        }
+        return DC;
+    }
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/* eslint-disable no-bitwise */
+/* eslint-disable no-mixed-operators */
+/* eslint-disable no-continue */
+/* eslint-disable unicorn/prefer-math-trunc */
+/**
+ * PNG Encoder.
+ * Based on https://github.com/photopea/UPNG.js.
+ */
+class PngEncoder {
+    /**
+     * Encode the image frames to png.
+     * @param buffers The frame buffers to encode.
+     * @param w The image width.
+     * @param h The image height.
+     * @returns The data for the image.
+     */
+    async encode(buffers, w, h) {
+        const ps = 0;
+        const forbidPlte = false;
+        const data = new Uint8Array(buffers[0].byteLength * buffers.length + 100);
+        const wr = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
+        for (let i = 0; i < 8; i++) {
+            data[i] = wr[i];
+        }
+        let offset = 8;
+        const nImg = await this.compressPNG(buffers, w, h, ps, forbidPlte);
+        this.writeUint(data, offset, 13);
+        offset += 4;
+        // cspell:disable-next-line
+        this.writeASCII(data, offset, "IHDR");
+        offset += 4;
+        this.writeUint(data, offset, w);
+        offset += 4;
+        this.writeUint(data, offset, h);
+        offset += 4;
+        data[offset] = nImg.depth;
+        offset++;
+        data[offset] = nImg.cType;
+        offset++;
+        data[offset] = 0; // compress
+        offset++;
+        data[offset] = 0; // filter
+        offset++;
+        data[offset] = 0; // interlace
+        offset++;
+        this.writeUint(data, offset, this.crc(data, offset - 17, 17));
+        offset += 4; // crc
+        // 9 bytes to say, that it is sRGB
+        this.writeUint(data, offset, 1);
+        offset += 4;
+        this.writeASCII(data, offset, "sRGB");
+        offset += 4;
+        data[offset] = 1;
+        offset++;
+        this.writeUint(data, offset, this.crc(data, offset - 5, 5));
+        offset += 4; // crc
+        const anim = buffers.length > 1;
+        if (anim) {
+            this.writeUint(data, offset, 8);
+            offset += 4;
+            this.writeASCII(data, offset, "acTL");
+            offset += 4;
+            this.writeUint(data, offset, buffers.length);
+            offset += 4;
+            this.writeUint(data, offset, 0);
+            offset += 4;
+            this.writeUint(data, offset, this.crc(data, offset - 12, 12));
+            offset += 4; // crc
+        }
+        if (nImg.cType === 3) {
+            const dl = nImg.plte.length;
+            this.writeUint(data, offset, dl * 3);
+            offset += 4;
+            this.writeASCII(data, offset, "PLTE");
+            offset += 4;
+            for (let i = 0; i < dl; i++) {
+                const ti = i * 3;
+                const c = nImg.plte[i];
+                const r = c & 255;
+                const g = (c >> 8) & 255;
+                const b = (c >> 16) & 255;
+                data[offset + ti + 0] = r;
+                data[offset + ti + 1] = g;
+                data[offset + ti + 2] = b;
+            }
+            offset += dl * 3;
+            this.writeUint(data, offset, this.crc(data, offset - dl * 3 - 4, dl * 3 + 4));
+            offset += 4; // crc
+            if (nImg.gotAlpha) {
+                this.writeUint(data, offset, dl);
+                offset += 4;
+                this.writeASCII(data, offset, "tRNS");
+                offset += 4;
+                for (let i = 0; i < dl; i++) {
+                    data[offset + i] = (nImg.plte[i] >> 24) & 255;
+                }
+                offset += dl;
+                this.writeUint(data, offset, this.crc(data, offset - dl - 4, dl + 4));
+                offset += 4; // crc
+            }
+        }
+        let fi = 0;
+        for (let j = 0; j < nImg.frames.length; j++) {
+            const fr = nImg.frames[j];
+            if (anim) {
+                this.writeUint(data, offset, 26);
+                offset += 4;
+                this.writeASCII(data, offset, "fcTL");
+                offset += 4;
+                this.writeUint(data, offset, fi++);
+                offset += 4;
+                this.writeUint(data, offset, fr.rect.width);
+                offset += 4;
+                this.writeUint(data, offset, fr.rect.height);
+                offset += 4;
+                this.writeUint(data, offset, fr.rect.x);
+                offset += 4;
+                this.writeUint(data, offset, fr.rect.y);
+                offset += 4;
+                this.writeUshort(data, offset, 0);
+                offset += 2;
+                this.writeUshort(data, offset, 1000);
+                offset += 2;
+                data[offset] = fr.dispose;
+                offset++; // dispose
+                data[offset] = fr.blend;
+                offset++; // blend
+                this.writeUint(data, offset, this.crc(data, offset - 30, 30));
+                offset += 4; // crc
+            }
+            const imgD = fr.cImg;
+            const dl = imgD?.length ?? 0;
+            this.writeUint(data, offset, dl + (j === 0 ? 0 : 4));
+            offset += 4;
+            const iOff = offset;
+            // cspell:disable-next-line
+            this.writeASCII(data, offset, j === 0 ? "IDAT" : "fdAT");
+            offset += 4;
+            if (j !== 0) {
+                this.writeUint(data, offset, fi++);
+                offset += 4;
+            }
+            if (imgD) {
+                for (let i = 0; i < dl; i++) {
+                    data[offset + i] = imgD[i];
+                }
+            }
+            offset += dl;
+            this.writeUint(data, offset, this.crc(data, iOff, offset - iOff));
+            offset += 4; // crc
+        }
+        this.writeUint(data, offset, 0);
+        offset += 4;
+        // cspell:disable-next-line
+        this.writeASCII(data, offset, "IEND");
+        offset += 4;
+        this.writeUint(data, offset, this.crc(data, offset - 4, 4));
+        offset += 4; // crc
+        return new Uint8Array(data.buffer.slice(0, offset));
+    }
+    /**
+     * @internal
+     */
+    async compressPNG(buffers, w, h, ps, forbidPlte) {
+        const out = this.compress(buffers, w, h, ps, 0, forbidPlte);
+        for (let i = 0; i < buffers.length; i++) {
+            const frm = out.frames[i];
+            const nw = frm.rect.width;
+            const nh = frm.rect.height;
+            const bpl = frm.bpl;
+            const bpp = frm.bpp;
+            const fData = new Uint8Array(nw * bpl + nh);
+            frm.cImg = await this.filterZero(frm.img, nh, bpp, bpl, fData);
+        }
+        return out;
+    }
+    /**
+     * @internal
+     */
+    compress(inBuffers, w, h, inPs, forGIF, forbidPlte) {
+        let cType = 6;
+        let depth = 8;
+        let bpp = 4;
+        let alphaAnd = 255;
+        let ps = inPs;
+        let buffers = inBuffers;
+        for (let j = 0; j < buffers.length; j++) {
+            // when not quantized, other frames can contain colors, that are not in an initial frame
+            const img = new Uint8Array(buffers[j]);
+            const iLen = img.length;
+            for (let i = 0; i < iLen; i += 4) {
+                alphaAnd &= img[i + 3];
+            }
+        }
+        let gotAlpha = alphaAnd !== 255;
+        const cMap = {};
+        const pLte = [];
+        if (buffers.length !== 0) {
+            cMap[0] = 0;
+            pLte.push(0);
+            if (ps !== 0) {
+                ps--;
+            }
+        }
+        if (ps !== 0) {
+            const qRes = this.quantize(buffers, ps, forGIF);
+            buffers = qRes.buffers;
+            for (let i = 0; i < qRes.plte.length; i++) {
+                const c = qRes.plte[i].est?.rgba ?? 0;
+                if (!cMap[c]) {
+                    cMap[c] = pLte.length;
+                    pLte.push(c);
+                }
+            }
+        }
+        else {
+            // what if ps==0, but there are <=256 colors?  we still need to detect, if the palette could be used
+            for (let j = 0; j < buffers.length; j++) {
+                // when not quantized, other frames can contain colors, that are not in an initial frame
+                const img32 = new Uint32Array(buffers[j]);
+                const iLen = img32.length;
+                for (let i = 0; i < iLen; i++) {
+                    const c = img32[i];
+                    if ((i < w || (c !== img32[i - 1] && c !== img32[i - w])) && !cMap[c]) {
+                        cMap[c] = pLte.length;
+                        pLte.push(c);
+                        if (pLte.length >= 300) {
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        const brute = gotAlpha ? forGIF : false; // brute : frames can only be copied, not "blended"
+        const cc = pLte.length;
+        if (cc <= 256 && !forbidPlte) {
+            if (cc <= 2) {
+                depth = 1;
+            }
+            else if (cc <= 4) {
+                depth = 2;
+            }
+            else if (cc <= 16) {
+                depth = 4;
+            }
+            else {
+                depth = 8;
+            }
+            if (forGIF) {
+                depth = 8;
+            }
+            gotAlpha = true;
+        }
+        const frames = [];
+        for (let j = 0; j < buffers.length; j++) {
+            let cImg = new Uint8Array(buffers[j]);
+            let cImg32 = new Uint32Array(cImg.buffer);
+            let nx = 0;
+            let ny = 0;
+            let nw = w;
+            let nh = h;
+            let blend = 0;
+            if (j !== 0 && !brute) {
+                const tLim = forGIF || j === 1 || frames[frames.length - 2].dispose === 2 ? 1 : 2;
+                let tStp = 0;
+                let tArea = 1e9;
+                for (let it = 0; it < tLim; it++) {
+                    const p32 = new Uint32Array(buffers[j - 1 - it]);
+                    let mix = w;
+                    let miy = h;
+                    let max = -1;
+                    let may = -1;
+                    for (let y = 0; y < h; y++) {
+                        for (let x = 0; x < w; x++) {
+                            const i = y * w + x;
+                            if (cImg32[i] !== p32[i]) {
+                                if (x < mix) {
+                                    mix = x;
+                                }
+                                if (x > max) {
+                                    max = x;
+                                }
+                                if (y < miy) {
+                                    miy = y;
+                                }
+                                if (y > may) {
+                                    may = y;
+                                }
+                            }
+                        }
+                    }
+                    const sArea = max === -1 ? 1 : (max - mix + 1) * (may - miy + 1);
+                    if (sArea < tArea) {
+                        tArea = sArea;
+                        tStp = it;
+                        if (max === -1) {
+                            nx = 0;
+                            ny = 0;
+                            nw = 1;
+                            nh = 1;
+                        }
+                        else {
+                            nx = mix;
+                            ny = miy;
+                            nw = max - mix + 1;
+                            nh = may - miy + 1;
+                        }
+                    }
+                }
+                const pImg = new Uint8Array(buffers[j - 1 - tStp]);
+                if (tStp === 1) {
+                    frames[frames.length - 1].dispose = 2;
+                }
+                const nImg = new Uint8Array(nw * nh * 4);
+                this.copyTile(pImg, w, h, nImg, nw, nh, -nx, -ny, 0);
+                if (this.copyTile(cImg, w, h, nImg, nw, nh, -nx, -ny, 3)) {
+                    this.copyTile(cImg, w, h, nImg, nw, nh, -nx, -ny, 2);
+                    blend = 1;
+                }
+                else {
+                    this.copyTile(cImg, w, h, nImg, nw, nh, -nx, -ny, 0);
+                    blend = 0;
+                }
+                cImg = nImg;
+                cImg32 = new Uint32Array(cImg.buffer);
+            }
+            let bpl = 4 * nw;
+            if (cc <= 256 && !forbidPlte) {
+                bpl = Math.ceil((depth * nw) / 8);
+                const nImg = new Uint8Array(bpl * nh);
+                for (let y = 0; y < nh; y++) {
+                    const i = y * bpl;
+                    const ii = y * nw;
+                    if (depth === 8) {
+                        for (let x = 0; x < nw; x++) {
+                            nImg[i + x] = cMap[cImg32[ii + x]];
+                        }
+                    }
+                    else if (depth === 4) {
+                        for (let x = 0; x < nw; x++) {
+                            nImg[i + (x >> 1)] |= cMap[cImg32[ii + x]] << (4 - (x & 1) * 4);
+                        }
+                    }
+                    else if (depth === 2) {
+                        for (let x = 0; x < nw; x++) {
+                            nImg[i + (x >> 2)] |= cMap[cImg32[ii + x]] << (6 - (x & 3) * 2);
+                        }
+                    }
+                    else if (depth === 1) {
+                        for (let x = 0; x < nw; x++) {
+                            nImg[i + (x >> 3)] |= cMap[cImg32[ii + x]] << (7 - (x & 7) * 1);
+                        }
+                    }
+                }
+                cImg = nImg;
+                cType = 3;
+                bpp = 1;
+            }
+            else if (!gotAlpha && buffers.length === 1) {
+                // some next "reduced" frames may contain alpha for blending
+                const nImg = new Uint8Array(nw * nh * 3);
+                const area = nw * nh;
+                for (let i = 0; i < area; i++) {
+                    const ti = i * 3;
+                    const qi = i * 4;
+                    nImg[ti] = cImg[qi];
+                    nImg[ti + 1] = cImg[qi + 1];
+                    nImg[ti + 2] = cImg[qi + 2];
+                }
+                cImg = nImg;
+                cType = 2;
+                bpp = 3;
+                bpl = 3 * nw;
+            }
+            frames.push({
+                rect: {
+                    x: nx,
+                    y: ny,
+                    width: nw,
+                    height: nh
+                },
+                img: cImg,
+                bpl,
+                bpp,
+                blend,
+                dispose: brute ? 1 : 0
+            });
+        }
+        return { cType, depth, plte: pLte, gotAlpha, frames };
+    }
+    /**
+     * @internal
+     */
+    async filterZero(img, h, bpp, bpl, data) {
+        const fls = [];
+        for (let t = 0; t < 5; t++) {
+            if (h * bpl > 500000 && (t === 2 || t === 3 || t === 4)) {
+                continue;
+            }
+            for (let y = 0; y < h; y++) {
+                this.filterLine(data, img, y, bpl, bpp, t);
+            }
+            const deflated = await Compression.compress(data, "deflate");
+            fls.push(deflated);
+            if (bpp === 1) {
+                break;
+            }
+        }
+        let ti = 0;
+        let tSize = 1e9;
+        for (let i = 0; i < fls.length; i++) {
+            if (fls[i].length < tSize) {
+                ti = i;
+                tSize = fls[i].length;
+            }
+        }
+        return fls[ti];
+    }
+    /**
+     * @internal
+     */
+    filterLine(data, img, y, bpl, bpp, type) {
+        const i = y * bpl;
+        let di = i + y;
+        data[di] = type;
+        di++;
+        if (type === 0) {
+            for (let x = 0; x < bpl; x++) {
+                data[di + x] = img[i + x];
+            }
+        }
+        else if (type === 1) {
+            for (let x = 0; x < bpp; x++) {
+                data[di + x] = img[i + x];
+            }
+            for (let x = bpp; x < bpl; x++) {
+                data[di + x] = (img[i + x] - img[i + x - bpp] + 256) & 255;
+            }
+        }
+        else if (y === 0) {
+            for (let x = 0; x < bpp; x++) {
+                data[di + x] = img[i + x];
+            }
+            if (type === 2) {
+                for (let x = bpp; x < bpl; x++) {
+                    data[di + x] = img[i + x];
+                }
+            }
+            if (type === 3) {
+                for (let x = bpp; x < bpl; x++) {
+                    data[di + x] = (img[i + x] - (img[i + x - bpp] >> 1) + 256) & 255;
+                }
+            }
+            if (type === 4) {
+                for (let x = bpp; x < bpl; x++) {
+                    data[di + x] = (img[i + x] - this.paeth(img[i + x - bpp], 0, 0) + 256) & 255;
+                }
+            }
+        }
+        else {
+            if (type === 2) {
+                for (let x = 0; x < bpl; x++) {
+                    data[di + x] = (img[i + x] + 256 - img[i + x - bpl]) & 255;
+                }
+            }
+            if (type === 3) {
+                for (let x = 0; x < bpp; x++) {
+                    data[di + x] = (img[i + x] + 256 - (img[i + x - bpl] >> 1)) & 255;
+                }
+                for (let x = bpp; x < bpl; x++) {
+                    data[di + x] = (img[i + x] + 256 - ((img[i + x - bpl] + img[i + x - bpp]) >> 1)) & 255;
+                }
+            }
+            if (type === 4) {
+                for (let x = 0; x < bpp; x++) {
+                    data[di + x] = (img[i + x] + 256 - this.paeth(0, img[i + x - bpl], 0)) & 255;
+                }
+                for (let x = bpp; x < bpl; x++) {
+                    data[di + x] =
+                        (img[i + x] +
+                            256 -
+                            this.paeth(img[i + x - bpp], img[i + x - bpl], img[i + x - bpp - bpl])) &
+                            255;
+                }
+            }
+        }
+    }
+    /**
+     * @internal
+     */
+    paeth(a, b, c) {
+        const p = a + b - c;
+        const pa = Math.abs(p - a);
+        const pb = Math.abs(p - b);
+        const pc = Math.abs(p - c);
+        if (pa <= pb && pa <= pc) {
+            return a;
+        }
+        if (pb <= pc) {
+            return b;
+        }
+        return c;
+    }
+    /**
+     * @internal
+     */
+    writeASCII(data, p, s) {
+        for (let i = 0; i < s.length; i++) {
+            data[p + i] = s.charCodeAt(i);
+        }
+    }
+    /**
+     * @internal
+     */
+    writeUint(buff, p, n) {
+        buff[p] = (n >> 24) & 255;
+        buff[p + 1] = (n >> 16) & 255;
+        buff[p + 2] = (n >> 8) & 255;
+        buff[p + 3] = n & 255;
+    }
+    /**
+     * @internal
+     */
+    writeUshort(buff, p, n) {
+        buff[p] = (n >> 8) & 255;
+        buff[p + 1] = n & 255;
+    }
+    /**
+     * @internal
+     */
+    copyTile(sb, sw, sh, tb, tw, th, xOffset, yOffset, mode) {
+        const w = Math.min(sw, tw);
+        const h = Math.min(sh, th);
+        let si = 0;
+        let ti = 0;
+        for (let y = 0; y < h; y++) {
+            for (let x = 0; x < w; x++) {
+                if (xOffset >= 0 && yOffset >= 0) {
+                    si = (y * sw + x) << 2;
+                    ti = ((yOffset + y) * tw + xOffset + x) << 2;
+                }
+                else {
+                    si = ((-yOffset + y) * sw - xOffset + x) << 2;
+                    ti = (y * tw + x) << 2;
+                }
+                if (mode === 0) {
+                    tb[ti] = sb[si];
+                    tb[ti + 1] = sb[si + 1];
+                    tb[ti + 2] = sb[si + 2];
+                    tb[ti + 3] = sb[si + 3];
+                }
+                else if (mode === 1) {
+                    const fa = sb[si + 3] * (1 / 255);
+                    const fr = sb[si] * fa;
+                    const fg = sb[si + 1] * fa;
+                    const fb = sb[si + 2] * fa;
+                    const ba = tb[ti + 3] * (1 / 255);
+                    const br = tb[ti] * ba;
+                    const bg = tb[ti + 1] * ba;
+                    const bb = tb[ti + 2] * ba;
+                    const ifa = 1 - fa;
+                    const oa = fa + ba * ifa;
+                    const ioa = oa === 0 ? 0 : 1 / oa;
+                    tb[ti + 3] = 255 * oa;
+                    tb[ti + 0] = (fr + br * ifa) * ioa;
+                    tb[ti + 1] = (fg + bg * ifa) * ioa;
+                    tb[ti + 2] = (fb + bb * ifa) * ioa;
+                }
+                else if (mode === 2) {
+                    // copy only differences, otherwise zero
+                    const fa = sb[si + 3];
+                    const fr = sb[si];
+                    const fg = sb[si + 1];
+                    const fb = sb[si + 2];
+                    const ba = tb[ti + 3];
+                    const br = tb[ti];
+                    const bg = tb[ti + 1];
+                    const bb = tb[ti + 2];
+                    if (fa === ba && fr === br && fg === bg && fb === bb) {
+                        tb[ti] = 0;
+                        tb[ti + 1] = 0;
+                        tb[ti + 2] = 0;
+                        tb[ti + 3] = 0;
+                    }
+                    else {
+                        tb[ti] = fr;
+                        tb[ti + 1] = fg;
+                        tb[ti + 2] = fb;
+                        tb[ti + 3] = fa;
+                    }
+                }
+                else if (mode === 3) {
+                    // check if can be blended
+                    const fa = sb[si + 3];
+                    const fr = sb[si];
+                    const fg = sb[si + 1];
+                    const fb = sb[si + 2];
+                    const ba = tb[ti + 3];
+                    const br = tb[ti];
+                    const bg = tb[ti + 1];
+                    const bb = tb[ti + 2];
+                    if (fa === ba && fr === br && fg === bg && fb === bb) {
+                        continue;
+                    }
+                    if (fa < 220 && ba > 20) {
+                        return false;
+                    }
+                }
+            }
+        }
+        return true;
+    }
+    /**
+     * @internal
+     */
+    crc(b, o, l) {
+        return this.crcUpdate(0xffffffff, b, o, l) ^ 0xffffffff;
+    }
+    /**
+     * @internal
+     */
+    crcUpdate(c, buf, off, len) {
+        let localC = c;
+        const crcTable = this.crcTable();
+        for (let i = 0; i < len; i++) {
+            localC = crcTable[(localC ^ buf[off + i]) & 0xff] ^ (localC >>> 8);
+        }
+        return localC;
+    }
+    /**
+     * @internal
+     */
+    crcTable() {
+        const tab = new Uint32Array(256);
+        for (let n = 0; n < 256; n++) {
+            let c = n;
+            for (let k = 0; k < 8; k++) {
+                if (c & 1) {
+                    c = 0xedb88320 ^ (c >>> 1);
+                }
+                else {
+                    c >>>= 1;
+                }
+            }
+            tab[n] = c;
+        }
+        return tab;
+    }
+    /**
+     * @internal
+     */
+    quantize(buffers, ps, roundAlpha) {
+        const imgs = [];
+        let total = 0;
+        for (let i = 0; i < buffers.length; i++) {
+            imgs.push(this.alphaMul(new Uint8Array(buffers[i]), roundAlpha));
+            total += buffers[i].byteLength;
+        }
+        const nImg = new Uint8Array(total);
+        const nImg32 = new Uint32Array(nImg.buffer);
+        let nOff = 0;
+        for (let i = 0; i < imgs.length; i++) {
+            const img = imgs[i];
+            const il = img.length;
+            for (let j = 0; j < il; j++) {
+                nImg[nOff + j] = img[j];
+            }
+            nOff += il;
+        }
+        const root = {
+            i0: 0,
+            i1: nImg.length,
+            bst: null,
+            est: null,
+            tDst: 0,
+            left: null,
+            right: null
+        };
+        root.bst = this.quantizeStats(nImg, root.i0, root.i1);
+        root.est = this.quantizeEStats(root.bst);
+        const leafs = [root];
+        while (leafs.length < ps) {
+            let maxL = 0;
+            let mi = 0;
+            for (let i = 0; i < leafs.length; i++) {
+                const est = leafs[i].est;
+                if (est && est.L > maxL) {
+                    maxL = est.L;
+                    mi = i;
+                }
+            }
+            if (maxL < 1e-3) {
+                break;
+            }
+            const node = leafs[mi];
+            const s0 = this.quantizeSplitPixels(nImg, nImg32, node.i0, node.i1, node.est?.e ?? [], node.est?.eMq255 ?? 0);
+            const ln = {
+                i0: node.i0,
+                i1: s0,
+                bst: null,
+                est: null,
+                tDst: 0,
+                left: null,
+                right: null
+            };
+            ln.bst = this.quantizeStats(nImg, ln.i0, ln.i1);
+            ln.est = this.quantizeEStats(ln.bst);
+            const rn = {
+                i0: s0,
+                i1: node.i1,
+                bst: null,
+                est: null,
+                tDst: 0,
+                left: null,
+                right: null
+            };
+            rn.bst = {
+                R: [],
+                m: [],
+                N: (node.bst?.N ?? 0) - ln.bst.N
+            };
+            for (let i = 0; i < 16; i++) {
+                rn.bst.R[i] = (node.bst?.R[i] ?? 0) - ln.bst.R[i];
+            }
+            for (let i = 0; i < 4; i++) {
+                rn.bst.m[i] = (node.bst?.m[i] ?? 0) - ln.bst.m[i];
+            }
+            rn.est = this.quantizeEStats(rn.bst);
+            node.left = ln;
+            node.right = rn;
+            leafs[mi] = ln;
+            leafs.push(rn);
+        }
+        leafs.sort((a, b) => (b.bst?.N ?? 0) - (a.bst?.N ?? 0));
+        const outBuffers = [];
+        for (let ii = 0; ii < imgs.length; ii++) {
+            const sb = new Uint8Array(imgs[ii]);
+            const tb = new Uint32Array(imgs[ii]);
+            const len = sb.length;
+            for (let i = 0; i < len; i += 4) {
+                const r = sb[i] * (1 / 255);
+                const g = sb[i + 1] * (1 / 255);
+                const b = sb[i + 2] * (1 / 255);
+                const a = sb[i + 3] * (1 / 255);
+                let nd = root;
+                while (nd?.left) {
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    nd = this.quantizePlaneDst(nd.est, r, g, b, a) <= 0 ? nd.left : nd.right;
+                }
+                tb[i >> 2] = nd?.est?.rgba ?? 0;
+            }
+            outBuffers[ii] = tb.buffer;
+        }
+        return { buffers: outBuffers, plte: leafs };
+    }
+    /**
+     * @internal
+     */
+    quantizeStats(nImg, i0, i1) {
+        const R = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+        const m = [0, 0, 0, 0];
+        const N = (i1 - i0) >> 2;
+        for (let i = i0; i < i1; i += 4) {
+            const r = nImg[i] * (1 / 255);
+            const g = nImg[i + 1] * (1 / 255);
+            const b = nImg[i + 2] * (1 / 255);
+            const a = nImg[i + 3] * (1 / 255);
+            m[0] += r;
+            m[1] += g;
+            m[2] += b;
+            m[3] += a;
+            R[0] += r * r;
+            R[1] += r * g;
+            R[2] += r * b;
+            R[3] += r * a;
+            R[5] += g * g;
+            R[6] += g * b;
+            R[7] += g * a;
+            R[10] += b * b;
+            R[11] += b * a;
+            R[15] += a * a;
+        }
+        R[4] = R[1];
+        R[8] = R[2];
+        R[12] = R[3];
+        R[9] = R[6];
+        R[13] = R[7];
+        R[14] = R[11];
+        return { R, m, N };
+    }
+    /**
+     * @internal
+     */
+    quantizeEStats(stats) {
+        const R = stats.R;
+        const m = stats.m;
+        const N = stats.N;
+        const m0 = m[0];
+        const m1 = m[1];
+        const m2 = m[2];
+        const m3 = m[3];
+        const iN = N === 0 ? 0 : 1 / N;
+        const rj = [
+            R[0] - m0 * m0 * iN,
+            R[1] - m0 * m1 * iN,
+            R[2] - m0 * m2 * iN,
+            R[3] - m0 * m3 * iN,
+            R[4] - m1 * m0 * iN,
+            R[5] - m1 * m1 * iN,
+            R[6] - m1 * m2 * iN,
+            R[7] - m1 * m3 * iN,
+            R[8] - m2 * m0 * iN,
+            R[9] - m2 * m1 * iN,
+            R[10] - m2 * m2 * iN,
+            R[11] - m2 * m3 * iN,
+            R[12] - m3 * m0 * iN,
+            R[13] - m3 * m1 * iN,
+            R[14] - m3 * m2 * iN,
+            R[15] - m3 * m3 * iN
+        ];
+        const A = rj;
+        let b = [0.5, 0.5, 0.5, 0.5];
+        let mi = 0;
+        let tmi = 0;
+        if (N !== 0) {
+            for (let i = 0; i < 10; i++) {
+                b = this.m4MultiplyVec(A, b);
+                tmi = Math.sqrt(this.m4Dot(b, b));
+                b = this.m4Sml(1 / tmi, b);
+                if (Math.abs(tmi - mi) < 1e-9) {
+                    break;
+                }
+                mi = tmi;
+            }
+        }
+        const q = [m0 * iN, m1 * iN, m2 * iN, m3 * iN];
+        const eMq255 = this.m4Dot(this.m4Sml(255, q), b);
+        const ia = q[3] < 0.001 ? 0 : 1 / q[3];
+        return {
+            Cov: rj,
+            q,
+            e: b,
+            L: mi,
+            eMq255,
+            eMq: this.m4Dot(b, q),
+            rgba: ((Math.round(255 * q[3]) << 24) |
+                (Math.round(255 * q[2] * ia) << 16) |
+                (Math.round(255 * q[1] * ia) << 8) |
+                (Math.round(255 * q[0] * ia) << 0)) >>>
+                0
+        };
+    }
+    /**
+     * @internal
+     */
+    quantizePlaneDst(est, r, g, b, a) {
+        const e = est.e;
+        return e[0] * r + e[1] * g + e[2] * b + e[3] * a - est.eMq;
+    }
+    /**
+     * @internal
+     */
+    quantizeSplitPixels(nImg, nImg32, i0in, i1in, e, eMq) {
+        let i1 = i1in - 4;
+        let i0 = i0in;
+        while (i0 < i1) {
+            while (this.quantizeVecDot(nImg, i0, e) <= eMq) {
+                i0 += 4;
+            }
+            while (this.quantizeVecDot(nImg, i1, e) > eMq) {
+                i1 -= 4;
+            }
+            if (i0 >= i1) {
+                break;
+            }
+            const t = nImg32[i0 >> 2];
+            nImg32[i0 >> 2] = nImg32[i1 >> 2];
+            nImg32[i1 >> 2] = t;
+            i0 += 4;
+            i1 -= 4;
+        }
+        while (this.quantizeVecDot(nImg, i0, e) > eMq) {
+            i0 -= 4;
+        }
+        return i0 + 4;
+    }
+    /**
+     * @internal
+     */
+    quantizeVecDot(nImg, i, e) {
+        return nImg[i] * e[0] + nImg[i + 1] * e[1] + nImg[i + 2] * e[2] + nImg[i + 3] * e[3];
+    }
+    /**
+     * @internal
+     */
+    m4MultiplyVec(m, v) {
+        return [
+            m[0] * v[0] + m[1] * v[1] + m[2] * v[2] + m[3] * v[3],
+            m[4] * v[0] + m[5] * v[1] + m[6] * v[2] + m[7] * v[3],
+            m[8] * v[0] + m[9] * v[1] + m[10] * v[2] + m[11] * v[3],
+            m[12] * v[0] + m[13] * v[1] + m[14] * v[2] + m[15] * v[3]
+        ];
+    }
+    /**
+     * @internal
+     */
+    m4Dot(x, y) {
+        return x[0] * y[0] + x[1] * y[1] + x[2] * y[2] + x[3] * y[3];
+    }
+    /**
+     * @internal
+     */
+    m4Sml(a, y) {
+        return [a * y[0], a * y[1], a * y[2], a * y[3]];
+    }
+    /**
+     * @internal
+     */
+    alphaMul(img, roundA) {
+        const nImg = new Uint8Array(img.length);
+        const area = img.length >> 2;
+        for (let i = 0; i < area; i++) {
+            const qi = i << 2;
+            let ia = img[qi + 3];
+            if (roundA) {
+                ia = ia < 128 ? 0 : 255;
+            }
+            const a = ia * (1 / 255);
+            nImg[qi + 0] = img[qi + 0] * a;
+            nImg[qi + 1] = img[qi + 1] * a;
+            nImg[qi + 2] = img[qi + 2] * a;
+            nImg[qi + 3] = ia;
+        }
+        return nImg;
+    }
+}
+
+export { Color, JpegEncoder, PngEncoder };