@woosh/meep-engine 2.126.75 → 2.127.1

package/src/engine/asset/loaders/image/jpeg/idct8x8_fixed.js

@@ -0,0 +1,214 @@
+// IDCT constants (20.12 fixed point format)
+const dctCos1 = 4017;   // cos(pi/16)
+const dctSin1 = 799;   // sin(pi/16)
+const dctCos3 = 3406;   // cos(3*pi/16)
+const dctSin3 = 2276;   // sin(3*pi/16)
+const dctCos6 = 1567;   // cos(6*pi/16)
+const dctSin6 = 3784;   // sin(6*pi/16)
+const dctSqrt2 = 5793;   // sqrt(2)
+const dctSqrt1d2 = 2896;  // sqrt(2) / 2
+
+/**
+ * Used internally for transformation
+ * @type {Int32Array}
+ */
+const p = new Int32Array(64);
+
+/**
+ * Decode 8x8 block quantized DCT coefficients and inverse DCT transform.
+ * This is a fixed-point implementation of the IDCT algorithm.
+ *
+ * This IDCT algorithm is taken from:
+ *    Y. A. Reznik, A. T. Hinds, L. Yu, Z. Ni, and C-X. Zhang,
+ *    "Efficient fixed-point approximations of the 8x8 inverse discrete
+ *    cosine transform" (invited paper), Proc. SPIE Vol. 6696, Sep. 24, 2007.
+ *
+ * which is based on:
+ *   Christoph Loeffler, Adriaan Ligtenberg, George S. Moschytz,
+ *   "Practical Fast 1-D DCT Algorithms with 11 Multiplications",
+ *   IEEE Intl. Conf. on Acoustics, Speech & Signal Processing, 1989,
+ *   988-991.
+ *
+ * The stage numbers mentioned in the comments refer to Figure 1 in the Loeffler paper.
+ *
+ * @param {Int32Array} qt quantization table
+ * @param {Int32Array} zz zigzag-ordered coefficients
+ * @param {Uint8Array|Uint8ClampedArray} dataOut
+ */
+export function idct8x8_fixed(
+    qt,
+    zz,
+    dataOut,
+) {
+
+    // TODO check https://github.com/ONLYOFFICE/core/blob/f6c835668482d70e59202394434314c8863fc1cf/PdfFile/lib/xpdf/Stream.cc#L3582
+
+    let v0, v1, v2, v3, v4, v5, v6, v7, t;
+    let i;
+
+    // dequant
+    for (i = 0; i < 64; i++) {
+        p[i] = zz[i] * qt[i];
+    }
+
+    // inverse DCT on rows
+    for (i = 0; i < 8; ++i) {
+        const row = 8 * i;
+
+        // check for all-zero AC coefficients
+        if (p[1 + row] === 0
+            && p[2 + row] === 0
+            && p[3 + row] === 0
+            && p[4 + row] === 0
+            && p[5 + row] === 0
+            && p[6 + row] === 0
+            && p[7 + row] === 0
+        ) {
+
+            t = (dctSqrt2 * p[0 + row] + 512) >> 10;
+
+            p[0 + row] = t;
+            p[1 + row] = t;
+            p[2 + row] = t;
+            p[3 + row] = t;
+            p[4 + row] = t;
+            p[5 + row] = t;
+            p[6 + row] = t;
+            p[7 + row] = t;
+
+            continue;
+        }
+
+        // stage 4
+        v0 = (dctSqrt2 * p[0 + row] + 128) >> 8;
+        v1 = (dctSqrt2 * p[4 + row] + 128) >> 8;
+        v2 = p[2 + row];
+        v3 = p[6 + row];
+        v4 = (dctSqrt1d2 * (p[1 + row] - p[7 + row]) + 128) >> 8;
+        v7 = (dctSqrt1d2 * (p[1 + row] + p[7 + row]) + 128) >> 8;
+        v5 = p[3 + row] << 4;
+        v6 = p[5 + row] << 4;
+
+        // stage 3
+        t = (v0 - v1 + 1) >> 1;
+        v0 = (v0 + v1 + 1) >> 1;
+        v1 = t;
+        t = (v2 * dctSin6 + v3 * dctCos6 + 128) >> 8;
+        v2 = (v2 * dctCos6 - v3 * dctSin6 + 128) >> 8;
+        v3 = t;
+        t = (v4 - v6 + 1) >> 1;
+        v4 = (v4 + v6 + 1) >> 1;
+        v6 = t;
+        t = (v7 + v5 + 1) >> 1;
+        v5 = (v7 - v5 + 1) >> 1;
+        v7 = t;
+
+        // stage 2
+        t = (v0 - v3 + 1) >> 1;
+        v0 = (v0 + v3 + 1) >> 1;
+        v3 = t;
+        t = (v1 - v2 + 1) >> 1;
+        v1 = (v1 + v2 + 1) >> 1;
+        v2 = t;
+        t = (v4 * dctSin3 + v7 * dctCos3 + 2048) >> 12;
+        v4 = (v4 * dctCos3 - v7 * dctSin3 + 2048) >> 12;
+        v7 = t;
+        t = (v5 * dctSin1 + v6 * dctCos1 + 2048) >> 12;
+        v5 = (v5 * dctCos1 - v6 * dctSin1 + 2048) >> 12;
+        v6 = t;
+
+        // stage 1
+        p[0 + row] = v0 + v7;
+        p[7 + row] = v0 - v7;
+        p[1 + row] = v1 + v6;
+        p[6 + row] = v1 - v6;
+        p[2 + row] = v2 + v5;
+        p[5 + row] = v2 - v5;
+        p[3 + row] = v3 + v4;
+        p[4 + row] = v3 - v4;
+    }
+
+    // inverse DCT on columns
+    for (i = 0; i < 8; ++i) {
+        const col = i;
+
+        // check for all-zero AC coefficients
+        if (p[1 * 8 + col] === 0
+            && p[2 * 8 + col] === 0
+            && p[3 * 8 + col] === 0
+            && p[4 * 8 + col] === 0
+            && p[5 * 8 + col] === 0
+            && p[6 * 8 + col] === 0
+            && p[7 * 8 + col] === 0
+        ) {
+
+            t = (dctSqrt2 * p[i + 0] + 8192) >> 14;
+
+            p[0 * 8 + col] = t;
+            p[1 * 8 + col] = t;
+            p[2 * 8 + col] = t;
+            p[3 * 8 + col] = t;
+            p[4 * 8 + col] = t;
+            p[5 * 8 + col] = t;
+            p[6 * 8 + col] = t;
+            p[7 * 8 + col] = t;
+            continue;
+        }
+
+        // stage 4
+        v0 = (dctSqrt2 * p[0 * 8 + col] + 2048) >> 12;
+        v1 = (dctSqrt2 * p[4 * 8 + col] + 2048) >> 12;
+        v2 = p[2 * 8 + col];
+        v3 = p[6 * 8 + col];
+        v4 = (dctSqrt1d2 * (p[1 * 8 + col] - p[7 * 8 + col]) + 2048) >> 12;
+        v7 = (dctSqrt1d2 * (p[1 * 8 + col] + p[7 * 8 + col]) + 2048) >> 12;
+        v5 = p[3 * 8 + col];
+        v6 = p[5 * 8 + col];
+
+        // stage 3
+        t = (v0 - v1 + 1) >> 1;
+        v0 = (v0 + v1 + 1) >> 1;
+        v1 = t;
+        t = (v2 * dctSin6 + v3 * dctCos6 + 2048) >> 12;
+        v2 = (v2 * dctCos6 - v3 * dctSin6 + 2048) >> 12;
+        v3 = t;
+        t = (v4 - v6 + 1) >> 1;
+        v4 = (v4 + v6 + 1) >> 1;
+        v6 = t;
+        t = (v7 + v5 + 1) >> 1;
+        v5 = (v7 - v5 + 1) >> 1;
+        v7 = t;
+
+        // stage 2
+        t = (v0 - v3 + 1) >> 1;
+        v0 = (v0 + v3 + 1) >> 1;
+        v3 = t;
+        t = (v1 - v2 + 1) >> 1;
+        v1 = (v1 + v2 + 1) >> 1;
+        v2 = t;
+        t = (v4 * dctSin3 + v7 * dctCos3 + 2048) >> 12;
+        v4 = (v4 * dctCos3 - v7 * dctSin3 + 2048) >> 12;
+        v7 = t;
+        t = (v5 * dctSin1 + v6 * dctCos1 + 2048) >> 12;
+        v5 = (v5 * dctCos1 - v6 * dctSin1 + 2048) >> 12;
+        v6 = t;
+
+        // stage 1
+        p[0 * 8 + col] = v0 + v7;
+        p[7 * 8 + col] = v0 - v7;
+        p[1 * 8 + col] = v1 + v6;
+        p[6 * 8 + col] = v1 - v6;
+        p[2 * 8 + col] = v2 + v5;
+        p[5 * 8 + col] = v2 - v5;
+        p[3 * 8 + col] = v3 + v4;
+        p[4 * 8 + col] = v3 - v4;
+    }
+
+    // convert to 8-bit integers
+    for (i = 0; i < 64; ++i) {
+        const q = p[i];
+
+        // clip to 8-bit range
+        dataOut[i] = (q <= -2056) ? 0 : (q >= 2024) ? 255 : (q + 2056) >> 4;
+    }
+}

