@realsee/live 0.5.4-alpha.1 → 0.5.4

package/dist/realsee-live.umd.development.js

@@ -1915,7 +1915,7 @@
 
     var uaParser = createCommonjsModule(function (module, exports) {
     /////////////////////////////////////////////////////////////////////////////////
-    /* UAParser.js v1.0.2
+    /* UAParser.js v1.0.33
        Copyright © 2012-2021 Faisal Salman <f@faisalman.com>
        MIT License *//*
        Detect Browser, Engine, OS, CPU, and Device type/model from User-Agent data.
@@ -1931,7 +1931,7 @@
         /////////////
 
 
-        var LIBVERSION  = '1.0.2',
+        var LIBVERSION  = '1.0.33',
             EMPTY       = '',
             UNKNOWN     = '?',
             FUNC_TYPE   = 'function',
@@ -1951,7 +1951,7 @@
             SMARTTV     = 'smarttv',
             WEARABLE    = 'wearable',
             EMBEDDED    = 'embedded',
-            UA_MAX_LENGTH = 255;
+            UA_MAX_LENGTH = 350;
 
         var AMAZON  = 'Amazon',
             APPLE   = 'Apple',
@@ -1968,6 +1968,7 @@
             MOTOROLA  = 'Motorola',
             OPERA   = 'Opera',
             SAMSUNG = 'Samsung',
+            SHARP   = 'Sharp',
             SONY    = 'Sony',
             XIAOMI  = 'Xiaomi',
             ZEBRA   = 'Zebra',
@@ -2006,7 +2007,7 @@
             },
             trim = function (str, len) {
                 if (typeof(str) === STR_TYPE) {
-                    str = str.replace(/^\s\s*/, EMPTY).replace(/\s\s*$/, EMPTY);
+                    str = str.replace(/^\s\s*/, EMPTY);
                     return typeof(len) === UNDEF_TYPE ? str : str.substring(0, UA_MAX_LENGTH);
                 }
         };
@@ -2145,13 +2146,14 @@
                 /(?:ms|\()(ie) ([\w\.]+)/i,                                         // Internet Explorer
 
                 // Webkit/KHTML based                                               // Flock/RockMelt/Midori/Epiphany/Silk/Skyfire/Bolt/Iron/Iridium/PhantomJS/Bowser/QupZilla/Falkon
-                /(flock|rockmelt|midori|epiphany|silk|skyfire|ovibrowser|bolt|iron|vivaldi|iridium|phantomjs|bowser|quark|qupzilla|falkon|rekonq|puffin|brave|whale|qqbrowserlite|qq)\/([-\w\.]+)/i,
+                /(flock|rockmelt|midori|epiphany|silk|skyfire|ovibrowser|bolt|iron|vivaldi|iridium|phantomjs|bowser|quark|qupzilla|falkon|rekonq|puffin|brave|whale|qqbrowserlite|qq|duckduckgo)\/([-\w\.]+)/i,
                                                                                     // Rekonq/Puffin/Brave/Whale/QQBrowserLite/QQ, aka ShouQ
                 /(weibo)__([\d\.]+)/i                                               // Weibo
                 ], [NAME, VERSION], [
                 /(?:\buc? ?browser|(?:juc.+)ucweb)[\/ ]?([\w\.]+)/i                 // UCBrowser
                 ], [VERSION, [NAME, 'UC'+BROWSER]], [
-                /\bqbcore\/([\w\.]+)/i                                              // WeChat Desktop for Windows Built-in Browser
+                /microm.+\bqbcore\/([\w\.]+)/i,                                     // WeChat Desktop for Windows Built-in Browser
+                /\bqbcore\/([\w\.]+).+microm/i
                 ], [VERSION, [NAME, 'WeChat(Win) Desktop']], [
                 /micromessenger\/([\w\.]+)/i                                        // WeChat
                 ], [VERSION, [NAME, 'WeChat']], [
@@ -2179,8 +2181,8 @@
                 ], [VERSION, [NAME, FIREFOX]], [
                 /\bqihu|(qi?ho?o?|360)browser/i                                     // 360
                 ], [[NAME, '360 '+BROWSER]], [
-                /(oculus|samsung|sailfish)browser\/([\w\.]+)/i
-                ], [[NAME, /(.+)/, '$1 '+BROWSER], VERSION], [                      // Oculus/Samsung/Sailfish Browser
+                /(oculus|samsung|sailfish|huawei)browser\/([\w\.]+)/i
+                ], [[NAME, /(.+)/, '$1 '+BROWSER], VERSION], [                      // Oculus/Samsung/Sailfish/Huawei Browser
                 /(comodo_dragon)\/([\w\.]+)/i                                       // Comodo Dragon
                 ], [[NAME, /_/g, ' '], VERSION], [
                 /(electron)\/([\w\.]+) safari/i,                                    // Electron-based App
@@ -2188,7 +2190,8 @@
                 /m?(qqbrowser|baiduboxapp|2345Explorer)[\/ ]?([\w\.]+)/i            // QQBrowser/Baidu App/2345 Browser
                 ], [NAME, VERSION], [
                 /(metasr)[\/ ]?([\w\.]+)/i,                                         // SouGouBrowser
-                /(lbbrowser)/i                                                      // LieBao Browser
+                /(lbbrowser)/i,                                                     // LieBao Browser
+                /\[(linkedin)app\]/i                                                // LinkedIn App for iOS & Android
                 ], [NAME], [
 
                 // WebView
@@ -2213,9 +2216,9 @@
                 /(chrome|omniweb|arora|[tizenoka]{5} ?browser)\/v?([\w\.]+)/i       // Chrome/OmniWeb/Arora/Tizen/Nokia
                 ], [NAME, VERSION], [
 
-                /version\/([\w\.]+) .*mobile\/\w+ (safari)/i                        // Mobile Safari
+                /version\/([\w\.\,]+) .*mobile\/\w+ (safari)/i                      // Mobile Safari
                 ], [VERSION, [NAME, 'Mobile Safari']], [
-                /version\/([\w\.]+) .*(mobile ?safari|safari)/i                     // Safari & Safari Mobile
+                /version\/([\w(\.|\,)]+) .*(mobile ?safari|safari)/i                // Safari & Safari Mobile
                 ], [VERSION, NAME], [
                 /webkit.+?(mobile ?safari|safari)(\/[\w\.]+)/i                      // Safari < 3.0
                 ], [NAME, [VERSION, strMapper, oldSafariMap]], [
@@ -2241,7 +2244,10 @@
                 /(polaris|lynx|dillo|icab|doris|amaya|w3m|netsurf|sleipnir|obigo|mosaic|(?:go|ice|up)[\. ]?browser)[-\/ ]?v?([\w\.]+)/i,
                                                                                     // Polaris/Lynx/Dillo/iCab/Doris/Amaya/w3m/NetSurf/Sleipnir/Obigo/Mosaic/Go/ICE/UP.Browser
                 /(links) \(([\w\.]+)/i                                              // Links
-                ], [NAME, VERSION]
+                ], [NAME, VERSION], [
+                
+                /(cobalt)\/([\w\.]+)/i                                              // Cobalt
+                ], [NAME, [VERSION, /master.|lts./, ""]]
             ],
 
             cpu : [[
@@ -2284,7 +2290,7 @@
                 /////////////////////////
 
                 // Samsung
-                /\b(sch-i[89]0\d|shw-m380s|sm-[pt]\w{2,4}|gt-[pn]\d{2,4}|sgh-t8[56]9|nexus 10)/i
+                /\b(sch-i[89]0\d|shw-m380s|sm-[ptx]\w{2,4}|gt-[pn]\d{2,4}|sgh-t8[56]9|nexus 10)/i
                 ], [MODEL, [VENDOR, SAMSUNG], [TYPE, TABLET]], [
                 /\b((?:s[cgp]h|gt|sm)-\w+|galaxy nexus)/i,
                 /samsung[- ]([-\w]+)/i,
@@ -2298,12 +2304,14 @@
                 /applecoremedia\/[\w\.]+ \((ipad)/i,
                 /\b(ipad)\d\d?,\d\d?[;\]].+ios/i
                 ], [MODEL, [VENDOR, APPLE], [TYPE, TABLET]], [
+                /(macintosh);/i
+                ], [MODEL, [VENDOR, APPLE]], [
 
                 // Huawei
                 /\b((?:ag[rs][23]?|bah2?|sht?|btv)-a?[lw]\d{2})\b(?!.+d\/s)/i
                 ], [MODEL, [VENDOR, HUAWEI], [TYPE, TABLET]], [
                 /(?:huawei|honor)([-\w ]+)[;\)]/i,
-                /\b(nexus 6p|\w{2,4}-[atu]?[ln][01259x][012359][an]?)\b(?!.+d\/s)/i
+                /\b(nexus 6p|\w{2,4}e?-[atu]?[ln][\dx][012359c][adn]?)\b(?!.+d\/s)/i
                 ], [MODEL, [VENDOR, HUAWEI], [TYPE, MOBILE]], [
 
                 // Xiaomi
@@ -2311,7 +2319,7 @@
                 /\b; (\w+) build\/hm\1/i,                                           // Xiaomi Hongmi 'numeric' models
                 /\b(hm[-_ ]?note?[_ ]?(?:\d\w)?) bui/i,                             // Xiaomi Hongmi
                 /\b(redmi[\-_ ]?(?:note|k)?[\w_ ]+)(?: bui|\))/i,                   // Xiaomi Redmi
-                /\b(mi[-_ ]?(?:a\d|one|one[_ ]plus|note lte|max)?[_ ]?(?:\d?\w?)[_ ]?(?:plus|se|lite)?)(?: bui|\))/i // Xiaomi Mi
+                /\b(mi[-_ ]?(?:a\d|one|one[_ ]plus|note lte|max|cc)?[_ ]?(?:\d?\w?)[_ ]?(?:plus|se|lite)?)(?: bui|\))/i // Xiaomi Mi
                 ], [[MODEL, /_/g, ' '], [VENDOR, XIAOMI], [TYPE, MOBILE]], [
                 /\b(mi[-_ ]?(?:pad)(?:[\w_ ]+))(?: bui|\))/i                        // Mi Pad tablets
                 ],[[MODEL, /_/g, ' '], [VENDOR, XIAOMI], [TYPE, TABLET]], [
@@ -2363,7 +2371,7 @@
                 ], [MODEL, [VENDOR, GOOGLE], [TYPE, MOBILE]], [
 
                 // Sony
-                /droid.+ ([c-g]\d{4}|so[-gl]\w+|xq-a\w[4-7][12])(?= bui|\).+chrome\/(?![1-6]{0,1}\d\.))/i
+                /droid.+ (a?\d[0-2]{2}so|[c-g]\d{4}|so[-gl]\w+|xq-a\w[4-7][12])(?= bui|\).+chrome\/(?![1-6]{0,1}\d\.))/i
                 ], [MODEL, [VENDOR, SONY], [TYPE, MOBILE]], [
                 /sony tablet [ps]/i,
                 /\b(?:sony)?sgp\w+(?: bui|\))/i
@@ -2402,7 +2410,7 @@
 
                 // ZTE
                 /(zte)[- ]([\w ]+?)(?: bui|\/|\))/i,
