@chr33s/pdf-upng 5.0.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Photopea
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,112 @@
+# @chr33s/pdf-upng
+
+> Small, fast, and modernized PNG/APNG encoder and decoder for the `@chr33s/pdf` ecosystem.
+
+This package wraps the excellent [`UPNG.js`](https://github.com/photopea/UPNG.js) library and keeps it maintained and
+published for `@chr33s/pdf` and related tools. Key differences from upstream distributions include:
+
+- native ES module output targeting NodeNext (Node.js 18+ or a modern bundler required),
+- TypeScript source with generated declaration files bundled in the package, and
+- continuous maintenance inside the [`chr33s/pdf`](https://github.com/chr33s/pdf) monorepo alongside other PDF
+dependencies.
+
+## Example of `UPNG.toRGBA8`
+```ts
+import UPNG from "@chr33s/pdf-upng";
+
+const pngImage = UPNG.decode(/* Uint8Array containing bytes of PNG image */);
+
+// `pixels` is a 1D array (in RGBA order) of decoded pixel data
+const pixels = UPNG.toRGBA8(pngImage)[0];
+```
+
+## Installation
+
+```bash
+npm install @chr33s/pdf-upng
+```
+
+Package consumers should run on Node.js 18+ or enable NodeNext-compatible module resolution in their bundler configuration.
+
+
+## Encoder
+
+UPNG.js supports APNG and the interface expects "frames". Regular PNG is just a single-frame animation (single-item array).
+
+#### `UPNG.encode(imgs, w, h, cnum, [dels])`
+* `imgs`: array of frames. A frame is an ArrayBuffer containing the pixel data (RGBA, 8 bits per channel)
+* `w`, `h` : width and height of the image
+* `cnum`: number of colors in the result;  0: all colors (lossless PNG)
+* `dels`: array of millisecond delays for each frame (only when 2 or more frames)
+* returns an ArrayBuffer with binary data of a PNG file
+
+UPNG.js can do a lossy minification of PNG files, similar to [TinyPNG](https://tinypng.com/) and other tools. It performed quantization with [k-means algorithm](https://en.wikipedia.org/wiki/K-means_clustering) in the past, but now we use [K-d trees](https://en.wikipedia.org/wiki/K-d_tree).
+
+Lossy compression is allowed by the last parameter `cnum`. Set it to zero for a lossless compression, or write the number of allowed colors in the image. Smaller values produce smaller files. **Or just use 0 for lossless / 256 for lossy.**
+
+    // Read RGBA from canvas and encode with UPNG
+    let dta = ctx.getImageData(0,0,200,300).data;  // ctx is Context2D of a Canvas
+    //  dta = new Uint8Array(200 * 300 * 4);       // or generate pixels manually
+    let png = UPNG.encode([dta.buffer], 200, 300, 0);   console.log(new Uint8Array(png));
+
+#### `UPNG.encodeLL(imgs, w, h, cc, ac, depth, [dels])` - low-level encode
+* `imgs`: array of frames. A frame is an ArrayBuffer containing the pixel data (corresponding to following parameters)
+* `w`, `h` : width and height of the image
+* `cc`, `ac`: number of color channels (1 or 3) and alpha channels (0 or 1)
+* `depth`: bit depth of pixel data (1, 2, 4, 8, 16)
+* `dels`: array of millisecond delays for each frame (only when 2 or more frames)
+* returns an ArrayBuffer with binary data of a PNG file
+
+This function does not do any optimizations, it just stores what you give it. There are two cases when it is useful:
+* saving 16-bit colors (note, that PNG is big-endian, unlike Uint16Array in JS)
+* your image is too large, and "expanding" to 8-bit RGBA would use too much memory (e.g. 4-bit grayscale 50,000 x 50,000 = 1.25 GB, 8-bit RGBA would be 10 GB)
+
+## Decoder
+
+Supports all color types (including Grayscale and Palettes), all channel depths (1, 2, 4, 8, 16), interlaced images etc. Opens PNGs which other libraries can not open (tested with [PngSuite](http://www.schaik.com/pngsuite/)).
+
+#### `UPNG.decode(buffer)`
+* `buffer`: ArrayBuffer containing the PNG file
+* returns an image object with following properties:
+* * `width`: the width of the image
+* * `height`: the height of the image
+* * `depth`: number of bits per channel
+* * `ctype`: color type of the file (Truecolor, Grayscale, Palette ...)
+* * `frames`: additional info about frames (frame delays etc.)
+* * `tabs`: additional chunks of the PNG file
+* * `data`: pixel data of the image
+
+PNG files may have a various number of channels and a various color depth. The interpretation of `data` depends on the current color type and color depth (see the [PNG specification](https://www.w3.org/TR/PNG/)).
+
+#### `UPNG.toRGBA8(img)`
+* `img`: PNG image object (returned by UPNG.decode())
+* returns an array of frames. A frame is ArrayBuffer of the image in RGBA format, 8 bits per channel.
+
+### Example
+    let img  = UPNG.decode(buff);        // put ArrayBuffer of the PNG file into UPNG.decode
+    let rgba = UPNG.toRGBA8(img)[0];     // UPNG.toRGBA8 returns array of frames, size: width * height * 4 bytes.
+
+PNG format uses the Inflate algorithm. Right now, UPNG.js calls [@chr33s/pdf-common](https://github.com/chr33s/pdf/tree/main/packages/common) for the Inflate and Deflate method.
+
+## Quantizer
+
+UPNG.js contains a very good Quantizer of 4-component 8-bit vectors (i.e. pixels). It can be used to generate nice color palettes (e.g. Photopea uses UPNG.js to make palettes for GIF images).
+
+Quantization consists of two important steps: Finding a nice palette and Finding the closest color in the palette for each sample (non-trivial for large palettes). UPNG perfroms both steps.
+
+    let res  = UPNG.quantize(data, psize);
+
+* `data`: ArrayBuffer of samples (byte length is a multiple of four)
+* `psize` : Palette size (how many colors you want to have)
+
+The result object "res" has following properties:
+
+* `abuf`: ArrayBuffer corresponding to `data`, where colors are remapped by a palette
+* `inds`: Uint8Array : the index of a color for each sample (only when `psize`<=256)
+* `plte`: Array : the Palette - a list of colors, `plte[i].est.q` and `plte[i].est.rgba` is the color value
+
+### FAQ
+
+- To get one common palette for multiple images (e.g. frames of the animation), concatenate them into one array `data`.
+- When working with less than four components, set the remaining components to a constant value (e.g. to zero)
+- When working with transparency, premultiply color components by transparency (otherwise, rgba(1,1,1,0) would be closer to rgba(1,1,1,1) than to rgba(0,0,0,0) - transparent mapped to white instead of transparent)

package/dist/bin.d.ts

@@ -0,0 +1,12 @@
+export declare class Bin {
+    static nextZero(data: Uint8Array, p: number): number;
+    static readUshort(buff: Uint8Array, p: number): number;
+    static writeUshort(buff: Uint8Array, p: number, n: number): void;
+    static readUint(buff: Uint8Array, p: number): number;
+    static writeUint(buff: Uint8Array, p: number, n: number): void;
+    static readASCII(buff: Uint8Array, p: number, l: number): string;
+    static writeASCII(data: Uint8Array, p: number, s: string): void;
+    static readBytes(buff: Uint8Array, p: number, l: number): number[];
+    static pad(n: string): string;
+    static readUTF8(buff: Uint8Array, p: number, l: number): string;
+}

package/dist/bin.js

@@ -0,0 +1,56 @@
+export class Bin {
+    static nextZero(data, p) {
+        while (data[p] != 0)
+            p++;
+        return p;
+    }
+    static readUshort(buff, p) {
+        return (buff[p] << 8) | buff[p + 1];
+    }
+    static writeUshort(buff, p, n) {
+        buff[p] = (n >> 8) & 255;
+        buff[p + 1] = n & 255;
+    }
+    static readUint(buff, p) {
+        return buff[p] * (256 * 256 * 256) + ((buff[p + 1] << 16) | (buff[p + 2] << 8) | buff[p + 3]);
+    }
+    static 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;
+    }
+    static readASCII(buff, p, l) {
+        let s = "";
+        for (let i = 0; i < l; i++)
+            s += String.fromCharCode(buff[p + i]);
+        return s;
+    }
+    static writeASCII(data, p, s) {
+        for (let i = 0; i < s.length; i++)
+            data[p + i] = s.charCodeAt(i);
+    }
+    static readBytes(buff, p, l) {
+        const arr = [];
+        for (let i = 0; i < l; i++)
+            arr.push(buff[p + i]);
+        return arr;
+    }
+    static pad(n) {
+        return n.length < 2 ? "0" + n : n;
+    }
+    static readUTF8(buff, p, l) {
+        let s = "";
+        let ns;
+        for (let i = 0; i < l; i++)
+            s += "%" + Bin.pad(buff[p + i].toString(16));
+        try {
+            ns = decodeURIComponent(s);
+        }
+        catch {
+            return Bin.readASCII(buff, p, l);
+        }
+        return ns;
+    }
+}
+//# sourceMappingURL=bin.js.map

package/dist/bin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.js","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":"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"}

package/dist/crc.d.ts

@@ -0,0 +1,5 @@
+export declare class CRC {
+    static table: Uint32Array;
+    static update(c: number, buf: Uint8Array, off: number, len: number): number;
+    static crc(b: Uint8Array, o: number, l: number): number;
+}

package/dist/crc.js

@@ -0,0 +1,25 @@
+export class CRC {
+    static table = (function () {
+        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 = c >>> 1;
+            }
+            tab[n] = c;
+        }
+        return tab;
+    })();
+    static update(c, buf, off, len) {
+        for (let i = 0; i < len; i++)
+            c = CRC.table[(c ^ buf[off + i]) & 0xff] ^ (c >>> 8);
+        return c;
+    }
+    static crc(b, o, l) {
+        return CRC.update(0xffffffff, b, o, l) ^ 0xffffffff;
+    }
+}
+//# sourceMappingURL=crc.js.map

package/dist/crc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crc.js","sourceRoot":"","sources":["../src/crc.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;IACd,MAAM,CAAC,KAAK,GAAgB,CAAC;QAC3B,MAAM,GAAG,GAAG,IAAI,WAAW,CAAC,GAAG,CAAC,CAAC;QACjC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC;YAC7B,IAAI,CAAC,GAAG,CAAC,CAAC;YACV,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC3B,IAAI,CAAC,GAAG,CAAC;oBAAE,CAAC,GAAG,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;;oBACjC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;YACnB,CAAC;YACD,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QACb,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC,CAAC,EAAE,CAAC;IAEL,MAAM,CAAC,MAAM,CAAC,CAAS,EAAE,GAAe,EAAE,GAAW,EAAE,GAAW;QAChE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE;YAAE,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;QACnF,OAAO,CAAC,CAAC;IACX,CAAC;IAED,MAAM,CAAC,GAAG,CAAC,CAAa,EAAE,CAAS,EAAE,CAAS;QAC5C,OAAO,GAAG,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,UAAU,CAAC;IACtD,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { UPNG } from "./upng.js";
+export default UPNG;
+export * from "./upng.js";

package/dist/index.js

@@ -0,0 +1,4 @@
+import { UPNG } from "./upng.js";
+export default UPNG;
+export * from "./upng.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,eAAe,IAAI,CAAC;AACpB,cAAc,WAAW,CAAC"}

package/dist/inflator.d.ts

@@ -0,0 +1,39 @@
+export declare class Inflator {
+    static readonly D: InflatorTables;
+    static inflateRaw(o: Uint8Array, j?: Uint8Array): Uint8Array<ArrayBufferLike>;
+    static C_inner(o: number[], j: number): void;
+    static t_inner(o: number[], j: number, I: Uint16Array): void;
+    static H(o: Uint8Array, j: number): Uint8Array<ArrayBufferLike>;
+    static B(o: Uint16Array, j: number, I: number, A: Uint8Array, r: number, i: number[]): number;
+    static d(o: number[], j: number, I: number, A: number[]): number;
+}
+interface InflatorTables {
+    m: Uint16Array;
+    v: Uint16Array;
+    d: number[];
+    o: number[];
+    z: number[];
+    B: Uint16Array;
+    p: number[];
+    w: number[];
+    h: Uint32Array;
+    g: Uint16Array;
+    s: number[];
+    A: Uint16Array;
+    t: number[];
+    k: Uint16Array;
+    c: number[];
+    a: number[];
+    n: Uint16Array;
+    e: number[];
+    C: Uint16Array;
+    b: number[];
+    i: Uint16Array;
+    r: Uint32Array;
+    f: Uint32Array;
+    l: Uint32Array;
+    u: Uint32Array;
+    q: Uint16Array;
+    j: Uint16Array;
+}
+export {};

package/dist/inflator.js

@@ -0,0 +1,368 @@
+const createInflatorTables = () => {
+    const Uint16Ctor = Uint16Array;
+    const Uint32Ctor = Uint32Array;
+    const tables = {
+        m: new Uint16Ctor(16),
+        v: new Uint16Ctor(16),
+        d: [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15],
+        o: [
+            3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131,
+            163, 195, 227, 258, 999, 999, 999,
+        ],
+        z: [
+            0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0,
+            0,
+        ],
+        B: new Uint16Ctor(32),
+        p: [
+            1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537,
+            2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 65535, 65535,
+        ],
+        w: [
+            0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13,
+            13, 0, 0,
+        ],
+        h: new Uint32Ctor(32),
+        g: new Uint16Ctor(512),
+        s: [],
+        A: new Uint16Ctor(32),
+        t: [],
+        k: new Uint16Ctor(32768),
+        c: [],
+        a: [],
+        n: new Uint16Ctor(32768),
+        e: [],
+        C: new Uint16Ctor(512),
+        b: [],
+        i: new Uint16Ctor(1 << 15),
+        r: new Uint32Ctor(286),
+        f: new Uint32Ctor(30),
+        l: new Uint32Ctor(19),
+        u: new Uint32Ctor(15e3),
+        q: new Uint16Ctor(1 << 16),
+        j: new Uint16Ctor(1 << 15),
+    };
+    const assignCanonicalCodes = (values, maxBits) => {
+        const len = values.length;
+        const counts = tables.v;
+        let acc = 0;
+        for (let idx = 0; idx <= maxBits; idx++)
+            counts[idx] = 0;
+        for (let idx = 1; idx < len; idx += 2)
+            counts[values[idx]]++;
+        const starts = tables.m;
+        counts[0] = 0;
+        for (let bit = 1; bit <= maxBits; bit++) {
+            acc = (acc + counts[bit - 1]) << 1;
+            starts[bit] = acc;
+        }
+        for (let idx = 0; idx < len; idx += 2) {
+            const bitLength = values[idx + 1];
+            if (bitLength != 0) {
+                values[idx] = starts[bitLength];
+                starts[bitLength]++;
+            }
+        }
+    };
+    const buildLookupTable = (values, bits, target) => {
+        const len = values.length;
+        const bitReverse = tables.i;
+        for (let idx = 0; idx < len; idx += 2) {
+            const bitLength = values[idx + 1];
+            if (bitLength != 0) {
+                const symbol = idx >> 1;
+                const packed = (symbol << 4) | bitLength;
+                const remaining = bits - bitLength;
+                const start = values[idx] << remaining;
+                const end = start + (1 << remaining);
+                for (let code = start; code < end; code++) {
+                    const mapped = bitReverse[code] >>> (15 - bits);
+                    target[mapped] = packed;
+                }
+            }
+        }
+    };
+    const remapCodes = (values, bits) => {
+        const bitReverse = tables.i;
+        const shift = 15 - bits;
+        for (let idx = 0; idx < values.length; idx += 2) {
+            const mapped = values[idx] << (bits - values[idx + 1]);
+            values[idx] = bitReverse[mapped] >>> shift;
+        }
+    };
+    const appendPairs = (target, count, bitLength) => {
+        for (let idx = 0; idx < count; idx++) {
+            target.push(0, bitLength);
+        }
+    };
+    const tableSize = 1 << 15;
+    for (let idx = 0; idx < tableSize; idx++) {
+        let value = idx;
+        value = ((value & 2863311530) >>> 1) | ((value & 1431655765) << 1);
+        value = ((value & 3435973836) >>> 2) | ((value & 858993459) << 2);
+        value = ((value & 4042322160) >>> 4) | ((value & 252645135) << 4);
+        value = ((value & 4278255360) >>> 8) | ((value & 16711935) << 8);
+        tables.i[idx] = ((value >>> 16) | (value << 16)) >>> 17;
+    }
+    for (let idx = 0; idx < 32; idx++) {
+        tables.B[idx] = (tables.o[idx] << 3) | tables.z[idx];
+        tables.h[idx] = (tables.p[idx] << 4) | tables.w[idx];
+    }
+    appendPairs(tables.s, 144, 8);
+    appendPairs(tables.s, 255 - 143, 9);
+    appendPairs(tables.s, 279 - 255, 7);
+    appendPairs(tables.s, 287 - 279, 8);
+    assignCanonicalCodes(tables.s, 9);
+    buildLookupTable(tables.s, 9, tables.g);
+    remapCodes(tables.s, 9);
+    appendPairs(tables.t, 32, 5);
+    assignCanonicalCodes(tables.t, 5);
+    buildLookupTable(tables.t, 5, tables.A);
+    remapCodes(tables.t, 5);
+    appendPairs(tables.b, 19, 0);
+    appendPairs(tables.c, 286, 0);
+    appendPairs(tables.e, 30, 0);
+    appendPairs(tables.a, 320, 0);
+    return tables;
+};
+export class Inflator {
+    static D = createInflatorTables();
+    static inflateRaw(o, j) {
+        const D = Inflator.D;
+        function F(o, j, I) {
+            return ((o[j >>> 3] | (o[(j >>> 3) + 1] << 8)) >>> (j & 7)) & ((1 << I) - 1);
+        }
+        function s(o, j, I) {
+            return (((o[j >>> 3] | (o[(j >>> 3) + 1] << 8) | (o[(j >>> 3) + 2] << 16)) >>> (j & 7)) &
+                ((1 << I) - 1));
+        }
+        function w(o, j) {
+            return (o[j >>> 3] | (o[(j >>> 3) + 1] << 8) | (o[(j >>> 3) + 2] << 16)) >>> (j & 7);
+        }
+        const I = Uint8Array;
+        let r = 0;
+        let i = 0;
+        let y = 0;
+        let G = 0;
+        let f = 0;
+        let a = 0;
+        let k = 0;
+        let N = 0;
+        let x = 0;
+        let P;
+        let J;
+        if (o[0] == 3 && o[1] == 0)
+            return j ? j : new I(0);
+        const A = j == null;
+        if (A)
+            j = new I((o.length >>> 2) << 3);
+        let j_arr = j;
+        while (r == 0) {
+            r = s(o, x, 1);
+            i = s(o, x + 1, 2);
+            x += 3;
+            if (i == 0) {
+                if ((x & 7) != 0)
+                    x += 8 - (x & 7);
+                const K = (x >>> 3) + 4;
+                const m = o[K - 4] | (o[K - 3] << 8);
+                if (A)
+                    j_arr = Inflator.H(j_arr, N + m);
+                j_arr.set(new I(o.buffer, o.byteOffset + K, m), N);
+                x = (K + m) << 3;
+                N += m;
+                continue;
+            }
+            if (A)
+                j_arr = Inflator.H(j_arr, N + (1 << 17));
+            if (i == 1) {
+                P = D.g;
+                J = D.A;
+                a = (1 << 9) - 1;
+                k = (1 << 5) - 1;
+            }
+            if (i == 2) {
+                y = F(o, x, 5) + 257;
+                G = F(o, x + 5, 5) + 1;
+                f = F(o, x + 10, 4) + 4;
+                x += 14;
+                let Q = 1;
+                for (let p = 0; p < 38; p += 2) {
+                    D.b[p] = 0;
+                    D.b[p + 1] = 0;
+                }
+                for (let p = 0; p < f; p++) {
+                    const l = F(o, x + p * 3, 3);
+                    D.b[(D.d[p] << 1) + 1] = l;
+                    if (l > Q)
+                        Q = l;
+                }
+                x += 3 * f;
+                Inflator.C_inner(D.b, Q);
+                Inflator.t_inner(D.b, Q, D.C);
+                P = D.k;
+                J = D.n;
+                x = Inflator.B(D.C, (1 << Q) - 1, y + G, o, x, D.a);
+                const u = Inflator.d(D.a, 0, y, D.c);
+                a = (1 << u) - 1;
+                const n = Inflator.d(D.a, y, G, D.e);
+                k = (1 << n) - 1;
+                Inflator.C_inner(D.c, u);
+                Inflator.t_inner(D.c, u, P);
+                Inflator.C_inner(D.e, n);
+                Inflator.t_inner(D.e, n, J);
+            }
+            for (;;) {
+                const h = P[w(o, x) & a];
+                x += h & 15;
+                const L = h >>> 4;
+                if (L >>> 8 == 0) {
+                    j_arr[N++] = L;
+                }
+                else if (L == 256) {
+                    break;
+                }
+                else {
+                    let M = N + L - 254;
+                    if (L > 264) {
+                        const z = D.B[L - 257];
+                        M = N + (z >>> 3) + F(o, x, z & 7);
+                        x += z & 7;
+                    }
+                    const e = J[w(o, x) & k];
+                    x += e & 15;
+                    const E = e >>> 4;
+                    const c = D.h[E];
+                    const q = (c >>> 4) + s(o, x, c & 15);
+                    x += c & 15;
+                    if (A)
+                        j_arr = Inflator.H(j_arr, N + (1 << 17));
+                    while (N < M) {
+                        j_arr[N] = j_arr[N++ - q];
+                        j_arr[N] = j_arr[N++ - q];
+                        j_arr[N] = j_arr[N++ - q];
+                        j_arr[N] = j_arr[N++ - q];
+                    }
+                    N = M;
+                }
+            }
+        }
+        return j_arr.length == N ? j_arr : j_arr.slice(0, N);
+    }
+    static C_inner(o, j) {
+        const D = Inflator.D;
+        const I = o.length;
+        const f = D.v;
+        let A;
+        let r;
+        let i;
+        let y;
+        let G;
+        for (y = 0; y <= j; y++)
+            f[y] = 0;
+        for (y = 1; y < I; y += 2)
+            f[o[y]]++;
+        const a = D.m;
+        A = 0;
+        f[0] = 0;
+        for (r = 1; r <= j; r++) {
+            A = (A + f[r - 1]) << 1;
+            a[r] = A;
+        }
+        for (i = 0; i < I; i += 2) {
+            G = o[i + 1];
+            if (G != 0) {
+                o[i] = a[G];
+                a[G]++;
+            }
+        }
+    }
+    static t_inner(o, j, I) {
+        const D = Inflator.D;
+        const A = o.length;
+        const r = D.i;
+        for (let i = 0; i < A; i += 2)
+            if (o[i + 1] != 0) {
+                let y = i >> 1;
+                let G = o[i + 1];
+                let f = (y << 4) | G;
+                let a = j - G;
+                let k = o[i] << a;
+                const N = k + (1 << a);
+                while (k != N) {
+                    const x = r[k] >>> (15 - j);
+                    I[x] = f;
+                    k++;
+                }
+            }
+    }
+    static H(o, j) {
+        const I = o.length;
+        if (j <= I)
+            return o;
+        const A = new Uint8Array(Math.max(I << 1, j));
+        A.set(o, 0);
+        return A;
+    }
+    static B(o, j, I, A, r, i) {
+        function w(o, j) {
+            return (o[j >>> 3] | (o[(j >>> 3) + 1] << 8) | (o[(j >>> 3) + 2] << 16)) >>> (j & 7);
+        }
+        function F(o, j, I) {
+            return ((o[j >>> 3] | (o[(j >>> 3) + 1] << 8)) >>> (j & 7)) & ((1 << I) - 1);
+        }
+        let y = 0;
+        while (y < I) {
+            const G = o[w(A, r) & j];
+            r += G & 15;
+            const f = G >>> 4;
+            if (f <= 15) {
+                i[y] = f;
+                y++;
+            }
+            else {
+                let a = 0;
+                let k = 0;
+                if (f == 16) {
+                    k = 3 + F(A, r, 2);
+                    r += 2;
+                    a = i[y - 1];
+                }
+                else if (f == 17) {
+                    k = 3 + F(A, r, 3);
+                    r += 3;
+                }
+                else if (f == 18) {
+                    k = 11 + F(A, r, 7);
+                    r += 7;
+                }
+                const N = y + k;
+                while (y < N) {
+                    i[y] = a;
+                    y++;
+                }
+            }
+        }
+        return r;
+    }
+    static d(o, j, I, A) {
+        let r = 0;
+        let i = 0;
+        const y = A.length >>> 1;
+        while (i < I) {
+            const G = o[i + j];
+            A[i << 1] = 0;
+            A[(i << 1) + 1] = G;
+            if (G > r)
+                r = G;
+            i++;
+        }
+        while (i < y) {
+            A[i << 1] = 0;
+            A[(i << 1) + 1] = 0;
+            i++;
+        }
+        return r;
+    }
+}
+//# sourceMappingURL=inflator.js.map