package/src/engine/asset/loaders/image/jpeg/idct8x8_float.d.ts

@@ -0,0 +1,9 @@
+/**
+ * An efficient, floating-point quantize and inverse DCT function based on the AAN fast IDCT algorithm.
+ * @param {Int32Array} qt quantization table
+ * @param {Int32Array} zz zigzag-ordered DCT coefficients
+ * @param {Uint8Array|Uint8ClampedArray} output The output array for the 8x8 block.
+ * @see idct8x8_fixed
+ */
+export function idct8x8_float(qt: Int32Array, zz: Int32Array, output: Uint8Array | Uint8ClampedArray): void;
+//# sourceMappingURL=idct8x8_float.d.ts.map

package/src/engine/asset/loaders/image/jpeg/idct8x8_float.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"idct8x8_float.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/jpeg/idct8x8_float.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,kCALW,UAAU,MACV,UAAU,UACV,UAAU,GAAC,iBAAiB,QAuBtC"}

package/src/engine/asset/loaders/image/jpeg/idct8x8_float.js

@@ -0,0 +1,32 @@
+import { idct_2d } from "../../../../../core/math/idct_2d.js";
+
+const p = new Float64Array(64);
+
+/**
+ * An efficient, floating-point quantize and inverse DCT function based on the AAN fast IDCT algorithm.
+ * @param {Int32Array} qt quantization table
+ * @param {Int32Array} zz zigzag-ordered DCT coefficients
+ * @param {Uint8Array|Uint8ClampedArray} output The output array for the 8x8 block.
+ * @see idct8x8_fixed
+ */
+export function idct8x8_float(
+    qt,
+    zz,
+    output
+) {
+
+    // 1. Dequantize the coefficients
+    for (let i = 0; i < 64; i++) {
+        p[i] = (zz[i] * qt[i]);
+    }
+
+    idct_2d(p);
+
+    // 4. Level-shift, scale, and clip to 8-bit range
+    for (let i = 0; i < 64; ++i) {
+        const sample = 128 + Math.round(p[i]);
+
+        // Clip to the valid 8-bit range [0, 255]
+        output[i] = sample < 0 ? 0 : sample > 255 ? 255 : sample;
+    }
+}