-                /(alcatel|geeksphone|nexian|panasonic|sony)[-_ ]?([-\w]*)/i         // Alcatel/GeeksPhone/Nexian/Panasonic/Sony
+                /(alcatel|geeksphone|nexian|panasonic|sony(?!-bra))[-_ ]?([-\w]*)/i         // Alcatel/GeeksPhone/Nexian/Panasonic/Sony
                 ], [VENDOR, [MODEL, /_/g, ' '], [TYPE, MOBILE]], [
 
                 // Acer
@@ -2416,7 +2424,7 @@
 
                 // Sharp
                 /\b(sh-?[altvz]?\d\d[a-ekm]?)/i
-                ], [MODEL, [VENDOR, 'Sharp'], [TYPE, MOBILE]], [
+                ], [MODEL, [VENDOR, SHARP], [TYPE, MOBILE]], [
 
                 // MIXED
                 /(blackberry|benq|palm(?=\-)|sonyericsson|acer|asus|dell|meizu|motorola|polytron)[-_ ]?([-\w]*)/i,
@@ -2528,8 +2536,13 @@
                 ], [[MODEL, CHROME+'cast'], [VENDOR, GOOGLE], [TYPE, SMARTTV]], [
                 /droid.+aft(\w)( bui|\))/i                                          // Fire TV
                 ], [MODEL, [VENDOR, AMAZON], [TYPE, SMARTTV]], [
-                /\(dtv[\);].+(aquos)/i                                              // Sharp
-                ], [MODEL, [VENDOR, 'Sharp'], [TYPE, SMARTTV]], [
+                /\(dtv[\);].+(aquos)/i,
+                /(aquos-tv[\w ]+)\)/i                                               // Sharp
+                ], [MODEL, [VENDOR, SHARP], [TYPE, SMARTTV]],[
+                /(bravia[\w ]+)( bui|\))/i                                              // Sony
+                ], [MODEL, [VENDOR, SONY], [TYPE, SMARTTV]], [
+                /(mitv-\w{5}) bui/i                                                 // Xiaomi
+                ], [MODEL, [VENDOR, XIAOMI], [TYPE, SMARTTV]], [
                 /\b(roku)[\dx]*[\)\/]((?:dvp-)?[\d\.]*)/i,                          // Roku
                 /hbbtv\/\d+\.\d+\.\d+ +\([\w ]*; *(\w[^;]*);([^;]*)/i               // HbbTV devices
                 ], [[VENDOR, trim], [MODEL, trim], [TYPE, SMARTTV]], [
@@ -2566,7 +2579,7 @@
                 ], [MODEL, [TYPE, TABLET]], [
                 /\b((tablet|tab)[;\/]|focus\/\d(?!.+mobile))/i                      // Unidentifiable Tablet
                 ], [[TYPE, TABLET]], [
-                /(phone|mobile(?:[;\/]| safari)|pda(?=.+windows ce))/i              // Unidentifiable Mobile
+                /(phone|mobile(?:[;\/]| [ \w\/\.]*safari)|pda(?=.+windows ce))/i    // Unidentifiable Mobile
                 ], [[TYPE, MOBILE]], [
                 /(android[-\w\. ]{0,9});.+buil/i                                    // Generic Android Device
                 ], [MODEL, [VENDOR, 'Generic']]
