@twin.org/image 0.0.2-next.8 → 0.0.3-next.1

package/dist/cjs/index.cjs

@@ -1,1898 +0,0 @@
-'use strict';
-
-var core = require('@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) {
-        core.Guards.number(Color._CLASS_NAME, "alpha", alpha);
-        core.Guards.number(Color._CLASS_NAME, "red", red);
-        core.Guards.number(Color._CLASS_NAME, "green", green);
-        core.Guards.number(Color._CLASS_NAME, "blue", blue);
-        if (alpha < 0 || alpha > 255) {
-            throw new core.GeneralError(Color._CLASS_NAME, "range", {
-                prop: "alpha",
-                value: alpha
-            });
-        }
-        if (red < 0 || red > 255) {
-            throw new core.GeneralError(Color._CLASS_NAME, "range", {
-                prop: "red",
-                value: red
-            });
-        }
-        if (green < 0 || green > 255) {
-            throw new core.GeneralError(Color._CLASS_NAME, "range", {
-                prop: "green",
-                value: green
-            });
-        }
-        if (blue < 0 || blue > 255) {
-            throw new core.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) {
-        core.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 core.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 (core.Is.object(value) &&
-            core.Is.number(value._alpha) &&
-            core.Is.number(value._red) &&
-            core.Is.number(value._green) &&
-            core.Is.number(value._blue)) {
-            return new Color(value._alpha, value._red, value._green, value._blue);
-        }
-        else if (core.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 */
-/**
- * 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 core.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 */
-/**
- * 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 core.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;
-    }
-}
-
-exports.Color = Color;
-exports.JpegEncoder = JpegEncoder;
-exports.PngEncoder = PngEncoder;