@kitware/vtk.js 19.2.13 → 19.3.0

package/vendor/pako/dist/pako.esm.mjs

@@ -1,4 +1,4 @@
-/*! pako 2.0.3 https://github.com/nodeca/pako @license (MIT AND Zlib) */
+/*! pako 2.0.4 https://github.com/nodeca/pako @license (MIT AND Zlib) */
 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
 // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
 //
@@ -27,19 +27,19 @@
 //const Z_FILTERED          = 1;
 //const Z_HUFFMAN_ONLY      = 2;
 //const Z_RLE               = 3;
-const Z_FIXED               = 4;
+const Z_FIXED$1               = 4;
 //const Z_DEFAULT_STRATEGY  = 0;
 
 /* Possible values of the data_type field (though see inflate()) */
 const Z_BINARY              = 0;
 const Z_TEXT                = 1;
 //const Z_ASCII             = 1; // = Z_TEXT
-const Z_UNKNOWN             = 2;
+const Z_UNKNOWN$1             = 2;
 
 /*============================================================================*/
 
 
-function zero(buf) { let len = buf.length; while (--len >= 0) { buf[len] = 0; } }
+function zero$1(buf) { let len = buf.length; while (--len >= 0) { buf[len] = 0; } }
 
 // From zutil.h
 
@@ -48,8 +48,8 @@ const STATIC_TREES = 1;
 const DYN_TREES    = 2;
 /* The three kinds of block type */
 
-const MIN_MATCH    = 3;
-const MAX_MATCH    = 258;
+const MIN_MATCH$1    = 3;
+const MAX_MATCH$1    = 258;
 /* The minimum and maximum match lengths */
 
 // From deflate.h
@@ -57,25 +57,25 @@ const MAX_MATCH    = 258;
  * Internal compression state.
  */
 
-const LENGTH_CODES  = 29;
+const LENGTH_CODES$1  = 29;
 /* number of length codes, not counting the special END_BLOCK code */
 
-const LITERALS      = 256;
+const LITERALS$1      = 256;
 /* number of literal bytes 0..255 */
 
-const L_CODES       = LITERALS + 1 + LENGTH_CODES;
+const L_CODES$1       = LITERALS$1 + 1 + LENGTH_CODES$1;
 /* number of Literal or Length codes, including the END_BLOCK code */
 
-const D_CODES       = 30;
+const D_CODES$1       = 30;
 /* number of distance codes */
 
-const BL_CODES      = 19;
+const BL_CODES$1      = 19;
 /* number of codes used to transfer the bit lengths */
 
-const HEAP_SIZE     = 2 * L_CODES + 1;
+const HEAP_SIZE$1     = 2 * L_CODES$1 + 1;
 /* maximum heap size */
 
-const MAX_BITS      = 15;
+const MAX_BITS$1      = 15;
 /* All codes must not exceed MAX_BITS bits */
 
 const Buf_size      = 16;
@@ -128,37 +128,37 @@ const bl_order =
 const DIST_CODE_LEN = 512; /* see definition of array dist_code below */
 
 // !!!! Use flat array instead of structure, Freq = i*2, Len = i*2+1
-const static_ltree  = new Array((L_CODES + 2) * 2);
-zero(static_ltree);
+const static_ltree  = new Array((L_CODES$1 + 2) * 2);
+zero$1(static_ltree);
 /* The static literal tree. Since the bit lengths are imposed, there is no
  * need for the L_CODES extra codes used during heap construction. However
  * The codes 286 and 287 are needed to build a canonical tree (see _tr_init
  * below).
  */
 
-const static_dtree  = new Array(D_CODES * 2);
-zero(static_dtree);
+const static_dtree  = new Array(D_CODES$1 * 2);
+zero$1(static_dtree);
 /* The static distance tree. (Actually a trivial tree since all codes use
  * 5 bits.)
  */
 
 const _dist_code    = new Array(DIST_CODE_LEN);
-zero(_dist_code);
+zero$1(_dist_code);
 /* Distance codes. The first 256 values correspond to the distances
  * 3 .. 258, the last 256 values correspond to the top 8 bits of
  * the 15 bit distances.
  */
 
-const _length_code  = new Array(MAX_MATCH - MIN_MATCH + 1);
-zero(_length_code);
+const _length_code  = new Array(MAX_MATCH$1 - MIN_MATCH$1 + 1);
+zero$1(_length_code);
 /* length code for each normalized match length (0 == MIN_MATCH) */
 
-const base_length   = new Array(LENGTH_CODES);
-zero(base_length);
+const base_length   = new Array(LENGTH_CODES$1);
+zero$1(base_length);
 /* First normalized length for each code (0 = MIN_MATCH) */
 
-const base_dist     = new Array(D_CODES);
-zero(base_dist);
+const base_dist     = new Array(D_CODES$1);
+zero$1(base_dist);
 /* First normalized distance for each code (0 = distance of 1) */
 
 
@@ -293,7 +293,7 @@ const gen_bitlen = (s, desc) =>
   let f;              /* frequency */
   let overflow = 0;   /* number of elements with bit length too large */
 