package/src/engine/asset/loaders/image/jpeg/jpeg_decode.d.ts

@@ -0,0 +1,13 @@
+/**
+ *
+ * @param {ArrayBuffer} jpegData
+ * @param [userOpts]
+ * @return {{width: number, height: number, exifBuffer: Uint8Array, data: Uint8Array}}
+ */
+export function jpeg_decode(jpegData: ArrayBuffer, userOpts?: {}): {
+    width: number;
+    height: number;
+    exifBuffer: Uint8Array;
+    data: Uint8Array;
+};
+//# sourceMappingURL=jpeg_decode.d.ts.map

package/src/engine/asset/loaders/image/jpeg/jpeg_decode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jpeg_decode.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/jpeg/jpeg_decode.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,sCAJW,WAAW,kBAEV;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAC,CAkCpF"}

package/src/engine/asset/loaders/image/jpeg/jpeg_decode.js

@@ -0,0 +1,41 @@
+import { JpegImage } from "./JpegImage.js";
+
+/**
+ *
+ * @param {ArrayBuffer} jpegData
+ * @param [userOpts]
+ * @return {{width: number, height: number, exifBuffer: Uint8Array, data: Uint8Array}}
+ */
+export function jpeg_decode(jpegData, userOpts = {}) {
+    const defaultOpts = {
+        // "undefined" means "Choose whether to transform colors based on the image’s color model."
+        colorTransform: undefined,
+        tolerantDecoding: true,
+    };
+
+    const opts = { ...defaultOpts, ...userOpts };
+    const arr = new Uint8Array(jpegData);
+    const decoder = new JpegImage();
+    decoder.opts = opts;
+    // If this constructor ever supports async decoding this will need to be done differently.
+    // Until then, treating as singleton limit is fine.
+    decoder.parse(arr);
+
+    const channels =  3;
+    const bytesNeeded = decoder.width * decoder.height * channels;
+
+    const image = {
+        width: decoder.width,
+        height: decoder.height,
+        exifBuffer: decoder.exifBuffer,
+        data: new Uint8Array(bytesNeeded)
+    };
+
+    if (decoder.comments.length > 0) {
+        image["comments"] = decoder.comments;
+    }
+
+    decoder.copyToImageData(image, false);
+
+    return image;
+}