@@ -2612,7 +2625,7 @@
                 ], [[NAME, 'Mac OS'], [VERSION, /_/g, '.']], [
 
                 // Mobile OSes
-                /droid ([\w\.]+)\b.+(android[- ]x86)/i                              // Android-x86
+                /droid ([\w\.]+)\b.+(android[- ]x86|harmonyos)/i                    // Android-x86/HarmonyOS
                 ], [VERSION, NAME], [                                               // Android/WebOS/QNX/Bada/RIM/Maemo/MeeGo/Sailfish OS
                 /(android|webos|qnx|bada|rim tablet os|maemo|meego|sailfish)[-\/ ]?([\w\.]*)/i,
                 /(blackberry)\w*\/([\w\.]*)/i,                                      // Blackberry
@@ -31023,10 +31036,10 @@
      *     The length opt_len is updated; static_len is also updated if stree is
      *     not null.
      */
-    const gen_bitlen = (s, desc) =>
+    const gen_bitlen = (s, desc) => {
     //    deflate_state *s;
     //    tree_desc *desc;    /* the tree descriptor */
-    {
+
       const tree            = desc.dyn_tree;
       const max_code        = desc.max_code;
       const stree           = desc.stat_desc.static_tree;
@@ -31075,7 +31088,7 @@
       }
       if (overflow === 0) { return; }
 
-      // Trace((stderr,"\nbit length overflow\n"));
+      // Tracev((stderr,"\nbit length overflow\n"));
       /* This happens for example on obj2 and pic of the Calgary corpus */
 
       /* Find the first bit length which could increase: */
@@ -31102,7 +31115,7 @@
           m = s.heap[--h];
           if (m > max_code) { continue; }
           if (tree[m * 2 + 1]/*.Len*/ !== bits) {
-            // Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
+            // Tracev((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
             s.opt_len += (bits - tree[m * 2 + 1]/*.Len*/) * tree[m * 2]/*.Freq*/;
             tree[m * 2 + 1]/*.Len*/ = bits;
           }
@@ -31120,11 +31133,11 @@
      * OUT assertion: the field code is set for all tree elements of non
      *     zero code length.
      */
-    const gen_codes = (tree, max_code, bl_count) =>
+    const gen_codes = (tree, max_code, bl_count) => {
     //    ct_data *tree;             /* the tree to decorate */
     //    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 + 1); /* next code value for each bit length */
       let code = 0;              /* running code value */
       let bits;                  /* bit index */
@@ -31134,7 +31147,8 @@
        * without bit reversal.
        */
       for (bits = 1; bits <= MAX_BITS$1; bits++) {
-        next_code[bits] = code = (code + bl_count[bits - 1]) << 1;
+        code = (code + bl_count[bits - 1]) << 1;
+        next_code[bits] = code;
       }
       /* Check that the bit counts in bl_count are consistent. The last code
        * must be all ones.
@@ -31274,7 +31288,7 @@
 
       s.dyn_ltree[END_BLOCK * 2]/*.Freq*/ = 1;
       s.opt_len = s.static_len = 0;
-      s.last_lit = s.matches = 0;
+      s.sym_next = s.matches = 0;
     };
 
 
@@ -31293,29 +31307,6 @@
       s.bi_valid = 0;
     };
 
-    /* ===========================================================================
-     * Copy a stored block, storing first the length and its
-     * one's complement if requested.
-     */
-    const copy_block = (s, buf, len, header) =>
-    //DeflateState *s;
-    //charf    *buf;    /* the input data */
-    //unsigned len;     /* its length */
-    //int      header;  /* true if block header must be written */
-    {
-      bi_windup(s);        /* align on byte boundary */
-
-      if (header) {
-        put_short(s, len);
-        put_short(s, ~len);
-      }
-    //  while (len--) {
-    //    put_byte(s, *buf++);
-    //  }
-      s.pending_buf.set(s.window.subarray(buf, buf + len), s.pending);
-      s.pending += len;
-    };
-
     /* ===========================================================================
      * Compares to subtrees, using the tree depth as tie breaker when
      * the subtrees have equal frequency. This minimizes the worst case length.
@@ -31334,11 +31325,11 @@
      * when the heap property is re-established (each father smaller than its
      * two sons).
      */
-    const pqdownheap = (s, tree, k) =>
+    const pqdownheap = (s, tree, k) => {
     //    deflate_state *s;
     //    ct_data *tree;  /* the tree to restore */
     //    int k;               /* node to move down */
-    {
+
       const v = s.heap[k];
       let j = k << 1;  /* left son of k */
       while (j <= s.heap_len) {
@@ -31367,23 +31358,22 @@
     /* ===========================================================================
      * Send the block data compressed using the given Huffman trees
      */
-    const compress_block = (s, ltree, dtree) =>
+    const compress_block = (s, ltree, dtree) => {
     //    deflate_state *s;
     //    const ct_data *ltree; /* literal tree */
     //    const ct_data *dtree; /* distance tree */
-    {
+
       let dist;           /* distance of matched string */
       let lc;             /* match length or unmatched char (if dist == 0) */
-      let lx = 0;         /* running index in l_buf */
+      let sx = 0;         /* running index in sym_buf */
       let code;           /* the code to send */
       let extra;          /* number of extra bits to send */
 
-      if (s.last_lit !== 0) {
+      if (s.sym_next !== 0) {
         do {
-          dist = (s.pending_buf[s.d_buf + lx * 2] << 8) | (s.pending_buf[s.d_buf + lx * 2 + 1]);
-          lc = s.pending_buf[s.l_buf + lx];
-          lx++;
-
+          dist = s.pending_buf[s.sym_buf + sx++] & 0xff;
+          dist += (s.pending_buf[s.sym_buf + sx++] & 0xff) << 8;
+          lc = s.pending_buf[s.sym_buf + sx++];
           if (dist === 0) {
             send_code(s, lc, ltree); /* send a literal byte */
             //Tracecv(isgraph(lc), (stderr," '%c' ", lc));
@@ -31408,11 +31398,10 @@
             }
           } /* literal or match pair ? */
 
-          /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */
-          //Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx,
-          //       "pendingBuf overflow");
+          /* Check that the overlay between pending_buf and sym_buf is ok: */
+          //Assert(s->pending < s->lit_bufsize + sx, "pendingBuf overflow");
 
-        } while (lx < s.last_lit);
+        } while (sx < s.sym_next);
       }
 
       send_code(s, END_BLOCK, ltree);
@@ -31427,10 +31416,10 @@
      *     and corresponding code. The length opt_len is updated; static_len is
      *     also updated if stree is not null. The field max_code is set.
      */
-    const build_tree = (s, desc) =>
+    const build_tree = (s, desc) => {
     //    deflate_state *s;
     //    tree_desc *desc; /* the tree descriptor */
-    {
+
       const tree     = desc.dyn_tree;
       const stree    = desc.stat_desc.static_tree;
       const has_stree = desc.stat_desc.has_stree;
@@ -31523,11 +31512,11 @@
      * Scan a literal or distance tree to determine the frequencies of the codes
      * in the bit length tree.
      */
-    const scan_tree = (s, tree, max_code) =>
+    const scan_tree = (s, tree, max_code) => {
     //    deflate_state *s;
     //    ct_data *tree;   /* the tree to be scanned */
     //    int max_code;    /* and its largest code of non zero frequency */
-    {
+
       let n;                     /* iterates over all tree elements */
       let prevlen = -1;          /* last emitted length */
       let curlen;                /* length of current code */
@@ -31589,11 +31578,11 @@
      * Send a literal or distance tree in compressed form, using the codes in
      * bl_tree.
      */
-    const send_tree = (s, tree, max_code) =>
+    const send_tree = (s, tree, max_code) => {
     //    deflate_state *s;
     //    ct_data *tree; /* the tree to be scanned */
     //    int max_code;       /* and its largest code of non zero frequency */
-    {
+
       let n;                     /* iterates over all tree elements */
       let prevlen = -1;          /* last emitted length */
       let curlen;                /* length of current code */
@@ -31697,10 +31686,10 @@
      * lengths of the bit length codes, the literal tree and the distance tree.
      * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
      */
-    const send_all_trees = (s, lcodes, dcodes, blcodes) =>
+    const send_all_trees = (s, lcodes, dcodes, blcodes) => {
     //    deflate_state *s;
     //    int lcodes, dcodes, blcodes; /* number of codes for each tree */
-    {
+
       let rank;                    /* index in bl_order */
 
       //Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
@@ -31728,9 +31717,9 @@
      * Check if the data type is TEXT or BINARY, using the following algorithm:
      * - TEXT if the two conditions below are satisfied:
      *    a) There are no non-portable control characters belonging to the
-     *       "black list" (0..6, 14..25, 28..31).
+     *       "block list" (0..6, 14..25, 28..31).
      *    b) There is at least one printable character belonging to the
-     *       "white list" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255).
+     *       "allow list" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255).
      * - BINARY otherwise.
      * - The following partially-portable control characters form a
      *   "gray list" that is ignored in this detection algorithm:
@@ -31738,21 +31727,21 @@
      * IN assertion: the fields Freq of dyn_ltree are set.
      */
     const detect_data_type = (s) => {
-      /* black_mask is the bit mask of black-listed bytes
+      /* block_mask is the bit mask of block-listed bytes
        * set bits 0..6, 14..25, and 28..31
        * 0xf3ffc07f = binary 11110011111111111100000001111111
        */
-      let black_mask = 0xf3ffc07f;
+      let block_mask = 0xf3ffc07f;
       let n;
 
-      /* Check for non-textual ("black-listed") bytes. */
-      for (n = 0; n <= 31; n++, black_mask >>>= 1) {
-        if ((black_mask & 1) && (s.dyn_ltree[n * 2]/*.Freq*/ !== 0)) {
+      /* Check for non-textual ("block-listed") bytes. */
+      for (n = 0; n <= 31; n++, block_mask >>>= 1) {
+        if ((block_mask & 1) && (s.dyn_ltree[n * 2]/*.Freq*/ !== 0)) {
           return Z_BINARY;
         }
       }
 
-      /* Check for textual ("white-listed") bytes. */
+      /* Check for textual ("allow-listed") bytes. */
       if (s.dyn_ltree[9 * 2]/*.Freq*/ !== 0 || s.dyn_ltree[10 * 2]/*.Freq*/ !== 0 ||
           s.dyn_ltree[13 * 2]/*.Freq*/ !== 0) {
         return Z_TEXT;
@@ -31763,7 +31752,7 @@
         }
       }
 
-      /* There are no "black-listed" or "white-listed" bytes:
+      /* There are no "block-listed" or "allow-listed" bytes:
        * this stream either is empty or has tolerated ("gray-listed") bytes only.
        */
       return Z_BINARY;
@@ -31798,14 +31787,20 @@
     /* ===========================================================================
      * Send a stored block
      */
-    const _tr_stored_block$1 = (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 */
     //int last;         /* one if this is the last block for a file */
-    {
+
       send_bits(s, (STORED_BLOCK << 1) + (last ? 1 : 0), 3);    /* send block type */
-      copy_block(s, buf, stored_len, true); /* with header */
+      bi_windup(s);        /* align on byte boundary */
+      put_short(s, stored_len);
+      put_short(s, ~stored_len);
+      if (stored_len) {
+        s.pending_buf.set(s.window.subarray(buf, buf + stored_len), s.pending);
+      }
+      s.pending += stored_len;
     };
 
 
@@ -31822,14 +31817,14 @@
 
     /* ===========================================================================
      * Determine the best encoding for the current block: dynamic trees, static
-     * trees or store, and output the encoded block to the zip file.
+     * trees or store, and write out the encoded block.
      */
-    const _tr_flush_block$1 = (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 */
     //int last;         /* one if this is the last block for a file */
-    {
+
       let opt_lenb, static_lenb;  /* opt_len and static_len in bytes */
       let max_blindex = 0;        /* index of last bit length code of non zero freq */
 
@@ -31864,7 +31859,7 @@
 
         // Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ",
         //        opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,
-        //        s->last_lit));
+        //        s->sym_next / 3));
 
         if (static_lenb <= opt_lenb) { opt_lenb = static_lenb; }
 
@@ -31911,19 +31906,14 @@
      * Save the match info and tally the frequency counts. Return true if
      * the current block must be flushed.
      */
-    const _tr_tally$1 = (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) */
-    {
-      //let out_length, in_length, dcode;
-
-      s.pending_buf[s.d_buf + s.last_lit * 2]     = (dist >>> 8) & 0xff;
-      s.pending_buf[s.d_buf + s.last_lit * 2 + 1] = dist & 0xff;
-
-      s.pending_buf[s.l_buf + s.last_lit] = lc & 0xff;
-      s.last_lit++;
 
+      s.pending_buf[s.sym_buf + s.sym_next++] = dist;
+      s.pending_buf[s.sym_buf + s.sym_next++] = dist >> 8;
+      s.pending_buf[s.sym_buf + s.sym_next++] = lc;
       if (dist === 0) {
         /* lc is the unmatched char */
         s.dyn_ltree[lc * 2]/*.Freq*/++;
@@ -31939,34 +31929,7 @@
         s.dyn_dtree[d_code(dist) * 2]/*.Freq*/++;
       }
 
-    // (!) This block is disabled in zlib defaults,
-    // don't enable it for binary compatibility
-
-    //#ifdef TRUNCATE_BLOCK
-    //  /* Try to guess if it is profitable to stop the current block here */
-    //  if ((s.last_lit & 0x1fff) === 0 && s.level > 2) {
-    //    /* Compute an upper bound for the compressed length */
-    //    out_length = s.last_lit*8;
-    //    in_length = s.strstart - s.block_start;
-    //
-    //    for (dcode = 0; dcode < D_CODES; dcode++) {
-    //      out_length += s.dyn_dtree[dcode*2]/*.Freq*/ * (5 + extra_dbits[dcode]);
-    //    }
-    //    out_length >>>= 3;
-    //    //Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ",
-    //    //       s->last_lit, in_length, out_length,
-    //    //       100L - out_length*100L/in_length));
-    //    if (s.matches < (s.last_lit>>1)/*int /2*/ && out_length < (in_length>>1)/*int /2*/) {
-    //      return true;
-    //    }
-    //  }
-    //#endif
-
-      return (s.last_lit === s.lit_bufsize - 1);
-      /* We avoid equality with lit_bufsize because of wraparound at 64K
-       * on 16 bit machines and because stored blocks are restricted to
-       * 64K-1 bytes.
-       */
+      return (s.sym_next === s.sym_end);
     };
 
     var _tr_init_1  = _tr_init$1;
@@ -32266,13 +32229,16 @@
 
     const PRESET_DICT = 0x20;
 
-    const INIT_STATE = 42;
-    const EXTRA_STATE = 69;
-    const NAME_STATE = 73;
-    const COMMENT_STATE = 91;
-    const HCRC_STATE = 103;
-    const BUSY_STATE = 113;
-    const FINISH_STATE = 666;
+    const INIT_STATE    =  42;    /* zlib header -> BUSY_STATE */
+    //#ifdef GZIP
+    const GZIP_STATE    =  57;    /* gzip header -> BUSY_STATE | EXTRA_STATE */
+    //#endif
+    const EXTRA_STATE   =  69;    /* gzip extra block -> NAME_STATE */
+    const NAME_STATE    =  73;    /* gzip file name -> COMMENT_STATE */
+    const COMMENT_STATE =  91;    /* gzip comment -> HCRC_STATE */
+    const HCRC_STATE    = 103;    /* gzip header CRC -> BUSY_STATE */
+    const BUSY_STATE    = 113;    /* deflate -> FINISH_STATE */
+    const FINISH_STATE  = 666;    /* stream complete */
 
     const BS_NEED_MORE      = 1; /* block not completed, need more input or more output */
     const BS_BLOCK_DONE     = 2; /* block flush performed */
@@ -32287,13 +32253,41 @@
     };
 
     const rank = (f) => {
-      return ((f) << 1) - ((f) > 4 ? 9 : 0);
+      return ((f) * 2) - ((f) > 4 ? 9 : 0);
     };
 
     const zero = (buf) => {
       let len = buf.length; while (--len >= 0) { buf[len] = 0; }
     };
 
+    /* ===========================================================================
+     * Slide the hash table when sliding the window down (could be avoided with 32
+     * bit values at the expense of memory usage). We slide even when level == 0 to
+     * keep the hash table consistent if we switch back to level > 0 later.
+     */
+    const slide_hash = (s) => {
+      let n, m;
+      let p;
+      let wsize = s.w_size;
+
+      n = s.hash_size;
+      p = n;
+      do {
+        m = s.head[--p];
+        s.head[p] = (m >= wsize ? m - wsize : 0);
+      } while (--n);
+      n = wsize;
+    //#ifndef FASTEST
+      p = n;
+      do {
+        m = s.prev[--p];
+        s.prev[p] = (m >= wsize ? m - wsize : 0);
+        /* If n is not on any hash chain, prev[n] is garbage but
+         * its value will never be used.
+         */
+      } while (--n);
+    //#endif
+    };
 
     /* eslint-disable new-cap */
     let HASH_ZLIB = (s, prev, data) => ((prev << s.hash_shift) ^ data) & s.hash_mask;
@@ -32302,11 +32296,12 @@
     //let HASH_FAST = (s, prev, data) => ((prev << 8) + (prev >> 8) + (data << 4)) & s.hash_mask;
     let HASH = HASH_ZLIB;
 
+
     /* =========================================================================
-     * Flush as much pending output as possible. All deflate() output goes
-     * through this function so some applications may wish to modify it
-     * to avoid allocating a large strm->output buffer and copying into it.
-     * (See also read_buf()).
+     * Flush as much pending output as possible. All deflate() output, except for
+     * some deflate_stored() output, goes through this function so some
+     * applications may wish to modify it to avoid allocating a large
+     * strm->next_out buffer and copying into it. (See also read_buf()).
      */
     const flush_pending = (strm) => {
       const s = strm.state;
@@ -32319,11 +32314,11 @@
       if (len === 0) { return; }
 
       strm.output.set(s.pending_buf.subarray(s.pending_out, s.pending_out + len), strm.next_out);
-      strm.next_out += len;
-      s.pending_out += len;
+      strm.next_out  += len;
+      s.pending_out  += len;
       strm.total_out += len;
       strm.avail_out -= len;
-      s.pending -= len;
+      s.pending      -= len;
       if (s.pending === 0) {
         s.pending_out = 0;
       }
@@ -32515,7 +32510,7 @@
     const fill_window = (s) => {
 
       const _w_size = s.w_size;
-      let p, n, m, more, str;
+      let n, more, str;
 
       //Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead");
 
@@ -32542,38 +32537,15 @@
          */
         if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) {
 
-          s.window.set(s.window.subarray(_w_size, _w_size + _w_size), 0);
+          s.window.set(s.window.subarray(_w_size, _w_size + _w_size - more), 0);
           s.match_start -= _w_size;
           s.strstart -= _w_size;
           /* we now have strstart >= MAX_DIST */
           s.block_start -= _w_size;
-
-          /* Slide the hash table (could be avoided with 32 bit values
-           at the expense of memory usage). We slide even when level == 0
-           to keep the hash table consistent if we switch back to level > 0
-           later. (Using level 0 permanently is not an optimal usage of
-           zlib, so we don't care about this pathological case.)
-           */
-
-          n = s.hash_size;
-          p = n;
-
-          do {
-            m = s.head[--p];
-            s.head[p] = (m >= _w_size ? m - _w_size : 0);
-          } while (--n);
-
-          n = _w_size;
-          p = n;
-
-          do {
-            m = s.prev[--p];
-            s.prev[p] = (m >= _w_size ? m - _w_size : 0);
-            /* If n is not on any hash chain, prev[n] is garbage but
-             * its value will never be used.
-             */
-          } while (--n);
-
+          if (s.insert > s.strstart) {
+            s.insert = s.strstart;
+          }
+          slide_hash(s);
           more += _w_size;
         }
         if (s.strm.avail_in === 0) {
@@ -32665,104 +32637,216 @@
     /* ===========================================================================
      * Copy without compression as much as possible from the input stream, return
      * the current block state.
-     * This function does not insert new strings in the dictionary since
-     * uncompressible data is probably not useful. This function is used
-     * only for the level=0 compression option.
-     * NOTE: this function should be optimized to avoid extra copying from
-     * window to pending_buf.
+     *
+     * In case deflateParams() is used to later switch to a non-zero compression
+     * level, s->matches (otherwise unused when storing) keeps track of the number
+     * of hash table slides to perform. If s->matches is 1, then one hash table
+     * slide will be done when switching. If s->matches is 2, the maximum value
+     * allowed here, then the hash table will be cleared, since two or more slides
+     * is the same as a clear.
+     *
+     * deflate_stored() is written to minimize the number of times an input byte is
+     * copied. It is most efficient with large input and output buffers, which
+     * maximizes the opportunites to have a single copy from next_in to next_out.
      */
     const deflate_stored = (s, flush) => {
 
-      /* Stored blocks are limited to 0xffff bytes, pending_buf is limited
-       * to pending_buf_size, and each stored block has a 5 byte header:
+      /* Smallest worthy block size when not flushing or finishing. By default
+       * this is 32K. This can be as small as 507 bytes for memLevel == 1. For
+       * large input and output buffers, the stored block size will be larger.
        */
-      let max_block_size = 0xffff;
-
-      if (max_block_size > s.pending_buf_size - 5) {
-        max_block_size = s.pending_buf_size - 5;
-      }
-
-      /* Copy as much as possible from input to output: */
-      for (;;) {
-        /* Fill the window as much as possible: */
-        if (s.lookahead <= 1) {
+      let min_block = s.pending_buf_size - 5 > s.w_size ? s.w_size : s.pending_buf_size - 5;
 
-          //Assert(s->strstart < s->w_size+MAX_DIST(s) ||
-          //  s->block_start >= (long)s->w_size, "slide too late");
-    //      if (!(s.strstart < s.w_size + (s.w_size - MIN_LOOKAHEAD) ||
-    //        s.block_start >= s.w_size)) {
-    //        throw  new Error("slide too late");
-    //      }
-
-          fill_window(s);
-          if (s.lookahead === 0 && flush === Z_NO_FLUSH$2) {
-            return BS_NEED_MORE;
-          }
+      /* Copy as many min_block or larger stored blocks directly to next_out as
+       * possible. If flushing, copy the remaining available input to next_out as
+       * stored blocks, if there is enough space.
+       */
+      let len, left, have, last = 0;
+      let used = s.strm.avail_in;
+      do {
+        /* Set len to the maximum size block that we can copy directly with the
+         * available input data and output space. Set left to how much of that
+         * would be copied from what's left in the window.
+         */
+        len = 65535/* MAX_STORED */;     /* maximum deflate stored block length */
+        have = (s.bi_valid + 42) >> 3;     /* number of header bytes */
+        if (s.strm.avail_out < have) {         /* need room for header */
+          break;
+        }
+          /* maximum stored block length that will fit in avail_out: */
+        have = s.strm.avail_out - have;
+        left = s.strstart - s.block_start;  /* bytes left in window */
+        if (len > left + s.strm.avail_in) {
+          len = left + s.strm.avail_in;   /* limit len to the input */
+        }
+        if (len > have) {
+          len = have;             /* limit len to the output */
+        }
 
-          if (s.lookahead === 0) {
-            break;
-          }
-          /* flush the current block */
+        /* If the stored block would be less than min_block in length, or if
+         * unable to copy all of the available input when flushing, then try
+         * copying to the window and the pending buffer instead. Also don't
+         * write an empty block when flushing -- deflate() does that.
+         */
+        if (len < min_block && ((len === 0 && flush !== Z_FINISH$3) ||
+                            flush === Z_NO_FLUSH$2 ||
+                            len !== left + s.strm.avail_in)) {
+          break;
         }
-        //Assert(s->block_start >= 0L, "block gone");
-    //    if (s.block_start < 0) throw new Error("block gone");
 
-        s.strstart += s.lookahead;
-        s.lookahead = 0;
+        /* Make a dummy stored block in pending to get the header bytes,
+         * including any pending bits. This also updates the debugging counts.
+         */
+        last = flush === Z_FINISH$3 && len === left + s.strm.avail_in ? 1 : 0;
+        _tr_stored_block(s, 0, 0, last);
 
-        /* Emit a stored block if pending_buf will be full: */
-        const max_start = s.block_start + max_block_size;
+        /* Replace the lengths in the dummy stored block with len. */
+        s.pending_buf[s.pending - 4] = len;
+        s.pending_buf[s.pending - 3] = len >> 8;
+        s.pending_buf[s.pending - 2] = ~len;
+        s.pending_buf[s.pending - 1] = ~len >> 8;
 
-        if (s.strstart === 0 || s.strstart >= max_start) {
-          /* strstart == 0 is possible when wraparound on 16-bit machine */
-          s.lookahead = s.strstart - max_start;
-          s.strstart = max_start;
-          /*** FLUSH_BLOCK(s, 0); ***/
-          flush_block_only(s, false);
-          if (s.strm.avail_out === 0) {
-            return BS_NEED_MORE;
-          }
-          /***/
+        /* Write the stored block header bytes. */
+        flush_pending(s.strm);
 
+    //#ifdef ZLIB_DEBUG
+    //    /* Update debugging counts for the data about to be copied. */
+    //    s->compressed_len += len << 3;
+    //    s->bits_sent += len << 3;
+    //#endif
 
+        /* Copy uncompressed bytes from the window to next_out. */
+        if (left) {
+          if (left > len) {
+            left = len;
+          }
+          //zmemcpy(s->strm->next_out, s->window + s->block_start, left);
+          s.strm.output.set(s.window.subarray(s.block_start, s.block_start + left), s.strm.next_out);
+          s.strm.next_out += left;
+          s.strm.avail_out -= left;
+          s.strm.total_out += left;
+          s.block_start += left;
+          len -= left;
         }
-        /* Flush if we may have to slide, otherwise block_start may become
-         * negative and the data will be gone:
+
+        /* Copy uncompressed bytes directly from next_in to next_out, updating
+         * the check value.
          */
-        if (s.strstart - s.block_start >= (s.w_size - MIN_LOOKAHEAD)) {
-          /*** FLUSH_BLOCK(s, 0); ***/
-          flush_block_only(s, false);
-          if (s.strm.avail_out === 0) {
-            return BS_NEED_MORE;
+        if (len) {
+          read_buf(s.strm, s.strm.output, s.strm.next_out, len);
+          s.strm.next_out += len;
+          s.strm.avail_out -= len;
+          s.strm.total_out += len;
+        }
+      } while (last === 0);
+
+      /* Update the sliding window with the last s->w_size bytes of the copied
+       * data, or append all of the copied data to the existing window if less
+       * than s->w_size bytes were copied. Also update the number of bytes to
+       * insert in the hash tables, in the event that deflateParams() switches to
+       * a non-zero compression level.
+       */
+      used -= s.strm.avail_in;    /* number of input bytes directly copied */
+      if (used) {
+        /* If any input was used, then no unused input remains in the window,
+         * therefore s->block_start == s->strstart.
+         */
+        if (used >= s.w_size) {  /* supplant the previous history */
+          s.matches = 2;     /* clear hash */
+          //zmemcpy(s->window, s->strm->next_in - s->w_size, s->w_size);
+          s.window.set(s.strm.input.subarray(s.strm.next_in - s.w_size, s.strm.next_in), 0);
+          s.strstart = s.w_size;
+          s.insert = s.strstart;
+        }
+        else {
+          if (s.window_size - s.strstart <= used) {
+            /* Slide the window down. */
+            s.strstart -= s.w_size;
+            //zmemcpy(s->window, s->window + s->w_size, s->strstart);
+            s.window.set(s.window.subarray(s.w_size, s.w_size + s.strstart), 0);
+            if (s.matches < 2) {
+              s.matches++;   /* add a pending slide_hash() */
+            }
+            if (s.insert > s.strstart) {
+              s.insert = s.strstart;
+            }
           }
-          /***/
+          //zmemcpy(s->window + s->strstart, s->strm->next_in - used, used);
+          s.window.set(s.strm.input.subarray(s.strm.next_in - used, s.strm.next_in), s.strstart);
+          s.strstart += used;
+          s.insert += used > s.w_size - s.insert ? s.w_size - s.insert : used;
         }
+        s.block_start = s.strstart;
+      }
+      if (s.high_water < s.strstart) {
+        s.high_water = s.strstart;
       }
 
-      s.insert = 0;
-
-      if (flush === Z_FINISH$3) {
-        /*** FLUSH_BLOCK(s, 1); ***/
-        flush_block_only(s, true);
-        if (s.strm.avail_out === 0) {
-          return BS_FINISH_STARTED;
-        }
-        /***/
+      /* If the last block was written to next_out, then done. */
+      if (last) {
         return BS_FINISH_DONE;
       }
 
-      if (s.strstart > s.block_start) {
-        /*** FLUSH_BLOCK(s, 0); ***/
-        flush_block_only(s, false);
-        if (s.strm.avail_out === 0) {
-          return BS_NEED_MORE;
+      /* If flushing and all input has been consumed, then done. */
+      if (flush !== Z_NO_FLUSH$2 && flush !== Z_FINISH$3 &&
+        s.strm.avail_in === 0 && s.strstart === s.block_start) {
+        return BS_BLOCK_DONE;
+      }
+
+      /* Fill the window with any remaining input. */
+      have = s.window_size - s.strstart;
+      if (s.strm.avail_in > have && s.block_start >= s.w_size) {
+        /* Slide the window down. */
+        s.block_start -= s.w_size;
+        s.strstart -= s.w_size;
+        //zmemcpy(s->window, s->window + s->w_size, s->strstart);
+        s.window.set(s.window.subarray(s.w_size, s.w_size + s.strstart), 0);
+        if (s.matches < 2) {
+          s.matches++;       /* add a pending slide_hash() */
+        }
+        have += s.w_size;      /* more space now */
+        if (s.insert > s.strstart) {
+          s.insert = s.strstart;
         }
-        /***/
+      }
+      if (have > s.strm.avail_in) {
+        have = s.strm.avail_in;
+      }
+      if (have) {
+        read_buf(s.strm, s.window, s.strstart, have);
+        s.strstart += have;
+        s.insert += have > s.w_size - s.insert ? s.w_size - s.insert : have;
+      }
+      if (s.high_water < s.strstart) {
+        s.high_water = s.strstart;
+      }
+
+      /* There was not enough avail_out to write a complete worthy or flushed
+       * stored block to next_out. Write a stored block to pending instead, if we
+       * have enough input for a worthy block, or if flushing and there is enough
+       * room for the remaining input as a stored block in the pending buffer.
+       */
+      have = (s.bi_valid + 42) >> 3;     /* number of header bytes */
+        /* maximum stored block length that will fit in pending: */
+      have = s.pending_buf_size - have > 65535/* MAX_STORED */ ? 65535/* MAX_STORED */ : s.pending_buf_size - have;
+      min_block = have > s.w_size ? s.w_size : have;
+      left = s.strstart - s.block_start;
+      if (left >= min_block ||
+         ((left || flush === Z_FINISH$3) && flush !== Z_NO_FLUSH$2 &&
+         s.strm.avail_in === 0 && left <= have)) {
+        len = left > have ? have : left;
+        last = flush === Z_FINISH$3 && s.strm.avail_in === 0 &&
+             len === left ? 1 : 0;
+        _tr_stored_block(s, s.block_start, len, last);
+        s.block_start += len;
+        flush_pending(s.strm);
       }
 
-      return BS_NEED_MORE;
+      /* We've done all we can with the available input and output. */
+      return last ? BS_FINISH_STARTED : BS_NEED_MORE;
     };
 
+
     /* ===========================================================================
      * Compress as much as possible from the input stream, return the current
      * block state.
@@ -32883,7 +32967,7 @@
         /***/
         return BS_FINISH_DONE;
       }
-      if (s.last_lit) {
+      if (s.sym_next) {
         /*** FLUSH_BLOCK(s, 0); ***/
         flush_block_only(s, false);
         if (s.strm.avail_out === 0) {
@@ -33044,7 +33128,7 @@
         /***/
         return BS_FINISH_DONE;
       }
-      if (s.last_lit) {
+      if (s.sym_next) {
         /*** FLUSH_BLOCK(s, 0); ***/
         flush_block_only(s, false);
         if (s.strm.avail_out === 0) {
@@ -33143,7 +33227,7 @@
         /***/
         return BS_FINISH_DONE;
       }
-      if (s.last_lit) {
+      if (s.sym_next) {
         /*** FLUSH_BLOCK(s, 0); ***/
         flush_block_only(s, false);
         if (s.strm.avail_out === 0) {
@@ -33200,7 +33284,7 @@
         /***/
         return BS_FINISH_DONE;
       }
-      if (s.last_lit) {
+      if (s.sym_next) {
         /*** FLUSH_BLOCK(s, 0); ***/
         flush_block_only(s, false);
         if (s.strm.avail_out === 0) {
@@ -33401,7 +33485,7 @@
       /* Depth of each subtree used as tie breaker for trees of equal frequency
        */
 
-      this.l_buf = 0;          /* buffer index for literals or lengths */
+      this.sym_buf = 0;        /* buffer for distances and literals/lengths */
 
       this.lit_bufsize = 0;
       /* Size of match buffer for literals/lengths.  There are 4 reasons for
@@ -33423,13 +33507,8 @@
        *   - I can't count above 4
        */
 
-      this.last_lit = 0;      /* running index in l_buf */
-
-      this.d_buf = 0;
-      /* Buffer index for distances. To simplify the code, d_buf and l_buf have
-       * the same number of elements. To use different lengths, an extra flag
-       * array would be necessary.
-       */
+      this.sym_next = 0;      /* running index in sym_buf */
+      this.sym_end = 0;       /* symbol table full when sym_next reaches this */
 
       this.opt_len = 0;       /* bit length of current block with optimal trees */
       this.static_len = 0;    /* bit length of current block with static trees */
@@ -33457,9 +33536,34 @@
     }
 
 
+    /* =========================================================================
+     * Check for a valid deflate stream state. Return 0 if ok, 1 if not.
+     */
+    const deflateStateCheck = (strm) => {
+
+      if (!strm) {
+        return 1;
+      }
+      const s = strm.state;
+      if (!s || s.strm !== strm || (s.status !== INIT_STATE &&
+    //#ifdef GZIP
+                                    s.status !== GZIP_STATE &&
+    //#endif
+                                    s.status !== EXTRA_STATE &&
+                                    s.status !== NAME_STATE &&
+                                    s.status !== COMMENT_STATE &&
+                                    s.status !== HCRC_STATE &&
+                                    s.status !== BUSY_STATE &&
+                                    s.status !== FINISH_STATE)) {
+        return 1;
+      }
+      return 0;
+    };
+
+
     const deflateResetKeep = (strm) => {
 
-      if (!strm || !strm.state) {
+      if (deflateStateCheck(strm)) {
         return err(strm, Z_STREAM_ERROR$2);
       }
 
@@ -33474,12 +33578,16 @@
         s.wrap = -s.wrap;
         /* was made negative by deflate(..., Z_FINISH); */
       }
-      s.status = (s.wrap ? INIT_STATE : BUSY_STATE);
+      s.status =
+    //#ifdef GZIP
+        s.wrap === 2 ? GZIP_STATE :
+    //#endif
+        s.wrap ? INIT_STATE : BUSY_STATE;
       strm.adler = (s.wrap === 2) ?
         0  // crc32(0, Z_NULL, 0)
       :
         1; // adler32(0, Z_NULL, 0)
-      s.last_flush = Z_NO_FLUSH$2;
+      s.last_flush = -2;
       _tr_init(s);
       return Z_OK$3;
     };
@@ -33497,8 +33605,9 @@
 
     const deflateSetHeader = (strm, head) => {
 
-      if (!strm || !strm.state) { return Z_STREAM_ERROR$2; }
-      if (strm.state.wrap !== 2) { return Z_STREAM_ERROR$2; }
+      if (deflateStateCheck(strm) || strm.state.wrap !== 2) {
+        return Z_STREAM_ERROR$2;
+      }
       strm.state.gzhead = head;
       return Z_OK$3;
     };
@@ -33528,7 +33637,7 @@
 
       if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method !== Z_DEFLATED$2 ||
         windowBits < 8 || windowBits > 15 || level < 0 || level > 9 ||
-        strategy < 0 || strategy > Z_FIXED) {
+        strategy < 0 || strategy > Z_FIXED || (windowBits === 8 && wrap !== 1)) {
         return err(strm, Z_STREAM_ERROR$2);
       }
 
@@ -33542,6 +33651,7 @@
 
       strm.state = s;
       s.strm = strm;
+      s.status = INIT_STATE;     /* to pass state test in deflateReset() */
 
       s.wrap = wrap;
       s.gzhead = null;
@@ -33563,18 +33673,58 @@
 
       s.lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */
 
-      s.pending_buf_size = s.lit_bufsize * 4;
+      /* We overlay pending_buf and sym_buf. This works since the average size
+       * for length/distance pairs over any compressed block is assured to be 31
+       * bits or less.
+       *
+       * Analysis: The longest fixed codes are a length code of 8 bits plus 5
+       * extra bits, for lengths 131 to 257. The longest fixed distance codes are
+       * 5 bits plus 13 extra bits, for distances 16385 to 32768. The longest
+       * possible fixed-codes length/distance pair is then 31 bits total.
+       *
+       * sym_buf starts one-fourth of the way into pending_buf. So there are
+       * three bytes in sym_buf for every four bytes in pending_buf. Each symbol
+       * in sym_buf is three bytes -- two for the distance and one for the
+       * literal/length. As each symbol is consumed, the pointer to the next
+       * sym_buf value to read moves forward three bytes. From that symbol, up to
+       * 31 bits are written to pending_buf. The closest the written pending_buf
+       * bits gets to the next sym_buf symbol to read is just before the last
+       * code is written. At that time, 31*(n-2) bits have been written, just
+       * after 24*(n-2) bits have been consumed from sym_buf. sym_buf starts at
+       * 8*n bits into pending_buf. (Note that the symbol buffer fills when n-1
+       * symbols are written.) The closest the writing gets to what is unread is
+       * then n+14 bits. Here n is lit_bufsize, which is 16384 by default, and
+       * can range from 128 to 32768.
+       *
+       * Therefore, at a minimum, there are 142 bits of space between what is
+       * written and what is read in the overlain buffers, so the symbols cannot
+       * be overwritten by the compressed data. That space is actually 139 bits,
+       * due to the three-bit fixed-code block header.
+       *
+       * That covers the case where either Z_FIXED is specified, forcing fixed
+       * codes, or when the use of fixed codes is chosen, because that choice
+       * results in a smaller compressed block than dynamic codes. That latter
+       * condition then assures that the above analysis also covers all dynamic
+       * blocks. A dynamic-code block will only be chosen to be emitted if it has
+       * fewer bits than a fixed-code block would for the same set of symbols.
+       * Therefore its average symbol length is assured to be less than 31. So
+       * the compressed data for a dynamic block also cannot overwrite the
+       * symbols from which it is being constructed.
+       */
 
-      //overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2);
-      //s->pending_buf = (uchf *) overlay;
+      s.pending_buf_size = s.lit_bufsize * 4;
       s.pending_buf = new Uint8Array(s.pending_buf_size);
 
       // It is offset from `s.pending_buf` (size is `s.lit_bufsize * 2`)
-      //s->d_buf = overlay + s->lit_bufsize/sizeof(ush);
-      s.d_buf = 1 * s.lit_bufsize;
+      //s->sym_buf = s->pending_buf + s->lit_bufsize;
+      s.sym_buf = s.lit_bufsize;
 
-      //s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize;
-      s.l_buf = (1 + 2) * s.lit_bufsize;
+      //s->sym_end = (s->lit_bufsize - 1) * 3;
+      s.sym_end = (s.lit_bufsize - 1) * 3;
+      /* We avoid equality with lit_bufsize*3 because of wraparound at 64K
+       * on 16 bit machines and because stored blocks are restricted to
+       * 64K-1 bytes.
+       */
 
       s.level = level;
       s.strategy = strategy;
@@ -33589,150 +33739,200 @@
     };
 
 
+    /* ========================================================================= */
     const deflate$2 = (strm, flush) => {
 
-      let beg, val; // for gzip header write only
-
-      if (!strm || !strm.state ||
-        flush > Z_BLOCK$1 || flush < 0) {
+      if (deflateStateCheck(strm) || 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) ||
+          (strm.avail_in !== 0 && !strm.input) ||
           (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 */
       const old_flush = s.last_flush;
       s.last_flush = flush;
 
+      /* Flush as much pending output as possible */
+      if (s.pending !== 0) {
+        flush_pending(strm);
+        if (strm.avail_out === 0) {
+          /* Since avail_out is 0, deflate will be called again with
+           * more output space, but possibly with both pending and
+           * avail_in equal to zero. There won't be anything to do,
+           * but this is not an error situation so make sure we
+           * return OK instead of BUF_ERROR at next call of deflate:
+           */
+          s.last_flush = -1;
+          return Z_OK$3;
+        }
+
+        /* Make sure there is something to do and avoid duplicate consecutive
+         * flushes. For repeated and useless calls with Z_FINISH, we keep
+         * returning Z_STREAM_END instead of Z_BUF_ERROR.
+         */
+      } else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) &&
+        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$1);
+      }
+
       /* Write the header */
+      if (s.status === INIT_STATE && s.wrap === 0) {
+        s.status = BUSY_STATE;
+      }
       if (s.status === INIT_STATE) {
+        /* zlib header */
+        let header = (Z_DEFLATED$2 + ((s.w_bits - 8) << 4)) << 8;
+        let level_flags = -1;
+
+        if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) {
+          level_flags = 0;
+        } else if (s.level < 6) {
+          level_flags = 1;
+        } else if (s.level === 6) {
+          level_flags = 2;
+        } else {
+          level_flags = 3;
+        }
+        header |= (level_flags << 6);
+        if (s.strstart !== 0) { header |= PRESET_DICT; }
+        header += 31 - (header % 31);
 
-        if (s.wrap === 2) { // GZIP header
-          strm.adler = 0;  //crc32(0L, Z_NULL, 0);
-          put_byte(s, 31);
-          put_byte(s, 139);
-          put_byte(s, 8);
-          if (!s.gzhead) { // s->gzhead == Z_NULL
-            put_byte(s, 0);
-            put_byte(s, 0);
-            put_byte(s, 0);
-            put_byte(s, 0);
-            put_byte(s, 0);
-            put_byte(s, s.level === 9 ? 2 :
-                        (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ?
-                         4 : 0));
-            put_byte(s, OS_CODE);
-            s.status = BUSY_STATE;
-          }
-          else {
-            put_byte(s, (s.gzhead.text ? 1 : 0) +
-                        (s.gzhead.hcrc ? 2 : 0) +
-                        (!s.gzhead.extra ? 0 : 4) +
-                        (!s.gzhead.name ? 0 : 8) +
-                        (!s.gzhead.comment ? 0 : 16)
-            );
-            put_byte(s, s.gzhead.time & 0xff);
-            put_byte(s, (s.gzhead.time >> 8) & 0xff);
-            put_byte(s, (s.gzhead.time >> 16) & 0xff);
-            put_byte(s, (s.gzhead.time >> 24) & 0xff);
-            put_byte(s, s.level === 9 ? 2 :
-                        (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ?
-                         4 : 0));
-            put_byte(s, s.gzhead.os & 0xff);
-            if (s.gzhead.extra && s.gzhead.extra.length) {
-              put_byte(s, s.gzhead.extra.length & 0xff);
-              put_byte(s, (s.gzhead.extra.length >> 8) & 0xff);
-            }
-            if (s.gzhead.hcrc) {
-              strm.adler = crc32(strm.adler, s.pending_buf, s.pending, 0);
-            }
-            s.gzindex = 0;
-            s.status = EXTRA_STATE;
-          }
+        putShortMSB(s, header);
+
+        /* Save the adler32 of the preset dictionary: */
+        if (s.strstart !== 0) {
+          putShortMSB(s, strm.adler >>> 16);
+          putShortMSB(s, strm.adler & 0xffff);
         }
-        else // DEFLATE header
-        {
-          let header = (Z_DEFLATED$2 + ((s.w_bits - 8) << 4)) << 8;
-          let level_flags = -1;
-
-          if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) {
-            level_flags = 0;
-          } else if (s.level < 6) {
-            level_flags = 1;
-          } else if (s.level === 6) {
-            level_flags = 2;
-          } else {
-            level_flags = 3;
-          }
-          header |= (level_flags << 6);
-          if (s.strstart !== 0) { header |= PRESET_DICT; }
-          header += 31 - (header % 31);
+        strm.adler = 1; // adler32(0L, Z_NULL, 0);
+        s.status = BUSY_STATE;
 
+        /* Compression must start with an empty pending buffer */
+        flush_pending(strm);
+        if (s.pending !== 0) {
+          s.last_flush = -1;
+          return Z_OK$3;
+        }
+      }
+    //#ifdef GZIP
+      if (s.status === GZIP_STATE) {
+        /* gzip header */
+        strm.adler = 0;  //crc32(0L, Z_NULL, 0);
+        put_byte(s, 31);
+        put_byte(s, 139);
+        put_byte(s, 8);
+        if (!s.gzhead) { // s->gzhead == Z_NULL
+          put_byte(s, 0);
+          put_byte(s, 0);
+          put_byte(s, 0);
+          put_byte(s, 0);
+          put_byte(s, 0);
+          put_byte(s, s.level === 9 ? 2 :
+                      (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ?
+                       4 : 0));
+          put_byte(s, OS_CODE);
           s.status = BUSY_STATE;
-          putShortMSB(s, header);
 
-          /* Save the adler32 of the preset dictionary: */
-          if (s.strstart !== 0) {
-            putShortMSB(s, strm.adler >>> 16);
-            putShortMSB(s, strm.adler & 0xffff);
+          /* Compression must start with an empty pending buffer */
+          flush_pending(strm);
+          if (s.pending !== 0) {
+            s.last_flush = -1;
+            return Z_OK$3;
+          }
+        }
+        else {
+          put_byte(s, (s.gzhead.text ? 1 : 0) +
+                      (s.gzhead.hcrc ? 2 : 0) +
+                      (!s.gzhead.extra ? 0 : 4) +
+                      (!s.gzhead.name ? 0 : 8) +
+                      (!s.gzhead.comment ? 0 : 16)
+          );
+          put_byte(s, s.gzhead.time & 0xff);
+          put_byte(s, (s.gzhead.time >> 8) & 0xff);
+          put_byte(s, (s.gzhead.time >> 16) & 0xff);
+          put_byte(s, (s.gzhead.time >> 24) & 0xff);
+          put_byte(s, s.level === 9 ? 2 :
+                      (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ?
+                       4 : 0));
+          put_byte(s, s.gzhead.os & 0xff);
+          if (s.gzhead.extra && s.gzhead.extra.length) {
+            put_byte(s, s.gzhead.extra.length & 0xff);
+            put_byte(s, (s.gzhead.extra.length >> 8) & 0xff);
+          }
+          if (s.gzhead.hcrc) {
+            strm.adler = crc32(strm.adler, s.pending_buf, s.pending, 0);
           }
-          strm.adler = 1; // adler32(0L, Z_NULL, 0);
+          s.gzindex = 0;
+          s.status = EXTRA_STATE;
         }
       }
-
-    //#ifdef GZIP
       if (s.status === EXTRA_STATE) {
         if (s.gzhead.extra/* != Z_NULL*/) {
-          beg = s.pending;  /* start of bytes to update crc */
-
-          while (s.gzindex < (s.gzhead.extra.length & 0xffff)) {
-            if (s.pending === s.pending_buf_size) {
-              if (s.gzhead.hcrc && s.pending > beg) {
-                strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
-              }
-              flush_pending(strm);
-              beg = s.pending;
-              if (s.pending === s.pending_buf_size) {
-                break;
-              }
+          let beg = s.pending;   /* start of bytes to update crc */
+          let left = (s.gzhead.extra.length & 0xffff) - s.gzindex;
+          while (s.pending + left > s.pending_buf_size) {
+            let copy = s.pending_buf_size - s.pending;
+            // zmemcpy(s.pending_buf + s.pending,
+            //    s.gzhead.extra + s.gzindex, copy);
+            s.pending_buf.set(s.gzhead.extra.subarray(s.gzindex, s.gzindex + copy), s.pending);
+            s.pending = s.pending_buf_size;
+            //--- HCRC_UPDATE(beg) ---//
+            if (s.gzhead.hcrc && s.pending > beg) {
+              strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
             }
-            put_byte(s, s.gzhead.extra[s.gzindex] & 0xff);
-            s.gzindex++;
+            //---//
+            s.gzindex += copy;
+            flush_pending(strm);
+            if (s.pending !== 0) {
+              s.last_flush = -1;
+              return Z_OK$3;
+            }
+            beg = 0;
+            left -= copy;
           }
+          // JS specific: s.gzhead.extra may be TypedArray or Array for backward compatibility
+          //              TypedArray.slice and TypedArray.from don't exist in IE10-IE11
+          let gzhead_extra = new Uint8Array(s.gzhead.extra);
+          // zmemcpy(s->pending_buf + s->pending,
+          //     s->gzhead->extra + s->gzindex, left);
+          s.pending_buf.set(gzhead_extra.subarray(s.gzindex, s.gzindex + left), s.pending);
+          s.pending += left;
+          //--- HCRC_UPDATE(beg) ---//
           if (s.gzhead.hcrc && s.pending > beg) {
             strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
           }
-          if (s.gzindex === s.gzhead.extra.length) {
-            s.gzindex = 0;
-            s.status = NAME_STATE;
-          }
-        }
-        else {
-          s.status = NAME_STATE;
+          //---//
+          s.gzindex = 0;
         }
+        s.status = NAME_STATE;
       }
       if (s.status === NAME_STATE) {
         if (s.gzhead.name/* != Z_NULL*/) {
-          beg = s.pending;  /* start of bytes to update crc */
-          //int val;
-
+          let beg = s.pending;   /* start of bytes to update crc */
+          let val;
           do {
             if (s.pending === s.pending_buf_size) {
+              //--- HCRC_UPDATE(beg) ---//
               if (s.gzhead.hcrc && s.pending > beg) {
                 strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
               }
+              //---//
               flush_pending(strm);
-              beg = s.pending;
-              if (s.pending === s.pending_buf_size) {
-                val = 1;
-                break;
+              if (s.pending !== 0) {
+                s.last_flush = -1;
+                return Z_OK$3;
               }
+              beg = 0;
             }
             // JS specific: little magic to add zero terminator to end of string
             if (s.gzindex < s.gzhead.name.length) {
@@ -33742,35 +33942,32 @@
             }
             put_byte(s, val);
           } while (val !== 0);
-
+          //--- HCRC_UPDATE(beg) ---//
           if (s.gzhead.hcrc && s.pending > beg) {
             strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
           }
-          if (val === 0) {
-            s.gzindex = 0;
-            s.status = COMMENT_STATE;
-          }
-        }
-        else {
-          s.status = COMMENT_STATE;
+          //---//
+          s.gzindex = 0;
         }
+        s.status = COMMENT_STATE;
       }
       if (s.status === COMMENT_STATE) {
         if (s.gzhead.comment/* != Z_NULL*/) {
-          beg = s.pending;  /* start of bytes to update crc */
-          //int val;
-
+          let beg = s.pending;   /* start of bytes to update crc */
+          let val;
           do {
             if (s.pending === s.pending_buf_size) {
+              //--- HCRC_UPDATE(beg) ---//
               if (s.gzhead.hcrc && s.pending > beg) {
                 strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
               }
+              //---//
               flush_pending(strm);
-              beg = s.pending;
-              if (s.pending === s.pending_buf_size) {
-                val = 1;
-                break;
+              if (s.pending !== 0) {
+                s.last_flush = -1;
+                return Z_OK$3;
               }
+              beg = 0;
             }
             // JS specific: little magic to add zero terminator to end of string
             if (s.gzindex < s.gzhead.comment.length) {
@@ -33780,71 +33977,46 @@
             }
             put_byte(s, val);
           } while (val !== 0);
-
+          //--- HCRC_UPDATE(beg) ---//
           if (s.gzhead.hcrc && s.pending > beg) {
             strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
           }
-          if (val === 0) {
-            s.status = HCRC_STATE;
-          }
-        }
-        else {
-          s.status = HCRC_STATE;
+          //---//
         }
+        s.status = HCRC_STATE;
       }
       if (s.status === HCRC_STATE) {
         if (s.gzhead.hcrc) {
           if (s.pending + 2 > s.pending_buf_size) {
             flush_pending(strm);
+            if (s.pending !== 0) {
+              s.last_flush = -1;
+              return Z_OK$3;
+            }
           }
-          if (s.pending + 2 <= s.pending_buf_size) {
-            put_byte(s, strm.adler & 0xff);
-            put_byte(s, (strm.adler >> 8) & 0xff);
-            strm.adler = 0; //crc32(0L, Z_NULL, 0);
-            s.status = BUSY_STATE;
-          }
+          put_byte(s, strm.adler & 0xff);
+          put_byte(s, (strm.adler >> 8) & 0xff);
+          strm.adler = 0; //crc32(0L, Z_NULL, 0);
         }
-        else {
-          s.status = BUSY_STATE;
-        }
-      }
-    //#endif
+        s.status = BUSY_STATE;
 
-      /* Flush as much pending output as possible */
-      if (s.pending !== 0) {
+        /* Compression must start with an empty pending buffer */
         flush_pending(strm);
-        if (strm.avail_out === 0) {
-          /* Since avail_out is 0, deflate will be called again with
-           * more output space, but possibly with both pending and
-           * avail_in equal to zero. There won't be anything to do,
-           * but this is not an error situation so make sure we
-           * return OK instead of BUF_ERROR at next call of deflate:
-           */
+        if (s.pending !== 0) {
           s.last_flush = -1;
           return Z_OK$3;
         }
-
-        /* Make sure there is something to do and avoid duplicate consecutive
-         * flushes. For repeated and useless calls with Z_FINISH, we keep
-         * returning Z_STREAM_END instead of Z_BUF_ERROR.
-         */
-      } else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) &&
-        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$1);
       }
+    //#endif
 
       /* Start a new block or continue the current one.
        */
       if (strm.avail_in !== 0 || s.lookahead !== 0 ||
         (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));
+        let bstate = s.level === 0 ? deflate_stored(s, flush) :
+                     s.strategy === Z_HUFFMAN_ONLY ? deflate_huff(s, flush) :
+                     s.strategy === Z_RLE ? deflate_rle(s, flush) :
+                     configuration_table[s.level].func(s, flush);
 
         if (bstate === BS_FINISH_STARTED || bstate === BS_FINISH_DONE) {
           s.status = FINISH_STATE;
@@ -33891,8 +34063,6 @@
           }
         }
       }
-      //Assert(strm->avail_out > 0, "bug2");
-      //if (strm.avail_out <= 0) { throw new Error("bug2");}
 
       if (flush !== Z_FINISH$3) { return Z_OK$3; }
       if (s.wrap <= 0) { return Z_STREAM_END$3; }
@@ -33926,21 +34096,11 @@
 
     const deflateEnd = (strm) => {
 
-      if (!strm/*== Z_NULL*/ || !strm.state/*== Z_NULL*/) {
+      if (deflateStateCheck(strm)) {
         return Z_STREAM_ERROR$2;
       }
 
       const status = strm.state.status;
-      if (status !== INIT_STATE &&
-        status !== EXTRA_STATE &&
-        status !== NAME_STATE &&
-        status !== COMMENT_STATE &&
-        status !== HCRC_STATE &&
-        status !== BUSY_STATE &&
-        status !== FINISH_STATE
-      ) {
-        return err(strm, Z_STREAM_ERROR$2);
-      }
 
       strm.state = null;
 
@@ -33956,7 +34116,7 @@
 
       let dictLength = dictionary.length;
 
-      if (!strm/*== Z_NULL*/ || !strm.state/*== Z_NULL*/) {
+      if (deflateStateCheck(strm)) {
         return Z_STREAM_ERROR$2;
       }
 
@@ -34042,6 +34202,7 @@
     /* Not implemented
     module.exports.deflateBound = deflateBound;
     module.exports.deflateCopy = deflateCopy;
+    module.exports.deflateGetDictionary = deflateGetDictionary;
     module.exports.deflateParams = deflateParams;
     module.exports.deflatePending = deflatePending;
     module.exports.deflatePrime = deflatePrime;
@@ -34639,7 +34800,7 @@
 
     /**
      * deflate(data[, options]) -> Uint8Array
-     * - data (Uint8Array|String): input data to compress.
+     * - data (Uint8Array|ArrayBuffer|String): input data to compress.
      * - options (Object): zlib deflate options.
      *
      * Compress `data` with deflate algorithm and `options`.
@@ -34683,7 +34844,7 @@
 
     /**
      * deflateRaw(data[, options]) -> Uint8Array
-     * - data (Uint8Array|String): input data to compress.
+     * - data (Uint8Array|ArrayBuffer|String): input data to compress.
      * - options (Object): zlib deflate options.
      *
      * The same as [[deflate]], but creates raw data, without wrapper
@@ -34698,7 +34859,7 @@
 
     /**
      * gzip(data[, options]) -> Uint8Array
-     * - data (Uint8Array|String): input data to compress.
+     * - data (Uint8Array|ArrayBuffer|String): input data to compress.
      * - options (Object): zlib deflate options.
      *
      * The same as [[deflate]], but create gzip wrapper instead of
@@ -34745,8 +34906,8 @@
     // 3. This notice may not be removed or altered from any source distribution.
 
     // See state defs from inflate.js
-    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 */
+    const BAD$1 = 16209;       /* got a data error -- remain here until reset */
+    const TYPE$1 = 16191;      /* i: waiting for type bits, including last-flag bit */
 
     /*
        Decode literal, length, and distance codes and write out the resulting
@@ -35138,13 +35299,11 @@
       let mask;              /* mask for low root bits */
       let next;             /* next available space in table */
       let base = null;     /* base value table to use */
-      let base_index = 0;
     //  let shoextra;    /* extra bits table to use */
-      let end;                    /* use base and extra for symbol > end */
+      let match;                  /* use base and extra for symbol >= match */
       const count = new Uint16Array(MAXBITS + 1); //[MAXBITS+1];    /* number of codes of each length */
       const offs = new Uint16Array(MAXBITS + 1); //[MAXBITS+1];     /* offsets in table for each length */
       let extra = null;
-      let extra_index = 0;
 
       let here_bits, here_op, here_val;
 
@@ -35279,19 +35438,17 @@
       // to avoid deopts in old v8
       if (type === CODES$1) {
         base = extra = work;    /* dummy value--not used */
-        end = 19;
+        match = 20;
 
       } else if (type === LENS$1) {
         base = lbase;
-        base_index -= 257;
         extra = lext;
-        extra_index -= 257;
-        end = 256;
+        match = 257;
 
       } else {                    /* DISTS */
         base = dbase;
         extra = dext;
-        end = -1;
+        match = 0;
       }
 
       /* initialize opts for loop */
@@ -35315,13 +35472,13 @@
       for (;;) {
         /* create table entry */
         here_bits = len - drop;
-        if (work[sym] < end) {
+        if (work[sym] + 1 < match) {
           here_op = 0;
           here_val = work[sym];
         }
-        else if (work[sym] > end) {
-          here_op = extra[extra_index + work[sym]];
-          here_val = base[base_index + work[sym]];
+        else if (work[sym] >= match) {
+          here_op = extra[work[sym] - match];
+          here_val = base[work[sym] - match];
         }
         else {
           here_op = 32 + 64;         /* end of block */
@@ -35457,38 +35614,38 @@
     /* ===========================================================================*/
 
 
-    const    HEAD = 1;       /* i: waiting for magic header */
-    const    FLAGS = 2;      /* i: waiting for method and flags (gzip) */
-    const    TIME = 3;       /* i: waiting for modification time (gzip) */
-    const    OS = 4;         /* i: waiting for extra flags and operating system (gzip) */
-    const    EXLEN = 5;      /* i: waiting for extra length (gzip) */
-    const    EXTRA = 6;      /* i: waiting for extra bytes (gzip) */
-    const    NAME = 7;       /* i: waiting for end of file name (gzip) */
-    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 = 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 */
-    const        COPY = 16;      /* i/o: waiting for input or output to copy stored block */
-    const        TABLE = 17;     /* i: waiting for dynamic block table lengths */
-    const        LENLENS = 18;   /* i: waiting for code length code lengths */
-    const        CODELENS = 19;  /* i: waiting for length/lit and distance code lengths */
-    const            LEN_ = 20;      /* i: same as LEN below, but only first time in */
-    const            LEN = 21;       /* i: waiting for length/lit/eob code */
-    const            LENEXT = 22;    /* i: waiting for length extra bits */
-    const            DIST = 23;      /* i: waiting for distance code */
-    const            DISTEXT = 24;   /* i: waiting for distance extra bits */
-    const            MATCH = 25;     /* o: waiting for output space to copy string */
-    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 = 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() */
+    const    HEAD = 16180;       /* i: waiting for magic header */
+    const    FLAGS = 16181;      /* i: waiting for method and flags (gzip) */
+    const    TIME = 16182;       /* i: waiting for modification time (gzip) */
+    const    OS = 16183;         /* i: waiting for extra flags and operating system (gzip) */
+    const    EXLEN = 16184;      /* i: waiting for extra length (gzip) */
+    const    EXTRA = 16185;      /* i: waiting for extra bytes (gzip) */
+    const    NAME = 16186;       /* i: waiting for end of file name (gzip) */
+    const    COMMENT = 16187;    /* i: waiting for end of comment (gzip) */
+    const    HCRC = 16188;       /* i: waiting for header crc (gzip) */
+    const    DICTID = 16189;    /* i: waiting for dictionary check value */
+    const    DICT = 16190;      /* waiting for inflateSetDictionary() call */
+    const        TYPE = 16191;      /* i: waiting for type bits, including last-flag bit */
+    const        TYPEDO = 16192;    /* i: same, but skip check to exit inflate on new block */
+    const        STORED = 16193;    /* i: waiting for stored size (length and complement) */
+    const        COPY_ = 16194;     /* i/o: same as COPY below, but only first time in */
+    const        COPY = 16195;      /* i/o: waiting for input or output to copy stored block */
+    const        TABLE = 16196;     /* i: waiting for dynamic block table lengths */
+    const        LENLENS = 16197;   /* i: waiting for code length code lengths */
+    const        CODELENS = 16198;  /* i: waiting for length/lit and distance code lengths */
+    const            LEN_ = 16199;      /* i: same as LEN below, but only first time in */
+    const            LEN = 16200;       /* i: waiting for length/lit/eob code */
+    const            LENEXT = 16201;    /* i: waiting for length extra bits */
+    const            DIST = 16202;      /* i: waiting for distance code */
+    const            DISTEXT = 16203;   /* i: waiting for distance extra bits */
+    const            MATCH = 16204;     /* o: waiting for output space to copy string */
+    const            LIT = 16205;       /* o: waiting for output space to write literal */
+    const    CHECK = 16206;     /* i: waiting for 32-bit check value */
+    const    LENGTH = 16207;    /* i: waiting for 32-bit length (gzip) */
+    const    DONE = 16208;      /* finished check, done -- remain here until reset */
+    const    BAD = 16209;       /* got a data error -- remain here until reset */
+    const    MEM = 16210;       /* got an inflate() memory error -- remain here until reset */
+    const    SYNC = 16211;      /* looking for synchronization bytes to restart inflate() */
 
     /* ===========================================================================*/
 
@@ -35513,11 +35670,14 @@
 
 
     function InflateState() {
-      this.mode = 0;             /* current inflate mode */
+      this.strm = null;           /* pointer back to this zlib stream */
+      this.mode = 0;              /* current inflate mode */
       this.last = false;          /* true if processing last block */
-      this.wrap = 0;              /* bit 0 true for zlib, bit 1 true for gzip */
+      this.wrap = 0;              /* bit 0 true for zlib, bit 1 true for gzip,
+                                     bit 2 true to validate check value */
       this.havedict = false;      /* true if dictionary provided */
-      this.flags = 0;             /* gzip header method and flags (0 if zlib) */
+      this.flags = 0;             /* gzip header method and flags (0 if zlib), or
+                                     -1 if raw or no header yet */
       this.dmax = 0;              /* zlib header max distance (INFLATE_STRICT) */
       this.check = 0;             /* protected copy of check value */
       this.total = 0;             /* protected copy of output count */
@@ -35571,9 +35731,23 @@
     }
 
 
+    const inflateStateCheck = (strm) => {
+
+      if (!strm) {
+        return 1;
+      }
+      const state = strm.state;
+      if (!state || state.strm !== strm ||
+        state.mode < HEAD || state.mode > SYNC) {
+        return 1;
+      }
+      return 0;
+    };
+
+
     const inflateResetKeep = (strm) => {
 
-      if (!strm || !strm.state) { return Z_STREAM_ERROR$1; }
+      if (inflateStateCheck(strm)) { return Z_STREAM_ERROR$1; }
       const state = strm.state;
       strm.total_in = strm.total_out = state.total = 0;
       strm.msg = ''; /*Z_NULL*/
@@ -35583,6 +35757,7 @@
       state.mode = HEAD;
       state.last = 0;
       state.havedict = 0;
+      state.flags = -1;
       state.dmax = 32768;
       state.head = null/*Z_NULL*/;
       state.hold = 0;
@@ -35600,7 +35775,7 @@
 
     const inflateReset = (strm) => {
 
-      if (!strm || !strm.state) { return Z_STREAM_ERROR$1; }
+      if (inflateStateCheck(strm)) { return Z_STREAM_ERROR$1; }
       const state = strm.state;
       state.wsize = 0;
       state.whave = 0;
@@ -35614,7 +35789,7 @@
       let wrap;
 
       /* get the state */
-      if (!strm || !strm.state) { return Z_STREAM_ERROR$1; }
+      if (inflateStateCheck(strm)) { return Z_STREAM_ERROR$1; }
       const state = strm.state;
 
       /* extract wrap request from windowBits parameter */
@@ -35623,7 +35798,7 @@
         windowBits = -windowBits;
       }
       else {
-        wrap = (windowBits >> 4) + 1;
+        wrap = (windowBits >> 4) + 5;
         if (windowBits < 48) {
           windowBits &= 15;
         }
@@ -35654,7 +35829,9 @@
       //if (state === Z_NULL) return Z_MEM_ERROR;
       //Tracev((stderr, "inflate: allocated\n"));
       strm.state = state;
+      state.strm = strm;
       state.window = null/*Z_NULL*/;
+      state.mode = HEAD;     /* to pass state test in inflateReset2() */
       const ret = inflateReset2(strm, windowBits);
       if (ret !== Z_OK$1) {
         strm.state = null/*Z_NULL*/;
@@ -35803,7 +35980,7 @@
         new Uint8Array([ 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 ]);
 
 
-      if (!strm || !strm.state || !strm.output ||
+      if (inflateStateCheck(strm) || !strm.output ||
           (!strm.input && strm.avail_in !== 0)) {
         return Z_STREAM_ERROR$1;
       }
@@ -35844,6 +36021,9 @@
             }
             //===//
             if ((state.wrap & 2) && hold === 0x8b1f) {  /* gzip header */
+              if (state.wbits === 0) {
+                state.wbits = 15;
+              }
               state.check = 0/*crc32(0L, Z_NULL, 0)*/;
               //=== CRC2(state.check, hold);
               hbuf[0] = hold & 0xff;
@@ -35858,7 +36038,6 @@
               state.mode = FLAGS;
               break;
             }
-            state.flags = 0;           /* expect zlib header */
             if (state.head) {
               state.head.done = false;
             }
@@ -35881,7 +36060,7 @@
             if (state.wbits === 0) {
               state.wbits = len;
             }
-            else if (len > state.wbits) {
+            if (len > 15 || len > state.wbits) {
               strm.msg = 'invalid window size';
               state.mode = BAD;
               break;
@@ -35892,6 +36071,7 @@
             state.dmax = 1 << state.wbits;
             //state.dmax = 1 << len;
 
+            state.flags = 0;               /* indicate zlib header */
             //Tracev((stderr, "inflate:   zlib header ok\n"));
             strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/;
             state.mode = hold & 0x200 ? DICTID : TYPE;
@@ -35923,7 +36103,7 @@
             if (state.head) {
               state.head.text = ((hold >> 8) & 1);
             }
-            if (state.flags & 0x0200) {
+            if ((state.flags & 0x0200) && (state.wrap & 4)) {
               //=== CRC2(state.check, hold);
               hbuf[0] = hold & 0xff;
               hbuf[1] = (hold >>> 8) & 0xff;
@@ -35948,7 +36128,7 @@
             if (state.head) {
               state.head.time = hold;
             }
-            if (state.flags & 0x0200) {
+            if ((state.flags & 0x0200) && (state.wrap & 4)) {
               //=== CRC4(state.check, hold)
               hbuf[0] = hold & 0xff;
               hbuf[1] = (hold >>> 8) & 0xff;
@@ -35976,7 +36156,7 @@
               state.head.xflags = (hold & 0xff);
               state.head.os = (hold >> 8);
             }
-            if (state.flags & 0x0200) {
+            if ((state.flags & 0x0200) && (state.wrap & 4)) {
               //=== CRC2(state.check, hold);
               hbuf[0] = hold & 0xff;
               hbuf[1] = (hold >>> 8) & 0xff;
@@ -36003,7 +36183,7 @@
               if (state.head) {
                 state.head.extra_len = hold;
               }
-              if (state.flags & 0x0200) {
+              if ((state.flags & 0x0200) && (state.wrap & 4)) {
                 //=== CRC2(state.check, hold);
                 hbuf[0] = hold & 0xff;
                 hbuf[1] = (hold >>> 8) & 0xff;
@@ -36045,7 +36225,7 @@
                   //        len + copy > state.head.extra_max ?
                   //        state.head.extra_max - len : copy);
                 }
-                if (state.flags & 0x0200) {
+                if ((state.flags & 0x0200) && (state.wrap & 4)) {
                   state.check = crc32(state.check, input, copy, next);
                 }
                 have -= copy;
@@ -36071,7 +36251,7 @@
                 }
               } while (len && copy < have);
 
-              if (state.flags & 0x0200) {
+              if ((state.flags & 0x0200) && (state.wrap & 4)) {
                 state.check = crc32(state.check, input, copy, next);
               }
               have -= copy;
@@ -36096,7 +36276,7 @@
                   state.head.comment += String.fromCharCode(len);
                 }
               } while (len && copy < have);
-              if (state.flags & 0x0200) {
+              if ((state.flags & 0x0200) && (state.wrap & 4)) {
                 state.check = crc32(state.check, input, copy, next);
               }
               have -= copy;
@@ -36118,7 +36298,7 @@
                 bits += 8;
               }
               //===//
-              if (hold !== (state.check & 0xffff)) {
+              if ((state.wrap & 4) && hold !== (state.check & 0xffff)) {
                 strm.msg = 'header crc mismatch';
                 state.mode = BAD;
                 break;
@@ -36771,15 +36951,15 @@
               _out -= left;
               strm.total_out += _out;
               state.total += _out;
-              if (_out) {
+              if ((state.wrap & 4) && _out) {
                 strm.adler = state.check =
-                    /*UPDATE(state.check, put - _out, _out);*/
+                    /*UPDATE_CHECK(state.check, put - _out, _out);*/
                     (state.flags ? crc32(state.check, output, _out, put - _out) : adler32(state.check, output, _out, put - _out));
 
               }
               _out = left;
               // NB: crc32 stored as signed 32-bit int, zswap32 returns signed too
-              if ((state.flags ? hold : zswap32(hold)) !== state.check) {
+              if ((state.wrap & 4) && (state.flags ? hold : zswap32(hold)) !== state.check) {
                 strm.msg = 'incorrect data check';
                 state.mode = BAD;
                 break;
@@ -36802,7 +36982,7 @@
                 bits += 8;
               }
               //===//
-              if (hold !== (state.total & 0xffffffff)) {
+              if ((state.wrap & 4) && hold !== (state.total & 0xffffffff)) {
                 strm.msg = 'incorrect length check';
                 state.mode = BAD;
                 break;
@@ -36857,8 +37037,8 @@
       strm.total_in += _in;
       strm.total_out += _out;
       state.total += _out;
-      if (state.wrap && _out) {
-        strm.adler = state.check = /*UPDATE(state.check, strm.next_out - _out, _out);*/
+      if ((state.wrap & 4) && _out) {
+        strm.adler = state.check = /*UPDATE_CHECK(state.check, strm.next_out - _out, _out);*/
           (state.flags ? crc32(state.check, output, _out, strm.next_out - _out) : adler32(state.check, output, _out, strm.next_out - _out));
       }
       strm.data_type = state.bits + (state.last ? 64 : 0) +
@@ -36873,7 +37053,7 @@
 
     const inflateEnd = (strm) => {
 
-      if (!strm || !strm.state /*|| strm->zfree == (free_func)0*/) {
+      if (inflateStateCheck(strm)) {
         return Z_STREAM_ERROR$1;
       }
 
@@ -36889,7 +37069,7 @@
     const inflateGetHeader = (strm, head) => {
 
       /* check state */
-      if (!strm || !strm.state) { return Z_STREAM_ERROR$1; }
+      if (inflateStateCheck(strm)) { return Z_STREAM_ERROR$1; }
       const state = strm.state;
       if ((state.wrap & 2) === 0) { return Z_STREAM_ERROR$1; }
 
@@ -36908,7 +37088,7 @@
       let ret;
 
       /* check state */
-      if (!strm /* == Z_NULL */ || !strm.state /* == Z_NULL */) { return Z_STREAM_ERROR$1; }
+      if (inflateStateCheck(strm)) { return Z_STREAM_ERROR$1; }
       state = strm.state;
 
       if (state.wrap !== 0 && state.mode !== DICT) {
@@ -36949,6 +37129,7 @@
     var inflateInfo = 'pako inflate (from Nodeca project)';
 
     /* Not implemented
+    module.exports.inflateCodesUsed = inflateCodesUsed;
     module.exports.inflateCopy = inflateCopy;
     module.exports.inflateGetDictionary = inflateGetDictionary;
     module.exports.inflateMark = inflateMark;
@@ -36956,6 +37137,7 @@
     module.exports.inflateSync = inflateSync;
     module.exports.inflateSyncPoint = inflateSyncPoint;
     module.exports.inflateUndermine = inflateUndermine;
+    module.exports.inflateValidate = inflateValidate;
     */
 
     var inflate_1$2 = {
@@ -37362,7 +37544,7 @@
 
     /**
      * inflate(data[, options]) -> Uint8Array|String
-     * - data (Uint8Array): input data to decompress.
+     * - data (Uint8Array|ArrayBuffer): input data to decompress.
      * - options (Object): zlib inflate options.
      *
      * Decompress `data` with inflate/ungzip and `options`. Autodetect
@@ -37413,7 +37595,7 @@
 
     /**
      * inflateRaw(data[, options]) -> Uint8Array|String
-     * - data (Uint8Array): input data to decompress.
+     * - data (Uint8Array|ArrayBuffer): input data to decompress.
      * - options (Object): zlib inflate options.
      *
      * The same as [[inflate]], but creates raw data, without wrapper
@@ -37428,7 +37610,7 @@
 
     /**
      * ungzip(data[, options]) -> Uint8Array|String
-     * - data (Uint8Array): input data to decompress.
+     * - data (Uint8Array|ArrayBuffer): input data to decompress.
      * - options (Object): zlib inflate options.
      *
      * Just shortcut to [[inflate]], because it autodetects format