-  for (bits = 0; bits <= MAX_BITS; bits++) {
+  for (bits = 0; bits <= MAX_BITS$1; bits++) {
     s.bl_count[bits] = 0;
   }
 
@@ -302,7 +302,7 @@ const gen_bitlen = (s, desc) =>
    */
   tree[s.heap[s.heap_max] * 2 + 1]/*.Len*/ = 0; /* root of the heap */
 
-  for (h = s.heap_max + 1; h < HEAP_SIZE; h++) {
+  for (h = s.heap_max + 1; h < HEAP_SIZE$1; h++) {
     n = s.heap[h];
     bits = tree[tree[n * 2 + 1]/*.Dad*/ * 2 + 1]/*.Len*/ + 1;
     if (bits > max_length) {
@@ -377,7 +377,7 @@ const gen_codes = (tree, max_code, bl_count) =>
 //    int max_code;              /* largest code with non zero frequency */
 //    ushf *bl_count;            /* number of codes at each bit length */
 {
-  const next_code = new Array(MAX_BITS + 1); /* next code value for each bit length */
+  const next_code = new Array(MAX_BITS$1 + 1); /* next code value for each bit length */
   let code = 0;              /* running code value */
   let bits;                  /* bit index */
   let n;                     /* code index */
@@ -385,7 +385,7 @@ const gen_codes = (tree, max_code, bl_count) =>
   /* The distribution counts are first used to generate the code values
    * without bit reversal.
    */
-  for (bits = 1; bits <= MAX_BITS; bits++) {
+  for (bits = 1; bits <= MAX_BITS$1; bits++) {
     next_code[bits] = code = (code + bl_count[bits - 1]) << 1;
   }
   /* Check that the bit counts in bl_count are consistent. The last code
@@ -417,7 +417,7 @@ const tr_static_init = () => {
   let length;   /* length value */
   let code;     /* code value */
   let dist;     /* distance index */
-  const bl_count = new Array(MAX_BITS + 1);
+  const bl_count = new Array(MAX_BITS$1 + 1);
   /* number of codes at each bit length for an optimal tree */
 
   // do check in _tr_init()
@@ -434,7 +434,7 @@ const tr_static_init = () => {
 
   /* Initialize the mapping length (0..255) -> length code (0..28) */
   length = 0;
-  for (code = 0; code < LENGTH_CODES - 1; code++) {
+  for (code = 0; code < LENGTH_CODES$1 - 1; code++) {
     base_length[code] = length;
     for (n = 0; n < (1 << extra_lbits[code]); n++) {
       _length_code[length++] = code;
@@ -457,7 +457,7 @@ const tr_static_init = () => {
   }
   //Assert (dist == 256, "tr_static_init: dist != 256");
   dist >>= 7; /* from now on, all distances are divided by 128 */
-  for (; code < D_CODES; code++) {
+  for (; code < D_CODES$1; code++) {
     base_dist[code] = dist << 7;
     for (n = 0; n < (1 << (extra_dbits[code] - 7)); n++) {
       _dist_code[256 + dist++] = code;
@@ -466,7 +466,7 @@ const tr_static_init = () => {
   //Assert (dist == 256, "tr_static_init: 256+dist != 512");
 
   /* Construct the codes of the static literal tree */
-  for (bits = 0; bits <= MAX_BITS; bits++) {
+  for (bits = 0; bits <= MAX_BITS$1; bits++) {
     bl_count[bits] = 0;
   }
 
@@ -495,18 +495,18 @@ const tr_static_init = () => {
    * tree construction to get a canonical Huffman tree (longest code
    * all ones)
    */
-  gen_codes(static_ltree, L_CODES + 1, bl_count);
+  gen_codes(static_ltree, L_CODES$1 + 1, bl_count);
 
   /* The static distance tree is trivial: */
-  for (n = 0; n < D_CODES; n++) {
+  for (n = 0; n < D_CODES$1; n++) {
     static_dtree[n * 2 + 1]/*.Len*/ = 5;
     static_dtree[n * 2]/*.Code*/ = bi_reverse(n, 5);
   }
 
   // Now data ready and we can init static trees
-  static_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, LITERALS + 1, L_CODES, MAX_BITS);
-  static_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0,          D_CODES, MAX_BITS);
-  static_bl_desc = new StaticTreeDesc(new Array(0), extra_blbits, 0,         BL_CODES, MAX_BL_BITS);
+  static_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, LITERALS$1 + 1, L_CODES$1, MAX_BITS$1);
+  static_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0,          D_CODES$1, MAX_BITS$1);
+  static_bl_desc = new StaticTreeDesc(new Array(0), extra_blbits, 0,         BL_CODES$1, MAX_BL_BITS);
 
   //static_init_done = true;
 };
@@ -520,9 +520,9 @@ const init_block = (s) => {
   let n; /* iterates over tree elements */
 
   /* Initialize the trees. */
-  for (n = 0; n < L_CODES;  n++) { s.dyn_ltree[n * 2]/*.Freq*/ = 0; }
-  for (n = 0; n < D_CODES;  n++) { s.dyn_dtree[n * 2]/*.Freq*/ = 0; }
-  for (n = 0; n < BL_CODES; n++) { s.bl_tree[n * 2]/*.Freq*/ = 0; }
+  for (n = 0; n < L_CODES$1;  n++) { s.dyn_ltree[n * 2]/*.Freq*/ = 0; }
+  for (n = 0; n < D_CODES$1;  n++) { s.dyn_dtree[n * 2]/*.Freq*/ = 0; }
+  for (n = 0; n < BL_CODES$1; n++) { s.bl_tree[n * 2]/*.Freq*/ = 0; }
 
   s.dyn_ltree[END_BLOCK * 2]/*.Freq*/ = 1;
   s.opt_len = s.static_len = 0;
@@ -642,7 +642,7 @@ const compress_block = (s, ltree, dtree) =>
       } else {
         /* Here, lc is the match length - MIN_MATCH */
         code = _length_code[lc];
-        send_code(s, code + LITERALS + 1, ltree); /* send the length code */
+        send_code(s, code + LITERALS$1 + 1, ltree); /* send the length code */
         extra = extra_lbits[code];
         if (extra !== 0) {
           lc -= base_length[code];
@@ -696,7 +696,7 @@ const build_tree = (s, desc) =>
    * heap[0] is not used.
    */
   s.heap_len = 0;
-  s.heap_max = HEAP_SIZE;
+  s.heap_max = HEAP_SIZE$1;
 
   for (n = 0; n < elems; n++) {
     if (tree[n * 2]/*.Freq*/ !== 0) {
@@ -930,7 +930,7 @@ const build_bl_tree = (s) => {
    * requires that at least 4 bit length codes be sent. (appnote.txt says
    * 3 but the actual value used is 4.)
    */
-  for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) {
+  for (max_blindex = BL_CODES$1 - 1; max_blindex >= 3; max_blindex--) {
     if (s.bl_tree[bl_order[max_blindex] * 2 + 1]/*.Len*/ !== 0) {
       break;
     }
@@ -1009,7 +1009,7 @@ const detect_data_type = (s) => {
       s.dyn_ltree[13 * 2]/*.Freq*/ !== 0) {
     return Z_TEXT;
   }
-  for (n = 32; n < LITERALS; n++) {
+  for (n = 32; n < LITERALS$1; n++) {
     if (s.dyn_ltree[n * 2]/*.Freq*/ !== 0) {
       return Z_TEXT;
     }
@@ -1027,7 +1027,7 @@ let static_init_done = false;
 /* ===========================================================================
  * Initialize the tree data structures for a new zlib stream.
  */
-const _tr_init = (s) =>
+const _tr_init$1 = (s) =>
 {
 
   if (!static_init_done) {
@@ -1050,7 +1050,7 @@ const _tr_init = (s) =>
 /* ===========================================================================
  * Send a stored block
  */
-const _tr_stored_block = (s, buf, stored_len, last) =>
+const _tr_stored_block$1 = (s, buf, stored_len, last) =>
 //DeflateState *s;
 //charf *buf;       /* input block */
 //ulg stored_len;   /* length of input block */
@@ -1065,7 +1065,7 @@ const _tr_stored_block = (s, buf, stored_len, last) =>
  * Send one empty static block to give enough lookahead for inflate.
  * This takes 10 bits, of which 7 may remain in the bit buffer.
  */
-const _tr_align = (s) => {
+const _tr_align$1 = (s) => {
   send_bits(s, STATIC_TREES << 1, 3);
   send_code(s, END_BLOCK, static_ltree);
   bi_flush(s);
@@ -1076,7 +1076,7 @@ const _tr_align = (s) => {
  * Determine the best encoding for the current block: dynamic trees, static
  * trees or store, and output the encoded block to the zip file.
  */
-const _tr_flush_block = (s, buf, stored_len, last) =>
+const _tr_flush_block$1 = (s, buf, stored_len, last) =>
 //DeflateState *s;
 //charf *buf;       /* input block, or NULL if too old */
 //ulg stored_len;   /* length of input block */
@@ -1089,7 +1089,7 @@ const _tr_flush_block = (s, buf, stored_len, last) =>
   if (s.level > 0) {
 
     /* Check if the file is binary or text */
-    if (s.strm.data_type === Z_UNKNOWN) {
+    if (s.strm.data_type === Z_UNKNOWN$1) {
       s.strm.data_type = detect_data_type(s);
     }
 
@@ -1134,9 +1134,9 @@ const _tr_flush_block = (s, buf, stored_len, last) =>
      * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
      * transform a block into a stored block.
      */
-    _tr_stored_block(s, buf, stored_len, last);
+    _tr_stored_block$1(s, buf, stored_len, last);
 
-  } else if (s.strategy === Z_FIXED || static_lenb === opt_lenb) {
+  } else if (s.strategy === Z_FIXED$1 || static_lenb === opt_lenb) {
 
     send_bits(s, (STATIC_TREES << 1) + (last ? 1 : 0), 3);
     compress_block(s, static_ltree, static_dtree);
@@ -1163,7 +1163,7 @@ const _tr_flush_block = (s, buf, stored_len, last) =>
  * Save the match info and tally the frequency counts. Return true if
  * the current block must be flushed.
  */
-const _tr_tally = (s, dist, lc) =>
+const _tr_tally$1 = (s, dist, lc) =>
 //    deflate_state *s;
 //    unsigned dist;  /* distance of matched string */
 //    unsigned lc;    /* match length-MIN_MATCH or unmatched char (if dist==0) */
@@ -1187,7 +1187,7 @@ const _tr_tally = (s, dist, lc) =>
     //       (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&
     //       (ush)d_code(dist) < (ush)D_CODES,  "_tr_tally: bad match");
 
-    s.dyn_ltree[(_length_code[lc] + LITERALS + 1) * 2]/*.Freq*/++;
+    s.dyn_ltree[(_length_code[lc] + LITERALS$1 + 1) * 2]/*.Freq*/++;
     s.dyn_dtree[d_code(dist) * 2]/*.Freq*/++;
   }
 
@@ -1221,11 +1221,11 @@ const _tr_tally = (s, dist, lc) =>
    */
 };
 
-var _tr_init_1  = _tr_init;
-var _tr_stored_block_1 = _tr_stored_block;
-var _tr_flush_block_1  = _tr_flush_block;
-var _tr_tally_1 = _tr_tally;
-var _tr_align_1 = _tr_align;
+var _tr_init_1  = _tr_init$1;
+var _tr_stored_block_1 = _tr_stored_block$1;
+var _tr_flush_block_1  = _tr_flush_block$1;
+var _tr_tally_1 = _tr_tally$1;
+var _tr_align_1 = _tr_align$1;
 
 var trees = {
 	_tr_init: _tr_init_1,
@@ -1393,7 +1393,7 @@ var messages = {
 //   misrepresented as being the original software.
 // 3. This notice may not be removed or altered from any source distribution.
 
-var constants = {
+var constants$2 = {
 
   /* Allowed flush values; see deflate() and inflate() below for details */
   Z_NO_FLUSH:         0,
@@ -1460,7 +1460,7 @@ var constants = {
 //   misrepresented as being the original software.
 // 3. This notice may not be removed or altered from any source distribution.
 
-const { _tr_init: _tr_init$1, _tr_stored_block: _tr_stored_block$1, _tr_flush_block: _tr_flush_block$1, _tr_tally: _tr_tally$1, _tr_align: _tr_align$1 } = trees;
+const { _tr_init, _tr_stored_block, _tr_flush_block, _tr_tally, _tr_align } = trees;
 
 
 
@@ -1469,42 +1469,42 @@ const { _tr_init: _tr_init$1, _tr_stored_block: _tr_stored_block$1, _tr_flush_bl
 /* ===========================================================================*/
 
 const {
-  Z_NO_FLUSH, Z_PARTIAL_FLUSH, Z_FULL_FLUSH, Z_FINISH, Z_BLOCK,
-  Z_OK, Z_STREAM_END, Z_STREAM_ERROR, Z_DATA_ERROR, Z_BUF_ERROR,
-  Z_DEFAULT_COMPRESSION,
-  Z_FILTERED, Z_HUFFMAN_ONLY, Z_RLE, Z_FIXED: Z_FIXED$1, Z_DEFAULT_STRATEGY,
-  Z_UNKNOWN: Z_UNKNOWN$1,
-  Z_DEFLATED
-} = constants;
+  Z_NO_FLUSH: Z_NO_FLUSH$2, Z_PARTIAL_FLUSH, Z_FULL_FLUSH: Z_FULL_FLUSH$1, Z_FINISH: Z_FINISH$3, Z_BLOCK: Z_BLOCK$1,
+  Z_OK: Z_OK$3, Z_STREAM_END: Z_STREAM_END$3, Z_STREAM_ERROR: Z_STREAM_ERROR$2, Z_DATA_ERROR: Z_DATA_ERROR$2, Z_BUF_ERROR: Z_BUF_ERROR$1,
+  Z_DEFAULT_COMPRESSION: Z_DEFAULT_COMPRESSION$1,
+  Z_FILTERED, Z_HUFFMAN_ONLY, Z_RLE, Z_FIXED, Z_DEFAULT_STRATEGY: Z_DEFAULT_STRATEGY$1,
+  Z_UNKNOWN,
+  Z_DEFLATED: Z_DEFLATED$2
+} = constants$2;
 
 /*============================================================================*/
 
 
 const MAX_MEM_LEVEL = 9;
 /* Maximum value for memLevel in deflateInit2 */
-const MAX_WBITS = 15;
+const MAX_WBITS$1 = 15;
 /* 32K LZ77 window */
 const DEF_MEM_LEVEL = 8;
 
 
-const LENGTH_CODES$1  = 29;
+const LENGTH_CODES  = 29;
 /* number of length codes, not counting the special END_BLOCK code */
-const LITERALS$1      = 256;
+const LITERALS      = 256;
 /* number of literal bytes 0..255 */
-const L_CODES$1       = LITERALS$1 + 1 + LENGTH_CODES$1;
+const L_CODES       = LITERALS + 1 + LENGTH_CODES;
 /* number of Literal or Length codes, including the END_BLOCK code */
-const D_CODES$1       = 30;
+const D_CODES       = 30;
 /* number of distance codes */
-const BL_CODES$1      = 19;
+const BL_CODES      = 19;
 /* number of codes used to transfer the bit lengths */
-const HEAP_SIZE$1     = 2 * L_CODES$1 + 1;
+const HEAP_SIZE     = 2 * L_CODES + 1;
 /* maximum heap size */
-const MAX_BITS$1  = 15;
+const MAX_BITS  = 15;
 /* All codes must not exceed MAX_BITS bits */
 
-const MIN_MATCH$1 = 3;
-const MAX_MATCH$1 = 258;
-const MIN_LOOKAHEAD = (MAX_MATCH$1 + MIN_MATCH$1 + 1);
+const MIN_MATCH = 3;
+const MAX_MATCH = 258;
+const MIN_LOOKAHEAD = (MAX_MATCH + MIN_MATCH + 1);
 
 const PRESET_DICT = 0x20;
 
@@ -1532,7 +1532,7 @@ const rank = (f) => {
   return ((f) << 1) - ((f) > 4 ? 9 : 0);
 };
 
-const zero$1 = (buf) => {
+const zero = (buf) => {
   let len = buf.length; while (--len >= 0) { buf[len] = 0; }
 };
 
@@ -1573,7 +1573,7 @@ const flush_pending = (strm) => {
 
 
 const flush_block_only = (s, last) => {
-  _tr_flush_block$1(s, (s.block_start >= 0 ? s.block_start : -1), s.strstart - s.block_start, last);
+  _tr_flush_block(s, (s.block_start >= 0 ? s.block_start : -1), s.strstart - s.block_start, last);
   s.block_start = s.strstart;
   flush_pending(s.strm);
 };
@@ -1660,7 +1660,7 @@ const longest_match = (s, cur_match) => {
    * we prevent matches with the string of window index 0.
    */
 
-  const strend = s.strstart + MAX_MATCH$1;
+  const strend = s.strstart + MAX_MATCH;
   let scan_end1  = _win[scan + best_len - 1];
   let scan_end   = _win[scan + best_len];
 
@@ -1723,8 +1723,8 @@ const longest_match = (s, cur_match) => {
 
     // Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
 
-    len = MAX_MATCH$1 - (strend - scan);
-    scan = strend - MAX_MATCH$1;
+    len = MAX_MATCH - (strend - scan);
+    scan = strend - MAX_MATCH;
 
     if (len > best_len) {
       s.match_start = cur_match;
@@ -1838,7 +1838,7 @@ const fill_window = (s) => {
     s.lookahead += n;
 
     /* Initialize the hash value now that we have some input: */
-    if (s.lookahead + s.insert >= MIN_MATCH$1) {
+    if (s.lookahead + s.insert >= MIN_MATCH) {
       str = s.strstart - s.insert;
       s.ins_h = s.window[str];
 
@@ -1849,13 +1849,13 @@ const fill_window = (s) => {
 //#endif
       while (s.insert) {
         /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */
-        s.ins_h = HASH(s, s.ins_h, s.window[str + MIN_MATCH$1 - 1]);
+        s.ins_h = HASH(s, s.ins_h, s.window[str + MIN_MATCH - 1]);
 
         s.prev[str & s.w_mask] = s.head[s.ins_h];
         s.head[s.ins_h] = str;
         str++;
         s.insert--;
-        if (s.lookahead + s.insert < MIN_MATCH$1) {
+        if (s.lookahead + s.insert < MIN_MATCH) {
           break;
         }
       }
@@ -1937,7 +1937,7 @@ const deflate_stored = (s, flush) => {
 //      }
 
       fill_window(s);
-      if (s.lookahead === 0 && flush === Z_NO_FLUSH) {
+      if (s.lookahead === 0 && flush === Z_NO_FLUSH$2) {
         return BS_NEED_MORE;
       }
 
@@ -1983,7 +1983,7 @@ const deflate_stored = (s, flush) => {
 
   s.insert = 0;
 
-  if (flush === Z_FINISH) {
+  if (flush === Z_FINISH$3) {
     /*** FLUSH_BLOCK(s, 1); ***/
     flush_block_only(s, true);
     if (s.strm.avail_out === 0) {
@@ -2025,7 +2025,7 @@ const deflate_fast = (s, flush) => {
      */
     if (s.lookahead < MIN_LOOKAHEAD) {
       fill_window(s);
-      if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {
+      if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH$2) {
         return BS_NEED_MORE;
       }
       if (s.lookahead === 0) {
@@ -2037,9 +2037,9 @@ const deflate_fast = (s, flush) => {
      * dictionary, and set hash_head to the head of the hash chain:
      */
     hash_head = 0/*NIL*/;
-    if (s.lookahead >= MIN_MATCH$1) {
+    if (s.lookahead >= MIN_MATCH) {
       /*** INSERT_STRING(s, s.strstart, hash_head); ***/
-      s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH$1 - 1]);
+      s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH - 1]);
       hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
       s.head[s.ins_h] = s.strstart;
       /***/
@@ -2056,24 +2056,24 @@ const deflate_fast = (s, flush) => {
       s.match_length = longest_match(s, hash_head);
       /* longest_match() sets match_start */
     }
-    if (s.match_length >= MIN_MATCH$1) {
+    if (s.match_length >= MIN_MATCH) {
       // check_match(s, s.strstart, s.match_start, s.match_length); // for debug only
 
       /*** _tr_tally_dist(s, s.strstart - s.match_start,
                      s.match_length - MIN_MATCH, bflush); ***/
-      bflush = _tr_tally$1(s, s.strstart - s.match_start, s.match_length - MIN_MATCH$1);
+      bflush = _tr_tally(s, s.strstart - s.match_start, s.match_length - MIN_MATCH);
 
       s.lookahead -= s.match_length;
 
       /* Insert new strings in the hash table only if the match length
        * is not too large. This saves time but degrades compression.
        */
-      if (s.match_length <= s.max_lazy_match/*max_insert_length*/ && s.lookahead >= MIN_MATCH$1) {
+      if (s.match_length <= s.max_lazy_match/*max_insert_length*/ && s.lookahead >= MIN_MATCH) {
         s.match_length--; /* string at strstart already in table */
         do {
           s.strstart++;
           /*** INSERT_STRING(s, s.strstart, hash_head); ***/
-          s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH$1 - 1]);
+          s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH - 1]);
           hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
           s.head[s.ins_h] = s.strstart;
           /***/
@@ -2101,7 +2101,7 @@ const deflate_fast = (s, flush) => {
       /* No match, output a literal byte */
       //Tracevv((stderr,"%c", s.window[s.strstart]));
       /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/
-      bflush = _tr_tally$1(s, 0, s.window[s.strstart]);
+      bflush = _tr_tally(s, 0, s.window[s.strstart]);
 
       s.lookahead--;
       s.strstart++;
@@ -2115,8 +2115,8 @@ const deflate_fast = (s, flush) => {
       /***/
     }
   }
-  s.insert = ((s.strstart < (MIN_MATCH$1 - 1)) ? s.strstart : MIN_MATCH$1 - 1);
-  if (flush === Z_FINISH) {
+  s.insert = ((s.strstart < (MIN_MATCH - 1)) ? s.strstart : MIN_MATCH - 1);
+  if (flush === Z_FINISH$3) {
     /*** FLUSH_BLOCK(s, 1); ***/
     flush_block_only(s, true);
     if (s.strm.avail_out === 0) {
@@ -2157,7 +2157,7 @@ const deflate_slow = (s, flush) => {
      */
     if (s.lookahead < MIN_LOOKAHEAD) {
       fill_window(s);
-      if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {
+      if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH$2) {
         return BS_NEED_MORE;
       }
       if (s.lookahead === 0) { break; } /* flush the current block */
@@ -2167,9 +2167,9 @@ const deflate_slow = (s, flush) => {
      * dictionary, and set hash_head to the head of the hash chain:
      */
     hash_head = 0/*NIL*/;
-    if (s.lookahead >= MIN_MATCH$1) {
+    if (s.lookahead >= MIN_MATCH) {
       /*** INSERT_STRING(s, s.strstart, hash_head); ***/
-      s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH$1 - 1]);
+      s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH - 1]);
       hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
       s.head[s.ins_h] = s.strstart;
       /***/
@@ -2179,7 +2179,7 @@ const deflate_slow = (s, flush) => {
      */
     s.prev_length = s.match_length;
     s.prev_match = s.match_start;
-    s.match_length = MIN_MATCH$1 - 1;
+    s.match_length = MIN_MATCH - 1;
 
     if (hash_head !== 0/*NIL*/ && s.prev_length < s.max_lazy_match &&
         s.strstart - hash_head <= (s.w_size - MIN_LOOKAHEAD)/*MAX_DIST(s)*/) {
@@ -2191,26 +2191,26 @@ const deflate_slow = (s, flush) => {
       /* longest_match() sets match_start */
 
       if (s.match_length <= 5 &&
-         (s.strategy === Z_FILTERED || (s.match_length === MIN_MATCH$1 && s.strstart - s.match_start > 4096/*TOO_FAR*/))) {
+         (s.strategy === Z_FILTERED || (s.match_length === MIN_MATCH && s.strstart - s.match_start > 4096/*TOO_FAR*/))) {
 
         /* If prev_match is also MIN_MATCH, match_start is garbage
          * but we will ignore the current match anyway.
          */
-        s.match_length = MIN_MATCH$1 - 1;
+        s.match_length = MIN_MATCH - 1;
       }
     }
     /* If there was a match at the previous step and the current
      * match is not better, output the previous match:
      */
-    if (s.prev_length >= MIN_MATCH$1 && s.match_length <= s.prev_length) {
-      max_insert = s.strstart + s.lookahead - MIN_MATCH$1;
+    if (s.prev_length >= MIN_MATCH && s.match_length <= s.prev_length) {
+      max_insert = s.strstart + s.lookahead - MIN_MATCH;
       /* Do not insert strings in hash table beyond this. */
 
       //check_match(s, s.strstart-1, s.prev_match, s.prev_length);
 
       /***_tr_tally_dist(s, s.strstart - 1 - s.prev_match,
                      s.prev_length - MIN_MATCH, bflush);***/
-      bflush = _tr_tally$1(s, s.strstart - 1 - s.prev_match, s.prev_length - MIN_MATCH$1);
+      bflush = _tr_tally(s, s.strstart - 1 - s.prev_match, s.prev_length - MIN_MATCH);
       /* Insert in hash table all strings up to the end of the match.
        * strstart-1 and strstart are already inserted. If there is not
        * enough lookahead, the last two strings are not inserted in
@@ -2221,14 +2221,14 @@ const deflate_slow = (s, flush) => {
       do {
         if (++s.strstart <= max_insert) {
           /*** INSERT_STRING(s, s.strstart, hash_head); ***/
-          s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH$1 - 1]);
+          s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH - 1]);
           hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
           s.head[s.ins_h] = s.strstart;
           /***/
         }
       } while (--s.prev_length !== 0);
       s.match_available = 0;
-      s.match_length = MIN_MATCH$1 - 1;
+      s.match_length = MIN_MATCH - 1;
       s.strstart++;
 
       if (bflush) {
@@ -2247,7 +2247,7 @@ const deflate_slow = (s, flush) => {
        */
       //Tracevv((stderr,"%c", s->window[s->strstart-1]));
       /*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/
-      bflush = _tr_tally$1(s, 0, s.window[s.strstart - 1]);
+      bflush = _tr_tally(s, 0, s.window[s.strstart - 1]);
 
       if (bflush) {
         /*** FLUSH_BLOCK_ONLY(s, 0) ***/
@@ -2272,12 +2272,12 @@ const deflate_slow = (s, flush) => {
   if (s.match_available) {
     //Tracevv((stderr,"%c", s->window[s->strstart-1]));
     /*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/
-    bflush = _tr_tally$1(s, 0, s.window[s.strstart - 1]);
+    bflush = _tr_tally(s, 0, s.window[s.strstart - 1]);
 
     s.match_available = 0;
   }
-  s.insert = s.strstart < MIN_MATCH$1 - 1 ? s.strstart : MIN_MATCH$1 - 1;
-  if (flush === Z_FINISH) {
+  s.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1;
+  if (flush === Z_FINISH$3) {
     /*** FLUSH_BLOCK(s, 1); ***/
     flush_block_only(s, true);
     if (s.strm.avail_out === 0) {
@@ -2317,9 +2317,9 @@ const deflate_rle = (s, flush) => {
      * at the end of the input file. We need MAX_MATCH bytes
      * for the longest run, plus one for the unrolled loop.
      */
-    if (s.lookahead <= MAX_MATCH$1) {
+    if (s.lookahead <= MAX_MATCH) {
       fill_window(s);
-      if (s.lookahead <= MAX_MATCH$1 && flush === Z_NO_FLUSH) {
+      if (s.lookahead <= MAX_MATCH && flush === Z_NO_FLUSH$2) {
         return BS_NEED_MORE;
       }
       if (s.lookahead === 0) { break; } /* flush the current block */
@@ -2327,11 +2327,11 @@ const deflate_rle = (s, flush) => {
 
     /* See how many times the previous byte repeats */
     s.match_length = 0;
-    if (s.lookahead >= MIN_MATCH$1 && s.strstart > 0) {
+    if (s.lookahead >= MIN_MATCH && s.strstart > 0) {
       scan = s.strstart - 1;
       prev = _win[scan];
       if (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan]) {
-        strend = s.strstart + MAX_MATCH$1;
+        strend = s.strstart + MAX_MATCH;
         do {
           /*jshint noempty:false*/
         } while (prev === _win[++scan] && prev === _win[++scan] &&
@@ -2339,7 +2339,7 @@ const deflate_rle = (s, flush) => {
                  prev === _win[++scan] && prev === _win[++scan] &&
                  prev === _win[++scan] && prev === _win[++scan] &&
                  scan < strend);
-        s.match_length = MAX_MATCH$1 - (strend - scan);
+        s.match_length = MAX_MATCH - (strend - scan);
         if (s.match_length > s.lookahead) {
           s.match_length = s.lookahead;
         }
@@ -2348,11 +2348,11 @@ const deflate_rle = (s, flush) => {
     }
 
     /* Emit match if have run of MIN_MATCH or longer, else emit literal */
-    if (s.match_length >= MIN_MATCH$1) {
+    if (s.match_length >= MIN_MATCH) {
       //check_match(s, s.strstart, s.strstart - 1, s.match_length);
 
       /*** _tr_tally_dist(s, 1, s.match_length - MIN_MATCH, bflush); ***/
-      bflush = _tr_tally$1(s, 1, s.match_length - MIN_MATCH$1);
+      bflush = _tr_tally(s, 1, s.match_length - MIN_MATCH);
 
       s.lookahead -= s.match_length;
       s.strstart += s.match_length;
@@ -2361,7 +2361,7 @@ const deflate_rle = (s, flush) => {
       /* No match, output a literal byte */
       //Tracevv((stderr,"%c", s->window[s->strstart]));
       /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/
-      bflush = _tr_tally$1(s, 0, s.window[s.strstart]);
+      bflush = _tr_tally(s, 0, s.window[s.strstart]);
 
       s.lookahead--;
       s.strstart++;
@@ -2376,7 +2376,7 @@ const deflate_rle = (s, flush) => {
     }
   }
   s.insert = 0;
-  if (flush === Z_FINISH) {
+  if (flush === Z_FINISH$3) {
     /*** FLUSH_BLOCK(s, 1); ***/
     flush_block_only(s, true);
     if (s.strm.avail_out === 0) {
@@ -2409,7 +2409,7 @@ const deflate_huff = (s, flush) => {
     if (s.lookahead === 0) {
       fill_window(s);
       if (s.lookahead === 0) {
-        if (flush === Z_NO_FLUSH) {
+        if (flush === Z_NO_FLUSH$2) {
           return BS_NEED_MORE;
         }
         break;      /* flush the current block */
@@ -2420,7 +2420,7 @@ const deflate_huff = (s, flush) => {
     s.match_length = 0;
     //Tracevv((stderr,"%c", s->window[s->strstart]));
     /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/
-    bflush = _tr_tally$1(s, 0, s.window[s.strstart]);
+    bflush = _tr_tally(s, 0, s.window[s.strstart]);
     s.lookahead--;
     s.strstart++;
     if (bflush) {
@@ -2433,7 +2433,7 @@ const deflate_huff = (s, flush) => {
     }
   }
   s.insert = 0;
-  if (flush === Z_FINISH) {
+  if (flush === Z_FINISH$3) {
     /*** FLUSH_BLOCK(s, 1); ***/
     flush_block_only(s, true);
     if (s.strm.avail_out === 0) {
@@ -2491,7 +2491,7 @@ const lm_init = (s) => {
   s.window_size = 2 * s.w_size;
 
   /*** CLEAR_HASH(s); ***/
-  zero$1(s.head); // Fill with NIL (= 0);
+  zero(s.head); // Fill with NIL (= 0);
 
   /* Set the default configuration parameters:
    */
@@ -2504,7 +2504,7 @@ const lm_init = (s) => {
   s.block_start = 0;
   s.lookahead = 0;
   s.insert = 0;
-  s.match_length = s.prev_length = MIN_MATCH$1 - 1;
+  s.match_length = s.prev_length = MIN_MATCH - 1;
   s.match_available = 0;
   s.ins_h = 0;
 };
@@ -2520,7 +2520,7 @@ function DeflateState() {
   this.wrap = 0;              /* bit 0 true for zlib, bit 1 true for gzip */
   this.gzhead = null;         /* gzip header information to write */
   this.gzindex = 0;           /* where in extra, name, or comment */
-  this.method = Z_DEFLATED; /* can only be DEFLATED */
+  this.method = Z_DEFLATED$2; /* can only be DEFLATED */
   this.last_flush = -1;   /* value of flush param for previous deflate call */
 
   this.w_size = 0;  /* LZ77 window size (32K by default) */
@@ -2613,24 +2613,24 @@ function DeflateState() {
 
   // Use flat array of DOUBLE size, with interleaved fata,
   // because JS does not support effective
-  this.dyn_ltree  = new Uint16Array(HEAP_SIZE$1 * 2);
-  this.dyn_dtree  = new Uint16Array((2 * D_CODES$1 + 1) * 2);
-  this.bl_tree    = new Uint16Array((2 * BL_CODES$1 + 1) * 2);
-  zero$1(this.dyn_ltree);
-  zero$1(this.dyn_dtree);
-  zero$1(this.bl_tree);
+  this.dyn_ltree  = new Uint16Array(HEAP_SIZE * 2);
+  this.dyn_dtree  = new Uint16Array((2 * D_CODES + 1) * 2);
+  this.bl_tree    = new Uint16Array((2 * BL_CODES + 1) * 2);
+  zero(this.dyn_ltree);
+  zero(this.dyn_dtree);
+  zero(this.bl_tree);
 
   this.l_desc   = null;         /* desc. for literal tree */
   this.d_desc   = null;         /* desc. for distance tree */
   this.bl_desc  = null;         /* desc. for bit length tree */
 
   //ush bl_count[MAX_BITS+1];
-  this.bl_count = new Uint16Array(MAX_BITS$1 + 1);
+  this.bl_count = new Uint16Array(MAX_BITS + 1);
   /* number of codes at each bit length for an optimal tree */
 
   //int heap[2*L_CODES+1];      /* heap used to build the Huffman trees */
-  this.heap = new Uint16Array(2 * L_CODES$1 + 1);  /* heap used to build the Huffman trees */
-  zero$1(this.heap);
+  this.heap = new Uint16Array(2 * L_CODES + 1);  /* heap used to build the Huffman trees */
+  zero(this.heap);
 
   this.heap_len = 0;               /* number of elements in the heap */
   this.heap_max = 0;               /* element of largest frequency */
@@ -2638,8 +2638,8 @@ function DeflateState() {
    * The same heap array is used to build all trees.
    */
 
-  this.depth = new Uint16Array(2 * L_CODES$1 + 1); //uch depth[2*L_CODES+1];
-  zero$1(this.depth);
+  this.depth = new Uint16Array(2 * L_CODES + 1); //uch depth[2*L_CODES+1];
+  zero(this.depth);
   /* Depth of each subtree used as tie breaker for trees of equal frequency
    */
 
@@ -2702,11 +2702,11 @@ function DeflateState() {
 const deflateResetKeep = (strm) => {
 
   if (!strm || !strm.state) {
-    return err(strm, Z_STREAM_ERROR);
+    return err(strm, Z_STREAM_ERROR$2);
   }
 
   strm.total_in = strm.total_out = 0;
-  strm.data_type = Z_UNKNOWN$1;
+  strm.data_type = Z_UNKNOWN;
 
   const s = strm.state;
   s.pending = 0;
@@ -2721,16 +2721,16 @@ const deflateResetKeep = (strm) => {
     0  // crc32(0, Z_NULL, 0)
   :
     1; // adler32(0, Z_NULL, 0)
-  s.last_flush = Z_NO_FLUSH;
-  _tr_init$1(s);
-  return Z_OK;
+  s.last_flush = Z_NO_FLUSH$2;
+  _tr_init(s);
+  return Z_OK$3;
 };
 
 
 const deflateReset = (strm) => {
 
   const ret = deflateResetKeep(strm);
-  if (ret === Z_OK) {
+  if (ret === Z_OK$3) {
     lm_init(strm.state);
   }
   return ret;
@@ -2739,21 +2739,21 @@ const deflateReset = (strm) => {
 
 const deflateSetHeader = (strm, head) => {
 
-  if (!strm || !strm.state) { return Z_STREAM_ERROR; }
-  if (strm.state.wrap !== 2) { return Z_STREAM_ERROR; }
+  if (!strm || !strm.state) { return Z_STREAM_ERROR$2; }
+  if (strm.state.wrap !== 2) { return Z_STREAM_ERROR$2; }
   strm.state.gzhead = head;
-  return Z_OK;
+  return Z_OK$3;
 };
 
 
 const deflateInit2 = (strm, level, method, windowBits, memLevel, strategy) => {
 
   if (!strm) { // === Z_NULL
-    return Z_STREAM_ERROR;
+    return Z_STREAM_ERROR$2;
   }
   let wrap = 1;
 
-  if (level === Z_DEFAULT_COMPRESSION) {
+  if (level === Z_DEFAULT_COMPRESSION$1) {
     level = 6;
   }
 
@@ -2768,10 +2768,10 @@ const deflateInit2 = (strm, level, method, windowBits, memLevel, strategy) => {
   }
 
 
-  if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method !== Z_DEFLATED ||
+  if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method !== Z_DEFLATED$2 ||
     windowBits < 8 || windowBits > 15 || level < 0 || level > 9 ||
-    strategy < 0 || strategy > Z_FIXED$1) {
-    return err(strm, Z_STREAM_ERROR);
+    strategy < 0 || strategy > Z_FIXED) {
+    return err(strm, Z_STREAM_ERROR$2);
   }
 
 
@@ -2794,7 +2794,7 @@ const deflateInit2 = (strm, level, method, windowBits, memLevel, strategy) => {
   s.hash_bits = memLevel + 7;
   s.hash_size = 1 << s.hash_bits;
   s.hash_mask = s.hash_size - 1;
-  s.hash_shift = ~~((s.hash_bits + MIN_MATCH$1 - 1) / MIN_MATCH$1);
+  s.hash_shift = ~~((s.hash_bits + MIN_MATCH - 1) / MIN_MATCH);
 
   s.window = new Uint8Array(s.w_size * 2);
   s.head = new Uint16Array(s.hash_size);
@@ -2827,25 +2827,25 @@ const deflateInit2 = (strm, level, method, windowBits, memLevel, strategy) => {
 
 const deflateInit = (strm, level) => {
 
-  return deflateInit2(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);
+  return deflateInit2(strm, level, Z_DEFLATED$2, MAX_WBITS$1, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY$1);
 };
 
 
-const deflate = (strm, flush) => {
+const deflate$2 = (strm, flush) => {
 
   let beg, val; // for gzip header write only
 
   if (!strm || !strm.state ||
-    flush > Z_BLOCK || flush < 0) {
-    return strm ? err(strm, Z_STREAM_ERROR) : Z_STREAM_ERROR;
+    flush > Z_BLOCK$1 || flush < 0) {
+    return strm ? err(strm, Z_STREAM_ERROR$2) : Z_STREAM_ERROR$2;
   }
 
   const s = strm.state;
 
   if (!strm.output ||
       (!strm.input && strm.avail_in !== 0) ||
-      (s.status === FINISH_STATE && flush !== Z_FINISH)) {
-    return err(strm, (strm.avail_out === 0) ? Z_BUF_ERROR : Z_STREAM_ERROR);
+      (s.status === FINISH_STATE && flush !== Z_FINISH$3)) {
+    return err(strm, (strm.avail_out === 0) ? Z_BUF_ERROR$1 : Z_STREAM_ERROR$2);
   }
 
   s.strm = strm; /* just in case */
@@ -2900,7 +2900,7 @@ const deflate = (strm, flush) => {
     }
     else // DEFLATE header
     {
-      let header = (Z_DEFLATED + ((s.w_bits - 8) << 4)) << 8;
+      let header = (Z_DEFLATED$2 + ((s.w_bits - 8) << 4)) << 8;
       let level_flags = -1;
 
       if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) {
@@ -3063,7 +3063,7 @@ const deflate = (strm, flush) => {
        * return OK instead of BUF_ERROR at next call of deflate:
        */
       s.last_flush = -1;
-      return Z_OK;
+      return Z_OK$3;
     }
 
     /* Make sure there is something to do and avoid duplicate consecutive
@@ -3071,19 +3071,19 @@ const deflate = (strm, flush) => {
      * returning Z_STREAM_END instead of Z_BUF_ERROR.
      */
   } else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) &&
-    flush !== Z_FINISH) {
-    return err(strm, Z_BUF_ERROR);
+    flush !== Z_FINISH$3) {
+    return err(strm, Z_BUF_ERROR$1);
   }
 
   /* User must not provide more input after the first FINISH: */
   if (s.status === FINISH_STATE && strm.avail_in !== 0) {
-    return err(strm, Z_BUF_ERROR);
+    return err(strm, Z_BUF_ERROR$1);
   }
 
   /* Start a new block or continue the current one.
    */
   if (strm.avail_in !== 0 || s.lookahead !== 0 ||
-    (flush !== Z_NO_FLUSH && s.status !== FINISH_STATE)) {
+    (flush !== Z_NO_FLUSH$2 && s.status !== FINISH_STATE)) {
     let bstate = (s.strategy === Z_HUFFMAN_ONLY) ? deflate_huff(s, flush) :
       (s.strategy === Z_RLE ? deflate_rle(s, flush) :
         configuration_table[s.level].func(s, flush));
@@ -3096,7 +3096,7 @@ const deflate = (strm, flush) => {
         s.last_flush = -1;
         /* avoid BUF_ERROR next call, see above */
       }
-      return Z_OK;
+      return Z_OK$3;
       /* If flush != Z_NO_FLUSH && avail_out == 0, the next call
        * of deflate should use the same flush parameter to make sure
        * that the flush is complete. So we don't have to output an
@@ -3107,17 +3107,17 @@ const deflate = (strm, flush) => {
     }
     if (bstate === BS_BLOCK_DONE) {
       if (flush === Z_PARTIAL_FLUSH) {
-        _tr_align$1(s);
+        _tr_align(s);
       }
-      else if (flush !== Z_BLOCK) { /* FULL_FLUSH or SYNC_FLUSH */
+      else if (flush !== Z_BLOCK$1) { /* FULL_FLUSH or SYNC_FLUSH */
 
-        _tr_stored_block$1(s, 0, 0, false);
+        _tr_stored_block(s, 0, 0, false);
         /* For a full flush, this empty block will be recognized
          * as a special marker by inflate_sync().
          */
-        if (flush === Z_FULL_FLUSH) {
+        if (flush === Z_FULL_FLUSH$1) {
           /*** CLEAR_HASH(s); ***/             /* forget history */
-          zero$1(s.head); // Fill with NIL (= 0);
+          zero(s.head); // Fill with NIL (= 0);
 
           if (s.lookahead === 0) {
             s.strstart = 0;
@@ -3129,15 +3129,15 @@ const deflate = (strm, flush) => {
       flush_pending(strm);
       if (strm.avail_out === 0) {
         s.last_flush = -1; /* avoid BUF_ERROR at next call, see above */
-        return Z_OK;
+        return Z_OK$3;
       }
     }
   }
   //Assert(strm->avail_out > 0, "bug2");
   //if (strm.avail_out <= 0) { throw new Error("bug2");}
 
-  if (flush !== Z_FINISH) { return Z_OK; }
-  if (s.wrap <= 0) { return Z_STREAM_END; }
+  if (flush !== Z_FINISH$3) { return Z_OK$3; }
+  if (s.wrap <= 0) { return Z_STREAM_END$3; }
 
   /* Write the trailer */
   if (s.wrap === 2) {
@@ -3162,14 +3162,14 @@ const deflate = (strm, flush) => {
    */
   if (s.wrap > 0) { s.wrap = -s.wrap; }
   /* write the trailer only once! */
-  return s.pending !== 0 ? Z_OK : Z_STREAM_END;
+  return s.pending !== 0 ? Z_OK$3 : Z_STREAM_END$3;
 };
 
 
 const deflateEnd = (strm) => {
 
   if (!strm/*== Z_NULL*/ || !strm.state/*== Z_NULL*/) {
-    return Z_STREAM_ERROR;
+    return Z_STREAM_ERROR$2;
   }
 
   const status = strm.state.status;
@@ -3181,12 +3181,12 @@ const deflateEnd = (strm) => {
     status !== BUSY_STATE &&
     status !== FINISH_STATE
   ) {
-    return err(strm, Z_STREAM_ERROR);
+    return err(strm, Z_STREAM_ERROR$2);
   }
 
   strm.state = null;
 
-  return status === BUSY_STATE ? err(strm, Z_DATA_ERROR) : Z_OK;
+  return status === BUSY_STATE ? err(strm, Z_DATA_ERROR$2) : Z_OK$3;
 };
 
 
@@ -3199,14 +3199,14 @@ const deflateSetDictionary = (strm, dictionary) => {
   let dictLength = dictionary.length;
 
   if (!strm/*== Z_NULL*/ || !strm.state/*== Z_NULL*/) {
-    return Z_STREAM_ERROR;
+    return Z_STREAM_ERROR$2;
   }
 
   const s = strm.state;
   const wrap = s.wrap;
 
   if (wrap === 2 || (wrap === 1 && s.status !== INIT_STATE) || s.lookahead) {
-    return Z_STREAM_ERROR;
+    return Z_STREAM_ERROR$2;
   }
 
   /* when using zlib wrappers, compute Adler-32 for provided dictionary */
@@ -3221,7 +3221,7 @@ const deflateSetDictionary = (strm, dictionary) => {
   if (dictLength >= s.w_size) {
     if (wrap === 0) {            /* already empty otherwise */
       /*** CLEAR_HASH(s); ***/
-      zero$1(s.head); // Fill with NIL (= 0);
+      zero(s.head); // Fill with NIL (= 0);
       s.strstart = 0;
       s.block_start = 0;
       s.insert = 0;
@@ -3241,12 +3241,12 @@ const deflateSetDictionary = (strm, dictionary) => {
   strm.next_in = 0;
   strm.input = dictionary;
   fill_window(s);
-  while (s.lookahead >= MIN_MATCH$1) {
+  while (s.lookahead >= MIN_MATCH) {
     let str = s.strstart;
-    let n = s.lookahead - (MIN_MATCH$1 - 1);
+    let n = s.lookahead - (MIN_MATCH - 1);
     do {
       /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */
-      s.ins_h = HASH(s, s.ins_h, s.window[str + MIN_MATCH$1 - 1]);
+      s.ins_h = HASH(s, s.ins_h, s.window[str + MIN_MATCH - 1]);
 
       s.prev[str & s.w_mask] = s.head[s.ins_h];
 
@@ -3254,20 +3254,20 @@ const deflateSetDictionary = (strm, dictionary) => {
       str++;
     } while (--n);
     s.strstart = str;
-    s.lookahead = MIN_MATCH$1 - 1;
+    s.lookahead = MIN_MATCH - 1;
     fill_window(s);
   }
   s.strstart += s.lookahead;
   s.block_start = s.strstart;
   s.insert = s.lookahead;
   s.lookahead = 0;
-  s.match_length = s.prev_length = MIN_MATCH$1 - 1;
+  s.match_length = s.prev_length = MIN_MATCH - 1;
   s.match_available = 0;
   strm.next_in = next;
   strm.input = input;
   strm.avail_in = avail;
   s.wrap = wrap;
-  return Z_OK;
+  return Z_OK$3;
 };
 
 
@@ -3276,7 +3276,7 @@ var deflateInit2_1 = deflateInit2;
 var deflateReset_1 = deflateReset;
 var deflateResetKeep_1 = deflateResetKeep;
 var deflateSetHeader_1 = deflateSetHeader;
-var deflate_2 = deflate;
+var deflate_2$1 = deflate$2;
 var deflateEnd_1 = deflateEnd;
 var deflateSetDictionary_1 = deflateSetDictionary;
 var deflateInfo = 'pako deflate (from Nodeca project)';
@@ -3290,13 +3290,13 @@ module.exports.deflatePrime = deflatePrime;
 module.exports.deflateTune = deflateTune;
 */
 
-var deflate_1 = {
+var deflate_1$2 = {
 	deflateInit: deflateInit_1,
 	deflateInit2: deflateInit2_1,
 	deflateReset: deflateReset_1,
 	deflateResetKeep: deflateResetKeep_1,
 	deflateSetHeader: deflateSetHeader_1,
-	deflate: deflate_2,
+	deflate: deflate_2$1,
 	deflateEnd: deflateEnd_1,
 	deflateSetDictionary: deflateSetDictionary_1,
 	deflateInfo: deflateInfo
@@ -3378,6 +3378,10 @@ _utf8len[254] = _utf8len[254] = 1; // Invalid sequence start
 
 // convert string to array (typed, when possible)
 var string2buf = (str) => {
+  if (typeof TextEncoder === 'function' && TextEncoder.prototype.encode) {
+    return new TextEncoder().encode(str);
+  }
+
   let buf, c, c2, m_pos, i, str_len = str.length, buf_len = 0;
 
   // count binary size
@@ -3451,9 +3455,14 @@ const buf2binstring = (buf, len) => {
 
 // convert array to string
 var buf2string = (buf, max) => {
-  let i, out;
   const len = max || buf.length;
 
+  if (typeof TextDecoder === 'function' && TextDecoder.prototype.decode) {
+    return new TextDecoder().decode(buf.subarray(0, max));
+  }
+
+  let i, out;
+
   // Reserve max possible length (2 words per char)
   // NB: by unknown reasons, Array is significantly faster for
   //     String.fromCharCode.apply than Uint16Array.
@@ -3570,18 +3579,18 @@ function ZStream() {
 
 var zstream = ZStream;
 
-const toString = Object.prototype.toString;
+const toString$1 = Object.prototype.toString;
 
 /* Public constants ==========================================================*/
 /* ===========================================================================*/
 
 const {
-  Z_NO_FLUSH: Z_NO_FLUSH$1, Z_SYNC_FLUSH, Z_FULL_FLUSH: Z_FULL_FLUSH$1, Z_FINISH: Z_FINISH$1,
-  Z_OK: Z_OK$1, Z_STREAM_END: Z_STREAM_END$1,
-  Z_DEFAULT_COMPRESSION: Z_DEFAULT_COMPRESSION$1,
-  Z_DEFAULT_STRATEGY: Z_DEFAULT_STRATEGY$1,
+  Z_NO_FLUSH: Z_NO_FLUSH$1, Z_SYNC_FLUSH, Z_FULL_FLUSH, Z_FINISH: Z_FINISH$2,
+  Z_OK: Z_OK$2, Z_STREAM_END: Z_STREAM_END$2,
+  Z_DEFAULT_COMPRESSION,
+  Z_DEFAULT_STRATEGY,
   Z_DEFLATED: Z_DEFLATED$1
-} = constants;
+} = constants$2;
 
 /* ===========================================================================*/
 
@@ -3671,14 +3680,14 @@ const {
  * console.log(deflate.result);
  * ```
  **/
-function Deflate(options) {
+function Deflate$1(options) {
   this.options = common.assign({
-    level: Z_DEFAULT_COMPRESSION$1,
+    level: Z_DEFAULT_COMPRESSION,
     method: Z_DEFLATED$1,
     chunkSize: 16384,
     windowBits: 15,
     memLevel: 8,
-    strategy: Z_DEFAULT_STRATEGY$1
+    strategy: Z_DEFAULT_STRATEGY
   }, options || {});
 
   let opt = this.options;
@@ -3699,7 +3708,7 @@ function Deflate(options) {
   this.strm = new zstream();
   this.strm.avail_out = 0;
 
-  let status = deflate_1.deflateInit2(
+  let status = deflate_1$2.deflateInit2(
     this.strm,
     opt.level,
     opt.method,
@@ -3708,12 +3717,12 @@ function Deflate(options) {
     opt.strategy
   );
 
-  if (status !== Z_OK$1) {
+  if (status !== Z_OK$2) {
     throw new Error(messages[status]);
   }
 
   if (opt.header) {
-    deflate_1.deflateSetHeader(this.strm, opt.header);
+    deflate_1$2.deflateSetHeader(this.strm, opt.header);
   }
 
   if (opt.dictionary) {
@@ -3722,15 +3731,15 @@ function Deflate(options) {
     if (typeof opt.dictionary === 'string') {
       // If we need to compress text, change encoding to utf8.
       dict = strings.string2buf(opt.dictionary);
-    } else if (toString.call(opt.dictionary) === '[object ArrayBuffer]') {
+    } else if (toString$1.call(opt.dictionary) === '[object ArrayBuffer]') {
       dict = new Uint8Array(opt.dictionary);
     } else {
       dict = opt.dictionary;
     }
 
-    status = deflate_1.deflateSetDictionary(this.strm, dict);
+    status = deflate_1$2.deflateSetDictionary(this.strm, dict);
 
-    if (status !== Z_OK$1) {
+    if (status !== Z_OK$2) {
       throw new Error(messages[status]);
     }
 
@@ -3760,7 +3769,7 @@ function Deflate(options) {
  * push(chunk, true);  // push last chunk
  * ```
  **/
-Deflate.prototype.push = function (data, flush_mode) {
+Deflate$1.prototype.push = function (data, flush_mode) {
   const strm = this.strm;
   const chunkSize = this.options.chunkSize;
   let status, _flush_mode;
@@ -3768,13 +3777,13 @@ Deflate.prototype.push = function (data, flush_mode) {
   if (this.ended) { return false; }
 
   if (flush_mode === ~~flush_mode) _flush_mode = flush_mode;
-  else _flush_mode = flush_mode === true ? Z_FINISH$1 : Z_NO_FLUSH$1;
+  else _flush_mode = flush_mode === true ? Z_FINISH$2 : Z_NO_FLUSH$1;
 
   // Convert data if needed
   if (typeof data === 'string') {
     // If we need to compress text, change encoding to utf8.
     strm.input = strings.string2buf(data);
-  } else if (toString.call(data) === '[object ArrayBuffer]') {
+  } else if (toString$1.call(data) === '[object ArrayBuffer]') {
     strm.input = new Uint8Array(data);
   } else {
     strm.input = data;
@@ -3791,23 +3800,23 @@ Deflate.prototype.push = function (data, flush_mode) {
     }
 
     // Make sure avail_out > 6 to avoid repeating markers
-    if ((_flush_mode === Z_SYNC_FLUSH || _flush_mode === Z_FULL_FLUSH$1) && strm.avail_out <= 6) {
+    if ((_flush_mode === Z_SYNC_FLUSH || _flush_mode === Z_FULL_FLUSH) && strm.avail_out <= 6) {
       this.onData(strm.output.subarray(0, strm.next_out));
       strm.avail_out = 0;
       continue;
     }
 
-    status = deflate_1.deflate(strm, _flush_mode);
+    status = deflate_1$2.deflate(strm, _flush_mode);
 
     // Ended => flush and finish
-    if (status === Z_STREAM_END$1) {
+    if (status === Z_STREAM_END$2) {
       if (strm.next_out > 0) {
         this.onData(strm.output.subarray(0, strm.next_out));
       }
-      status = deflate_1.deflateEnd(this.strm);
+      status = deflate_1$2.deflateEnd(this.strm);
       this.onEnd(status);
       this.ended = true;
-      return status === Z_OK$1;
+      return status === Z_OK$2;
     }
 
     // Flush if out buffer full
@@ -3837,7 +3846,7 @@ Deflate.prototype.push = function (data, flush_mode) {
  * By default, stores data blocks in `chunks[]` property and glue
  * those in `onEnd`. Override this handler, if you need another behaviour.
  **/
-Deflate.prototype.onData = function (chunk) {
+Deflate$1.prototype.onData = function (chunk) {
   this.chunks.push(chunk);
 };
 
@@ -3851,9 +3860,9 @@ Deflate.prototype.onData = function (chunk) {
  * complete (Z_FINISH). By default - join collected chunks,
  * free memory and fill `results` / `err` properties.
  **/
-Deflate.prototype.onEnd = function (status) {
+Deflate$1.prototype.onEnd = function (status) {
   // On success - join
-  if (status === Z_OK$1) {
+  if (status === Z_OK$2) {
     this.result = common.flattenChunks(this.chunks);
   }
   this.chunks = [];
@@ -3895,7 +3904,7 @@ Deflate.prototype.onEnd = function (status) {
  * ```
  **/
 function deflate$1(input, options) {
-  const deflator = new Deflate(options);
+  const deflator = new Deflate$1(options);
 
   deflator.push(input, true);
 
@@ -3914,7 +3923,7 @@ function deflate$1(input, options) {
  * The same as [[deflate]], but creates raw data, without wrapper
  * (header and adler32 crc).
  **/
-function deflateRaw(input, options) {
+function deflateRaw$1(input, options) {
   options = options || {};
   options.raw = true;
   return deflate$1(input, options);
@@ -3929,24 +3938,24 @@ function deflateRaw(input, options) {
  * The same as [[deflate]], but create gzip wrapper instead of
  * deflate one.
  **/
-function gzip(input, options) {
+function gzip$1(input, options) {
   options = options || {};
   options.gzip = true;
   return deflate$1(input, options);
 }
 
 
-var Deflate_1 = Deflate;
-var deflate_2$1 = deflate$1;
-var deflateRaw_1 = deflateRaw;
-var gzip_1 = gzip;
-var constants$1 = constants;
+var Deflate_1$1 = Deflate$1;
+var deflate_2 = deflate$1;
+var deflateRaw_1$1 = deflateRaw$1;
+var gzip_1$1 = gzip$1;
+var constants$1 = constants$2;
 
 var deflate_1$1 = {
-	Deflate: Deflate_1,
-	deflate: deflate_2$1,
-	deflateRaw: deflateRaw_1,
-	gzip: gzip_1,
+	Deflate: Deflate_1$1,
+	deflate: deflate_2,
+	deflateRaw: deflateRaw_1$1,
+	gzip: gzip_1$1,
 	constants: constants$1
 };
 
@@ -3970,8 +3979,8 @@ var deflate_1$1 = {
 // 3. This notice may not be removed or altered from any source distribution.
 
 // See state defs from inflate.js
-const BAD = 30;       /* got a data error -- remain here until reset */
-const TYPE = 12;      /* i: waiting for type bits, including last-flag bit */
+const BAD$1 = 30;       /* got a data error -- remain here until reset */
+const TYPE$1 = 12;      /* i: waiting for type bits, including last-flag bit */
 
 /*
    Decode literal, length, and distance codes and write out the resulting
@@ -4133,7 +4142,7 @@ var inffast = function inflate_fast(strm, start) {
 //#ifdef INFLATE_STRICT
             if (dist > dmax) {
               strm.msg = 'invalid distance too far back';
-              state.mode = BAD;
+              state.mode = BAD$1;
               break top;
             }
 //#endif
@@ -4146,7 +4155,7 @@ var inffast = function inflate_fast(strm, start) {
               if (op > whave) {
                 if (state.sane) {
                   strm.msg = 'invalid distance too far back';
-                  state.mode = BAD;
+                  state.mode = BAD$1;
                   break top;
                 }
 
@@ -4251,7 +4260,7 @@ var inffast = function inflate_fast(strm, start) {
           }
           else {
             strm.msg = 'invalid distance code';
-            state.mode = BAD;
+            state.mode = BAD$1;
             break top;
           }
 
@@ -4264,12 +4273,12 @@ var inffast = function inflate_fast(strm, start) {
       }
       else if (op & 32) {                     /* end-of-block */
         //Tracevv((stderr, "inflate:         end of block\n"));
-        state.mode = TYPE;
+        state.mode = TYPE$1;
         break top;
       }
       else {
         strm.msg = 'invalid literal/length code';
-        state.mode = BAD;
+        state.mode = BAD$1;
         break top;
       }
 
@@ -4313,13 +4322,13 @@ var inffast = function inflate_fast(strm, start) {
 // 3. This notice may not be removed or altered from any source distribution.
 
 const MAXBITS = 15;
-const ENOUGH_LENS = 852;
-const ENOUGH_DISTS = 592;
+const ENOUGH_LENS$1 = 852;
+const ENOUGH_DISTS$1 = 592;
 //const ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS);
 
-const CODES = 0;
-const LENS = 1;
-const DISTS = 2;
+const CODES$1 = 0;
+const LENS$1 = 1;
+const DISTS$1 = 2;
 
 const lbase = new Uint16Array([ /* Length codes 257..285 base */
   3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
@@ -4451,7 +4460,7 @@ const inflate_table = (type, lens, lens_index, codes, table, table_index, work,
       return -1;
     }        /* over-subscribed */
   }
-  if (left > 0 && (type === CODES || max !== 1)) {
+  if (left > 0 && (type === CODES$1 || max !== 1)) {
     return -1;                      /* incomplete set */
   }
 
@@ -4502,11 +4511,11 @@ const inflate_table = (type, lens, lens_index, codes, table, table_index, work,
   /* set up for code type */
   // poor man optimization - use if-else instead of switch,
   // to avoid deopts in old v8
-  if (type === CODES) {
+  if (type === CODES$1) {
     base = extra = work;    /* dummy value--not used */
     end = 19;
 
-  } else if (type === LENS) {
+  } else if (type === LENS$1) {
     base = lbase;
     base_index -= 257;
     extra = lext;
@@ -4531,8 +4540,8 @@ const inflate_table = (type, lens, lens_index, codes, table, table_index, work,
   mask = used - 1;            /* mask for comparing low */
 
   /* check available table space */
-  if ((type === LENS && used > ENOUGH_LENS) ||
-    (type === DISTS && used > ENOUGH_DISTS)) {
+  if ((type === LENS$1 && used > ENOUGH_LENS$1) ||
+    (type === DISTS$1 && used > ENOUGH_DISTS$1)) {
     return 1;
   }
 
@@ -4603,8 +4612,8 @@ const inflate_table = (type, lens, lens_index, codes, table, table_index, work,
 
       /* check for enough space */
       used += 1 << curr;
-      if ((type === LENS && used > ENOUGH_LENS) ||
-        (type === DISTS && used > ENOUGH_DISTS)) {
+      if ((type === LENS$1 && used > ENOUGH_LENS$1) ||
+        (type === DISTS$1 && used > ENOUGH_DISTS$1)) {
         return 1;
       }
 
@@ -4660,18 +4669,18 @@ var inftrees = inflate_table;
 
 
 
-const CODES$1 = 0;
-const LENS$1 = 1;
-const DISTS$1 = 2;
+const CODES = 0;
+const LENS = 1;
+const DISTS = 2;
 
 /* Public constants ==========================================================*/
 /* ===========================================================================*/
 
 const {
-  Z_FINISH: Z_FINISH$2, Z_BLOCK: Z_BLOCK$1, Z_TREES,
-  Z_OK: Z_OK$2, Z_STREAM_END: Z_STREAM_END$2, Z_NEED_DICT, Z_STREAM_ERROR: Z_STREAM_ERROR$1, Z_DATA_ERROR: Z_DATA_ERROR$1, Z_MEM_ERROR, Z_BUF_ERROR: Z_BUF_ERROR$1,
-  Z_DEFLATED: Z_DEFLATED$2
-} = constants;
+  Z_FINISH: Z_FINISH$1, Z_BLOCK, Z_TREES,
+  Z_OK: Z_OK$1, Z_STREAM_END: Z_STREAM_END$1, Z_NEED_DICT: Z_NEED_DICT$1, Z_STREAM_ERROR: Z_STREAM_ERROR$1, Z_DATA_ERROR: Z_DATA_ERROR$1, Z_MEM_ERROR: Z_MEM_ERROR$1, Z_BUF_ERROR,
+  Z_DEFLATED
+} = constants$2;
 
 
 /* STATES ====================================================================*/
@@ -4689,7 +4698,7 @@ const    COMMENT = 8;    /* i: waiting for end of comment (gzip) */
 const    HCRC = 9;       /* i: waiting for header crc (gzip) */
 const    DICTID = 10;    /* i: waiting for dictionary check value */
 const    DICT = 11;      /* waiting for inflateSetDictionary() call */
-const        TYPE$1 = 12;      /* i: waiting for type bits, including last-flag bit */
+const        TYPE = 12;      /* i: waiting for type bits, including last-flag bit */
 const        TYPEDO = 13;    /* i: same, but skip check to exit inflate on new block */
 const        STORED = 14;    /* i: waiting for stored size (length and complement) */
 const        COPY_ = 15;     /* i/o: same as COPY below, but only first time in */
@@ -4707,7 +4716,7 @@ const            LIT = 26;       /* o: waiting for output space to write literal
 const    CHECK = 27;     /* i: waiting for 32-bit check value */
 const    LENGTH = 28;    /* i: waiting for 32-bit length (gzip) */
 const    DONE = 29;      /* finished check, done -- remain here until reset */
-const    BAD$1 = 30;       /* got a data error -- remain here until reset */
+const    BAD = 30;       /* got a data error -- remain here until reset */
 const    MEM = 31;       /* got an inflate() memory error -- remain here until reset */
 const    SYNC = 32;      /* looking for synchronization bytes to restart inflate() */
 
@@ -4715,13 +4724,13 @@ const    SYNC = 32;      /* looking for synchronization bytes to restart inflate
 
 
 
-const ENOUGH_LENS$1 = 852;
-const ENOUGH_DISTS$1 = 592;
+const ENOUGH_LENS = 852;
+const ENOUGH_DISTS = 592;
 //const ENOUGH =  (ENOUGH_LENS+ENOUGH_DISTS);
 
-const MAX_WBITS$1 = 15;
+const MAX_WBITS = 15;
 /* 32K LZ77 window */
-const DEF_WBITS = MAX_WBITS$1;
+const DEF_WBITS = MAX_WBITS;
 
 
 const zswap32 = (q) => {
@@ -4809,13 +4818,13 @@ const inflateResetKeep = (strm) => {
   state.hold = 0;
   state.bits = 0;
   //state.lencode = state.distcode = state.next = state.codes;
-  state.lencode = state.lendyn = new Int32Array(ENOUGH_LENS$1);
-  state.distcode = state.distdyn = new Int32Array(ENOUGH_DISTS$1);
+  state.lencode = state.lendyn = new Int32Array(ENOUGH_LENS);
+  state.distcode = state.distdyn = new Int32Array(ENOUGH_DISTS);
 
   state.sane = 1;
   state.back = -1;
   //Tracev((stderr, "inflate: reset\n"));
-  return Z_OK$2;
+  return Z_OK$1;
 };
 
 
@@ -4877,7 +4886,7 @@ const inflateInit2 = (strm, windowBits) => {
   strm.state = state;
   state.window = null/*Z_NULL*/;
   const ret = inflateReset2(strm, windowBits);
-  if (ret !== Z_OK$2) {
+  if (ret !== Z_OK$1) {
     strm.state = null/*Z_NULL*/;
   }
   return ret;
@@ -4919,13 +4928,13 @@ const fixedtables = (state) => {
     while (sym < 280) { state.lens[sym++] = 7; }
     while (sym < 288) { state.lens[sym++] = 8; }
 
-    inftrees(LENS$1,  state.lens, 0, 288, lenfix,   0, state.work, { bits: 9 });
+    inftrees(LENS,  state.lens, 0, 288, lenfix,   0, state.work, { bits: 9 });
 
     /* distance table */
     sym = 0;
     while (sym < 32) { state.lens[sym++] = 5; }
 
-    inftrees(DISTS$1, state.lens, 0, 32,   distfix, 0, state.work, { bits: 5 });
+    inftrees(DISTS, state.lens, 0, 32,   distfix, 0, state.work, { bits: 5 });
 
     /* do this just once */
     virgin = false;
@@ -4996,7 +5005,7 @@ const updatewindow = (strm, src, end, copy) => {
 };
 
 
-const inflate = (strm, flush) => {
+const inflate$2 = (strm, flush) => {
 
   let state;
   let input, output;          // input/output buffers
@@ -5030,7 +5039,7 @@ const inflate = (strm, flush) => {
   }
 
   state = strm.state;
-  if (state.mode === TYPE$1) { state.mode = TYPEDO; }    /* skip check */
+  if (state.mode === TYPE) { state.mode = TYPEDO; }    /* skip check */
 
 
   //--- LOAD() ---
@@ -5046,7 +5055,7 @@ const inflate = (strm, flush) => {
 
   _in = have;
   _out = left;
-  ret = Z_OK$2;
+  ret = Z_OK$1;
 
   inf_leave: // goto emulation
   for (;;) {
@@ -5086,12 +5095,12 @@ const inflate = (strm, flush) => {
         if (!(state.wrap & 1) ||   /* check if zlib header allowed */
           (((hold & 0xff)/*BITS(8)*/ << 8) + (hold >> 8)) % 31) {
           strm.msg = 'incorrect header check';
-          state.mode = BAD$1;
+          state.mode = BAD;
           break;
         }
-        if ((hold & 0x0f)/*BITS(4)*/ !== Z_DEFLATED$2) {
+        if ((hold & 0x0f)/*BITS(4)*/ !== Z_DEFLATED) {
           strm.msg = 'unknown compression method';
-          state.mode = BAD$1;
+          state.mode = BAD;
           break;
         }
         //--- DROPBITS(4) ---//
@@ -5104,7 +5113,7 @@ const inflate = (strm, flush) => {
         }
         else if (len > state.wbits) {
           strm.msg = 'invalid window size';
-          state.mode = BAD$1;
+          state.mode = BAD;
           break;
         }
 
@@ -5115,7 +5124,7 @@ const inflate = (strm, flush) => {
 
         //Tracev((stderr, "inflate:   zlib header ok\n"));
         strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/;
-        state.mode = hold & 0x200 ? DICTID : TYPE$1;
+        state.mode = hold & 0x200 ? DICTID : TYPE;
         //=== INITBITS();
         hold = 0;
         bits = 0;
@@ -5131,14 +5140,14 @@ const inflate = (strm, flush) => {
         }
         //===//
         state.flags = hold;
-        if ((state.flags & 0xff) !== Z_DEFLATED$2) {
+        if ((state.flags & 0xff) !== Z_DEFLATED) {
           strm.msg = 'unknown compression method';
-          state.mode = BAD$1;
+          state.mode = BAD;
           break;
         }
         if (state.flags & 0xe000) {
           strm.msg = 'unknown header flags set';
-          state.mode = BAD$1;
+          state.mode = BAD;
           break;
         }
         if (state.head) {
@@ -5341,7 +5350,7 @@ const inflate = (strm, flush) => {
           //===//
           if (hold !== (state.check & 0xffff)) {
             strm.msg = 'header crc mismatch';
-            state.mode = BAD$1;
+            state.mode = BAD;
             break;
           }
           //=== INITBITS();
@@ -5354,7 +5363,7 @@ const inflate = (strm, flush) => {
           state.head.done = true;
         }
         strm.adler = state.check = 0;
-        state.mode = TYPE$1;
+        state.mode = TYPE;
         break;
       case DICTID:
         //=== NEEDBITS(32); */
@@ -5382,13 +5391,13 @@ const inflate = (strm, flush) => {
           state.hold = hold;
           state.bits = bits;
           //---
-          return Z_NEED_DICT;
+          return Z_NEED_DICT$1;
         }
         strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/;
-        state.mode = TYPE$1;
+        state.mode = TYPE;
         /* falls through */
-      case TYPE$1:
-        if (flush === Z_BLOCK$1 || flush === Z_TREES) { break inf_leave; }
+      case TYPE:
+        if (flush === Z_BLOCK || flush === Z_TREES) { break inf_leave; }
         /* falls through */
       case TYPEDO:
         if (state.last) {
@@ -5439,7 +5448,7 @@ const inflate = (strm, flush) => {
             break;
           case 3:
             strm.msg = 'invalid block type';
-            state.mode = BAD$1;
+            state.mode = BAD;
         }
         //--- DROPBITS(2) ---//
         hold >>>= 2;
@@ -5461,7 +5470,7 @@ const inflate = (strm, flush) => {
         //===//
         if ((hold & 0xffff) !== ((hold >>> 16) ^ 0xffff)) {
           strm.msg = 'invalid stored block lengths';
-          state.mode = BAD$1;
+          state.mode = BAD;
           break;
         }
         state.length = hold & 0xffff;
@@ -5494,7 +5503,7 @@ const inflate = (strm, flush) => {
           break;
         }
         //Tracev((stderr, "inflate:       stored end\n"));
-        state.mode = TYPE$1;
+        state.mode = TYPE;
         break;
       case TABLE:
         //=== NEEDBITS(14); */
@@ -5523,7 +5532,7 @@ const inflate = (strm, flush) => {
 //#ifndef PKZIP_BUG_WORKAROUND
         if (state.nlen > 286 || state.ndist > 30) {
           strm.msg = 'too many length or distance symbols';
-          state.mode = BAD$1;
+          state.mode = BAD;
           break;
         }
 //#endif
@@ -5558,12 +5567,12 @@ const inflate = (strm, flush) => {
         state.lenbits = 7;
 
         opts = { bits: state.lenbits };
-        ret = inftrees(CODES$1, state.lens, 0, 19, state.lencode, 0, state.work, opts);
+        ret = inftrees(CODES, state.lens, 0, 19, state.lencode, 0, state.work, opts);
         state.lenbits = opts.bits;
 
         if (ret) {
           strm.msg = 'invalid code lengths set';
-          state.mode = BAD$1;
+          state.mode = BAD;
           break;
         }
         //Tracev((stderr, "inflate:       code lengths ok\n"));
@@ -5610,7 +5619,7 @@ const inflate = (strm, flush) => {
               //---//
               if (state.have === 0) {
                 strm.msg = 'invalid bit length repeat';
-                state.mode = BAD$1;
+                state.mode = BAD;
                 break;
               }
               len = state.lens[state.have - 1];
@@ -5664,7 +5673,7 @@ const inflate = (strm, flush) => {
             }
             if (state.have + copy > state.nlen + state.ndist) {
               strm.msg = 'invalid bit length repeat';
-              state.mode = BAD$1;
+              state.mode = BAD;
               break;
             }
             while (copy--) {
@@ -5674,12 +5683,12 @@ const inflate = (strm, flush) => {
         }
 
         /* handle error breaks in while */
-        if (state.mode === BAD$1) { break; }
+        if (state.mode === BAD) { break; }
 
         /* check for end-of-block code (better have one) */
         if (state.lens[256] === 0) {
           strm.msg = 'invalid code -- missing end-of-block';
-          state.mode = BAD$1;
+          state.mode = BAD;
           break;
         }
 
@@ -5689,7 +5698,7 @@ const inflate = (strm, flush) => {
         state.lenbits = 9;
 
         opts = { bits: state.lenbits };
-        ret = inftrees(LENS$1, state.lens, 0, state.nlen, state.lencode, 0, state.work, opts);
+        ret = inftrees(LENS, state.lens, 0, state.nlen, state.lencode, 0, state.work, opts);
         // We have separate tables & no pointers. 2 commented lines below not needed.
         // state.next_index = opts.table_index;
         state.lenbits = opts.bits;
@@ -5697,7 +5706,7 @@ const inflate = (strm, flush) => {
 
         if (ret) {
           strm.msg = 'invalid literal/lengths set';
-          state.mode = BAD$1;
+          state.mode = BAD;
           break;
         }
 
@@ -5706,7 +5715,7 @@ const inflate = (strm, flush) => {
         // Switch to use dynamic table
         state.distcode = state.distdyn;
         opts = { bits: state.distbits };
-        ret = inftrees(DISTS$1, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, opts);
+        ret = inftrees(DISTS, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, opts);
         // We have separate tables & no pointers. 2 commented lines below not needed.
         // state.next_index = opts.table_index;
         state.distbits = opts.bits;
@@ -5714,7 +5723,7 @@ const inflate = (strm, flush) => {
 
         if (ret) {
           strm.msg = 'invalid distances set';
-          state.mode = BAD$1;
+          state.mode = BAD;
           break;
         }
         //Tracev((stderr, 'inflate:       codes ok\n'));
@@ -5746,7 +5755,7 @@ const inflate = (strm, flush) => {
           bits = state.bits;
           //---
 
-          if (state.mode === TYPE$1) {
+          if (state.mode === TYPE) {
             state.back = -1;
           }
           break;
@@ -5807,12 +5816,12 @@ const inflate = (strm, flush) => {
         if (here_op & 32) {
           //Tracevv((stderr, "inflate:         end of block\n"));
           state.back = -1;
-          state.mode = TYPE$1;
+          state.mode = TYPE;
           break;
         }
         if (here_op & 64) {
           strm.msg = 'invalid literal/length code';
-          state.mode = BAD$1;
+          state.mode = BAD;
           break;
         }
         state.extra = here_op & 15;
@@ -5887,7 +5896,7 @@ const inflate = (strm, flush) => {
         state.back += here_bits;
         if (here_op & 64) {
           strm.msg = 'invalid distance code';
-          state.mode = BAD$1;
+          state.mode = BAD;
           break;
         }
         state.offset = here_val;
@@ -5915,7 +5924,7 @@ const inflate = (strm, flush) => {
 //#ifdef INFLATE_STRICT
         if (state.offset > state.dmax) {
           strm.msg = 'invalid distance too far back';
-          state.mode = BAD$1;
+          state.mode = BAD;
           break;
         }
 //#endif
@@ -5930,7 +5939,7 @@ const inflate = (strm, flush) => {
           if (copy > state.whave) {
             if (state.sane) {
               strm.msg = 'invalid distance too far back';
-              state.mode = BAD$1;
+              state.mode = BAD;
               break;
             }
 // (!) This block is disabled in zlib defaults,
@@ -6002,7 +6011,7 @@ const inflate = (strm, flush) => {
           // NB: crc32 stored as signed 32-bit int, zswap32 returns signed too
           if ((state.flags ? hold : zswap32(hold)) !== state.check) {
             strm.msg = 'incorrect data check';
-            state.mode = BAD$1;
+            state.mode = BAD;
             break;
           }
           //=== INITBITS();
@@ -6025,7 +6034,7 @@ const inflate = (strm, flush) => {
           //===//
           if (hold !== (state.total & 0xffffffff)) {
             strm.msg = 'incorrect length check';
-            state.mode = BAD$1;
+            state.mode = BAD;
             break;
           }
           //=== INITBITS();
@@ -6037,13 +6046,13 @@ const inflate = (strm, flush) => {
         state.mode = DONE;
         /* falls through */
       case DONE:
-        ret = Z_STREAM_END$2;
+        ret = Z_STREAM_END$1;
         break inf_leave;
-      case BAD$1:
+      case BAD:
         ret = Z_DATA_ERROR$1;
         break inf_leave;
       case MEM:
-        return Z_MEM_ERROR;
+        return Z_MEM_ERROR$1;
       case SYNC:
         /* falls through */
       default:
@@ -6069,8 +6078,8 @@ const inflate = (strm, flush) => {
   state.bits = bits;
   //---
 
-  if (state.wsize || (_out !== strm.avail_out && state.mode < BAD$1 &&
-                      (state.mode < CHECK || flush !== Z_FINISH$2))) {
+  if (state.wsize || (_out !== strm.avail_out && state.mode < BAD &&
+                      (state.mode < CHECK || flush !== Z_FINISH$1))) {
     if (updatewindow(strm, strm.output, strm.next_out, _out - strm.avail_out)) ;
   }
   _in -= strm.avail_in;
@@ -6083,10 +6092,10 @@ const inflate = (strm, flush) => {
       (state.flags ? crc32_1(state.check, output, _out, strm.next_out - _out) : adler32_1(state.check, output, _out, strm.next_out - _out));
   }
   strm.data_type = state.bits + (state.last ? 64 : 0) +
-                    (state.mode === TYPE$1 ? 128 : 0) +
+                    (state.mode === TYPE ? 128 : 0) +
                     (state.mode === LEN_ || state.mode === COPY_ ? 256 : 0);
-  if (((_in === 0 && _out === 0) || flush === Z_FINISH$2) && ret === Z_OK$2) {
-    ret = Z_BUF_ERROR$1;
+  if (((_in === 0 && _out === 0) || flush === Z_FINISH$1) && ret === Z_OK$1) {
+    ret = Z_BUF_ERROR;
   }
   return ret;
 };
@@ -6103,7 +6112,7 @@ const inflateEnd = (strm) => {
     state.window = null;
   }
   strm.state = null;
-  return Z_OK$2;
+  return Z_OK$1;
 };
 
 
@@ -6117,7 +6126,7 @@ const inflateGetHeader = (strm, head) => {
   /* save header structure */
   state.head = head;
   head.done = false;
-  return Z_OK$2;
+  return Z_OK$1;
 };
 
 
@@ -6150,11 +6159,11 @@ const inflateSetDictionary = (strm, dictionary) => {
   ret = updatewindow(strm, dictionary, dictLength, dictLength);
   if (ret) {
     state.mode = MEM;
-    return Z_MEM_ERROR;
+    return Z_MEM_ERROR$1;
   }
   state.havedict = 1;
   // Tracev((stderr, "inflate:   dictionary set\n"));
-  return Z_OK$2;
+  return Z_OK$1;
 };
 
 
@@ -6163,7 +6172,7 @@ var inflateReset2_1 = inflateReset2;
 var inflateResetKeep_1 = inflateResetKeep;
 var inflateInit_1 = inflateInit;
 var inflateInit2_1 = inflateInit2;
-var inflate_2 = inflate;
+var inflate_2$1 = inflate$2;
 var inflateEnd_1 = inflateEnd;
 var inflateGetHeader_1 = inflateGetHeader;
 var inflateSetDictionary_1 = inflateSetDictionary;
@@ -6179,13 +6188,13 @@ module.exports.inflateSyncPoint = inflateSyncPoint;
 module.exports.inflateUndermine = inflateUndermine;
 */
 
-var inflate_1 = {
+var inflate_1$2 = {
 	inflateReset: inflateReset_1,
 	inflateReset2: inflateReset2_1,
 	inflateResetKeep: inflateResetKeep_1,
 	inflateInit: inflateInit_1,
 	inflateInit2: inflateInit2_1,
-	inflate: inflate_2,
+	inflate: inflate_2$1,
 	inflateEnd: inflateEnd_1,
 	inflateGetHeader: inflateGetHeader_1,
 	inflateSetDictionary: inflateSetDictionary_1,
@@ -6249,15 +6258,15 @@ function GZheader() {
 
 var gzheader = GZheader;
 
-const toString$1 = Object.prototype.toString;
+const toString = Object.prototype.toString;
 
 /* Public constants ==========================================================*/
 /* ===========================================================================*/
 
 const {
-  Z_NO_FLUSH: Z_NO_FLUSH$2, Z_FINISH: Z_FINISH$3,
-  Z_OK: Z_OK$3, Z_STREAM_END: Z_STREAM_END$3, Z_NEED_DICT: Z_NEED_DICT$1, Z_STREAM_ERROR: Z_STREAM_ERROR$2, Z_DATA_ERROR: Z_DATA_ERROR$2, Z_MEM_ERROR: Z_MEM_ERROR$1
-} = constants;
+  Z_NO_FLUSH, Z_FINISH,
+  Z_OK, Z_STREAM_END, Z_NEED_DICT, Z_STREAM_ERROR, Z_DATA_ERROR, Z_MEM_ERROR
+} = constants$2;
 
 /* ===========================================================================*/
 
@@ -6339,7 +6348,7 @@ const {
  * console.log(inflate.result);
  * ```
  **/
-function Inflate(options) {
+function Inflate$1(options) {
   this.options = common.assign({
     chunkSize: 1024 * 64,
     windowBits: 15,
@@ -6379,30 +6388,30 @@ function Inflate(options) {
   this.strm   = new zstream();
   this.strm.avail_out = 0;
 
-  let status  = inflate_1.inflateInit2(
+  let status  = inflate_1$2.inflateInit2(
     this.strm,
     opt.windowBits
   );
 
-  if (status !== Z_OK$3) {
+  if (status !== Z_OK) {
     throw new Error(messages[status]);
   }
 
   this.header = new gzheader();
 
-  inflate_1.inflateGetHeader(this.strm, this.header);
+  inflate_1$2.inflateGetHeader(this.strm, this.header);
 
   // Setup dictionary
   if (opt.dictionary) {
     // Convert data if needed
     if (typeof opt.dictionary === 'string') {
       opt.dictionary = strings.string2buf(opt.dictionary);
-    } else if (toString$1.call(opt.dictionary) === '[object ArrayBuffer]') {
+    } else if (toString.call(opt.dictionary) === '[object ArrayBuffer]') {
       opt.dictionary = new Uint8Array(opt.dictionary);
     }
     if (opt.raw) { //In raw mode we need to set the dictionary early
-      status = inflate_1.inflateSetDictionary(this.strm, opt.dictionary);
-      if (status !== Z_OK$3) {
+      status = inflate_1$2.inflateSetDictionary(this.strm, opt.dictionary);
+      if (status !== Z_OK) {
         throw new Error(messages[status]);
       }
     }
@@ -6434,7 +6443,7 @@ function Inflate(options) {
  * push(chunk, true);  // push last chunk
  * ```
  **/
-Inflate.prototype.push = function (data, flush_mode) {
+Inflate$1.prototype.push = function (data, flush_mode) {
   const strm = this.strm;
   const chunkSize = this.options.chunkSize;
   const dictionary = this.options.dictionary;
@@ -6443,10 +6452,10 @@ Inflate.prototype.push = function (data, flush_mode) {
   if (this.ended) return false;
 
   if (flush_mode === ~~flush_mode) _flush_mode = flush_mode;
-  else _flush_mode = flush_mode === true ? Z_FINISH$3 : Z_NO_FLUSH$2;
+  else _flush_mode = flush_mode === true ? Z_FINISH : Z_NO_FLUSH;
 
   // Convert data if needed
-  if (toString$1.call(data) === '[object ArrayBuffer]') {
+  if (toString.call(data) === '[object ArrayBuffer]') {
     strm.input = new Uint8Array(data);
   } else {
     strm.input = data;
@@ -6462,34 +6471,34 @@ Inflate.prototype.push = function (data, flush_mode) {
       strm.avail_out = chunkSize;
     }
 
-    status = inflate_1.inflate(strm, _flush_mode);
+    status = inflate_1$2.inflate(strm, _flush_mode);
 
-    if (status === Z_NEED_DICT$1 && dictionary) {
-      status = inflate_1.inflateSetDictionary(strm, dictionary);
+    if (status === Z_NEED_DICT && dictionary) {
+      status = inflate_1$2.inflateSetDictionary(strm, dictionary);
 
-      if (status === Z_OK$3) {
-        status = inflate_1.inflate(strm, _flush_mode);
-      } else if (status === Z_DATA_ERROR$2) {
+      if (status === Z_OK) {
+        status = inflate_1$2.inflate(strm, _flush_mode);
+      } else if (status === Z_DATA_ERROR) {
         // Replace code with more verbose
-        status = Z_NEED_DICT$1;
+        status = Z_NEED_DICT;
       }
     }
 
     // Skip snyc markers if more data follows and not raw mode
     while (strm.avail_in > 0 &&
-           status === Z_STREAM_END$3 &&
+           status === Z_STREAM_END &&
            strm.state.wrap > 0 &&
            data[strm.next_in] !== 0)
     {
-      inflate_1.inflateReset(strm);
-      status = inflate_1.inflate(strm, _flush_mode);
+      inflate_1$2.inflateReset(strm);
+      status = inflate_1$2.inflate(strm, _flush_mode);
     }
 
     switch (status) {
-      case Z_STREAM_ERROR$2:
-      case Z_DATA_ERROR$2:
-      case Z_NEED_DICT$1:
-      case Z_MEM_ERROR$1:
+      case Z_STREAM_ERROR:
+      case Z_DATA_ERROR:
+      case Z_NEED_DICT:
+      case Z_MEM_ERROR:
         this.onEnd(status);
         this.ended = true;
         return false;
@@ -6500,7 +6509,7 @@ Inflate.prototype.push = function (data, flush_mode) {
     last_avail_out = strm.avail_out;
 
     if (strm.next_out) {
-      if (strm.avail_out === 0 || status === Z_STREAM_END$3) {
+      if (strm.avail_out === 0 || status === Z_STREAM_END) {
 
         if (this.options.to === 'string') {
 
@@ -6523,11 +6532,11 @@ Inflate.prototype.push = function (data, flush_mode) {
     }
 
     // Must repeat iteration if out buffer is full
-    if (status === Z_OK$3 && last_avail_out === 0) continue;
+    if (status === Z_OK && last_avail_out === 0) continue;
 
     // Finalize if end of stream reached.
-    if (status === Z_STREAM_END$3) {
-      status = inflate_1.inflateEnd(this.strm);
+    if (status === Z_STREAM_END) {
+      status = inflate_1$2.inflateEnd(this.strm);
       this.onEnd(status);
       this.ended = true;
       return true;
@@ -6548,7 +6557,7 @@ Inflate.prototype.push = function (data, flush_mode) {
  * By default, stores data blocks in `chunks[]` property and glue
  * those in `onEnd`. Override this handler, if you need another behaviour.
  **/
-Inflate.prototype.onData = function (chunk) {
+Inflate$1.prototype.onData = function (chunk) {
   this.chunks.push(chunk);
 };
 
@@ -6562,9 +6571,9 @@ Inflate.prototype.onData = function (chunk) {
  * complete (Z_FINISH). By default - join collected chunks,
  * free memory and fill `results` / `err` properties.
  **/
-Inflate.prototype.onEnd = function (status) {
+Inflate$1.prototype.onEnd = function (status) {
   // On success - join
-  if (status === Z_OK$3) {
+  if (status === Z_OK) {
     if (this.options.to === 'string') {
       this.result = this.chunks.join('');
     } else {
@@ -6611,13 +6620,13 @@ Inflate.prototype.onEnd = function (status) {
  *
  * try {
  *   output = pako.inflate(input);
- * } catch (err)
+ * } catch (err) {
  *   console.log(err);
  * }
  * ```
  **/
 function inflate$1(input, options) {
-  const inflator = new Inflate(options);
+  const inflator = new Inflate$1(options);
 
   inflator.push(input);
 
@@ -6636,7 +6645,7 @@ function inflate$1(input, options) {
  * The same as [[inflate]], but creates raw data, without wrapper
  * (header and adler32 crc).
  **/
-function inflateRaw(input, options) {
+function inflateRaw$1(input, options) {
   options = options || {};
   options.raw = true;
   return inflate$1(input, options);
@@ -6653,44 +6662,44 @@ function inflateRaw(input, options) {
  **/
 
 
-var Inflate_1 = Inflate;
-var inflate_2$1 = inflate$1;
-var inflateRaw_1 = inflateRaw;
-var ungzip = inflate$1;
-var constants$2 = constants;
+var Inflate_1$1 = Inflate$1;
+var inflate_2 = inflate$1;
+var inflateRaw_1$1 = inflateRaw$1;
+var ungzip$1 = inflate$1;
+var constants = constants$2;
 
 var inflate_1$1 = {
-	Inflate: Inflate_1,
-	inflate: inflate_2$1,
-	inflateRaw: inflateRaw_1,
-	ungzip: ungzip,
-	constants: constants$2
+	Inflate: Inflate_1$1,
+	inflate: inflate_2,
+	inflateRaw: inflateRaw_1$1,
+	ungzip: ungzip$1,
+	constants: constants
 };
 
-const { Deflate: Deflate$1, deflate: deflate$2, deflateRaw: deflateRaw$1, gzip: gzip$1 } = deflate_1$1;
+const { Deflate, deflate, deflateRaw, gzip } = deflate_1$1;
 
-const { Inflate: Inflate$1, inflate: inflate$2, inflateRaw: inflateRaw$1, ungzip: ungzip$1 } = inflate_1$1;
+const { Inflate, inflate, inflateRaw, ungzip } = inflate_1$1;
 
 
 
-var Deflate_1$1 = Deflate$1;
-var deflate_1$2 = deflate$2;
-var deflateRaw_1$1 = deflateRaw$1;
-var gzip_1$1 = gzip$1;
-var Inflate_1$1 = Inflate$1;
-var inflate_1$2 = inflate$2;
-var inflateRaw_1$1 = inflateRaw$1;
-var ungzip_1 = ungzip$1;
-var constants_1 = constants;
+var Deflate_1 = Deflate;
+var deflate_1 = deflate;
+var deflateRaw_1 = deflateRaw;
+var gzip_1 = gzip;
+var Inflate_1 = Inflate;
+var inflate_1 = inflate;
+var inflateRaw_1 = inflateRaw;
+var ungzip_1 = ungzip;
+var constants_1 = constants$2;
 
 var pako = {
-	Deflate: Deflate_1$1,
-	deflate: deflate_1$2,
-	deflateRaw: deflateRaw_1$1,
-	gzip: gzip_1$1,
-	Inflate: Inflate_1$1,
-	inflate: inflate_1$2,
-	inflateRaw: inflateRaw_1$1,
+	Deflate: Deflate_1,
+	deflate: deflate_1,
+	deflateRaw: deflateRaw_1,
+	gzip: gzip_1,
+	Inflate: Inflate_1,
+	inflate: inflate_1,
+	inflateRaw: inflateRaw_1,
 	ungzip: ungzip_1,
 	constants: constants_1
 };