{"version":3,"file":"static/chunks/3f2dd09b-d4e638efc4c1991b.js","mappings":"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","sources":["webpack://_N_E/./node_modules/@datadog/browser-rum/esm/domain/segmentCollection/deflateWorker.js"],"sourcesContent":["var workerURL;\nexport function createDeflateWorker() {\n    // Lazily compute the worker URL to allow importing the SDK in NodeJS\n    if (!workerURL) {\n        workerURL = URL.createObjectURL(new Blob([\"(\".concat(workerCodeFn, \")(self)\")]));\n    }\n    return new Worker(workerURL);\n}\nfunction workerCodeFn() {\n    monitor(function () {\n        var _a = makePakoDeflate(), Deflate = _a.Deflate, constants = _a.constants, string2buf = _a.string2buf;\n        var deflate = new Deflate();\n        var rawBytesCount = 0;\n        self.addEventListener('message', monitor(function (event) {\n            var data = event.data;\n            switch (data.action) {\n                case 'init':\n                    self.postMessage({\n                        type: 'initialized',\n                    });\n                    break;\n                case 'write': {\n                    var additionalBytesCount = pushData(data.data);\n                    self.postMessage({\n                        type: 'wrote',\n                        id: data.id,\n                        compressedBytesCount: deflate.chunks.reduce(function (total, chunk) { return total + chunk.length; }, 0),\n                        additionalBytesCount: additionalBytesCount,\n                    });\n                    break;\n                }\n                case 'flush': {\n                    var additionalBytesCount = data.data ? pushData(data.data) : 0;\n                    deflate.push('', constants.Z_FINISH);\n                    self.postMessage({\n                        type: 'flushed',\n                        id: data.id,\n                        result: deflate.result,\n                        additionalBytesCount: additionalBytesCount,\n                        rawBytesCount: rawBytesCount,\n                    });\n                    deflate = new Deflate();\n                    rawBytesCount = 0;\n                    break;\n                }\n            }\n        }));\n        function pushData(data) {\n            // TextEncoder is not supported on old browser version like Edge 18, therefore we use string2buf\n            var binaryData = string2buf(data);\n            deflate.push(binaryData, constants.Z_SYNC_FLUSH);\n            rawBytesCount += binaryData.length;\n            return binaryData.length;\n        }\n    })();\n    function monitor(fn) {\n        return function () {\n            try {\n                return fn.apply(this, arguments);\n            }\n            catch (e) {\n                try {\n                    self.postMessage({\n                        type: 'errored',\n                        error: e,\n                    });\n                }\n                catch (_) {\n                    // DATA_CLONE_ERR, cf https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm\n                    self.postMessage({\n                        type: 'errored',\n                        error: \"\".concat(e),\n                    });\n                }\n            }\n        };\n    }\n    // https://github.com/nodeca/pako/blob/034669ba0f1a4c0590e45f7c2820128200f972b3/dist/pako_deflate.es5.js\n    function makePakoDeflate() {\n        /* eslint-disable camelcase, no-bitwise */\n        // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n        //\n        // This software is provided 'as-is', without any express or implied\n        // warranty. In no event will the authors be held liable for any damages\n        // arising from the use of this software.\n        //\n        // Permission is granted to anyone to use this software for any purpose,\n        // including commercial applications, and to alter it and redistribute it\n        // freely, subject to the following restrictions:\n        //\n        // 1. The origin of this software must not be misrepresented; you must not\n        //   claim that you wrote the original software. If you use this software\n        //   in a product, an acknowledgment in the product documentation would be\n        //   appreciated but is not required.\n        // 2. Altered source versions must be plainly marked as such, and must not be\n        //   misrepresented as being the original software.\n        // 3. This notice may not be removed or altered from any source distribution.\n        /* Public constants ========================================================== */\n        /* =========================================================================== */\n        // const Z_FILTERED          = 1;\n        // const Z_HUFFMAN_ONLY      = 2;\n        // const Z_RLE               = 3;\n        var Z_FIXED = 4; // const Z_DEFAULT_STRATEGY  = 0;\n        /* Possible values of the data_type field (though see inflate()) */\n        var Z_BINARY = 0;\n        var Z_TEXT = 1; // const Z_ASCII             = 1; // = Z_TEXT\n        var Z_UNKNOWN = 2;\n        /* ============================================================================ */\n        function zero(buf) {\n            var len = buf.length;\n            while (--len >= 0) {\n                buf[len] = 0;\n            }\n        } // From zutil.h\n        var STORED_BLOCK = 0;\n        var STATIC_TREES = 1;\n        var DYN_TREES = 2;\n        /* The three kinds of block type */\n        var MIN_MATCH = 3;\n        var MAX_MATCH = 258;\n        /* The minimum and maximum match lengths */\n        // From deflate.h\n        /* ===========================================================================\n         * Internal compression state.\n         */\n        var LENGTH_CODES = 29;\n        /* number of length codes, not counting the special END_BLOCK code */\n        var LITERALS = 256;\n        /* number of literal bytes 0..255 */\n        var L_CODES = LITERALS + 1 + LENGTH_CODES;\n        /* number of Literal or Length codes, including the END_BLOCK code */\n        var D_CODES = 30;\n        /* number of distance codes */\n        var BL_CODES = 19;\n        /* number of codes used to transfer the bit lengths */\n        var HEAP_SIZE = 2 * L_CODES + 1;\n        /* maximum heap size */\n        var MAX_BITS = 15;\n        /* All codes must not exceed MAX_BITS bits */\n        var Buf_size = 16;\n        /* size of bit buffer in bi_buf */\n        /* ===========================================================================\n         * Constants\n         */\n        var MAX_BL_BITS = 7;\n        /* Bit length codes must not exceed MAX_BL_BITS bits */\n        var END_BLOCK = 256;\n        /* end of block literal code */\n        var REP_3_6 = 16;\n        /* repeat previous bit length 3-6 times (2 bits of repeat count) */\n        var REPZ_3_10 = 17;\n        /* repeat a zero length 3-10 times  (3 bits of repeat count) */\n        var REPZ_11_138 = 18;\n        /* repeat a zero length 11-138 times  (7 bits of repeat count) */\n        var extra_lbits = \n        /* extra bits for each length code */\n        new Uint8Array([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]);\n        var extra_dbits = \n        /* extra bits for each distance code */\n        new Uint8Array([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]);\n        var extra_blbits = \n        /* extra bits for each bit length code */\n        new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7]);\n        var bl_order = new Uint8Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);\n        /* eslint-enable comma-spacing,array-bracket-spacing */\n        /* The lengths of the bit length codes are sent in order of decreasing\n         * probability, to avoid transmitting the lengths for unused bit length codes.\n         */\n        /* ===========================================================================\n         * Local data. These are initialized only once.\n         */\n        // We pre-fill arrays with 0 to avoid uninitialized gaps\n        var DIST_CODE_LEN = 512;\n        /* see definition of array dist_code below */\n        // !!!! Use flat array instead of structure, Freq = i*2, Len = i*2+1\n        var static_ltree = new Array((L_CODES + 2) * 2);\n        zero(static_ltree);\n        /* The static literal tree. Since the bit lengths are imposed, there is no\n         * need for the L_CODES extra codes used during heap construction. However\n         * The codes 286 and 287 are needed to build a canonical tree (see _tr_init\n         * below).\n         */\n        var static_dtree = new Array(D_CODES * 2);\n        zero(static_dtree);\n        /* The static distance tree. (Actually a trivial tree since all codes use\n         * 5 bits.)\n         */\n        var _dist_code = new Array(DIST_CODE_LEN);\n        zero(_dist_code);\n        /* Distance codes. The first 256 values correspond to the distances\n         * 3 .. 258, the last 256 values correspond to the top 8 bits of\n         * the 15 bit distances.\n         */\n        var _length_code = new Array(MAX_MATCH - MIN_MATCH + 1);\n        zero(_length_code);\n        /* length code for each normalized match length (0 == MIN_MATCH) */\n        var base_length = new Array(LENGTH_CODES);\n        zero(base_length);\n        /* First normalized length for each code (0 = MIN_MATCH) */\n        var base_dist = new Array(D_CODES);\n        zero(base_dist);\n        /* First normalized distance for each code (0 = distance of 1) */\n        function StaticTreeDesc(static_tree, extra_bits, extra_base, elems, max_length) {\n            this.static_tree = static_tree;\n            /* static tree or NULL */\n            this.extra_bits = extra_bits;\n            /* extra bits for each code or NULL */\n            this.extra_base = extra_base;\n            /* base index for extra_bits */\n            this.elems = elems;\n            /* max number of elements in the tree */\n            this.max_length = max_length;\n            /* max bit length for the codes */\n            // show if `static_tree` has data or dummy - needed for monomorphic objects\n            this.has_stree = static_tree && static_tree.length;\n        }\n        var static_l_desc;\n        var static_d_desc;\n        var static_bl_desc;\n        function TreeDesc(dyn_tree, stat_desc) {\n            this.dyn_tree = dyn_tree;\n            /* the dynamic tree */\n            this.max_code = 0;\n            /* largest code with non zero frequency */\n            this.stat_desc = stat_desc;\n            /* the corresponding static tree */\n        }\n        var d_code = function d_code(dist) {\n            return dist < 256 ? _dist_code[dist] : _dist_code[256 + (dist >>> 7)];\n        };\n        /* ===========================================================================\n         * Output a short LSB first on the stream.\n         * IN assertion: there is enough room in pendingBuf.\n         */\n        var put_short = function put_short(s, w) {\n            //    put_byte(s, (uch)((w) & 0xff));\n            //    put_byte(s, (uch)((ush)(w) >> 8));\n            s.pending_buf[s.pending++] = w & 0xff;\n            s.pending_buf[s.pending++] = (w >>> 8) & 0xff;\n        };\n        /* ===========================================================================\n         * Send a value on a given number of bits.\n         * IN assertion: length <= 16 and value fits in length bits.\n         */\n        var send_bits = function send_bits(s, value, length) {\n            if (s.bi_valid > Buf_size - length) {\n                s.bi_buf |= (value << s.bi_valid) & 0xffff;\n                put_short(s, s.bi_buf);\n                s.bi_buf = value >> (Buf_size - s.bi_valid);\n                s.bi_valid += length - Buf_size;\n            }\n            else {\n                s.bi_buf |= (value << s.bi_valid) & 0xffff;\n                s.bi_valid += length;\n            }\n        };\n        var send_code = function send_code(s, c, tree) {\n            send_bits(s, tree[c * 2], \n            /* .Code */\n            tree[c * 2 + 1]\n            /* .Len */\n            );\n        };\n        /* ===========================================================================\n         * Reverse the first len bits of a code, using straightforward code (a faster\n         * method would use a table)\n         * IN assertion: 1 <= len <= 15\n         */\n        var bi_reverse = function bi_reverse(code, len) {\n            var res = 0;\n            do {\n                res |= code & 1;\n                code >>>= 1;\n                res <<= 1;\n            } while (--len > 0);\n            return res >>> 1;\n        };\n        /* ===========================================================================\n         * Flush the bit buffer, keeping at most 7 bits in it.\n         */\n        var bi_flush = function bi_flush(s) {\n            if (s.bi_valid === 16) {\n                put_short(s, s.bi_buf);\n                s.bi_buf = 0;\n                s.bi_valid = 0;\n            }\n            else if (s.bi_valid >= 8) {\n                s.pending_buf[s.pending++] = s.bi_buf & 0xff;\n                s.bi_buf >>= 8;\n                s.bi_valid -= 8;\n            }\n        };\n        /* ===========================================================================\n         * Compute the optimal bit lengths for a tree and update the total bit length\n         * for the current block.\n         * IN assertion: the fields freq and dad are set, heap[heap_max] and\n         *    above are the tree nodes sorted by increasing frequency.\n         * OUT assertions: the field len is set to the optimal bit length, the\n         *     array bl_count contains the frequencies for each bit length.\n         *     The length opt_len is updated; static_len is also updated if stree is\n         *     not null.\n         */\n        var gen_bitlen = function gen_bitlen(s, desc //    deflate_state *s; //    tree_desc *desc;    /* the tree descriptor */\n        ) {\n            var tree = desc.dyn_tree;\n            var max_code = desc.max_code;\n            var stree = desc.stat_desc.static_tree;\n            var has_stree = desc.stat_desc.has_stree;\n            var extra = desc.stat_desc.extra_bits;\n            var base = desc.stat_desc.extra_base;\n            var max_length = desc.stat_desc.max_length;\n            var h;\n            /* heap index */\n            var n;\n            var m;\n            /* iterate over the tree elements */\n            var bits;\n            /* bit length */\n            var xbits;\n            /* extra bits */\n            var f;\n            /* frequency */\n            var overflow = 0;\n            /* number of elements with bit length too large */\n            for (bits = 0; bits <= MAX_BITS; bits++) {\n                s.bl_count[bits] = 0;\n            }\n            /* In a first pass, compute the optimal bit lengths (which may\n             * overflow in the case of the bit length tree).\n             */\n            tree[s.heap[s.heap_max] * 2 + 1] =\n                /* .Len */\n                0;\n            /* root of the heap */\n            for (h = s.heap_max + 1; h < HEAP_SIZE; h++) {\n                n = s.heap[h];\n                bits =\n                    tree[tree[n * 2 + 1] *\n                        /* .Dad */\n                        2 +\n                        1] +\n                        /* .Len */\n                        1;\n                if (bits > max_length) {\n                    bits = max_length;\n                    overflow++;\n                }\n                tree[n * 2 + 1] =\n                    /* .Len */\n                    bits;\n                /* We overwrite tree[n].Dad which is no longer needed */\n                if (n > max_code) {\n                    continue;\n                }\n                /* not a leaf node */\n                s.bl_count[bits]++;\n                xbits = 0;\n                if (n >= base) {\n                    xbits = extra[n - base];\n                }\n                f = tree[n * 2];\n                /* .Freq */\n                s.opt_len += f * (bits + xbits);\n                if (has_stree) {\n                    s.static_len +=\n                        f *\n                            (stree[n * 2 + 1] +\n                                /* .Len */\n                                xbits);\n                }\n            }\n            if (overflow === 0) {\n                return;\n            } // Trace((stderr,\"\\nbit length overflow\\n\"));\n            /* This happens for example on obj2 and pic of the Calgary corpus */\n            /* Find the first bit length which could increase: */\n            do {\n                bits = max_length - 1;\n                while (s.bl_count[bits] === 0) {\n                    bits--;\n                }\n                s.bl_count[bits]--;\n                /* move one leaf down the tree */\n                s.bl_count[bits + 1] += 2;\n                /* move one overflow item as its brother */\n                s.bl_count[max_length]--;\n                /* The brother of the overflow item also moves one step up,\n                 * but this does not affect bl_count[max_length]\n                 */\n                overflow -= 2;\n            } while (overflow > 0);\n            /* Now recompute all bit lengths, scanning in increasing frequency.\n             * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all\n             * lengths instead of fixing only the wrong ones. This idea is taken\n             * from 'ar' written by Haruhiko Okumura.)\n             */\n            for (bits = max_length; bits !== 0; bits--) {\n                n = s.bl_count[bits];\n                while (n !== 0) {\n                    m = s.heap[--h];\n                    if (m > max_code) {\n                        continue;\n                    }\n                    if (tree[m * 2 + 1] !==\n                        /* .Len */\n                        bits) {\n                        // Trace((stderr,\"code %d bits %d->%d\\n\", m, tree[m].Len, bits));\n                        s.opt_len +=\n                            (bits - tree[m * 2 + 1]) *\n                                /* .Len */\n                                tree[m * 2];\n                        /* .Freq */\n                        tree[m * 2 + 1] =\n                            /* .Len */\n                            bits;\n                    }\n                    n--;\n                }\n            }\n        };\n        /* ===========================================================================\n         * Generate the codes for a given tree and bit counts (which need not be\n         * optimal).\n         * IN assertion: the array bl_count contains the bit length statistics for\n         * the given tree and the field len is set for all tree elements.\n         * OUT assertion: the field code is set for all tree elements of non\n         *     zero code length.\n         */\n        var gen_codes = function gen_codes(tree, max_code, bl_count\n        //    ct_data *tree;             /* the tree to decorate */\n        //    int max_code;              /* largest code with non zero frequency */\n        //    ushf *bl_count;            /* number of codes at each bit length */\n        ) {\n            var next_code = new Array(MAX_BITS + 1);\n            /* next code value for each bit length */\n            var code = 0;\n            /* running code value */\n            var bits;\n            /* bit index */\n            var n;\n            /* code index */\n            /* The distribution counts are first used to generate the code values\n             * without bit reversal.\n             */\n            for (bits = 1; bits <= MAX_BITS; bits++) {\n                next_code[bits] = code = (code + bl_count[bits - 1]) << 1;\n            }\n            /* Check that the bit counts in bl_count are consistent. The last code\n             * must be all ones.\n             */\n            // Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,\n            //        \"inconsistent bit counts\");\n            // Tracev((stderr,\"\\ngen_codes: max_code %d \", max_code));\n            for (n = 0; n <= max_code; n++) {\n                var len = tree[n * 2 + 1];\n                /* .Len */\n                if (len === 0) {\n                    continue;\n                }\n                /* Now reverse the bits */\n                tree[n * 2] =\n                    /* .Code */\n                    bi_reverse(next_code[len]++, len); // Tracecv(tree != static_ltree, (stderr,\"\\nn %3d %c l %2d c %4x (%x) \",\n                //     n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));\n            }\n        };\n        /* ===========================================================================\n         * Initialize the various 'constant' tables.\n         */\n        var tr_static_init = function tr_static_init() {\n            var n;\n            /* iterates over tree elements */\n            var bits;\n            /* bit counter */\n            var length;\n            /* length value */\n            var code;\n            /* code value */\n            var dist;\n            /* distance index */\n            var bl_count = new Array(MAX_BITS + 1);\n            /* number of codes at each bit length for an optimal tree */\n            // do check in _tr_init()\n            // if (static_init_done) return;\n            /* For some embedded targets, global variables are not initialized: */\n            /* #ifdef NO_INIT_GLOBAL_POINTERS\n            static_l_desc.static_tree = static_ltree;\n            static_l_desc.extra_bits = extra_lbits;\n            static_d_desc.static_tree = static_dtree;\n            static_d_desc.extra_bits = extra_dbits;\n            static_bl_desc.extra_bits = extra_blbits;\n          #endif */\n            /* Initialize the mapping length (0..255) -> length code (0..28) */\n            length = 0;\n            for (code = 0; code < LENGTH_CODES - 1; code++) {\n                base_length[code] = length;\n                for (n = 0; n < 1 << extra_lbits[code]; n++) {\n                    _length_code[length++] = code;\n                }\n            } // Assert (length == 256, \"tr_static_init: length != 256\");\n            /* Note that the length 255 (match length 258) can be represented\n             * in two different ways: code 284 + 5 bits or code 285, so we\n             * overwrite length_code[255] to use the best encoding:\n             */\n            _length_code[length - 1] = code;\n            /* Initialize the mapping dist (0..32K) -> dist code (0..29) */\n            dist = 0;\n            for (code = 0; code < 16; code++) {\n                base_dist[code] = dist;\n                for (n = 0; n < 1 << extra_dbits[code]; n++) {\n                    _dist_code[dist++] = code;\n                }\n            } // Assert (dist == 256, \"tr_static_init: dist != 256\");\n            dist >>= 7;\n            /* from now on, all distances are divided by 128 */\n            for (; code < D_CODES; code++) {\n                base_dist[code] = dist << 7;\n                for (n = 0; n < 1 << (extra_dbits[code] - 7); n++) {\n                    _dist_code[256 + dist++] = code;\n                }\n            } // Assert (dist == 256, \"tr_static_init: 256+dist != 512\");\n            /* Construct the codes of the static literal tree */\n            for (bits = 0; bits <= MAX_BITS; bits++) {\n                bl_count[bits] = 0;\n            }\n            n = 0;\n            while (n <= 143) {\n                static_ltree[n * 2 + 1] =\n                    /* .Len */\n                    8;\n                n++;\n                bl_count[8]++;\n            }\n            while (n <= 255) {\n                static_ltree[n * 2 + 1] =\n                    /* .Len */\n                    9;\n                n++;\n                bl_count[9]++;\n            }\n            while (n <= 279) {\n                static_ltree[n * 2 + 1] =\n                    /* .Len */\n                    7;\n                n++;\n                bl_count[7]++;\n            }\n            while (n <= 287) {\n                static_ltree[n * 2 + 1] =\n                    /* .Len */\n                    8;\n                n++;\n                bl_count[8]++;\n            }\n            /* Codes 286 and 287 do not exist, but we must include them in the\n             * tree construction to get a canonical Huffman tree (longest code\n             * all ones)\n             */\n            gen_codes(static_ltree, L_CODES + 1, bl_count);\n            /* The static distance tree is trivial: */\n            for (n = 0; n < D_CODES; n++) {\n                static_dtree[n * 2 + 1] =\n                    /* .Len */\n                    5;\n                static_dtree[n * 2] =\n                    /* .Code */\n                    bi_reverse(n, 5);\n            } // Now data ready and we can init static trees\n            static_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, LITERALS + 1, L_CODES, MAX_BITS);\n            static_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0, D_CODES, MAX_BITS);\n            static_bl_desc = new StaticTreeDesc(new Array(0), extra_blbits, 0, BL_CODES, MAX_BL_BITS);\n            // static_init_done = true;\n        };\n        /* ===========================================================================\n         * Initialize a new block.\n         */\n        var init_block = function init_block(s) {\n            var n;\n            /* iterates over tree elements */\n            /* Initialize the trees. */\n            for (n = 0; n < L_CODES; n++) {\n                s.dyn_ltree[n * 2] =\n                    /* .Freq */\n                    0;\n            }\n            for (n = 0; n < D_CODES; n++) {\n                s.dyn_dtree[n * 2] =\n                    /* .Freq */\n                    0;\n            }\n            for (n = 0; n < BL_CODES; n++) {\n                s.bl_tree[n * 2] =\n                    /* .Freq */\n                    0;\n            }\n            s.dyn_ltree[END_BLOCK * 2] =\n                /* .Freq */\n                1;\n            s.opt_len = s.static_len = 0;\n            s.last_lit = s.matches = 0;\n        };\n        /* ===========================================================================\n         * Flush the bit buffer and align the output on a byte boundary\n         */\n        var bi_windup = function bi_windup(s) {\n            if (s.bi_valid > 8) {\n                put_short(s, s.bi_buf);\n            }\n            else if (s.bi_valid > 0) {\n                // put_byte(s, (Byte)s->bi_buf);\n                s.pending_buf[s.pending++] = s.bi_buf;\n            }\n            s.bi_buf = 0;\n            s.bi_valid = 0;\n        };\n        /* ===========================================================================\n         * Copy a stored block, storing first the length and its\n         * one's complement if requested.\n         */\n        var copy_block = function copy_block(s, buf, len, header\n        // DeflateState *s;\n        // charf    *buf;    /* the input data */\n        // unsigned len;     /* its length */\n        // int      header;  /* true if block header must be written */\n        ) {\n            bi_windup(s);\n            /* align on byte boundary */\n            if (header) {\n                put_short(s, len);\n                put_short(s, ~len);\n            }\n            //  while (len--) {\n            //    put_byte(s, *buf++);\n            //  }\n            s.pending_buf.set(s.window.subarray(buf, buf + len), s.pending);\n            s.pending += len;\n        };\n        /* ===========================================================================\n         * Compares to subtrees, using the tree depth as tie breaker when\n         * the subtrees have equal frequency. This minimizes the worst case length.\n         */\n        var smaller = function smaller(tree, n, m, depth) {\n            var _n2 = n * 2;\n            var _m2 = m * 2;\n            return (tree[_n2] <\n                /* .Freq */\n                tree[_m2] ||\n                /* .Freq */\n                (tree[_n2] ===\n                    /* .Freq */\n                    tree[_m2] &&\n                    /* .Freq */\n                    depth[n] <= depth[m]));\n        };\n        /* ===========================================================================\n         * Restore the heap property by moving down the tree starting at node k,\n         * exchanging a node with the smallest of its two sons if necessary, stopping\n         * when the heap property is re-established (each father smaller than its\n         * two sons).\n         */\n        var pqdownheap = function pqdownheap(s, tree, k\n        //    deflate_state *s;\n        //    ct_data *tree;  /* the tree to restore */\n        //    int k;               /* node to move down */\n        ) {\n            var v = s.heap[k];\n            var j = k << 1;\n            /* left son of k */\n            while (j <= s.heap_len) {\n                /* Set j to the smallest of the two sons: */\n                if (j < s.heap_len && smaller(tree, s.heap[j + 1], s.heap[j], s.depth)) {\n                    j++;\n                }\n                /* Exit if v is smaller than both sons */\n                if (smaller(tree, v, s.heap[j], s.depth)) {\n                    break;\n                }\n                /* Exchange v with the smallest son */\n                s.heap[k] = s.heap[j];\n                k = j;\n                /* And continue down the tree, setting j to the left son of k */\n                j <<= 1;\n            }\n            s.heap[k] = v;\n        }; // inlined manually\n        // const SMALLEST = 1;\n        /* ===========================================================================\n         * Send the block data compressed using the given Huffman trees\n         */\n        var compress_block = function compress_block(s, ltree, dtree\n        //    deflate_state *s;\n        //    const ct_data *ltree; /* literal tree */\n        //    const ct_data *dtree; /* distance tree */\n        ) {\n            var dist;\n            /* distance of matched string */\n            var lc;\n            /* match length or unmatched char (if dist == 0) */\n            var lx = 0;\n            /* running index in l_buf */\n            var code;\n            /* the code to send */\n            var extra;\n            /* number of extra bits to send */\n            if (s.last_lit !== 0) {\n                do {\n                    dist = (s.pending_buf[s.d_buf + lx * 2] << 8) | s.pending_buf[s.d_buf + lx * 2 + 1];\n                    lc = s.pending_buf[s.l_buf + lx];\n                    lx++;\n                    if (dist === 0) {\n                        send_code(s, lc, ltree);\n                        /* send a literal byte */\n                        // Tracecv(isgraph(lc), (stderr,\" '%c' \", lc));\n                    }\n                    else {\n                        /* Here, lc is the match length - MIN_MATCH */\n                        code = _length_code[lc];\n                        send_code(s, code + LITERALS + 1, ltree);\n                        /* send the length code */\n                        extra = extra_lbits[code];\n                        if (extra !== 0) {\n                            lc -= base_length[code];\n                            send_bits(s, lc, extra);\n                            /* send the extra length bits */\n                        }\n                        dist--;\n                        /* dist is now the match distance - 1 */\n                        code = d_code(dist); // Assert (code < D_CODES, \"bad d_code\");\n                        send_code(s, code, dtree);\n                        /* send the distance code */\n                        extra = extra_dbits[code];\n                        if (extra !== 0) {\n                            dist -= base_dist[code];\n                            send_bits(s, dist, extra);\n                            /* send the extra distance bits */\n                        }\n                    }\n                    /* literal or match pair ? */\n                    /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */\n                    // Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx,\n                    //       \"pendingBuf overflow\");\n                } while (lx < s.last_lit);\n            }\n            send_code(s, END_BLOCK, ltree);\n        };\n        /* ===========================================================================\n         * Construct one Huffman tree and assigns the code bit strings and lengths.\n         * Update the total bit length for the current block.\n         * IN assertion: the field freq is set for all tree elements.\n         * OUT assertions: the fields len and code are set to the optimal bit length\n         *     and corresponding code. The length opt_len is updated; static_len is\n         *     also updated if stree is not null. The field max_code is set.\n         */\n        var build_tree = function build_tree(s, desc //    deflate_state *s; //    tree_desc *desc; /* the tree descriptor */\n        ) {\n            var tree = desc.dyn_tree;\n            var stree = desc.stat_desc.static_tree;\n            var has_stree = desc.stat_desc.has_stree;\n            var elems = desc.stat_desc.elems;\n            var n;\n            var m;\n            /* iterate over heap elements */\n            var max_code = -1;\n            /* largest code with non zero frequency */\n            var node;\n            /* new node being created */\n            /* Construct the initial heap, with least frequent element in\n             * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].\n             * heap[0] is not used.\n             */\n            s.heap_len = 0;\n            s.heap_max = HEAP_SIZE;\n            for (n = 0; n < elems; n++) {\n                if (tree[n * 2] !==\n                    /* .Freq */\n                    0) {\n                    s.heap[++s.heap_len] = max_code = n;\n                    s.depth[n] = 0;\n                }\n                else {\n                    tree[n * 2 + 1] =\n                        /* .Len */\n                        0;\n                }\n            }\n            /* The pkzip format requires that at least one distance code exists,\n             * and that at least one bit should be sent even if there is only one\n             * possible code. So to avoid special checks later on we force at least\n             * two codes of non zero frequency.\n             */\n            while (s.heap_len < 2) {\n                node = s.heap[++s.heap_len] = max_code < 2 ? ++max_code : 0;\n                tree[node * 2] =\n                    /* .Freq */\n                    1;\n                s.depth[node] = 0;\n                s.opt_len--;\n                if (has_stree) {\n                    s.static_len -= stree[node * 2 + 1];\n                    /* .Len */\n                }\n                /* node is 0 or 1 so it does not have extra bits */\n            }\n            desc.max_code = max_code;\n            /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,\n             * establish sub-heaps of increasing lengths:\n             */\n            for (n = s.heap_len >> 1; \n            /* int /2 */\n            n >= 1; n--) {\n                pqdownheap(s, tree, n);\n            }\n            /* Construct the Huffman tree by repeatedly combining the least two\n             * frequent nodes.\n             */\n            node = elems;\n            /* next internal node of the tree */\n            do {\n                // pqremove(s, tree, n);  /* n = node of least frequency */\n                /** * pqremove ** */\n                n = s.heap[1];\n                /* SMALLEST */\n                s.heap[1] = s.heap[s.heap_len--];\n                /* SMALLEST */\n                pqdownheap(s, tree, 1\n                /* SMALLEST */\n                );\n                /***/\n                m = s.heap[1];\n                /* SMALLEST */\n                /* m = node of next least frequency */\n                s.heap[--s.heap_max] = n;\n                /* keep the nodes sorted by frequency */\n                s.heap[--s.heap_max] = m;\n                /* Create a new node father of n and m */\n                tree[node * 2] =\n                    /* .Freq */\n                    tree[n * 2] +\n                        /* .Freq */\n                        tree[m * 2];\n                /* .Freq */\n                s.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1;\n                tree[n * 2 + 1] =\n                    /* .Dad */\n                    tree[m * 2 + 1] =\n                        /* .Dad */\n                        node;\n                /* and insert the new node in the heap */\n                s.heap[1] = node++;\n                /* SMALLEST */\n                pqdownheap(s, tree, 1\n                /* SMALLEST */\n                );\n            } while (s.heap_len >= 2);\n            s.heap[--s.heap_max] = s.heap[1];\n            /* SMALLEST */\n            /* At this point, the fields freq and dad are set. We can now\n             * generate the bit lengths.\n             */\n            gen_bitlen(s, desc);\n            /* The field len is now set, we can generate the bit codes */\n            gen_codes(tree, max_code, s.bl_count);\n        };\n        /* ===========================================================================\n         * Scan a literal or distance tree to determine the frequencies of the codes\n         * in the bit length tree.\n         */\n        var scan_tree = function scan_tree(s, tree, max_code\n        //    deflate_state *s;\n        //    ct_data *tree;   /* the tree to be scanned */\n        //    int max_code;    /* and its largest code of non zero frequency */\n        ) {\n            var n;\n            /* iterates over all tree elements */\n            var prevlen = -1;\n            /* last emitted length */\n            var curlen;\n            /* length of current code */\n            var nextlen = tree[0 * 2 + 1];\n            /* .Len */\n            /* length of next code */\n            var count = 0;\n            /* repeat count of the current code */\n            var max_count = 7;\n            /* max repeat count */\n            var min_count = 4;\n            /* min repeat count */\n            if (nextlen === 0) {\n                max_count = 138;\n                min_count = 3;\n            }\n            tree[(max_code + 1) * 2 + 1] =\n                /* .Len */\n                0xffff;\n            /* guard */\n            for (n = 0; n <= max_code; n++) {\n                curlen = nextlen;\n                nextlen = tree[(n + 1) * 2 + 1];\n                /* .Len */\n                if (++count < max_count && curlen === nextlen) {\n                    continue;\n                }\n                else if (count < min_count) {\n                    s.bl_tree[curlen * 2] +=\n                        /* .Freq */\n                        count;\n                }\n                else if (curlen !== 0) {\n                    if (curlen !== prevlen) {\n                        s.bl_tree[curlen * 2] /* .Freq */++;\n                    }\n                    s.bl_tree[REP_3_6 * 2] /* .Freq */++;\n                }\n                else if (count <= 10) {\n                    s.bl_tree[REPZ_3_10 * 2] /* .Freq */++;\n                }\n                else {\n                    s.bl_tree[REPZ_11_138 * 2] /* .Freq */++;\n                }\n                count = 0;\n                prevlen = curlen;\n                if (nextlen === 0) {\n                    max_count = 138;\n                    min_count = 3;\n                }\n                else if (curlen === nextlen) {\n                    max_count = 6;\n                    min_count = 3;\n                }\n                else {\n                    max_count = 7;\n                    min_count = 4;\n                }\n            }\n        };\n        /* ===========================================================================\n         * Send a literal or distance tree in compressed form, using the codes in\n         * bl_tree.\n         */\n        var send_tree = function send_tree(s, tree, max_code\n        //    deflate_state *s;\n        //    ct_data *tree; /* the tree to be scanned */\n        //    int max_code;       /* and its largest code of non zero frequency */\n        ) {\n            var n;\n            /* iterates over all tree elements */\n            var prevlen = -1;\n            /* last emitted length */\n            var curlen;\n            /* length of current code */\n            var nextlen = tree[0 * 2 + 1];\n            /* .Len */\n            /* length of next code */\n            var count = 0;\n            /* repeat count of the current code */\n            var max_count = 7;\n            /* max repeat count */\n            var min_count = 4;\n            /* min repeat count */\n            /* tree[max_code+1].Len = -1; */\n            /* guard already set */\n            if (nextlen === 0) {\n                max_count = 138;\n                min_count = 3;\n            }\n            for (n = 0; n <= max_code; n++) {\n                curlen = nextlen;\n                nextlen = tree[(n + 1) * 2 + 1];\n                /* .Len */\n                if (++count < max_count && curlen === nextlen) {\n                    continue;\n                }\n                else if (count < min_count) {\n                    do {\n                        send_code(s, curlen, s.bl_tree);\n                    } while (--count !== 0);\n                }\n                else if (curlen !== 0) {\n                    if (curlen !== prevlen) {\n                        send_code(s, curlen, s.bl_tree);\n                        count--;\n                    } // Assert(count >= 3 && count <= 6, \" 3_6?\");\n                    send_code(s, REP_3_6, s.bl_tree);\n                    send_bits(s, count - 3, 2);\n                }\n                else if (count <= 10) {\n                    send_code(s, REPZ_3_10, s.bl_tree);\n                    send_bits(s, count - 3, 3);\n                }\n                else {\n                    send_code(s, REPZ_11_138, s.bl_tree);\n                    send_bits(s, count - 11, 7);\n                }\n                count = 0;\n                prevlen = curlen;\n                if (nextlen === 0) {\n                    max_count = 138;\n                    min_count = 3;\n                }\n                else if (curlen === nextlen) {\n                    max_count = 6;\n                    min_count = 3;\n                }\n                else {\n                    max_count = 7;\n                    min_count = 4;\n                }\n            }\n        };\n        /* ===========================================================================\n         * Construct the Huffman tree for the bit lengths and return the index in\n         * bl_order of the last bit length code to send.\n         */\n        var build_bl_tree = function build_bl_tree(s) {\n            var max_blindex;\n            /* index of last bit length code of non zero freq */\n            /* Determine the bit length frequencies for literal and distance trees */\n            scan_tree(s, s.dyn_ltree, s.l_desc.max_code);\n            scan_tree(s, s.dyn_dtree, s.d_desc.max_code);\n            /* Build the bit length tree: */\n            build_tree(s, s.bl_desc);\n            /* opt_len now includes the length of the tree representations, except\n             * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.\n             */\n            /* Determine the number of bit length codes to send. The pkzip format\n             * requires that at least 4 bit length codes be sent. (appnote.txt says\n             * 3 but the actual value used is 4.)\n             */\n            for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) {\n                if (s.bl_tree[bl_order[max_blindex] * 2 + 1] !==\n                    /* .Len */\n                    0) {\n                    break;\n                }\n            }\n            /* Update opt_len to include the bit length tree and counts */\n            s.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4; // Tracev((stderr, \"\\ndyn trees: dyn %ld, stat %ld\",\n            //        s->opt_len, s->static_len));\n            return max_blindex;\n        };\n        /* ===========================================================================\n         * Send the header for a block using dynamic Huffman trees: the counts, the\n         * lengths of the bit length codes, the literal tree and the distance tree.\n         * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.\n         */\n        var send_all_trees = function send_all_trees(s, lcodes, dcodes, blcodes //    deflate_state *s; //    int lcodes, dcodes, blcodes; /* number of codes for each tree */\n        ) {\n            var rank;\n            /* index in bl_order */\n            // Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, \"not enough codes\");\n            // Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,\n            //        \"too many codes\");\n            // Tracev((stderr, \"\\nbl counts: \"));\n            send_bits(s, lcodes - 257, 5);\n            /* not +255 as stated in appnote.txt */\n            send_bits(s, dcodes - 1, 5);\n            send_bits(s, blcodes - 4, 4);\n            /* not -3 as stated in appnote.txt */\n            for (rank = 0; rank < blcodes; rank++) {\n                // Tracev((stderr, \"\\nbl code %2d \", bl_order[rank]));\n                send_bits(s, s.bl_tree[bl_order[rank] * 2 + 1], \n                /* .Len */\n                3);\n            } // Tracev((stderr, \"\\nbl tree: sent %ld\", s->bits_sent));\n            send_tree(s, s.dyn_ltree, lcodes - 1);\n            /* literal tree */\n            // Tracev((stderr, \"\\nlit tree: sent %ld\", s->bits_sent));\n            send_tree(s, s.dyn_dtree, dcodes - 1);\n            /* distance tree */\n            // Tracev((stderr, \"\\ndist tree: sent %ld\", s->bits_sent));\n        };\n        /* ===========================================================================\n         * Check if the data type is TEXT or BINARY, using the following algorithm:\n         * - TEXT if the two conditions below are satisfied:\n         *    a) There are no non-portable control characters belonging to the\n         *       \"black list\" (0..6, 14..25, 28..31).\n         *    b) There is at least one printable character belonging to the\n         *       \"white list\" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255).\n         * - BINARY otherwise.\n         * - The following partially-portable control characters form a\n         *   \"gray list\" that is ignored in this detection algorithm:\n         *   (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}).\n         * IN assertion: the fields Freq of dyn_ltree are set.\n         */\n        var detect_data_type = function detect_data_type(s) {\n            /* black_mask is the bit mask of black-listed bytes\n             * set bits 0..6, 14..25, and 28..31\n             * 0xf3ffc07f = binary 11110011111111111100000001111111\n             */\n            var black_mask = 0xf3ffc07f;\n            var n;\n            /* Check for non-textual (\"black-listed\") bytes. */\n            for (n = 0; n <= 31; n++, black_mask >>>= 1) {\n                if (black_mask & 1 &&\n                    s.dyn_ltree[n * 2] !==\n                        /* .Freq */\n                        0) {\n                    return Z_BINARY;\n                }\n            }\n            /* Check for textual (\"white-listed\") bytes. */\n            if (s.dyn_ltree[9 * 2] !==\n                /* .Freq */\n                0 ||\n                s.dyn_ltree[10 * 2] !==\n                    /* .Freq */\n                    0 ||\n                s.dyn_ltree[13 * 2] !==\n                    /* .Freq */\n                    0) {\n                return Z_TEXT;\n            }\n            for (n = 32; n < LITERALS; n++) {\n                if (s.dyn_ltree[n * 2] !==\n                    /* .Freq */\n                    0) {\n                    return Z_TEXT;\n                }\n            }\n            /* There are no \"black-listed\" or \"white-listed\" bytes:\n             * this stream either is empty or has tolerated (\"gray-listed\") bytes only.\n             */\n            return Z_BINARY;\n        };\n        var static_init_done = false;\n        /* ===========================================================================\n         * Initialize the tree data structures for a new zlib stream.\n         */\n        var _tr_init = function _tr_init(s) {\n            if (!static_init_done) {\n                tr_static_init();\n                static_init_done = true;\n            }\n            s.l_desc = new TreeDesc(s.dyn_ltree, static_l_desc);\n            s.d_desc = new TreeDesc(s.dyn_dtree, static_d_desc);\n            s.bl_desc = new TreeDesc(s.bl_tree, static_bl_desc);\n            s.bi_buf = 0;\n            s.bi_valid = 0;\n            /* Initialize the first block of the first file: */\n            init_block(s);\n        };\n        /* ===========================================================================\n         * Send a stored block\n         */\n        var _tr_stored_block = function _tr_stored_block(s, buf, stored_len, last\n        // DeflateState *s;\n        // charf *buf;       /* input block */\n        // ulg stored_len;   /* length of input block */\n        // int last;         /* one if this is the last block for a file */\n        ) {\n            send_bits(s, (STORED_BLOCK << 1) + (last ? 1 : 0), 3);\n            /* send block type */\n            copy_block(s, buf, stored_len, true);\n            /* with header */\n        };\n        /* ===========================================================================\n         * Send one empty static block to give enough lookahead for inflate.\n         * This takes 10 bits, of which 7 may remain in the bit buffer.\n         */\n        var _tr_align = function _tr_align(s) {\n            send_bits(s, STATIC_TREES << 1, 3);\n            send_code(s, END_BLOCK, static_ltree);\n            bi_flush(s);\n        };\n        /* ===========================================================================\n         * Determine the best encoding for the current block: dynamic trees, static\n         * trees or store, and output the encoded block to the zip file.\n         */\n        var _tr_flush_block = function _tr_flush_block(s, buf, stored_len, last\n        // DeflateState *s;\n        // charf *buf;       /* input block, or NULL if too old */\n        // ulg stored_len;   /* length of input block */\n        // int last;         /* one if this is the last block for a file */\n        ) {\n            var opt_lenb;\n            var static_lenb;\n            /* opt_len and static_len in bytes */\n            var max_blindex = 0;\n            /* index of last bit length code of non zero freq */\n            /* Build the Huffman trees unless a stored block is forced */\n            if (s.level > 0) {\n                /* Check if the file is binary or text */\n                if (s.strm.data_type === Z_UNKNOWN) {\n                    s.strm.data_type = detect_data_type(s);\n                }\n                /* Construct the literal and distance trees */\n                build_tree(s, s.l_desc); // Tracev((stderr, \"\\nlit data: dyn %ld, stat %ld\", s->opt_len,\n                //        s->static_len));\n                build_tree(s, s.d_desc); // Tracev((stderr, \"\\ndist data: dyn %ld, stat %ld\", s->opt_len,\n                //        s->static_len));\n                /* At this point, opt_len and static_len are the total bit lengths of\n                 * the compressed block data, excluding the tree representations.\n                 */\n                /* Build the bit length tree for the above two trees, and get the index\n                 * in bl_order of the last bit length code to send.\n                 */\n                max_blindex = build_bl_tree(s);\n                /* Determine the best encoding. Compute the block lengths in bytes. */\n                opt_lenb = (s.opt_len + 3 + 7) >>> 3;\n                static_lenb = (s.static_len + 3 + 7) >>> 3; // Tracev((stderr, \"\\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u \",\n                //        opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,\n                //        s->last_lit));\n                if (static_lenb <= opt_lenb) {\n                    opt_lenb = static_lenb;\n                }\n            }\n            else {\n                // Assert(buf != (char*)0, \"lost buf\");\n                opt_lenb = static_lenb = stored_len + 5;\n                /* force a stored block */\n            }\n            if (stored_len + 4 <= opt_lenb && buf !== -1) {\n                /* 4: two words for the lengths */\n                /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.\n                 * Otherwise we can't have processed more than WSIZE input bytes since\n                 * the last block flush, because compression would have been\n                 * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to\n                 * transform a block into a stored block.\n                 */\n                _tr_stored_block(s, buf, stored_len, last);\n            }\n            else if (s.strategy === Z_FIXED || static_lenb === opt_lenb) {\n                send_bits(s, (STATIC_TREES << 1) + (last ? 1 : 0), 3);\n                compress_block(s, static_ltree, static_dtree);\n            }\n            else {\n                send_bits(s, (DYN_TREES << 1) + (last ? 1 : 0), 3);\n                send_all_trees(s, s.l_desc.max_code + 1, s.d_desc.max_code + 1, max_blindex + 1);\n                compress_block(s, s.dyn_ltree, s.dyn_dtree);\n            } // Assert (s->compressed_len == s->bits_sent, \"bad compressed size\");\n            /* The above check is made mod 2^32, for files larger than 512 MB\n             * and uLong implemented on 32 bits.\n             */\n            init_block(s);\n            if (last) {\n                bi_windup(s);\n            } // Tracev((stderr,\"\\ncomprlen %lu(%lu) \", s->compressed_len>>3,\n            //       s->compressed_len-7*last));\n        };\n        /* ===========================================================================\n         * Save the match info and tally the frequency counts. Return true if\n         * the current block must be flushed.\n         */\n        var _tr_tally = function _tr_tally(s, dist, lc\n        //    deflate_state *s;\n        //    unsigned dist;  /* distance of matched string */\n        //    unsigned lc;    /* match length-MIN_MATCH or unmatched char (if dist==0) */\n        ) {\n            // let out_length, in_length, dcode;\n            s.pending_buf[s.d_buf + s.last_lit * 2] = (dist >>> 8) & 0xff;\n            s.pending_buf[s.d_buf + s.last_lit * 2 + 1] = dist & 0xff;\n            s.pending_buf[s.l_buf + s.last_lit] = lc & 0xff;\n            s.last_lit++;\n            if (dist === 0) {\n                /* lc is the unmatched char */\n                s.dyn_ltree[lc * 2] /* .Freq */++;\n            }\n            else {\n                s.matches++;\n                /* Here, lc is the match length - MIN_MATCH */\n                dist--;\n                /* dist = match distance - 1 */\n                // Assert((ush)dist < (ush)MAX_DIST(s) &&\n                //       (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&\n                //       (ush)d_code(dist) < (ush)D_CODES,  \"_tr_tally: bad match\");\n                s.dyn_ltree[(_length_code[lc] + LITERALS + 1) * 2] /* .Freq */++;\n                s.dyn_dtree[d_code(dist) * 2] /* .Freq */++;\n            } // (!) This block is disabled in zlib defaults,\n            // don't enable it for binary compatibility\n            // #ifdef TRUNCATE_BLOCK\n            //  /* Try to guess if it is profitable to stop the current block here */\n            //  if ((s.last_lit & 0x1fff) === 0 && s.level > 2) {\n            //    /* Compute an upper bound for the compressed length */\n            //    out_length = s.last_lit*8;\n            //    in_length = s.strstart - s.block_start;\n            //\n            //    for (dcode = 0; dcode < D_CODES; dcode++) {\n            //      out_length += s.dyn_dtree[dcode*2]/*.Freq*/ * (5 + extra_dbits[dcode]);\n            //    }\n            //    out_length >>>= 3;\n            //    //Tracev((stderr,\"\\nlast_lit %u, in %ld, out ~%ld(%ld%%) \",\n            //    //       s->last_lit, in_length, out_length,\n            //    //       100L - out_length*100L/in_length));\n            //    if (s.matches < (s.last_lit>>1)/*int /2*/ && out_length < (in_length>>1)/*int /2*/) {\n            //      return true;\n            //    }\n            //  }\n            // #endif\n            return s.last_lit === s.lit_bufsize - 1;\n            /* We avoid equality with lit_bufsize because of wraparound at 64K\n             * on 16 bit machines and because stored blocks are restricted to\n             * 64K-1 bytes.\n             */\n        };\n        var _tr_init_1 = _tr_init;\n        var _tr_stored_block_1 = _tr_stored_block;\n        var _tr_flush_block_1 = _tr_flush_block;\n        var _tr_tally_1 = _tr_tally;\n        var _tr_align_1 = _tr_align;\n        var trees = {\n            _tr_init: _tr_init_1,\n            _tr_stored_block: _tr_stored_block_1,\n            _tr_flush_block: _tr_flush_block_1,\n            _tr_tally: _tr_tally_1,\n            _tr_align: _tr_align_1,\n        };\n        // It isn't worth it to make additional optimizations as in original.\n        // Small size is preferable.\n        // (C) 1995-2013 Jean-loup Gailly and Mark Adler\n        // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n        //\n        // This software is provided 'as-is', without any express or implied\n        // warranty. In no event will the authors be held liable for any damages\n        // arising from the use of this software.\n        //\n        // Permission is granted to anyone to use this software for any purpose,\n        // including commercial applications, and to alter it and redistribute it\n        // freely, subject to the following restrictions:\n        //\n        // 1. The origin of this software must not be misrepresented; you must not\n        //   claim that you wrote the original software. If you use this software\n        //   in a product, an acknowledgment in the product documentation would be\n        //   appreciated but is not required.\n        // 2. Altered source versions must be plainly marked as such, and must not be\n        //   misrepresented as being the original software.\n        // 3. This notice may not be removed or altered from any source distribution.\n        var adler32 = function adler32(adler, buf, len, pos) {\n            var s1 = (adler & 0xffff) | 0;\n            var s2 = ((adler >>> 16) & 0xffff) | 0;\n            var n = 0;\n            while (len !== 0) {\n                // Set limit ~ twice less than 5552, to keep\n                // s2 in 31-bits, because we force signed ints.\n                // in other case %= will fail.\n                n = len > 2000 ? 2000 : len;\n                len -= n;\n                do {\n                    s1 = (s1 + buf[pos++]) | 0;\n                    s2 = (s2 + s1) | 0;\n                } while (--n);\n                s1 %= 65521;\n                s2 %= 65521;\n            }\n            return s1 | (s2 << 16) | 0;\n        };\n        var adler32_1 = adler32;\n        // So write code to minimize size - no pregenerated tables\n        // and array tools dependencies.\n        // (C) 1995-2013 Jean-loup Gailly and Mark Adler\n        // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n        //\n        // This software is provided 'as-is', without any express or implied\n        // warranty. In no event will the authors be held liable for any damages\n        // arising from the use of this software.\n        //\n        // Permission is granted to anyone to use this software for any purpose,\n        // including commercial applications, and to alter it and redistribute it\n        // freely, subject to the following restrictions:\n        //\n        // 1. The origin of this software must not be misrepresented; you must not\n        //   claim that you wrote the original software. If you use this software\n        //   in a product, an acknowledgment in the product documentation would be\n        //   appreciated but is not required.\n        // 2. Altered source versions must be plainly marked as such, and must not be\n        //   misrepresented as being the original software.\n        // 3. This notice may not be removed or altered from any source distribution.\n        // Use ordinary array, since untyped makes no boost here\n        var makeTable = function makeTable() {\n            var c;\n            var table = [];\n            for (var n = 0; n < 256; n++) {\n                c = n;\n                for (var k = 0; k < 8; k++) {\n                    c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;\n                }\n                table[n] = c;\n            }\n            return table;\n        }; // Create table on load. Just 255 signed longs. Not a problem.\n        var crcTable = new Uint32Array(makeTable());\n        var crc32 = function crc32(crc, buf, len, pos) {\n            var t = crcTable;\n            var end = pos + len;\n            crc ^= -1;\n            for (var i = pos; i < end; i++) {\n                crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & 0xff];\n            }\n            return crc ^ -1; // >>> 0;\n        };\n        var crc32_1 = crc32;\n        // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n        //\n        // This software is provided 'as-is', without any express or implied\n        // warranty. In no event will the authors be held liable for any damages\n        // arising from the use of this software.\n        //\n        // Permission is granted to anyone to use this software for any purpose,\n        // including commercial applications, and to alter it and redistribute it\n        // freely, subject to the following restrictions:\n        //\n        // 1. The origin of this software must not be misrepresented; you must not\n        //   claim that you wrote the original software. If you use this software\n        //   in a product, an acknowledgment in the product documentation would be\n        //   appreciated but is not required.\n        // 2. Altered source versions must be plainly marked as such, and must not be\n        //   misrepresented as being the original software.\n        // 3. This notice may not be removed or altered from any source distribution.\n        var messages = {\n            2: 'need dictionary',\n            /* Z_NEED_DICT       2  */\n            1: 'stream end',\n            /* Z_STREAM_END      1  */\n            0: '',\n            /* Z_OK              0  */\n            '-1': 'file error',\n            /* Z_ERRNO         (-1) */\n            '-2': 'stream error',\n            /* Z_STREAM_ERROR  (-2) */\n            '-3': 'data error',\n            /* Z_DATA_ERROR    (-3) */\n            '-4': 'insufficient memory',\n            /* Z_MEM_ERROR     (-4) */\n            '-5': 'buffer error',\n            /* Z_BUF_ERROR     (-5) */\n            '-6': 'incompatible version',\n            /* Z_VERSION_ERROR (-6) */\n        };\n        // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n        //\n        // This software is provided 'as-is', without any express or implied\n        // warranty. In no event will the authors be held liable for any damages\n        // arising from the use of this software.\n        //\n        // Permission is granted to anyone to use this software for any purpose,\n        // including commercial applications, and to alter it and redistribute it\n        // freely, subject to the following restrictions:\n        //\n        // 1. The origin of this software must not be misrepresented; you must not\n        //   claim that you wrote the original software. If you use this software\n        //   in a product, an acknowledgment in the product documentation would be\n        //   appreciated but is not required.\n        // 2. Altered source versions must be plainly marked as such, and must not be\n        //   misrepresented as being the original software.\n        // 3. This notice may not be removed or altered from any source distribution.\n        var constants = {\n            /* Allowed flush values; see deflate() and inflate() below for details */\n            Z_NO_FLUSH: 0,\n            Z_PARTIAL_FLUSH: 1,\n            Z_SYNC_FLUSH: 2,\n            Z_FULL_FLUSH: 3,\n            Z_FINISH: 4,\n            Z_BLOCK: 5,\n            Z_TREES: 6,\n            /* Return codes for the compression/decompression functions. Negative values\n             * are errors, positive values are used for special but normal events.\n             */\n            Z_OK: 0,\n            Z_STREAM_END: 1,\n            Z_NEED_DICT: 2,\n            Z_ERRNO: -1,\n            Z_STREAM_ERROR: -2,\n            Z_DATA_ERROR: -3,\n            Z_MEM_ERROR: -4,\n            Z_BUF_ERROR: -5,\n            // Z_VERSION_ERROR: -6,\n            /* compression levels */\n            Z_NO_COMPRESSION: 0,\n            Z_BEST_SPEED: 1,\n            Z_BEST_COMPRESSION: 9,\n            Z_DEFAULT_COMPRESSION: -1,\n            Z_FILTERED: 1,\n            Z_HUFFMAN_ONLY: 2,\n            Z_RLE: 3,\n            Z_FIXED: 4,\n            Z_DEFAULT_STRATEGY: 0,\n            /* Possible values of the data_type field (though see inflate()) */\n            Z_BINARY: 0,\n            Z_TEXT: 1,\n            // Z_ASCII:                1, // = Z_TEXT (deprecated)\n            Z_UNKNOWN: 2,\n            /* The deflate compression method */\n            Z_DEFLATED: 8, // Z_NULL:                 null // Use -1 or null inline, depending on var type\n        };\n        // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n        //\n        // This software is provided 'as-is', without any express or implied\n        // warranty. In no event will the authors be held liable for any damages\n        // arising from the use of this software.\n        //\n        // Permission is granted to anyone to use this software for any purpose,\n        // including commercial applications, and to alter it and redistribute it\n        // freely, subject to the following restrictions:\n        //\n        // 1. The origin of this software must not be misrepresented; you must not\n        //   claim that you wrote the original software. If you use this software\n        //   in a product, an acknowledgment in the product documentation would be\n        //   appreciated but is not required.\n        // 2. Altered source versions must be plainly marked as such, and must not be\n        //   misrepresented as being the original software.\n        // 3. This notice may not be removed or altered from any source distribution.\n        var _tr_init$1 = trees._tr_init;\n        var _tr_stored_block$1 = trees._tr_stored_block;\n        var _tr_flush_block$1 = trees._tr_flush_block;\n        var _tr_tally$1 = trees._tr_tally;\n        var _tr_align$1 = trees._tr_align;\n        /* Public constants ========================================================== */\n        /* =========================================================================== */\n        var Z_NO_FLUSH = constants.Z_NO_FLUSH;\n        var Z_PARTIAL_FLUSH = constants.Z_PARTIAL_FLUSH;\n        var Z_FULL_FLUSH = constants.Z_FULL_FLUSH;\n        var Z_FINISH = constants.Z_FINISH;\n        var Z_BLOCK = constants.Z_BLOCK;\n        var Z_OK = constants.Z_OK;\n        var Z_STREAM_END = constants.Z_STREAM_END;\n        var Z_STREAM_ERROR = constants.Z_STREAM_ERROR;\n        var Z_DATA_ERROR = constants.Z_DATA_ERROR;\n        var Z_BUF_ERROR = constants.Z_BUF_ERROR;\n        var Z_DEFAULT_COMPRESSION = constants.Z_DEFAULT_COMPRESSION;\n        var Z_FILTERED = constants.Z_FILTERED;\n        var Z_HUFFMAN_ONLY = constants.Z_HUFFMAN_ONLY;\n        var Z_RLE = constants.Z_RLE;\n        var Z_FIXED$1 = constants.Z_FIXED;\n        var Z_DEFAULT_STRATEGY = constants.Z_DEFAULT_STRATEGY;\n        var Z_UNKNOWN$1 = constants.Z_UNKNOWN;\n        var Z_DEFLATED = constants.Z_DEFLATED;\n        /* ============================================================================ */\n        var MAX_MEM_LEVEL = 9;\n        /* Maximum value for memLevel in deflateInit2 */\n        var MAX_WBITS = 15;\n        /* 32K LZ77 window */\n        var DEF_MEM_LEVEL = 8;\n        var LENGTH_CODES$1 = 29;\n        /* number of length codes, not counting the special END_BLOCK code */\n        var LITERALS$1 = 256;\n        /* number of literal bytes 0..255 */\n        var L_CODES$1 = LITERALS$1 + 1 + LENGTH_CODES$1;\n        /* number of Literal or Length codes, including the END_BLOCK code */\n        var D_CODES$1 = 30;\n        /* number of distance codes */\n        var BL_CODES$1 = 19;\n        /* number of codes used to transfer the bit lengths */\n        var HEAP_SIZE$1 = 2 * L_CODES$1 + 1;\n        /* maximum heap size */\n        var MAX_BITS$1 = 15;\n        /* All codes must not exceed MAX_BITS bits */\n        var MIN_MATCH$1 = 3;\n        var MAX_MATCH$1 = 258;\n        var MIN_LOOKAHEAD = MAX_MATCH$1 + MIN_MATCH$1 + 1;\n        var PRESET_DICT = 0x20;\n        var INIT_STATE = 42;\n        var EXTRA_STATE = 69;\n        var NAME_STATE = 73;\n        var COMMENT_STATE = 91;\n        var HCRC_STATE = 103;\n        var BUSY_STATE = 113;\n        var FINISH_STATE = 666;\n        var BS_NEED_MORE = 1;\n        /* block not completed, need more input or more output */\n        var BS_BLOCK_DONE = 2;\n        /* block flush performed */\n        var BS_FINISH_STARTED = 3;\n        /* finish started, need only more output at next deflate */\n        var BS_FINISH_DONE = 4;\n        /* finish done, accept no more input or output */\n        var OS_CODE = 0x03; // Unix :) . Don't detect, use this default.\n        var err = function err(strm, errorCode) {\n            strm.msg = messages[errorCode];\n            return errorCode;\n        };\n        var rank = function rank(f) {\n            return (f << 1) - (f > 4 ? 9 : 0);\n        };\n        var zero$1 = function zero(buf) {\n            var len = buf.length;\n            while (--len >= 0) {\n                buf[len] = 0;\n            }\n        };\n        var HASH_ZLIB = function HASH_ZLIB(s, prev, data) {\n            return ((prev << s.hash_shift) ^ data) & s.hash_mask;\n        }; // This hash causes less collisions, https://github.com/nodeca/pako/issues/135\n        // But breaks binary compatibility\n        // let HASH_FAST = (s, prev, data) => ((prev << 8) + (prev >> 8) + (data << 4)) & s.hash_mask;\n        var HASH = HASH_ZLIB;\n        /* =========================================================================\n         * Flush as much pending output as possible. All deflate() output goes\n         * through this function so some applications may wish to modify it\n         * to avoid allocating a large strm->output buffer and copying into it.\n         * (See also read_buf()).\n         */\n        var flush_pending = function flush_pending(strm) {\n            var s = strm.state; // _tr_flush_bits(s);\n            var len = s.pending;\n            if (len > strm.avail_out) {\n                len = strm.avail_out;\n            }\n            if (len === 0) {\n                return;\n            }\n            strm.output.set(s.pending_buf.subarray(s.pending_out, s.pending_out + len), strm.next_out);\n            strm.next_out += len;\n            s.pending_out += len;\n            strm.total_out += len;\n            strm.avail_out -= len;\n            s.pending -= len;\n            if (s.pending === 0) {\n                s.pending_out = 0;\n            }\n        };\n        var flush_block_only = function flush_block_only(s, last) {\n            _tr_flush_block$1(s, s.block_start >= 0 ? s.block_start : -1, s.strstart - s.block_start, last);\n            s.block_start = s.strstart;\n            flush_pending(s.strm);\n        };\n        var put_byte = function put_byte(s, b) {\n            s.pending_buf[s.pending++] = b;\n        };\n        /* =========================================================================\n         * Put a short in the pending buffer. The 16-bit value is put in MSB order.\n         * IN assertion: the stream state is correct and there is enough room in\n         * pending_buf.\n         */\n        var putShortMSB = function putShortMSB(s, b) {\n            //  put_byte(s, (Byte)(b >> 8));\n            //  put_byte(s, (Byte)(b & 0xff));\n            s.pending_buf[s.pending++] = (b >>> 8) & 0xff;\n            s.pending_buf[s.pending++] = b & 0xff;\n        };\n        /* ===========================================================================\n         * Read a new buffer from the current input stream, update the adler32\n         * and total number of bytes read.  All deflate() input goes through\n         * this function so some applications may wish to modify it to avoid\n         * allocating a large strm->input buffer and copying from it.\n         * (See also flush_pending()).\n         */\n        var read_buf = function read_buf(strm, buf, start, size) {\n            var len = strm.avail_in;\n            if (len > size) {\n                len = size;\n            }\n            if (len === 0) {\n                return 0;\n            }\n            strm.avail_in -= len; // zmemcpy(buf, strm->next_in, len);\n            buf.set(strm.input.subarray(strm.next_in, strm.next_in + len), start);\n            if (strm.state.wrap === 1) {\n                strm.adler = adler32_1(strm.adler, buf, len, start);\n            }\n            else if (strm.state.wrap === 2) {\n                strm.adler = crc32_1(strm.adler, buf, len, start);\n            }\n            strm.next_in += len;\n            strm.total_in += len;\n            return len;\n        };\n        /* ===========================================================================\n         * Set match_start to the longest match starting at the given string and\n         * return its length. Matches shorter or equal to prev_length are discarded,\n         * in which case the result is equal to prev_length and match_start is\n         * garbage.\n         * IN assertions: cur_match is the head of the hash chain for the current\n         *   string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1\n         * OUT assertion: the match length is not greater than s->lookahead.\n         */\n        var longest_match = function longest_match(s, cur_match) {\n            var chain_length = s.max_chain_length;\n            /* max hash chain length */\n            var scan = s.strstart;\n            /* current string */\n            var match;\n            /* matched string */\n            var len;\n            /* length of current match */\n            var best_len = s.prev_length;\n            /* best match length so far */\n            var nice_match = s.nice_match;\n            /* stop if match long enough */\n            var limit = s.strstart > s.w_size - MIN_LOOKAHEAD ? s.strstart - (s.w_size - MIN_LOOKAHEAD) : 0;\n            /* NIL */\n            var _win = s.window; // shortcut\n            var wmask = s.w_mask;\n            var prev = s.prev;\n            /* Stop when cur_match becomes <= limit. To simplify the code,\n             * we prevent matches with the string of window index 0.\n             */\n            var strend = s.strstart + MAX_MATCH$1;\n            var scan_end1 = _win[scan + best_len - 1];\n            var scan_end = _win[scan + best_len];\n            /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.\n             * It is easy to get rid of this optimization if necessary.\n             */\n            // Assert(s->hash_bits >= 8 && MAX_MATCH == 258, \"Code too clever\");\n            /* Do not waste too much time if we already have a good match: */\n            if (s.prev_length >= s.good_match) {\n                chain_length >>= 2;\n            }\n            /* Do not look for matches beyond the end of the input. This is necessary\n             * to make deflate deterministic.\n             */\n            if (nice_match > s.lookahead) {\n                nice_match = s.lookahead;\n            } // Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, \"need lookahead\");\n            do {\n                // Assert(cur_match < s->strstart, \"no future\");\n                match = cur_match;\n                /* Skip to next match if the match length cannot increase\n                 * or if the match length is less than 2.  Note that the checks below\n                 * for insufficient lookahead only occur occasionally for performance\n                 * reasons.  Therefore uninitialized memory will be accessed, and\n                 * conditional jumps will be made that depend on those values.\n                 * However the length of the match is limited to the lookahead, so\n                 * the output of deflate is not affected by the uninitialized values.\n                 */\n                if (_win[match + best_len] !== scan_end ||\n                    _win[match + best_len - 1] !== scan_end1 ||\n                    _win[match] !== _win[scan] ||\n                    _win[++match] !== _win[scan + 1]) {\n                    continue;\n                }\n                /* The check at best_len-1 can be removed because it will be made\n                 * again later. (This heuristic is not always a win.)\n                 * It is not necessary to compare scan[2] and match[2] since they\n                 * are always equal when the other bytes match, given that\n                 * the hash keys are equal and that HASH_BITS >= 8.\n                 */\n                scan += 2;\n                match++; // Assert(*scan == *match, \"match[2]?\");\n                /* We check for insufficient lookahead only every 8th comparison;\n                 * the 256th check will be made at strstart+258.\n                 */\n                do {\n                    /* jshint noempty:false */\n                } while (_win[++scan] === _win[++match] &&\n                    _win[++scan] === _win[++match] &&\n                    _win[++scan] === _win[++match] &&\n                    _win[++scan] === _win[++match] &&\n                    _win[++scan] === _win[++match] &&\n                    _win[++scan] === _win[++match] &&\n                    _win[++scan] === _win[++match] &&\n                    _win[++scan] === _win[++match] &&\n                    scan < strend); // Assert(scan <= s->window+(unsigned)(s->window_size-1), \"wild scan\");\n                len = MAX_MATCH$1 - (strend - scan);\n                scan = strend - MAX_MATCH$1;\n                if (len > best_len) {\n                    s.match_start = cur_match;\n                    best_len = len;\n                    if (len >= nice_match) {\n                        break;\n                    }\n                    scan_end1 = _win[scan + best_len - 1];\n                    scan_end = _win[scan + best_len];\n                }\n            } while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length !== 0);\n            if (best_len <= s.lookahead) {\n                return best_len;\n            }\n            return s.lookahead;\n        };\n        /* ===========================================================================\n         * Fill the window when the lookahead becomes insufficient.\n         * Updates strstart and lookahead.\n         *\n         * IN assertion: lookahead < MIN_LOOKAHEAD\n         * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD\n         *    At least one byte has been read, or avail_in == 0; reads are\n         *    performed for at least two bytes (required for the zip translate_eol\n         *    option -- not supported here).\n         */\n        var fill_window = function fill_window(s) {\n            var _w_size = s.w_size;\n            var p;\n            var n;\n            var m;\n            var more;\n            var str; // Assert(s->lookahead < MIN_LOOKAHEAD, \"already enough lookahead\");\n            do {\n                more = s.window_size - s.lookahead - s.strstart; // JS ints have 32 bit, block below not needed\n                /* Deal with !@#$% 64K limit: */\n                // if (sizeof(int) <= 2) {\n                //    if (more == 0 && s->strstart == 0 && s->lookahead == 0) {\n                //        more = wsize;\n                //\n                //  } else if (more == (unsigned)(-1)) {\n                //        /* Very unlikely, but possible on 16 bit machine if\n                //         * strstart == 0 && lookahead == 1 (input done a byte at time)\n                //         */\n                //        more--;\n                //    }\n                // }\n                /* If the window is almost full and there is insufficient lookahead,\n                 * move the upper half to the lower one to make room in the upper half.\n                 */\n                if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) {\n                    s.window.set(s.window.subarray(_w_size, _w_size + _w_size), 0);\n                    s.match_start -= _w_size;\n                    s.strstart -= _w_size;\n                    /* we now have strstart >= MAX_DIST */\n                    s.block_start -= _w_size;\n                    /* Slide the hash table (could be avoided with 32 bit values\n                   at the expense of memory usage). We slide even when level == 0\n                   to keep the hash table consistent if we switch back to level > 0\n                   later. (Using level 0 permanently is not an optimal usage of\n                   zlib, so we don't care about this pathological case.)\n                   */\n                    n = s.hash_size;\n                    p = n;\n                    do {\n                        m = s.head[--p];\n                        s.head[p] = m >= _w_size ? m - _w_size : 0;\n                    } while (--n);\n                    n = _w_size;\n                    p = n;\n                    do {\n                        m = s.prev[--p];\n                        s.prev[p] = m >= _w_size ? m - _w_size : 0;\n                        /* If n is not on any hash chain, prev[n] is garbage but\n                         * its value will never be used.\n                         */\n                    } while (--n);\n                    more += _w_size;\n                }\n                if (s.strm.avail_in === 0) {\n                    break;\n                }\n                /* If there was no sliding:\n                 *    strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&\n                 *    more == window_size - lookahead - strstart\n                 * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)\n                 * => more >= window_size - 2*WSIZE + 2\n                 * In the BIG_MEM or MMAP case (not yet supported),\n                 *   window_size == input_size + MIN_LOOKAHEAD  &&\n                 *   strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.\n                 * Otherwise, window_size == 2*WSIZE so more >= 2.\n                 * If there was sliding, more >= WSIZE. So in all cases, more >= 2.\n                 */\n                // Assert(more >= 2, \"more < 2\");\n                n = read_buf(s.strm, s.window, s.strstart + s.lookahead, more);\n                s.lookahead += n;\n                /* Initialize the hash value now that we have some input: */\n                if (s.lookahead + s.insert >= MIN_MATCH$1) {\n                    str = s.strstart - s.insert;\n                    s.ins_h = s.window[str];\n                    /* UPDATE_HASH(s, s->ins_h, s->window[str + 1]); */\n                    s.ins_h = HASH(s, s.ins_h, s.window[str + 1]); // #if MIN_MATCH != 3\n                    //        Call update_hash() MIN_MATCH-3 more times\n                    // #endif\n                    while (s.insert) {\n                        /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */\n                        s.ins_h = HASH(s, s.ins_h, s.window[str + MIN_MATCH$1 - 1]);\n                        s.prev[str & s.w_mask] = s.head[s.ins_h];\n                        s.head[s.ins_h] = str;\n                        str++;\n                        s.insert--;\n                        if (s.lookahead + s.insert < MIN_MATCH$1) {\n                            break;\n                        }\n                    }\n                }\n                /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage,\n                 * but this is not important since only literal bytes will be emitted.\n                 */\n            } while (s.lookahead < MIN_LOOKAHEAD && s.strm.avail_in !== 0);\n            /* If the WIN_INIT bytes after the end of the current data have never been\n             * written, then zero those bytes in order to avoid memory check reports of\n             * the use of uninitialized (or uninitialised as Julian writes) bytes by\n             * the longest match routines.  Update the high water mark for the next\n             * time through here.  WIN_INIT is set to MAX_MATCH since the longest match\n             * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead.\n             */\n            //  if (s.high_water < s.window_size) {\n            //    const curr = s.strstart + s.lookahead;\n            //    let init = 0;\n            //\n            //    if (s.high_water < curr) {\n            //      /* Previous high water mark below current data -- zero WIN_INIT\n            //       * bytes or up to end of window, whichever is less.\n            //       */\n            //      init = s.window_size - curr;\n            //      if (init > WIN_INIT)\n            //        init = WIN_INIT;\n            //      zmemzero(s->window + curr, (unsigned)init);\n            //      s->high_water = curr + init;\n            //    }\n            //    else if (s->high_water < (ulg)curr + WIN_INIT) {\n            //      /* High water mark at or above current data, but below current data\n            //       * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up\n            //       * to end of window, whichever is less.\n            //       */\n            //      init = (ulg)curr + WIN_INIT - s->high_water;\n            //      if (init > s->window_size - s->high_water)\n            //        init = s->window_size - s->high_water;\n            //      zmemzero(s->window + s->high_water, (unsigned)init);\n            //      s->high_water += init;\n            //    }\n            //  }\n            //\n            //  Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD,\n            //    \"not enough room for search\");\n        };\n        /* ===========================================================================\n         * Copy without compression as much as possible from the input stream, return\n         * the current block state.\n         * This function does not insert new strings in the dictionary since\n         * uncompressible data is probably not useful. This function is used\n         * only for the level=0 compression option.\n         * NOTE: this function should be optimized to avoid extra copying from\n         * window to pending_buf.\n         */\n        var deflate_stored = function deflate_stored(s, flush) {\n            /* Stored blocks are limited to 0xffff bytes, pending_buf is limited\n             * to pending_buf_size, and each stored block has a 5 byte header:\n             */\n            var max_block_size = 0xffff;\n            if (max_block_size > s.pending_buf_size - 5) {\n                max_block_size = s.pending_buf_size - 5;\n            }\n            /* Copy as much as possible from input to output: */\n            for (;;) {\n                /* Fill the window as much as possible: */\n                if (s.lookahead <= 1) {\n                    // Assert(s->strstart < s->w_size+MAX_DIST(s) ||\n                    //  s->block_start >= (long)s->w_size, \"slide too late\");\n                    //      if (!(s.strstart < s.w_size + (s.w_size - MIN_LOOKAHEAD) ||\n                    //        s.block_start >= s.w_size)) {\n                    //        throw  new Error(\"slide too late\");\n                    //      }\n                    fill_window(s);\n                    if (s.lookahead === 0 && flush === Z_NO_FLUSH) {\n                        return BS_NEED_MORE;\n                    }\n                    if (s.lookahead === 0) {\n                        break;\n                    }\n                    /* flush the current block */\n                } // Assert(s->block_start >= 0L, \"block gone\");\n                //    if (s.block_start < 0) throw new Error(\"block gone\");\n                s.strstart += s.lookahead;\n                s.lookahead = 0;\n                /* Emit a stored block if pending_buf will be full: */\n                var max_start = s.block_start + max_block_size;\n                if (s.strstart === 0 || s.strstart >= max_start) {\n                    /* strstart == 0 is possible when wraparound on 16-bit machine */\n                    s.lookahead = s.strstart - max_start;\n                    s.strstart = max_start;\n                    /** * FLUSH_BLOCK(s, 0); ** */\n                    flush_block_only(s, false);\n                    if (s.strm.avail_out === 0) {\n                        return BS_NEED_MORE;\n                    }\n                    /***/\n                }\n                /* Flush if we may have to slide, otherwise block_start may become\n                 * negative and the data will be gone:\n                 */\n                if (s.strstart - s.block_start >= s.w_size - MIN_LOOKAHEAD) {\n                    /** * FLUSH_BLOCK(s, 0); ** */\n                    flush_block_only(s, false);\n                    if (s.strm.avail_out === 0) {\n                        return BS_NEED_MORE;\n                    }\n                    /***/\n                }\n            }\n            s.insert = 0;\n            if (flush === Z_FINISH) {\n                /** * FLUSH_BLOCK(s, 1); ** */\n                flush_block_only(s, true);\n                if (s.strm.avail_out === 0) {\n                    return BS_FINISH_STARTED;\n                }\n                /***/\n                return BS_FINISH_DONE;\n            }\n            if (s.strstart > s.block_start) {\n                /** * FLUSH_BLOCK(s, 0); ** */\n                flush_block_only(s, false);\n                if (s.strm.avail_out === 0) {\n                    return BS_NEED_MORE;\n                }\n                /***/\n            }\n            return BS_NEED_MORE;\n        };\n        /* ===========================================================================\n         * Compress as much as possible from the input stream, return the current\n         * block state.\n         * This function does not perform lazy evaluation of matches and inserts\n         * new strings in the dictionary only for unmatched strings or for short\n         * matches. It is used only for the fast compression options.\n         */\n        var deflate_fast = function deflate_fast(s, flush) {\n            var hash_head;\n            /* head of the hash chain */\n            var bflush;\n            /* set if current block must be flushed */\n            for (;;) {\n                /* Make sure that we always have enough lookahead, except\n                 * at the end of the input file. We need MAX_MATCH bytes\n                 * for the next match, plus MIN_MATCH bytes to insert the\n                 * string following the next match.\n                 */\n                if (s.lookahead < MIN_LOOKAHEAD) {\n                    fill_window(s);\n                    if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {\n                        return BS_NEED_MORE;\n                    }\n                    if (s.lookahead === 0) {\n                        break;\n                        /* flush the current block */\n                    }\n                }\n                /* Insert the string window[strstart .. strstart+2] in the\n                 * dictionary, and set hash_head to the head of the hash chain:\n                 */\n                hash_head = 0;\n                /* NIL */\n                if (s.lookahead >= MIN_MATCH$1) {\n                    /** * INSERT_STRING(s, s.strstart, hash_head); ** */\n                    s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH$1 - 1]);\n                    hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];\n                    s.head[s.ins_h] = s.strstart;\n                    /***/\n                }\n                /* Find the longest match, discarding those <= prev_length.\n                 * At this point we have always match_length < MIN_MATCH\n                 */\n                if (hash_head !== 0 &&\n                    /* NIL */\n                    s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD) {\n                    /* To simplify the code, we prevent matches with the string\n                     * of window index 0 (in particular we have to avoid a match\n                     * of the string with itself at the start of the input file).\n                     */\n                    s.match_length = longest_match(s, hash_head);\n                    /* longest_match() sets match_start */\n                }\n                if (s.match_length >= MIN_MATCH$1) {\n                    // check_match(s, s.strstart, s.match_start, s.match_length); // for debug only\n                    /** * _tr_tally_dist(s, s.strstart - s.match_start,\n                                 s.match_length - MIN_MATCH, bflush); ** */\n                    bflush = _tr_tally$1(s, s.strstart - s.match_start, s.match_length - MIN_MATCH$1);\n                    s.lookahead -= s.match_length;\n                    /* Insert new strings in the hash table only if the match length\n                     * is not too large. This saves time but degrades compression.\n                     */\n                    if (s.match_length <= s.max_lazy_match &&\n                        /* max_insert_length */\n                        s.lookahead >= MIN_MATCH$1) {\n                        s.match_length--;\n                        /* string at strstart already in table */\n                        do {\n                            s.strstart++;\n                            /** * INSERT_STRING(s, s.strstart, hash_head); ** */\n                            s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH$1 - 1]);\n                            hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];\n                            s.head[s.ins_h] = s.strstart;\n                            /***/\n                            /* strstart never exceeds WSIZE-MAX_MATCH, so there are\n                             * always MIN_MATCH bytes ahead.\n                             */\n                        } while (--s.match_length !== 0);\n                        s.strstart++;\n                    }\n                    else {\n                        s.strstart += s.match_length;\n                        s.match_length = 0;\n                        s.ins_h = s.window[s.strstart];\n                        /* UPDATE_HASH(s, s.ins_h, s.window[s.strstart+1]); */\n                        s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + 1]); // #if MIN_MATCH != 3\n                        //                Call UPDATE_HASH() MIN_MATCH-3 more times\n                        // #endif\n                        /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not\n                         * matter since it will be recomputed at next deflate call.\n                         */\n                    }\n                }\n                else {\n                    /* No match, output a literal byte */\n                    // Tracevv((stderr,\"%c\", s.window[s.strstart]));\n                    /** * _tr_tally_lit(s, s.window[s.strstart], bflush); ** */\n                    bflush = _tr_tally$1(s, 0, s.window[s.strstart]);\n                    s.lookahead--;\n                    s.strstart++;\n                }\n                if (bflush) {\n                    /** * FLUSH_BLOCK(s, 0); ** */\n                    flush_block_only(s, false);\n                    if (s.strm.avail_out === 0) {\n                        return BS_NEED_MORE;\n                    }\n                    /***/\n                }\n            }\n            s.insert = s.strstart < MIN_MATCH$1 - 1 ? s.strstart : MIN_MATCH$1 - 1;\n            if (flush === Z_FINISH) {\n                /** * FLUSH_BLOCK(s, 1); ** */\n                flush_block_only(s, true);\n                if (s.strm.avail_out === 0) {\n                    return BS_FINISH_STARTED;\n                }\n                /***/\n                return BS_FINISH_DONE;\n            }\n            if (s.last_lit) {\n                /** * FLUSH_BLOCK(s, 0); ** */\n                flush_block_only(s, false);\n                if (s.strm.avail_out === 0) {\n                    return BS_NEED_MORE;\n                }\n                /***/\n            }\n            return BS_BLOCK_DONE;\n        };\n        /* ===========================================================================\n         * Same as above, but achieves better compression. We use a lazy\n         * evaluation for matches: a match is finally adopted only if there is\n         * no better match at the next window position.\n         */\n        var deflate_slow = function deflate_slow(s, flush) {\n            var hash_head;\n            /* head of hash chain */\n            var bflush;\n            /* set if current block must be flushed */\n            var max_insert;\n            /* Process the input block. */\n            for (;;) {\n                /* Make sure that we always have enough lookahead, except\n                 * at the end of the input file. We need MAX_MATCH bytes\n                 * for the next match, plus MIN_MATCH bytes to insert the\n                 * string following the next match.\n                 */\n                if (s.lookahead < MIN_LOOKAHEAD) {\n                    fill_window(s);\n                    if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {\n                        return BS_NEED_MORE;\n                    }\n                    if (s.lookahead === 0) {\n                        break;\n                    }\n                    /* flush the current block */\n                }\n                /* Insert the string window[strstart .. strstart+2] in the\n                 * dictionary, and set hash_head to the head of the hash chain:\n                 */\n                hash_head = 0;\n                /* NIL */\n                if (s.lookahead >= MIN_MATCH$1) {\n                    /** * INSERT_STRING(s, s.strstart, hash_head); ** */\n                    s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH$1 - 1]);\n                    hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];\n                    s.head[s.ins_h] = s.strstart;\n                    /***/\n                }\n                /* Find the longest match, discarding those <= prev_length.\n                 */\n                s.prev_length = s.match_length;\n                s.prev_match = s.match_start;\n                s.match_length = MIN_MATCH$1 - 1;\n                if (hash_head !== 0 &&\n                    /* NIL */\n                    s.prev_length < s.max_lazy_match &&\n                    s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD\n                /* MAX_DIST(s) */\n                ) {\n                    /* To simplify the code, we prevent matches with the string\n                     * of window index 0 (in particular we have to avoid a match\n                     * of the string with itself at the start of the input file).\n                     */\n                    s.match_length = longest_match(s, hash_head);\n                    /* longest_match() sets match_start */\n                    if (s.match_length <= 5 &&\n                        (s.strategy === Z_FILTERED || (s.match_length === MIN_MATCH$1 && s.strstart - s.match_start > 4096))\n                    /* TOO_FAR */\n                    ) {\n                        /* If prev_match is also MIN_MATCH, match_start is garbage\n                         * but we will ignore the current match anyway.\n                         */\n                        s.match_length = MIN_MATCH$1 - 1;\n                    }\n                }\n                /* If there was a match at the previous step and the current\n                 * match is not better, output the previous match:\n                 */\n                if (s.prev_length >= MIN_MATCH$1 && s.match_length <= s.prev_length) {\n                    max_insert = s.strstart + s.lookahead - MIN_MATCH$1;\n                    /* Do not insert strings in hash table beyond this. */\n                    // check_match(s, s.strstart-1, s.prev_match, s.prev_length);\n                    /** *_tr_tally_dist(s, s.strstart - 1 - s.prev_match,\n                                 s.prev_length - MIN_MATCH, bflush);** */\n                    bflush = _tr_tally$1(s, s.strstart - 1 - s.prev_match, s.prev_length - MIN_MATCH$1);\n                    /* Insert in hash table all strings up to the end of the match.\n                     * strstart-1 and strstart are already inserted. If there is not\n                     * enough lookahead, the last two strings are not inserted in\n                     * the hash table.\n                     */\n                    s.lookahead -= s.prev_length - 1;\n                    s.prev_length -= 2;\n                    do {\n                        if (++s.strstart <= max_insert) {\n                            /** * INSERT_STRING(s, s.strstart, hash_head); ** */\n                            s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH$1 - 1]);\n                            hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];\n                            s.head[s.ins_h] = s.strstart;\n                            /***/\n                        }\n                    } while (--s.prev_length !== 0);\n                    s.match_available = 0;\n                    s.match_length = MIN_MATCH$1 - 1;\n                    s.strstart++;\n                    if (bflush) {\n                        /** * FLUSH_BLOCK(s, 0); ** */\n                        flush_block_only(s, false);\n                        if (s.strm.avail_out === 0) {\n                            return BS_NEED_MORE;\n                        }\n                        /***/\n                    }\n                }\n                else if (s.match_available) {\n                    /* If there was no match at the previous position, output a\n                     * single literal. If there was a match but the current match\n                     * is longer, truncate the previous match to a single literal.\n                     */\n                    // Tracevv((stderr,\"%c\", s->window[s->strstart-1]));\n                    /** * _tr_tally_lit(s, s.window[s.strstart-1], bflush); ** */\n                    bflush = _tr_tally$1(s, 0, s.window[s.strstart - 1]);\n                    if (bflush) {\n                        /** * FLUSH_BLOCK_ONLY(s, 0) ** */\n                        flush_block_only(s, false);\n                        /***/\n                    }\n                    s.strstart++;\n                    s.lookahead--;\n                    if (s.strm.avail_out === 0) {\n                        return BS_NEED_MORE;\n                    }\n                }\n                else {\n                    /* There is no previous match to compare with, wait for\n                     * the next step to decide.\n                     */\n                    s.match_available = 1;\n                    s.strstart++;\n                    s.lookahead--;\n                }\n            } // Assert (flush != Z_NO_FLUSH, \"no flush?\");\n            if (s.match_available) {\n                // Tracevv((stderr,\"%c\", s->window[s->strstart-1]));\n                /** * _tr_tally_lit(s, s.window[s.strstart-1], bflush); ** */\n                bflush = _tr_tally$1(s, 0, s.window[s.strstart - 1]);\n                s.match_available = 0;\n            }\n            s.insert = s.strstart < MIN_MATCH$1 - 1 ? s.strstart : MIN_MATCH$1 - 1;\n            if (flush === Z_FINISH) {\n                /** * FLUSH_BLOCK(s, 1); ** */\n                flush_block_only(s, true);\n                if (s.strm.avail_out === 0) {\n                    return BS_FINISH_STARTED;\n                }\n                /***/\n                return BS_FINISH_DONE;\n            }\n            if (s.last_lit) {\n                /** * FLUSH_BLOCK(s, 0); ** */\n                flush_block_only(s, false);\n                if (s.strm.avail_out === 0) {\n                    return BS_NEED_MORE;\n                }\n                /***/\n            }\n            return BS_BLOCK_DONE;\n        };\n        /* ===========================================================================\n         * For Z_RLE, simply look for runs of bytes, generate matches only of distance\n         * one.  Do not maintain a hash table.  (It will be regenerated if this run of\n         * deflate switches away from Z_RLE.)\n         */\n        var deflate_rle = function deflate_rle(s, flush) {\n            var bflush;\n            /* set if current block must be flushed */\n            var prev;\n            /* byte at distance one to match */\n            var scan;\n            var strend;\n            /* scan goes up to strend for length of run */\n            var _win = s.window;\n            for (;;) {\n                /* Make sure that we always have enough lookahead, except\n                 * at the end of the input file. We need MAX_MATCH bytes\n                 * for the longest run, plus one for the unrolled loop.\n                 */\n                if (s.lookahead <= MAX_MATCH$1) {\n                    fill_window(s);\n                    if (s.lookahead <= MAX_MATCH$1 && flush === Z_NO_FLUSH) {\n                        return BS_NEED_MORE;\n                    }\n                    if (s.lookahead === 0) {\n                        break;\n                    }\n                    /* flush the current block */\n                }\n                /* See how many times the previous byte repeats */\n                s.match_length = 0;\n                if (s.lookahead >= MIN_MATCH$1 && s.strstart > 0) {\n                    scan = s.strstart - 1;\n                    prev = _win[scan];\n                    if (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan]) {\n                        strend = s.strstart + MAX_MATCH$1;\n                        do {\n                            /* jshint noempty:false */\n                        } while (prev === _win[++scan] &&\n                            prev === _win[++scan] &&\n                            prev === _win[++scan] &&\n                            prev === _win[++scan] &&\n                            prev === _win[++scan] &&\n                            prev === _win[++scan] &&\n                            prev === _win[++scan] &&\n                            prev === _win[++scan] &&\n                            scan < strend);\n                        s.match_length = MAX_MATCH$1 - (strend - scan);\n                        if (s.match_length > s.lookahead) {\n                            s.match_length = s.lookahead;\n                        }\n                    } // Assert(scan <= s->window+(uInt)(s->window_size-1), \"wild scan\");\n                }\n                /* Emit match if have run of MIN_MATCH or longer, else emit literal */\n                if (s.match_length >= MIN_MATCH$1) {\n                    // check_match(s, s.strstart, s.strstart - 1, s.match_length);\n                    /** * _tr_tally_dist(s, 1, s.match_length - MIN_MATCH, bflush); ** */\n                    bflush = _tr_tally$1(s, 1, s.match_length - MIN_MATCH$1);\n                    s.lookahead -= s.match_length;\n                    s.strstart += s.match_length;\n                    s.match_length = 0;\n                }\n                else {\n                    /* No match, output a literal byte */\n                    // Tracevv((stderr,\"%c\", s->window[s->strstart]));\n                    /** * _tr_tally_lit(s, s.window[s.strstart], bflush); ** */\n                    bflush = _tr_tally$1(s, 0, s.window[s.strstart]);\n                    s.lookahead--;\n                    s.strstart++;\n                }\n                if (bflush) {\n                    /** * FLUSH_BLOCK(s, 0); ** */\n                    flush_block_only(s, false);\n                    if (s.strm.avail_out === 0) {\n                        return BS_NEED_MORE;\n                    }\n                    /***/\n                }\n            }\n            s.insert = 0;\n            if (flush === Z_FINISH) {\n                /** * FLUSH_BLOCK(s, 1); ** */\n                flush_block_only(s, true);\n                if (s.strm.avail_out === 0) {\n                    return BS_FINISH_STARTED;\n                }\n                /***/\n                return BS_FINISH_DONE;\n            }\n            if (s.last_lit) {\n                /** * FLUSH_BLOCK(s, 0); ** */\n                flush_block_only(s, false);\n                if (s.strm.avail_out === 0) {\n                    return BS_NEED_MORE;\n                }\n                /***/\n            }\n            return BS_BLOCK_DONE;\n        };\n        /* ===========================================================================\n         * For Z_HUFFMAN_ONLY, do not look for matches.  Do not maintain a hash table.\n         * (It will be regenerated if this run of deflate switches away from Huffman.)\n         */\n        var deflate_huff = function deflate_huff(s, flush) {\n            var bflush;\n            /* set if current block must be flushed */\n            for (;;) {\n                /* Make sure that we have a literal to write. */\n                if (s.lookahead === 0) {\n                    fill_window(s);\n                    if (s.lookahead === 0) {\n                        if (flush === Z_NO_FLUSH) {\n                            return BS_NEED_MORE;\n                        }\n                        break;\n                        /* flush the current block */\n                    }\n                }\n                /* Output a literal byte */\n                s.match_length = 0; // Tracevv((stderr,\"%c\", s->window[s->strstart]));\n                /** * _tr_tally_lit(s, s.window[s.strstart], bflush); ** */\n                bflush = _tr_tally$1(s, 0, s.window[s.strstart]);\n                s.lookahead--;\n                s.strstart++;\n                if (bflush) {\n                    /** * FLUSH_BLOCK(s, 0); ** */\n                    flush_block_only(s, false);\n                    if (s.strm.avail_out === 0) {\n                        return BS_NEED_MORE;\n                    }\n                    /***/\n                }\n            }\n            s.insert = 0;\n            if (flush === Z_FINISH) {\n                /** * FLUSH_BLOCK(s, 1); ** */\n                flush_block_only(s, true);\n                if (s.strm.avail_out === 0) {\n                    return BS_FINISH_STARTED;\n                }\n                /***/\n                return BS_FINISH_DONE;\n            }\n            if (s.last_lit) {\n                /** * FLUSH_BLOCK(s, 0); ** */\n                flush_block_only(s, false);\n                if (s.strm.avail_out === 0) {\n                    return BS_NEED_MORE;\n                }\n                /***/\n            }\n            return BS_BLOCK_DONE;\n        };\n        /* Values for max_lazy_match, good_match and max_chain_length, depending on\n         * the desired pack level (0..9). The values given below have been tuned to\n         * exclude worst case performance for pathological files. Better values may be\n         * found for specific files.\n         */\n        function Config(good_length, max_lazy, nice_length, max_chain, func) {\n            this.good_length = good_length;\n            this.max_lazy = max_lazy;\n            this.nice_length = nice_length;\n            this.max_chain = max_chain;\n            this.func = func;\n        }\n        var configuration_table = [\n            /*      good lazy nice chain */\n            new Config(0, 0, 0, 0, deflate_stored),\n            /* 0 store only */\n            new Config(4, 4, 8, 4, deflate_fast),\n            /* 1 max speed, no lazy matches */\n            new Config(4, 5, 16, 8, deflate_fast),\n            /* 2 */\n            new Config(4, 6, 32, 32, deflate_fast),\n            /* 3 */\n            new Config(4, 4, 16, 16, deflate_slow),\n            /* 4 lazy matches */\n            new Config(8, 16, 32, 32, deflate_slow),\n            /* 5 */\n            new Config(8, 16, 128, 128, deflate_slow),\n            /* 6 */\n            new Config(8, 32, 128, 256, deflate_slow),\n            /* 7 */\n            new Config(32, 128, 258, 1024, deflate_slow),\n            /* 8 */\n            new Config(32, 258, 258, 4096, deflate_slow),\n            /* 9 max compression */\n        ];\n        /* ===========================================================================\n         * Initialize the \"longest match\" routines for a new zlib stream\n         */\n        var lm_init = function lm_init(s) {\n            s.window_size = 2 * s.w_size;\n            /** * CLEAR_HASH(s); ** */\n            zero$1(s.head); // Fill with NIL (= 0);\n            /* Set the default configuration parameters:\n             */\n            s.max_lazy_match = configuration_table[s.level].max_lazy;\n            s.good_match = configuration_table[s.level].good_length;\n            s.nice_match = configuration_table[s.level].nice_length;\n            s.max_chain_length = configuration_table[s.level].max_chain;\n            s.strstart = 0;\n            s.block_start = 0;\n            s.lookahead = 0;\n            s.insert = 0;\n            s.match_length = s.prev_length = MIN_MATCH$1 - 1;\n            s.match_available = 0;\n            s.ins_h = 0;\n        };\n        function DeflateState() {\n            this.strm = null;\n            /* pointer back to this zlib stream */\n            this.status = 0;\n            /* as the name implies */\n            this.pending_buf = null;\n            /* output still pending */\n            this.pending_buf_size = 0;\n            /* size of pending_buf */\n            this.pending_out = 0;\n            /* next pending byte to output to the stream */\n            this.pending = 0;\n            /* nb of bytes in the pending buffer */\n            this.wrap = 0;\n            /* bit 0 true for zlib, bit 1 true for gzip */\n            this.gzhead = null;\n            /* gzip header information to write */\n            this.gzindex = 0;\n            /* where in extra, name, or comment */\n            this.method = Z_DEFLATED;\n            /* can only be DEFLATED */\n            this.last_flush = -1;\n            /* value of flush param for previous deflate call */\n            this.w_size = 0;\n            /* LZ77 window size (32K by default) */\n            this.w_bits = 0;\n            /* log2(w_size)  (8..16) */\n            this.w_mask = 0;\n            /* w_size - 1 */\n            this.window = null;\n            /* Sliding window. Input bytes are read into the second half of the window,\n             * and move to the first half later to keep a dictionary of at least wSize\n             * bytes. With this organization, matches are limited to a distance of\n             * wSize-MAX_MATCH bytes, but this ensures that IO is always\n             * performed with a length multiple of the block size.\n             */\n            this.window_size = 0;\n            /* Actual size of window: 2*wSize, except when the user input buffer\n             * is directly used as sliding window.\n             */\n            this.prev = null;\n            /* Link to older string with same hash index. To limit the size of this\n             * array to 64K, this link is maintained only for the last 32K strings.\n             * An index in this array is thus a window index modulo 32K.\n             */\n            this.head = null;\n            /* Heads of the hash chains or NIL. */\n            this.ins_h = 0;\n            /* hash index of string to be inserted */\n            this.hash_size = 0;\n            /* number of elements in hash table */\n            this.hash_bits = 0;\n            /* log2(hash_size) */\n            this.hash_mask = 0;\n            /* hash_size-1 */\n            this.hash_shift = 0;\n            /* Number of bits by which ins_h must be shifted at each input\n             * step. It must be such that after MIN_MATCH steps, the oldest\n             * byte no longer takes part in the hash key, that is:\n             *   hash_shift * MIN_MATCH >= hash_bits\n             */\n            this.block_start = 0;\n            /* Window position at the beginning of the current output block. Gets\n             * negative when the window is moved backwards.\n             */\n            this.match_length = 0;\n            /* length of best match */\n            this.prev_match = 0;\n            /* previous match */\n            this.match_available = 0;\n            /* set if previous match exists */\n            this.strstart = 0;\n            /* start of string to insert */\n            this.match_start = 0;\n            /* start of matching string */\n            this.lookahead = 0;\n            /* number of valid bytes ahead in window */\n            this.prev_length = 0;\n            /* Length of the best match at previous step. Matches not greater than this\n             * are discarded. This is used in the lazy match evaluation.\n             */\n            this.max_chain_length = 0;\n            /* To speed up deflation, hash chains are never searched beyond this\n             * length.  A higher limit improves compression ratio but degrades the\n             * speed.\n             */\n            this.max_lazy_match = 0;\n            /* Attempt to find a better match only when the current match is strictly\n             * smaller than this value. This mechanism is used only for compression\n             * levels >= 4.\n             */\n            // That's alias to max_lazy_match, don't use directly\n            // this.max_insert_length = 0;\n            /* Insert new strings in the hash table only if the match length is not\n             * greater than this length. This saves time but degrades compression.\n             * max_insert_length is used only for compression levels <= 3.\n             */\n            this.level = 0;\n            /* compression level (1..9) */\n            this.strategy = 0;\n            /* favor or force Huffman coding */\n            this.good_match = 0;\n            /* Use a faster search when the previous match is longer than this */\n            this.nice_match = 0;\n            /* Stop searching when current match exceeds this */\n            /* used by trees.c: */\n            /* Didn't use ct_data typedef below to suppress compiler warning */\n            // struct ct_data_s dyn_ltree[HEAP_SIZE];   /* literal and length tree */\n            // struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */\n            // struct ct_data_s bl_tree[2*BL_CODES+1];  /* Huffman tree for bit lengths */\n            // Use flat array of DOUBLE size, with interleaved fata,\n            // because JS does not support effective\n            this.dyn_ltree = new Uint16Array(HEAP_SIZE$1 * 2);\n            this.dyn_dtree = new Uint16Array((2 * D_CODES$1 + 1) * 2);\n            this.bl_tree = new Uint16Array((2 * BL_CODES$1 + 1) * 2);\n            zero$1(this.dyn_ltree);\n            zero$1(this.dyn_dtree);\n            zero$1(this.bl_tree);\n            this.l_desc = null;\n            /* desc. for literal tree */\n            this.d_desc = null;\n            /* desc. for distance tree */\n            this.bl_desc = null;\n            /* desc. for bit length tree */\n            // ush bl_count[MAX_BITS+1];\n            this.bl_count = new Uint16Array(MAX_BITS$1 + 1);\n            /* number of codes at each bit length for an optimal tree */\n            // int heap[2*L_CODES+1];      /* heap used to build the Huffman trees */\n            this.heap = new Uint16Array(2 * L_CODES$1 + 1);\n            /* heap used to build the Huffman trees */\n            zero$1(this.heap);\n            this.heap_len = 0;\n            /* number of elements in the heap */\n            this.heap_max = 0;\n            /* element of largest frequency */\n            /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.\n             * The same heap array is used to build all trees.\n             */\n            this.depth = new Uint16Array(2 * L_CODES$1 + 1); // uch depth[2*L_CODES+1];\n            zero$1(this.depth);\n            /* Depth of each subtree used as tie breaker for trees of equal frequency\n             */\n            this.l_buf = 0;\n            /* buffer index for literals or lengths */\n            this.lit_bufsize = 0;\n            /* Size of match buffer for literals/lengths.  There are 4 reasons for\n             * limiting lit_bufsize to 64K:\n             *   - frequencies can be kept in 16 bit counters\n             *   - if compression is not successful for the first block, all input\n             *     data is still in the window so we can still emit a stored block even\n             *     when input comes from standard input.  (This can also be done for\n             *     all blocks if lit_bufsize is not greater than 32K.)\n             *   - if compression is not successful for a file smaller than 64K, we can\n             *     even emit a stored file instead of a stored block (saving 5 bytes).\n             *     This is applicable only for zip (not gzip or zlib).\n             *   - creating new Huffman trees less frequently may not provide fast\n             *     adaptation to changes in the input data statistics. (Take for\n             *     example a binary file with poorly compressible code followed by\n             *     a highly compressible string table.) Smaller buffer sizes give\n             *     fast adaptation but have of course the overhead of transmitting\n             *     trees more frequently.\n             *   - I can't count above 4\n             */\n            this.last_lit = 0;\n            /* running index in l_buf */\n            this.d_buf = 0;\n            /* Buffer index for distances. To simplify the code, d_buf and l_buf have\n             * the same number of elements. To use different lengths, an extra flag\n             * array would be necessary.\n             */\n            this.opt_len = 0;\n            /* bit length of current block with optimal trees */\n            this.static_len = 0;\n            /* bit length of current block with static trees */\n            this.matches = 0;\n            /* number of string matches in current block */\n            this.insert = 0;\n            /* bytes at end of window left to insert */\n            this.bi_buf = 0;\n            /* Output buffer. bits are inserted starting at the bottom (least\n             * significant bits).\n             */\n            this.bi_valid = 0;\n            /* Number of valid bits in bi_buf.  All bits above the last valid bit\n             * are always zero.\n             */\n            // Used for window memory init. We safely ignore it for JS. That makes\n            // sense only for pointers and memory check tools.\n            // this.high_water = 0;\n            /* High water mark offset in window for initialized bytes -- bytes above\n             * this are set to zero in order to avoid memory check warnings when\n             * longest match routines access bytes past the input.  This is then\n             * updated to the new high water mark.\n             */\n        }\n        var deflateResetKeep = function deflateResetKeep(strm) {\n            if (!strm || !strm.state) {\n                return err(strm, Z_STREAM_ERROR);\n            }\n            strm.total_in = strm.total_out = 0;\n            strm.data_type = Z_UNKNOWN$1;\n            var s = strm.state;\n            s.pending = 0;\n            s.pending_out = 0;\n            if (s.wrap < 0) {\n                s.wrap = -s.wrap;\n                /* was made negative by deflate(..., Z_FINISH); */\n            }\n            s.status = s.wrap ? INIT_STATE : BUSY_STATE;\n            strm.adler =\n                s.wrap === 2\n                    ? 0 // crc32(0, Z_NULL, 0)\n                    : 1; // adler32(0, Z_NULL, 0)\n            s.last_flush = Z_NO_FLUSH;\n            _tr_init$1(s);\n            return Z_OK;\n        };\n        var deflateReset = function deflateReset(strm) {\n            var ret = deflateResetKeep(strm);\n            if (ret === Z_OK) {\n                lm_init(strm.state);\n            }\n            return ret;\n        };\n        var deflateSetHeader = function deflateSetHeader(strm, head) {\n            if (!strm || !strm.state) {\n                return Z_STREAM_ERROR;\n            }\n            if (strm.state.wrap !== 2) {\n                return Z_STREAM_ERROR;\n            }\n            strm.state.gzhead = head;\n            return Z_OK;\n        };\n        var deflateInit2 = function deflateInit2(strm, level, method, windowBits, memLevel, strategy) {\n            if (!strm) {\n                // === Z_NULL\n                return Z_STREAM_ERROR;\n            }\n            var wrap = 1;\n            if (level === Z_DEFAULT_COMPRESSION) {\n                level = 6;\n            }\n            if (windowBits < 0) {\n                /* suppress zlib wrapper */\n                wrap = 0;\n                windowBits = -windowBits;\n            }\n            else if (windowBits > 15) {\n                wrap = 2;\n                /* write gzip wrapper instead */\n                windowBits -= 16;\n            }\n            if (memLevel < 1 ||\n                memLevel > MAX_MEM_LEVEL ||\n                method !== Z_DEFLATED ||\n                windowBits < 8 ||\n                windowBits > 15 ||\n                level < 0 ||\n                level > 9 ||\n                strategy < 0 ||\n                strategy > Z_FIXED$1) {\n                return err(strm, Z_STREAM_ERROR);\n            }\n            if (windowBits === 8) {\n                windowBits = 9;\n            }\n            /* until 256-byte window bug fixed */\n            var s = new DeflateState();\n            strm.state = s;\n            s.strm = strm;\n            s.wrap = wrap;\n            s.gzhead = null;\n            s.w_bits = windowBits;\n            s.w_size = 1 << s.w_bits;\n            s.w_mask = s.w_size - 1;\n            s.hash_bits = memLevel + 7;\n            s.hash_size = 1 << s.hash_bits;\n            s.hash_mask = s.hash_size - 1;\n            s.hash_shift = ~~((s.hash_bits + MIN_MATCH$1 - 1) / MIN_MATCH$1);\n            s.window = new Uint8Array(s.w_size * 2);\n            s.head = new Uint16Array(s.hash_size);\n            s.prev = new Uint16Array(s.w_size); // Don't need mem init magic for JS.\n            // s.high_water = 0;  /* nothing written to s->window yet */\n            s.lit_bufsize = 1 << (memLevel + 6);\n            /* 16K elements by default */\n            s.pending_buf_size = s.lit_bufsize * 4;\n            // overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2);\n            // s->pending_buf = (uchf *) overlay;\n            // It is offset from `s.pending_buf` (size is `s.lit_bufsize * 2`)\n            s.pending_buf = new Uint8Array(s.pending_buf_size);\n            // s->d_buf = overlay + s->lit_bufsize/sizeof(ush);\n            s.d_buf = 1 * s.lit_bufsize; // s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize;\n            s.l_buf = (1 + 2) * s.lit_bufsize;\n            s.level = level;\n            s.strategy = strategy;\n            s.method = method;\n            return deflateReset(strm);\n        };\n        var deflateInit = function deflateInit(strm, level) {\n            return deflateInit2(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);\n        };\n        var deflate = function deflate(strm, flush) {\n            var beg;\n            var val; // for gzip header write only\n            if (!strm || !strm.state || flush > Z_BLOCK || flush < 0) {\n                return strm ? err(strm, Z_STREAM_ERROR) : Z_STREAM_ERROR;\n            }\n            var s = strm.state;\n            if (!strm.output || (!strm.input && strm.avail_in !== 0) || (s.status === FINISH_STATE && flush !== Z_FINISH)) {\n                return err(strm, strm.avail_out === 0 ? Z_BUF_ERROR : Z_STREAM_ERROR);\n            }\n            s.strm = strm;\n            /* just in case */\n            var old_flush = s.last_flush;\n            s.last_flush = flush;\n            /* Write the header */\n            if (s.status === INIT_STATE) {\n                if (s.wrap === 2) {\n                    // GZIP header\n                    strm.adler = 0; // crc32(0L, Z_NULL, 0);\n                    put_byte(s, 31);\n                    put_byte(s, 139);\n                    put_byte(s, 8);\n                    if (!s.gzhead) {\n                        // s->gzhead == Z_NULL\n                        put_byte(s, 0);\n                        put_byte(s, 0);\n                        put_byte(s, 0);\n                        put_byte(s, 0);\n                        put_byte(s, 0);\n                        put_byte(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? 4 : 0);\n                        put_byte(s, OS_CODE);\n                        s.status = BUSY_STATE;\n                    }\n                    else {\n                        put_byte(s, (s.gzhead.text ? 1 : 0) +\n                            (s.gzhead.hcrc ? 2 : 0) +\n                            (!s.gzhead.extra ? 0 : 4) +\n                            (!s.gzhead.name ? 0 : 8) +\n                            (!s.gzhead.comment ? 0 : 16));\n                        put_byte(s, s.gzhead.time & 0xff);\n                        put_byte(s, (s.gzhead.time >> 8) & 0xff);\n                        put_byte(s, (s.gzhead.time >> 16) & 0xff);\n                        put_byte(s, (s.gzhead.time >> 24) & 0xff);\n                        put_byte(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? 4 : 0);\n                        put_byte(s, s.gzhead.os & 0xff);\n                        if (s.gzhead.extra && s.gzhead.extra.length) {\n                            put_byte(s, s.gzhead.extra.length & 0xff);\n                            put_byte(s, (s.gzhead.extra.length >> 8) & 0xff);\n                        }\n                        if (s.gzhead.hcrc) {\n                            strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending, 0);\n                        }\n                        s.gzindex = 0;\n                        s.status = EXTRA_STATE;\n                    }\n                } // DEFLATE header\n                else {\n                    var header = (Z_DEFLATED + ((s.w_bits - 8) << 4)) << 8;\n                    var level_flags = -1;\n                    if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) {\n                        level_flags = 0;\n                    }\n                    else if (s.level < 6) {\n                        level_flags = 1;\n                    }\n                    else if (s.level === 6) {\n                        level_flags = 2;\n                    }\n                    else {\n                        level_flags = 3;\n                    }\n                    header |= level_flags << 6;\n                    if (s.strstart !== 0) {\n                        header |= PRESET_DICT;\n                    }\n                    header += 31 - (header % 31);\n                    s.status = BUSY_STATE;\n                    putShortMSB(s, header);\n                    /* Save the adler32 of the preset dictionary: */\n                    if (s.strstart !== 0) {\n                        putShortMSB(s, strm.adler >>> 16);\n                        putShortMSB(s, strm.adler & 0xffff);\n                    }\n                    strm.adler = 1; // adler32(0L, Z_NULL, 0);\n                }\n            } // #ifdef GZIP\n            if (s.status === EXTRA_STATE) {\n                if (s.gzhead.extra\n                /* != Z_NULL */\n                ) {\n                    beg = s.pending;\n                    /* start of bytes to update crc */\n                    while (s.gzindex < (s.gzhead.extra.length & 0xffff)) {\n                        if (s.pending === s.pending_buf_size) {\n                            if (s.gzhead.hcrc && s.pending > beg) {\n                                strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);\n                            }\n                            flush_pending(strm);\n                            beg = s.pending;\n                            if (s.pending === s.pending_buf_size) {\n                                break;\n                            }\n                        }\n                        put_byte(s, s.gzhead.extra[s.gzindex] & 0xff);\n                        s.gzindex++;\n                    }\n                    if (s.gzhead.hcrc && s.pending > beg) {\n                        strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);\n                    }\n                    if (s.gzindex === s.gzhead.extra.length) {\n                        s.gzindex = 0;\n                        s.status = NAME_STATE;\n                    }\n                }\n                else {\n                    s.status = NAME_STATE;\n                }\n            }\n            if (s.status === NAME_STATE) {\n                if (s.gzhead.name\n                /* != Z_NULL */\n                ) {\n                    beg = s.pending;\n                    /* start of bytes to update crc */\n                    // int val;\n                    do {\n                        if (s.pending === s.pending_buf_size) {\n                            if (s.gzhead.hcrc && s.pending > beg) {\n                                strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);\n                            }\n                            flush_pending(strm);\n                            beg = s.pending;\n                            if (s.pending === s.pending_buf_size) {\n                                val = 1;\n                                break;\n                            }\n                        } // JS specific: little magic to add zero terminator to end of string\n                        if (s.gzindex < s.gzhead.name.length) {\n                            val = s.gzhead.name.charCodeAt(s.gzindex++) & 0xff;\n                        }\n                        else {\n                            val = 0;\n                        }\n                        put_byte(s, val);\n                    } while (val !== 0);\n                    if (s.gzhead.hcrc && s.pending > beg) {\n                        strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);\n                    }\n                    if (val === 0) {\n                        s.gzindex = 0;\n                        s.status = COMMENT_STATE;\n                    }\n                }\n                else {\n                    s.status = COMMENT_STATE;\n                }\n            }\n            if (s.status === COMMENT_STATE) {\n                if (s.gzhead.comment\n                /* != Z_NULL */\n                ) {\n                    beg = s.pending;\n                    /* start of bytes to update crc */\n                    // int val;\n                    do {\n                        if (s.pending === s.pending_buf_size) {\n                            if (s.gzhead.hcrc && s.pending > beg) {\n                                strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);\n                            }\n                            flush_pending(strm);\n                            beg = s.pending;\n                            if (s.pending === s.pending_buf_size) {\n                                val = 1;\n                                break;\n                            }\n                        } // JS specific: little magic to add zero terminator to end of string\n                        if (s.gzindex < s.gzhead.comment.length) {\n                            val = s.gzhead.comment.charCodeAt(s.gzindex++) & 0xff;\n                        }\n                        else {\n                            val = 0;\n                        }\n                        put_byte(s, val);\n                    } while (val !== 0);\n                    if (s.gzhead.hcrc && s.pending > beg) {\n                        strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);\n                    }\n                    if (val === 0) {\n                        s.status = HCRC_STATE;\n                    }\n                }\n                else {\n                    s.status = HCRC_STATE;\n                }\n            }\n            if (s.status === HCRC_STATE) {\n                if (s.gzhead.hcrc) {\n                    if (s.pending + 2 > s.pending_buf_size) {\n                        flush_pending(strm);\n                    }\n                    if (s.pending + 2 <= s.pending_buf_size) {\n                        put_byte(s, strm.adler & 0xff);\n                        put_byte(s, (strm.adler >> 8) & 0xff);\n                        strm.adler = 0; // crc32(0L, Z_NULL, 0);\n                        s.status = BUSY_STATE;\n                    }\n                }\n                else {\n                    s.status = BUSY_STATE;\n                }\n            } // #endif\n            /* Flush as much pending output as possible */\n            if (s.pending !== 0) {\n                flush_pending(strm);\n                if (strm.avail_out === 0) {\n                    /* Since avail_out is 0, deflate will be called again with\n                     * more output space, but possibly with both pending and\n                     * avail_in equal to zero. There won't be anything to do,\n                     * but this is not an error situation so make sure we\n                     * return OK instead of BUF_ERROR at next call of deflate:\n                     */\n                    s.last_flush = -1;\n                    return Z_OK;\n                }\n                /* Make sure there is something to do and avoid duplicate consecutive\n                 * flushes. For repeated and useless calls with Z_FINISH, we keep\n                 * returning Z_STREAM_END instead of Z_BUF_ERROR.\n                 */\n            }\n            else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) && flush !== Z_FINISH) {\n                return err(strm, Z_BUF_ERROR);\n            }\n            /* User must not provide more input after the first FINISH: */\n            if (s.status === FINISH_STATE && strm.avail_in !== 0) {\n                return err(strm, Z_BUF_ERROR);\n            }\n            /* Start a new block or continue the current one.\n             */\n            if (strm.avail_in !== 0 || s.lookahead !== 0 || (flush !== Z_NO_FLUSH && s.status !== FINISH_STATE)) {\n                var bstate = s.strategy === Z_HUFFMAN_ONLY\n                    ? deflate_huff(s, flush)\n                    : s.strategy === Z_RLE\n                        ? deflate_rle(s, flush)\n                        : configuration_table[s.level].func(s, flush);\n                if (bstate === BS_FINISH_STARTED || bstate === BS_FINISH_DONE) {\n                    s.status = FINISH_STATE;\n                }\n                if (bstate === BS_NEED_MORE || bstate === BS_FINISH_STARTED) {\n                    if (strm.avail_out === 0) {\n                        s.last_flush = -1;\n                        /* avoid BUF_ERROR next call, see above */\n                    }\n                    return Z_OK;\n                    /* If flush != Z_NO_FLUSH && avail_out == 0, the next call\n                     * of deflate should use the same flush parameter to make sure\n                     * that the flush is complete. So we don't have to output an\n                     * empty block here, this will be done at next call. This also\n                     * ensures that for a very small output buffer, we emit at most\n                     * one empty block.\n                     */\n                }\n                if (bstate === BS_BLOCK_DONE) {\n                    if (flush === Z_PARTIAL_FLUSH) {\n                        _tr_align$1(s);\n                    }\n                    else if (flush !== Z_BLOCK) {\n                        /* FULL_FLUSH or SYNC_FLUSH */\n                        _tr_stored_block$1(s, 0, 0, false);\n                        /* For a full flush, this empty block will be recognized\n                         * as a special marker by inflate_sync().\n                         */\n                        if (flush === Z_FULL_FLUSH) {\n                            /** * CLEAR_HASH(s); ** */\n                            /* forget history */\n                            zero$1(s.head); // Fill with NIL (= 0);\n                            if (s.lookahead === 0) {\n                                s.strstart = 0;\n                                s.block_start = 0;\n                                s.insert = 0;\n                            }\n                        }\n                    }\n                    flush_pending(strm);\n                    if (strm.avail_out === 0) {\n                        s.last_flush = -1;\n                        /* avoid BUF_ERROR at next call, see above */\n                        return Z_OK;\n                    }\n                }\n            } // Assert(strm->avail_out > 0, \"bug2\");\n            // if (strm.avail_out <= 0) { throw new Error(\"bug2\");}\n            if (flush !== Z_FINISH) {\n                return Z_OK;\n            }\n            if (s.wrap <= 0) {\n                return Z_STREAM_END;\n            }\n            /* Write the trailer */\n            if (s.wrap === 2) {\n                put_byte(s, strm.adler & 0xff);\n                put_byte(s, (strm.adler >> 8) & 0xff);\n                put_byte(s, (strm.adler >> 16) & 0xff);\n                put_byte(s, (strm.adler >> 24) & 0xff);\n                put_byte(s, strm.total_in & 0xff);\n                put_byte(s, (strm.total_in >> 8) & 0xff);\n                put_byte(s, (strm.total_in >> 16) & 0xff);\n                put_byte(s, (strm.total_in >> 24) & 0xff);\n            }\n            else {\n                putShortMSB(s, strm.adler >>> 16);\n                putShortMSB(s, strm.adler & 0xffff);\n            }\n            flush_pending(strm);\n            /* If avail_out is zero, the application will call deflate again\n             * to flush the rest.\n             */\n            if (s.wrap > 0) {\n                s.wrap = -s.wrap;\n            }\n            /* write the trailer only once! */\n            return s.pending !== 0 ? Z_OK : Z_STREAM_END;\n        };\n        var deflateEnd = function deflateEnd(strm) {\n            if (!strm ||\n                /* == Z_NULL */\n                !strm.state\n            /* == Z_NULL */\n            ) {\n                return Z_STREAM_ERROR;\n            }\n            var status = strm.state.status;\n            if (status !== INIT_STATE &&\n                status !== EXTRA_STATE &&\n                status !== NAME_STATE &&\n                status !== COMMENT_STATE &&\n                status !== HCRC_STATE &&\n                status !== BUSY_STATE &&\n                status !== FINISH_STATE) {\n                return err(strm, Z_STREAM_ERROR);\n            }\n            strm.state = null;\n            return status === BUSY_STATE ? err(strm, Z_DATA_ERROR) : Z_OK;\n        };\n        /* =========================================================================\n         * Initializes the compression dictionary from the given byte\n         * sequence without producing any compressed output.\n         */\n        var deflateSetDictionary = function deflateSetDictionary(strm, dictionary) {\n            var dictLength = dictionary.length;\n            if (!strm ||\n                /* == Z_NULL */\n                !strm.state\n            /* == Z_NULL */\n            ) {\n                return Z_STREAM_ERROR;\n            }\n            var s = strm.state;\n            var wrap = s.wrap;\n            if (wrap === 2 || (wrap === 1 && s.status !== INIT_STATE) || s.lookahead) {\n                return Z_STREAM_ERROR;\n            }\n            /* when using zlib wrappers, compute Adler-32 for provided dictionary */\n            if (wrap === 1) {\n                /* adler32(strm->adler, dictionary, dictLength); */\n                strm.adler = adler32_1(strm.adler, dictionary, dictLength, 0);\n            }\n            s.wrap = 0;\n            /* avoid computing Adler-32 in read_buf */\n            /* if dictionary would fill window, just replace the history */\n            if (dictLength >= s.w_size) {\n                if (wrap === 0) {\n                    /* already empty otherwise */\n                    /** * CLEAR_HASH(s); ** */\n                    zero$1(s.head); // Fill with NIL (= 0);\n                    s.strstart = 0;\n                    s.block_start = 0;\n                    s.insert = 0;\n                }\n                /* use the tail */\n                // dictionary = dictionary.slice(dictLength - s.w_size);\n                var tmpDict = new Uint8Array(s.w_size);\n                tmpDict.set(dictionary.subarray(dictLength - s.w_size, dictLength), 0);\n                dictionary = tmpDict;\n                dictLength = s.w_size;\n            }\n            /* insert dictionary into window and hash */\n            var avail = strm.avail_in;\n            var next = strm.next_in;\n            var input = strm.input;\n            strm.avail_in = dictLength;\n            strm.next_in = 0;\n            strm.input = dictionary;\n            fill_window(s);\n            while (s.lookahead >= MIN_MATCH$1) {\n                var str = s.strstart;\n                var n = s.lookahead - (MIN_MATCH$1 - 1);\n                do {\n                    /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */\n                    s.ins_h = HASH(s, s.ins_h, s.window[str + MIN_MATCH$1 - 1]);\n                    s.prev[str & s.w_mask] = s.head[s.ins_h];\n                    s.head[s.ins_h] = str;\n                    str++;\n                } while (--n);\n                s.strstart = str;\n                s.lookahead = MIN_MATCH$1 - 1;\n                fill_window(s);\n            }\n            s.strstart += s.lookahead;\n            s.block_start = s.strstart;\n            s.insert = s.lookahead;\n            s.lookahead = 0;\n            s.match_length = s.prev_length = MIN_MATCH$1 - 1;\n            s.match_available = 0;\n            strm.next_in = next;\n            strm.input = input;\n            strm.avail_in = avail;\n            s.wrap = wrap;\n            return Z_OK;\n        };\n        var deflateInit_1 = deflateInit;\n        var deflateInit2_1 = deflateInit2;\n        var deflateReset_1 = deflateReset;\n        var deflateResetKeep_1 = deflateResetKeep;\n        var deflateSetHeader_1 = deflateSetHeader;\n        var deflate_2 = deflate;\n        var deflateEnd_1 = deflateEnd;\n        var deflateSetDictionary_1 = deflateSetDictionary;\n        var deflateInfo = 'pako deflate (from Nodeca project)';\n        /* Not implemented\n      module.exports.deflateBound = deflateBound;\n      module.exports.deflateCopy = deflateCopy;\n      module.exports.deflateParams = deflateParams;\n      module.exports.deflatePending = deflatePending;\n      module.exports.deflatePrime = deflatePrime;\n      module.exports.deflateTune = deflateTune;\n      */\n        var deflate_1 = {\n            deflateInit: deflateInit_1,\n            deflateInit2: deflateInit2_1,\n            deflateReset: deflateReset_1,\n            deflateResetKeep: deflateResetKeep_1,\n            deflateSetHeader: deflateSetHeader_1,\n            deflate: deflate_2,\n            deflateEnd: deflateEnd_1,\n            deflateSetDictionary: deflateSetDictionary_1,\n            deflateInfo: deflateInfo,\n        };\n        // Join array of chunks to single array.\n        function flattenChunks(chunks) {\n            // calculate data length\n            var len = 0;\n            for (var i = 0, l = chunks.length; i < l; i++) {\n                len += chunks[i].length;\n            } // join chunks\n            var result = new Uint8Array(len);\n            for (var _i = 0, pos = 0, _l = chunks.length; _i < _l; _i++) {\n                var chunk = chunks[_i];\n                result.set(chunk, pos);\n                pos += chunk.length;\n            }\n            return result;\n        }\n        // String encode/decode helpers\n        //\n        // - apply(Array) can fail on Android 2.2\n        // - apply(Uint8Array) can fail on iOS 5.1 Safari\n        //\n        // Table with utf8 lengths (calculated by first byte of sequence)\n        // Note, that 5 & 6-byte values and some 4-byte values can not be represented in JS,\n        // because max possible codepoint is 0x10ffff\n        var _utf8len = new Uint8Array(256);\n        for (var q = 0; q < 256; q++) {\n            _utf8len[q] = q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1;\n        }\n        _utf8len[254] = _utf8len[254] = 1; // Invalid sequence start\n        // convert string to array (typed, when possible)\n        // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n        //\n        // This software is provided 'as-is', without any express or implied\n        // warranty. In no event will the authors be held liable for any damages\n        // arising from the use of this software.\n        //\n        // Permission is granted to anyone to use this software for any purpose,\n        // including commercial applications, and to alter it and redistribute it\n        // freely, subject to the following restrictions:\n        //\n        // 1. The origin of this software must not be misrepresented; you must not\n        //   claim that you wrote the original software. If you use this software\n        //   in a product, an acknowledgment in the product documentation would be\n        //   appreciated but is not required.\n        // 2. Altered source versions must be plainly marked as such, and must not be\n        //   misrepresented as being the original software.\n        // 3. This notice may not be removed or altered from any source distribution.\n        function ZStream() {\n            /* next input byte */\n            this.input = null; // JS specific, because we have no pointers\n            this.next_in = 0;\n            /* number of bytes available at input */\n            this.avail_in = 0;\n            /* total number of input bytes read so far */\n            this.total_in = 0;\n            /* next output byte should be put there */\n            this.output = null; // JS specific, because we have no pointers\n            this.next_out = 0;\n            /* remaining free space at output */\n            this.avail_out = 0;\n            /* total number of bytes output so far */\n            this.total_out = 0;\n            /* last error message, NULL if no error */\n            this.msg = '';\n            /* Z_NULL */\n            /* not visible by applications */\n            this.state = null;\n            /* best guess about the data type: binary or text */\n            this.data_type = 2;\n            /* Z_UNKNOWN */\n            /* adler32 value of the uncompressed data */\n            this.adler = 0;\n        }\n        var zstream = ZStream;\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        var toString = Object.prototype.toString;\n        /* Public constants ========================================================== */\n        /* =========================================================================== */\n        var Z_NO_FLUSH$1 = constants.Z_NO_FLUSH;\n        var Z_SYNC_FLUSH = constants.Z_SYNC_FLUSH;\n        var Z_FULL_FLUSH$1 = constants.Z_FULL_FLUSH;\n        var Z_FINISH$1 = constants.Z_FINISH;\n        var Z_OK$1 = constants.Z_OK;\n        var Z_STREAM_END$1 = constants.Z_STREAM_END;\n        var Z_DEFAULT_COMPRESSION$1 = constants.Z_DEFAULT_COMPRESSION;\n        var Z_DEFAULT_STRATEGY$1 = constants.Z_DEFAULT_STRATEGY;\n        var Z_DEFLATED$1 = constants.Z_DEFLATED;\n        /* =========================================================================== */\n        /**\n         * class Deflate\n         *\n         * Generic JS-style wrapper for zlib calls. If you don't need\n         * streaming behaviour - use more simple functions: [[deflate]],\n         * [[deflateRaw]] and [[gzip]].\n         * */\n        /* internal\n         * Deflate.chunks -> Array\n         *\n         * Chunks of output data, if [[Deflate#onData]] not overridden.\n         * */\n        /**\n         * Deflate.result -> Uint8Array\n         *\n         * Compressed result, generated by default [[Deflate#onData]]\n         * and [[Deflate#onEnd]] handlers. Filled after you push last chunk\n         * (call [[Deflate#push]] with `Z_FINISH` / `true` param).\n         * */\n        /**\n         * Deflate.err -> Number\n         *\n         * Error code after deflate finished. 0 (Z_OK) on success.\n         * You will not need it in real life, because deflate errors\n         * are possible only on wrong options or bad `onData` / `onEnd`\n         * custom handlers.\n         * */\n        /**\n         * Deflate.msg -> String\n         *\n         * Error message, if [[Deflate.err]] != 0\n         * */\n        /**\n         * new Deflate(options)\n         * - options (Object): zlib deflate options.\n         *\n         * Creates new deflator instance with specified params. Throws exception\n         * on bad params. Supported options:\n         *\n         * - `level`\n         * - `windowBits`\n         * - `memLevel`\n         * - `strategy`\n         * - `dictionary`\n         *\n         * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)\n         * for more information on these.\n         *\n         * Additional options, for internal needs:\n         *\n         * * `chunkSize` - size of generated data chunks (16K by default)\n         * * `raw` (Boolean) - do raw deflate\n         * * `gzip` (Boolean) - create gzip wrapper\n         * * `header` (Object) - custom header for gzip\n         * ** `text` (Boolean) - true if compressed data believed to be text\n         * ** `time` (Number) - modification time, unix timestamp\n         * ** `os` (Number) - operation system code\n         * ** `extra` (Array) - array of bytes with extra data (max 65536)\n         * ** `name` (String) - file name (binary string)\n         * ** `comment` (String) - comment (binary string)\n         * ** `hcrc` (Boolean) - true if header crc should be added\n         *\n         * ##### Example:\n         *\n         * ```javascript\n         * const pako = require('pako')\n         *   , chunk1 = new Uint8Array([1,2,3,4,5,6,7,8,9])\n         *   , chunk2 = new Uint8Array([10,11,12,13,14,15,16,17,18,19]);\n         *\n         * const deflate = new pako.Deflate({ level: 3});\n         *\n         * deflate.push(chunk1, false);\n         * deflate.push(chunk2, true);  // true -> last chunk\n         *\n         * if (deflate.err) { throw new Error(deflate.err); }\n         *\n         * console.log(deflate.result);\n         * ```\n         * */\n        function Deflate() {\n            this.options = {\n                level: Z_DEFAULT_COMPRESSION$1,\n                method: Z_DEFLATED$1,\n                chunkSize: 16384,\n                windowBits: 15,\n                memLevel: 8,\n                strategy: Z_DEFAULT_STRATEGY$1,\n            };\n            var opt = this.options;\n            if (opt.raw && opt.windowBits > 0) {\n                opt.windowBits = -opt.windowBits;\n            }\n            else if (opt.gzip && opt.windowBits > 0 && opt.windowBits < 16) {\n                opt.windowBits += 16;\n            }\n            this.err = 0; // error code, if happens (0 = Z_OK)\n            this.msg = ''; // error message\n            this.ended = false; // used to avoid multiple onEnd() calls\n            this.chunks = []; // chunks of compressed data\n            this.strm = new zstream();\n            this.strm.avail_out = 0;\n            var status = deflate_1.deflateInit2(this.strm, opt.level, opt.method, opt.windowBits, opt.memLevel, opt.strategy);\n            if (status !== Z_OK$1) {\n                throw new Error(messages[status]);\n            }\n            if (opt.header) {\n                deflate_1.deflateSetHeader(this.strm, opt.header);\n            }\n            if (opt.dictionary) {\n                var dict; // Convert data if needed\n                if (toString.call(opt.dictionary) === '[object ArrayBuffer]') {\n                    dict = new Uint8Array(opt.dictionary);\n                }\n                else {\n                    dict = opt.dictionary;\n                }\n                status = deflate_1.deflateSetDictionary(this.strm, dict);\n                if (status !== Z_OK$1) {\n                    throw new Error(messages[status]);\n                }\n                this._dict_set = true;\n            }\n        }\n        /**\n         * Deflate#push(data[, flush_mode]) -> Boolean\n         * - data (Uint8Array|ArrayBuffer|String): input data. Strings will be\n         * converted to utf8 byte sequence.\n         * - flush_mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE modes.\n         * See constants. Skipped or `false` means Z_NO_FLUSH, `true` means Z_FINISH.\n         *\n         * Sends input data to deflate pipe, generating [[Deflate#onData]] calls with\n         * new compressed chunks. Returns `true` on success. The last data block must\n         * have `flush_mode` Z_FINISH (or `true`). That will flush internal pending\n         * buffers and call [[Deflate#onEnd]].\n         *\n         * On fail call [[Deflate#onEnd]] with error code and return false.\n         *\n         * ##### Example\n         *\n         * ```javascript\n         * push(chunk, false); // push one of data chunks\n         * ...\n         * push(chunk, true);  // push last chunk\n         * ```\n         * */\n        Deflate.prototype.push = function (data, flush_mode) {\n            var strm = this.strm;\n            var chunkSize = this.options.chunkSize;\n            var status;\n            var _flush_mode;\n            if (this.ended) {\n                return false;\n            }\n            if (flush_mode === ~~flush_mode) {\n                _flush_mode = flush_mode;\n            }\n            else {\n                _flush_mode = flush_mode === true ? Z_FINISH$1 : Z_NO_FLUSH$1;\n            } // Convert data if needed\n            if (toString.call(data) === '[object ArrayBuffer]') {\n                strm.input = new Uint8Array(data);\n            }\n            else {\n                strm.input = data;\n            }\n            strm.next_in = 0;\n            strm.avail_in = strm.input.length;\n            for (;;) {\n                if (strm.avail_out === 0) {\n                    strm.output = new Uint8Array(chunkSize);\n                    strm.next_out = 0;\n                    strm.avail_out = chunkSize;\n                } // Make sure avail_out > 6 to avoid repeating markers\n                if ((_flush_mode === Z_SYNC_FLUSH || _flush_mode === Z_FULL_FLUSH$1) && strm.avail_out <= 6) {\n                    this.onData(strm.output.subarray(0, strm.next_out));\n                    strm.avail_out = 0;\n                    continue;\n                }\n                status = deflate_1.deflate(strm, _flush_mode); // Ended => flush and finish\n                if (status === Z_STREAM_END$1) {\n                    if (strm.next_out > 0) {\n                        this.onData(strm.output.subarray(0, strm.next_out));\n                    }\n                    status = deflate_1.deflateEnd(this.strm);\n                    this.onEnd(status);\n                    this.ended = true;\n                    return status === Z_OK$1;\n                } // Flush if out buffer full\n                if (strm.avail_out === 0) {\n                    this.onData(strm.output);\n                    continue;\n                } // Flush if requested and has data\n                if (_flush_mode > 0 && strm.next_out > 0) {\n                    this.onData(strm.output.subarray(0, strm.next_out));\n                    strm.avail_out = 0;\n                    continue;\n                }\n                if (strm.avail_in === 0) {\n                    break;\n                }\n            }\n            return true;\n        };\n        /**\n         * Deflate#onData(chunk) -> Void\n         * - chunk (Uint8Array): output data.\n         *\n         * By default, stores data blocks in `chunks[]` property and glue\n         * those in `onEnd`. Override this handler, if you need another behaviour.\n         * */\n        Deflate.prototype.onData = function (chunk) {\n            this.chunks.push(chunk);\n        };\n        /**\n         * Deflate#onEnd(status) -> Void\n         * - status (Number): deflate status. 0 (Z_OK) on success,\n         * other if not.\n         *\n         * Called once after you tell deflate that the input stream is\n         * complete (Z_FINISH). By default - join collected chunks,\n         * free memory and fill `results` / `err` properties.\n         * */\n        Deflate.prototype.onEnd = function (status) {\n            // On success - join\n            if (status === Z_OK$1) {\n                this.result = flattenChunks(this.chunks);\n            }\n            this.chunks = [];\n            this.err = status;\n            this.msg = this.strm.msg;\n        };\n        // https://github.com/nodeca/pako/blob/26dff4fb3472c5532b3bd8856421146d35ab7592/lib/utils/strings.js#L26\n        function string2buf(str) {\n            if (typeof TextEncoder === 'function' && TextEncoder.prototype.encode) {\n                return new TextEncoder().encode(str);\n            }\n            var buf;\n            var c;\n            var c2;\n            var m_pos;\n            var i;\n            var str_len = str.length;\n            var buf_len = 0;\n            // count binary size\n            for (m_pos = 0; m_pos < str_len; m_pos++) {\n                c = str.charCodeAt(m_pos);\n                if ((c & 0xfc00) === 0xd800 && m_pos + 1 < str_len) {\n                    c2 = str.charCodeAt(m_pos + 1);\n                    if ((c2 & 0xfc00) === 0xdc00) {\n                        c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);\n                        m_pos++;\n                    }\n                }\n                buf_len += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4;\n            }\n            // allocate buffer\n            buf = new Uint8Array(buf_len);\n            // convert\n            for (i = 0, m_pos = 0; i < buf_len; m_pos++) {\n                c = str.charCodeAt(m_pos);\n                if ((c & 0xfc00) === 0xd800 && m_pos + 1 < str_len) {\n                    c2 = str.charCodeAt(m_pos + 1);\n                    if ((c2 & 0xfc00) === 0xdc00) {\n                        c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);\n                        m_pos++;\n                    }\n                }\n                if (c < 0x80) {\n                    /* one byte */\n                    buf[i++] = c;\n                }\n                else if (c < 0x800) {\n                    /* two bytes */\n                    buf[i++] = 0xc0 | (c >>> 6);\n                    buf[i++] = 0x80 | (c & 0x3f);\n                }\n                else if (c < 0x10000) {\n                    /* three bytes */\n                    buf[i++] = 0xe0 | (c >>> 12);\n                    buf[i++] = 0x80 | ((c >>> 6) & 0x3f);\n                    buf[i++] = 0x80 | (c & 0x3f);\n                }\n                else {\n                    /* four bytes */\n                    buf[i++] = 0xf0 | (c >>> 18);\n                    buf[i++] = 0x80 | ((c >>> 12) & 0x3f);\n                    buf[i++] = 0x80 | ((c >>> 6) & 0x3f);\n                    buf[i++] = 0x80 | (c & 0x3f);\n                }\n            }\n            return buf;\n        }\n        return { Deflate: Deflate, constants: constants, string2buf: string2buf };\n    }\n}\n//# sourceMappingURL=deflateWorker.js.map"],"names":["workerURL","createDeflateWorker","URL","createObjectURL","Blob","concat","workerCodeFn","Worker","monitor","fn","apply","this","arguments","e","self","postMessage","type","error","_","_a","Z_FIXED","Z_BINARY","Z_TEXT","Z_UNKNOWN","zero","buf","len","length","STORED_BLOCK","STATIC_TREES","DYN_TREES","MIN_MATCH","MAX_MATCH","LENGTH_CODES","LITERALS","L_CODES","D_CODES","BL_CODES","HEAP_SIZE","MAX_BITS","Buf_size","MAX_BL_BITS","END_BLOCK","REP_3_6","REPZ_3_10","REPZ_11_138","extra_lbits","Uint8Array","extra_dbits","extra_blbits","bl_order","DIST_CODE_LEN","static_ltree","Array","static_dtree","_dist_code","_length_code","base_length","static_l_desc","static_d_desc","static_bl_desc","base_dist","StaticTreeDesc","static_tree","extra_bits","extra_base","elems","max_length","has_stree","TreeDesc","dyn_tree","stat_desc","max_code","d_code","dist","put_short","s","w","pending_buf","pending","send_bits","value","bi_valid","bi_buf","send_code","c","tree","bi_reverse","code","res","bi_flush","gen_bitlen","desc","h","n","m","bits","xbits","f","stree","extra","base","overflow","bl_count","heap","heap_max","opt_len","static_len","gen_codes","next_code","tr_static_init","init_block","dyn_ltree","dyn_dtree","bl_tree","last_lit","matches","bi_windup","copy_block","header","set","window","subarray","smaller","depth","_n2","_m2","pqdownheap","k","v","j","heap_len","compress_block","ltree","dtree","lc","lx","d_buf","l_buf","build_tree","node","scan_tree","curlen","prevlen","nextlen","count","max_count","min_count","send_tree","build_bl_tree","max_blindex","l_desc","d_desc","bl_desc","send_all_trees","lcodes","dcodes","blcodes","rank","detect_data_type","black_mask","static_init_done","_tr_stored_block","stored_len","last","_tr_flush_block","opt_lenb","static_lenb","level","strm","data_type","strategy","trees","_tr_init","_tr_tally","lit_bufsize","_tr_align","adler32_1","adler","pos","s1","s2","crcTable","Uint32Array","table","makeTable","crc32_1","crc","t","end","i","messages","constants","Z_NO_FLUSH","Z_PARTIAL_FLUSH","Z_SYNC_FLUSH","Z_FULL_FLUSH","Z_FINISH","Z_BLOCK","Z_TREES","Z_OK","Z_STREAM_END","Z_NEED_DICT","Z_ERRNO","Z_STREAM_ERROR","Z_DATA_ERROR","Z_MEM_ERROR","Z_BUF_ERROR","Z_NO_COMPRESSION","Z_BEST_SPEED","Z_BEST_COMPRESSION","Z_DEFAULT_COMPRESSION","Z_FILTERED","Z_HUFFMAN_ONLY","Z_RLE","Z_DEFAULT_STRATEGY","Z_DEFLATED","_tr_init$1","_tr_stored_block$1","_tr_flush_block$1","_tr_tally$1","_tr_align$1","Z_FIXED$1","Z_UNKNOWN$1","MAX_MEM_LEVEL","MAX_WBITS","DEF_MEM_LEVEL","L_CODES$1","LITERALS$1","D_CODES$1","BL_CODES$1","HEAP_SIZE$1","MAX_BITS$1","MIN_MATCH$1","MAX_MATCH$1","MIN_LOOKAHEAD","PRESET_DICT","INIT_STATE","EXTRA_STATE","NAME_STATE","COMMENT_STATE","HCRC_STATE","BUSY_STATE","FINISH_STATE","BS_NEED_MORE","BS_BLOCK_DONE","BS_FINISH_STARTED","BS_FINISH_DONE","OS_CODE","err","errorCode","msg","zero$1","HASH","prev","data","hash_shift","hash_mask","flush_pending","state","avail_out","output","pending_out","next_out","total_out","flush_block_only","block_start","strstart","put_byte","b","putShortMSB","read_buf","start","size","avail_in","input","next_in","wrap","total_in","longest_match","cur_match","match","chain_length","max_chain_length","scan","best_len","prev_length","nice_match","limit","w_size","_win","wmask","w_mask","strend","scan_end1","scan_end","good_match","lookahead","match_start","fill_window","p","more","str","_w_size","window_size","hash_size","head","insert","ins_h","deflate_fast","flush","hash_head","bflush","match_length","max_lazy_match","deflate_slow","max_insert","prev_match","match_available","deflate_rle","deflate_huff","Config","good_length","max_lazy","nice_length","max_chain","func","configuration_table","max_block_size","pending_buf_size","max_start","lm_init","DeflateState","status","gzhead","gzindex","method","last_flush","w_bits","hash_bits","Uint16Array","deflateResetKeep","deflateReset","ret","deflateInit2","windowBits","memLevel","deflate_1","deflateInit","deflateSetHeader","deflate","beg","val","old_flush","text","hcrc","name","comment","time","os","charCodeAt","bstate","deflateEnd","deflateSetDictionary","dictionary","dictLength","tmpDict","avail","next","deflateInfo","flattenChunks","chunks","l","result","_i","_l","chunk","_utf8len","q","ZStream","zstream","toString","Object","prototype","Z_NO_FLUSH$1","Z_FULL_FLUSH$1","Z_FINISH$1","Z_OK$1","Z_STREAM_END$1","Z_DEFAULT_COMPRESSION$1","Z_DEFAULT_STRATEGY$1","Z_DEFLATED$1","Deflate","options","chunkSize","opt","raw","gzip","ended","Error","dict","call","_dict_set","string2buf","TextEncoder","encode","c2","m_pos","str_len","buf_len","push","flush_mode","_flush_mode","onData","onEnd","makePakoDeflate","rawBytesCount","pushData","binaryData","addEventListener","event","action","additionalBytesCount","id","compressedBytesCount","reduce","total"],"sourceRoot":""}