package/src/engine/asset/loaders/image/png/PNG.d.ts

@@ -25,8 +25,11 @@ export class PNG {
      */
     colors: number;
     alpha: boolean;
-    pixelBits: number;
-    palette: any;
+    /**
+     *
+     * @type {Uint8Array|null}
+     */
+    palette: Uint8Array | null;
     /**
      *
      * @type {Uint8Array|null}
@@ -36,7 +39,7 @@ export class PNG {
      * Transparency palette
      * @type {Uint8Array|null}
      */
-    trns: Uint8Array | null;
+    transparency_lookup: Uint8Array | null;
     /**
      * Text metadata coming from tEXt chunks
      * @type {Object<string>}
@@ -50,19 +53,23 @@ export class PNG {
     setBitDepth(bitDepth: any): void;
     getColorType(): number;
     setColorType(colorType: any): void;
-    getCompressionMethod(): number;
-    setCompressionMethod(compressionMethod: any): void;
-    getFilterMethod(): number;
-    setFilterMethod(filterMethod: any): void;
+    /**
+     *
+     * @param {number} compressionMethod
+     */
+    setCompressionMethod(compressionMethod: number): void;
+    /**
+     *
+     * @param {number} filterMethod
+     */
+    setFilterMethod(filterMethod: number): void;
     getInterlaceMethod(): number;
     setInterlaceMethod(interlaceMethod: any): void;
     /**
      *
-     * @param {Uint8Array} trns
+     * @param {Uint8Array} palette
      */
-    setTRNS(trns: Uint8Array): void;
-    setPalette(palette: any): void;
-    getPalette(): any;
+    setPalette(palette: Uint8Array): void;
     /**
      * get the pixel color on a certain location in a normalized way
      * result is an array: [red, green, blue, alpha]

package/src/engine/asset/loaders/image/png/PNG.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PNG.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/png/PNG.js"],"names":[],"mappings":"AAAA;IAEI;;;OAGG;IACH,OAFU,MAAM,CAEN;IACV;;;OAGG;IACH,QAFU,MAAM,CAEL;IAEX;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb,kBAAc;IACd,0BAAsB;IACtB,qBAAiB;IACjB,wBAAoB;IAEpB;;;;OAIG;IACH,QAFU,MAAM,CAEL;IACX,eAAc;IACd,kBAAc;IAEd,aAAe;IAEf;;;OAGG;IACH,QAFU,UAAU,GAAC,IAAI,CAEX;IAEd;;;OAGG;IACH,MAFU,UAAU,GAAC,IAAI,CAEb;IAGZ;;;OAGG;IACH,UAAU;IAGV,mBAEC;IAED,2BAEC;IAED,oBAEC;IAED,6BAEC;IAED,sBAEC;IAED,iCAKC;IAED,uBAEC;IAED,mCA6CC;IAED,+BAEC;IAED,mDAKC;IAED,0BAEC;IAED,yCAKC;IAED,6BAEC;IAED,+CAKC;IAED;;;OAGG;IACH,cAFW,UAAU,QAIpB;IAED,+BAQC;IAED,kBAEC;IAED;;;OAGG;IACH,gEA+DC;IAED;;;OAGG;IACH,mCAFW,UAAU,QAqBpB;IAED;;;OAGG;IACH,mCAFW,UAAU,QAiBpB;IAED;;;OAGG;IACH,4BAoBC;IAED;;;MA4DC;IAED;;OAEG;IACH;kBAFuB,MAAM;cAAO,UAAU;kBAAY,MAAM;MA0C/D;CACJ"}
+{"version":3,"file":"PNG.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/png/PNG.js"],"names":[],"mappings":"AAAA;IAEI;;;OAGG;IACH,OAFU,MAAM,CAEN;IACV;;;OAGG;IACH,QAFU,MAAM,CAEL;IAEX;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb,kBAAc;IACd,0BAAsB;IACtB,qBAAiB;IACjB,wBAAoB;IAEpB;;;;OAIG;IACH,QAFU,MAAM,CAEL;IACX,eAAc;IAEd;;;OAGG;IACH,SAFU,UAAU,GAAC,IAAI,CAEV;IAEf;;;OAGG;IACH,QAFU,UAAU,GAAC,IAAI,CAEX;IAEd;;;OAGG;IACH,qBAFU,UAAU,GAAC,IAAI,CAEE;IAG3B;;;OAGG;IACH,UAAU;IAGV,mBAEC;IAED,2BAEC;IAED,oBAEC;IAED,6BAEC;IAED,sBAEC;IAED,iCAKC;IAED,uBAEC;IAED,mCA6CC;IAED;;;OAGG;IACH,wCAFW,MAAM,QAOhB;IAED;;;OAGG;IACH,8BAFW,MAAM,QAOhB;IAED,6BAEC;IAED,+CAKC;IAED;;;OAGG;IACH,oBAFW,UAAU,QAUpB;IAED;;;OAGG;IACH,gEA+DC;IAED;;;OAGG;IACH,mCAFW,UAAU,QAqBpB;IAED;;;OAGG;IACH,mCAFW,UAAU,QAiBpB;IAED;;;OAGG;IACH,4BAoBC;IAED;;;MA4DC;IAED;;OAEG;IACH;kBAFuB,MAAM;cAAO,UAAU;kBAAY,MAAM;MA0C/D;CACJ"}

package/src/engine/asset/loaders/image/png/PNG.js

@@ -29,8 +29,11 @@ export class PNG {
      */
     colors = 0;
     alpha = false;
-    pixelBits = 0;
 
+    /**
+     *
+     * @type {Uint8Array|null}
+     */
     palette = null;
 
     /**
@@ -43,7 +46,7 @@ export class PNG {
      * Transparency palette
      * @type {Uint8Array|null}
      */
-    trns = null;
+    transparency_lookup = null;
 
 
     /**
@@ -131,10 +134,10 @@ export class PNG {
         this.colorType = colorType;
     }
 
-    getCompressionMethod() {
-        return this.compressionMethod;
-    }
-
+    /**
+     *
+     * @param {number} compressionMethod
+     */
     setCompressionMethod(compressionMethod) {
         if (compressionMethod !== 0) {
             throw new Error("invalid compression method " + compressionMethod);
@@ -142,10 +145,10 @@ export class PNG {
         this.compressionMethod = compressionMethod;
     }
 
-    getFilterMethod() {
-        return this.filterMethod;
-    }
-
+    /**
+     *
+     * @param {number} filterMethod
+     */
     setFilterMethod(filterMethod) {
         if (filterMethod !== 0) {
             throw new Error("invalid filter method " + filterMethod);
@@ -166,12 +169,8 @@ export class PNG {
 
     /**
      *
-     * @param {Uint8Array} trns
+     * @param {Uint8Array} palette
      */
-    setTRNS(trns) {
-        this.trns = trns;
-    }
-
     setPalette(palette) {
         if (palette.length % 3 !== 0) {
             throw new Error("incorrect PLTE chunk length");
@@ -182,10 +181,6 @@ export class PNG {
         this.palette = palette;
     }
 
-    getPalette() {
-        return this.palette;
-    }
-
     /**
      * get the pixel color on a certain location in a normalized way
      * result is an array: [red, green, blue, alpha]
@@ -221,8 +216,8 @@ export class PNG {
             case 3:
                 a = 255;
 
-                if (this.trns != null) {
-                    a = this.trns[pixels[i]];
+                if (this.transparency_lookup != null) {
+                    a = this.transparency_lookup[pixels[i]];
                 }
 
                 const offset = pixels[i] * 3;
@@ -335,7 +330,7 @@ export class PNG {
 
         let itemSize;
 
-        const transparency_lookup = this.trns;
+        const transparency_lookup = this.transparency_lookup;
         if (transparency_lookup !== null) {
             // has transparency
             itemSize = 4;

package/src/engine/asset/loaders/image/png/PNGReader.d.ts

@@ -26,7 +26,11 @@ export class PNGReader {
      * @type {PNG}
      */
     png: PNG;
-    dataChunks: any[];
+    /**
+     *
+     * @type {Uint8Array[]}
+     */
+    dataChunks: Uint8Array[];
     /**
      *
      * @type {BinaryBuffer}
@@ -120,8 +124,9 @@ export class PNGReader {
     /**
      *
      * http://www.w3.org/TR/PNG/#11PLTE
+     * @param {Uint8Array} chunk
      */
-    decodePLTE(chunk: any): void;
+    decodePLTE(chunk: Uint8Array): void;
     /**
      * http://www.w3.org/TR/2003/REC-PNG-20031110/#11IDAT
      */
@@ -142,36 +147,84 @@ export class PNGReader {
     /**
      * @param {Uint8Array} data
      */
-    interlaceNone(data: Uint8Array): void;
+    interlaceNone(data: Uint8Array): Uint8Array;
     /**
      * De-interlace image according to Adam 7 scheme
      * @param {Uint8Array} data
      */
-    interlaceAdam7(data: Uint8Array): never;
+    interlaceAdam7(data: Uint8Array): Uint8Array | Uint16Array;
+    /**
+     *
+     * @param {number} filter_type
+     * @param {Uint8Array} data
+     * @param {number} scanline_address
+     * @param {Uint8Array} output
+     * @param {number} bytes_per_pixel
+     * @param {number} output_offset
+     * @param {number} output_offset_previous where does result of previous scanline begin in the output? Needed for various filters such as `Up`
+     * @param {number} length
+     */
+    unFilter(filter_type: number, data: Uint8Array, scanline_address: number, output: Uint8Array, bytes_per_pixel: number, output_offset: number, output_offset_previous: number, length: number): void;
+    /**
+     *
+     * @param {Uint8Array} data
+     * @param {number} scanline_address
+     * @param {Uint8Array} output
+     * @param {number} bytes_per_pixel
+     * @param {number} output_offset
+     * @param {number} output_offset_previous
+     * @param {number} length
+     */
+    unFilterNone(data: Uint8Array, scanline_address: number, output: Uint8Array, bytes_per_pixel: number, output_offset: number, output_offset_previous: number, length: number): void;
     /**
      * The Sub() filter transmits the difference between each byte and the value
      * of the corresponding byte of the prior pixel.
      * Sub(x) = Raw(x) + Raw(x - bpp)
+     *
+     * @param {Uint8Array} scanline raw data
+     * @param {number} scanline_offset
+     * @param {Uint8Array} pixels processed output
+     * @param {number} bpp bytes-per-pixel
+     * @param {number} offset
+     * @param {number} output_offset_previous
+     * @param {number} length
      */
-    unFilterSub(scanline: any, scanline_offset: any, pixels: any, bpp: any, of: any, length: any): void;
+    unFilterSub(scanline: Uint8Array, scanline_offset: number, pixels: Uint8Array, bpp: number, offset: number, output_offset_previous: number, length: number): void;
     /**
      * The Up() filter is just like the Sub() filter except that the pixel
      * immediately above the current pixel, rather than just to its left, is used
      * as the predictor.
      * Up(x) = Raw(x) + Prior(x)
+     *
+     * @param {Uint8Array} scanline raw data
+     * @param {number} scanline_offset
+     * @param {Uint8Array} pixels processed output
+     * @param {number} bpp bytes-per-pixel
+     * @param {number} offset
+     * @param {number} output_offset_previous
+     * @param {number} length
      */
-    unFilterUp(scanline: any, scanline_offset: any, pixels: any, bpp: any, of: any, length: any): void;
+    unFilterUp(scanline: Uint8Array, scanline_offset: number, pixels: Uint8Array, bpp: number, offset: number, output_offset_previous: number, length: number): void;
     /**
      * The Average() filter uses the average of the two neighboring pixels (left
      * and above) to predict the value of a pixel.
      * Average(x) = Raw(x) + floor((Raw(x-bpp)+Prior(x))/2)
+     *
+     * @param {Uint8Array} scanline raw data
+     * @param {number} scanline_offset
+     * @param {Uint8Array} pixels processed output
+     * @param {number} bpp bytes-per-pixel
+     * @param {number} offset
+     * @param {number} output_offset_previous
+     * @param {number} length
      */
-    unFilterAverage(scanline: any, scanline_offset: any, pixels: any, bpp: any, of: any, length: any): void;
+    unFilterAverage(scanline: Uint8Array, scanline_offset: number, pixels: Uint8Array, bpp: number, offset: number, output_offset_previous: number, length: number): void;
     /**
      * The Paeth() filter computes a simple linear function of the three
      * neighboring pixels (left, above, upper left), then chooses as predictor
-     * the neighboring pixel closest to the computed value. This technique is due
-     * to Alan W. Paeth.
+     * the neighboring pixel closest to the computed value.
+     * This technique is due to Alan W. Paeth.
+     *
      * Paeth(x) = Raw(x) +
      *            PaethPredictor(Raw(x-bpp), Prior(x), Prior(x-bpp))
      *  function PaethPredictor (a, b, c)
@@ -187,8 +240,16 @@ export class PNGReader {
      *       else if pb <= pc then return b
      *       else return c
      *  end
+     *
+     * @param {Uint8Array} scanline raw data
+     * @param {number} scanline_offset
+     * @param {Uint8Array} pixels processed output
+     * @param {number} bpp bytes-per-pixel
+     * @param {number} offset
+     * @param {number} output_offset_previous
+     * @param {number} length
      */
-    unFilterPaeth(scanline: any, scanline_offset: any, pixels: any, bpp: any, of: any, length: any): void;
+    unFilterPaeth(scanline: Uint8Array, scanline_offset: number, pixels: Uint8Array, bpp: number, offset: number, output_offset_previous: number, length: number): void;
     /**
      * Parse the PNG file
      * @returns {PNG}

package/src/engine/asset/loaders/image/png/PNGReader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PNGReader.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/png/PNGReader.js"],"names":[],"mappings":"AAuDA;;;;GAIG;AACH,iCAHW,WAAW,QA8CrB;;IAhDD;;;;OAIG;IACH,mBAHW,WAAW,EA8CrB;IA1CG;;;OAGG;IACH,GAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,OAFU,UAAU,CAEc;IAElC;;;OAGG;IACH,KAFU,GAAG,CAEO;IAEpB,kBAAoB;IAEpB;;;OAGG;IACH,QAFU,YAAY,CAEU;IAOhC;;;OAGG;IACH,aAFU,OAAO,CAEO;IAExB;;;OAGG;IACH,QAFU,UAAU,CAEW;IAGnC;;;;OAIG;IACH,kBAHW,MAAM,GACL,UAAU,CAQrB;IAED;;OAEG;IACH,qBAkBC;IAED;;;;;;;;;OASG;IACH,eAFa,MAAM,CA4ElB;IAGD;;;OAGG;IACH,kBAFW,UAAU,QAOpB;IAED;;;OAGG;IACH,kBAFW,UAAU,QAapB;IAED;;;;OAIG;IACH,kBAFW,UAAU;;;;;MAiCpB;IAGD;;;;OAIG;IACH,kBAFW,UAAU;;;MA6BpB;IAED;;;OAGG;IACH,kBAFW,UAAU,QASpB;IACD;;;;OAIG;IACH,kBAFW,UAAU,QAqBpB;IAED;;;;;;;;;;;OAWG;IACH,6BAWC;IAED;;;OAGG;IACH,6BAEC;IAED;;OAEG;IACH,6BAGC;IAED;;;OAGG;IACH,kBAFW,UAAU,QAIpB;IAED;;OAEG;IACH,mBACC;IAED;;OAEG;IACH,qBAwBC;IAID;;OAEG;IACH,oBAFW,UAAU,QAyFpB;IAED;;;OAGG;IACH,qBAFW,UAAU,SAIpB;IAKD;;;;OAIG;IACH,oGAYC;IAED;;;;;OAKG;IACH,mGAYC;IAED;;;;OAIG;IACH,wGA+BC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,sGA8CC;IAED;;;OAGG;IACH,SAFa,GAAG,CAqBf;;oBA5sBmB,UAAU;6BALD,4CAA4C"}
+{"version":3,"file":"PNGReader.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/png/PNGReader.js"],"names":[],"mappings":"AAyDA;;;;GAIG;AACH,iCAHW,WAAW,QAkDrB;;IApDD;;;;OAIG;IACH,mBAHW,WAAW,EAkDrB;IA9CG;;;OAGG;IACH,GAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,OAFU,UAAU,CAEc;IAElC;;;OAGG;IACH,KAFU,GAAG,CAEO;IAEpB;;;OAGG;IACH,YAFU,UAAU,EAAE,CAEF;IAEpB;;;OAGG;IACH,QAFU,YAAY,CAEU;IAOhC;;;OAGG;IACH,aAFU,OAAO,CAEO;IAExB;;;OAGG;IACH,QAFU,UAAU,CAEW;IAGnC;;;;OAIG;IACH,kBAHW,MAAM,GACL,UAAU,CAarB;IAED;;OAEG;IACH,qBAkBC;IAED;;;;;;;;;OASG;IACH,eAFa,MAAM,CA4ElB;IAGD;;;OAGG;IACH,kBAFW,UAAU,QAOpB;IAED;;;OAGG;IACH,kBAFW,UAAU,QAapB;IAED;;;;OAIG;IACH,kBAFW,UAAU;;;;;MAuCpB;IAGD;;;;OAIG;IACH,kBAFW,UAAU;;;MAiCpB;IAED;;;OAGG;IACH,kBAFW,UAAU,QASpB;IACD;;;;OAIG;IACH,kBAFW,UAAU,QAwBpB;IAED;;;;;;;;;;;OAWG;IACH,6BAWC;IAED;;;;OAIG;IACH,kBAFW,UAAU,QAIpB;IAED;;OAEG;IACH,6BAGC;IAED;;;OAGG;IACH,kBAFW,UAAU,QAIpB;IAED;;OAEG;IACH,mBACC;IAED;;OAEG;IACH,qBAyBC;IAID;;OAEG;IACH,oBAFW,UAAU,cA+CpB;IAGD;;;OAGG;IACH,qBAFW,UAAU,4BA8GpB;IAID;;;;;;;;;;OAUG;IACH,sBATW,MAAM,QACN,UAAU,oBACV,MAAM,UACN,UAAU,mBACV,MAAM,iBACN,MAAM,0BACN,MAAM,UACN,MAAM,QA6EhB;IAED;;;;;;;;;OASG;IACH,mBARW,UAAU,oBACV,MAAM,UACN,UAAU,mBACV,MAAM,iBACN,MAAM,0BACN,MAAM,UACN,MAAM,QA+ChB;IAED;;;;;;;;;;;;OAYG;IACH,sBARW,UAAU,mBACV,MAAM,UACN,UAAU,OACV,MAAM,UACN,MAAM,0BACN,MAAM,UACN,MAAM,QAwBhB;IAED;;;;;;;;;;;;;OAaG;IACH,qBARW,UAAU,mBACV,MAAM,UACN,UAAU,OACV,MAAM,UACN,MAAM,0BACN,MAAM,UACN,MAAM,QAkChB;IAED;;;;;;;;;;;;OAYG;IACH,0BARW,UAAU,mBACV,MAAM,UACN,UAAU,OACV,MAAM,UACN,MAAM,0BACN,MAAM,UACN,MAAM,QA4ChB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,wBARW,UAAU,mBACV,MAAM,UACN,UAAU,OACV,MAAM,UACN,MAAM,0BACN,MAAM,UACN,MAAM,QA4DhB;IAED;;;OAGG;IACH,SAFa,GAAG,CAqBf;;oBA3gCmB,UAAU;6BAND,4CAA4C"}