@wordpress/global-styles-ui 1.1.0

package/build/font-library-modal/lib/inflate.js

@@ -0,0 +1,2628 @@
+"use strict";
+(function(f) {
+  if (typeof exports === "object" && typeof module !== "undefined") {
+    module.exports = f();
+  } else if (typeof define === "function" && define.amd) {
+    define([], f);
+  } else {
+    var g;
+    if (typeof window !== "undefined") {
+      g = window;
+    } else if (typeof global !== "undefined") {
+      g = global;
+    } else if (typeof self !== "undefined") {
+      g = self;
+    } else {
+      g = this;
+    }
+    g.pako = f();
+  }
+})(function() {
+  var define2, module2, exports2;
+  return (/* @__PURE__ */ (function() {
+    function r(e, n, t) {
+      function o(i2, f) {
+        if (!n[i2]) {
+          if (!e[i2]) {
+            var c = "function" == typeof require && require;
+            if (!f && c) return c(i2, true);
+            if (u) return u(i2, true);
+            var a = new Error("Cannot find module '" + i2 + "'");
+            throw a.code = "MODULE_NOT_FOUND", a;
+          }
+          var p = n[i2] = { exports: {} };
+          e[i2][0].call(
+            p.exports,
+            function(r2) {
+              var n2 = e[i2][1][r2];
+              return o(n2 || r2);
+            },
+            p,
+            p.exports,
+            r,
+            e,
+            n,
+            t
+          );
+        }
+        return n[i2].exports;
+      }
+      for (var u = "function" == typeof require && require, i = 0; i < t.length; i++)
+        o(t[i]);
+      return o;
+    }
+    return r;
+  })())(
+    {
+      1: [
+        function(require2, module3, exports3) {
+          "use strict";
+          var TYPED_OK = typeof Uint8Array !== "undefined" && typeof Uint16Array !== "undefined" && typeof Int32Array !== "undefined";
+          function _has(obj, key) {
+            return Object.prototype.hasOwnProperty.call(obj, key);
+          }
+          exports3.assign = function(obj) {
+            var sources = Array.prototype.slice.call(
+              arguments,
+              1
+            );
+            while (sources.length) {
+              var source = sources.shift();
+              if (!source) {
+                continue;
+              }
+              if (typeof source !== "object") {
+                throw new TypeError(
+                  source + "must be non-object"
+                );
+              }
+              for (var p in source) {
+                if (_has(source, p)) {
+                  obj[p] = source[p];
+                }
+              }
+            }
+            return obj;
+          };
+          exports3.shrinkBuf = function(buf, size) {
+            if (buf.length === size) {
+              return buf;
+            }
+            if (buf.subarray) {
+              return buf.subarray(0, size);
+            }
+            buf.length = size;
+            return buf;
+          };
+          var fnTyped = {
+            arraySet: function(dest, src, src_offs, len, dest_offs) {
+              if (src.subarray && dest.subarray) {
+                dest.set(
+                  src.subarray(src_offs, src_offs + len),
+                  dest_offs
+                );
+                return;
+              }
+              for (var i = 0; i < len; i++) {
+                dest[dest_offs + i] = src[src_offs + i];
+              }
+            },
+            // Join array of chunks to single array.
+            flattenChunks: function(chunks) {
+              var i, l, len, pos, chunk, result;
+              len = 0;
+              for (i = 0, l = chunks.length; i < l; i++) {
+                len += chunks[i].length;
+              }
+              result = new Uint8Array(len);
+              pos = 0;
+              for (i = 0, l = chunks.length; i < l; i++) {
+                chunk = chunks[i];
+                result.set(chunk, pos);
+                pos += chunk.length;
+              }
+              return result;
+            }
+          };
+          var fnUntyped = {
+            arraySet: function(dest, src, src_offs, len, dest_offs) {
+              for (var i = 0; i < len; i++) {
+                dest[dest_offs + i] = src[src_offs + i];
+              }
+            },
+            // Join array of chunks to single array.
+            flattenChunks: function(chunks) {
+              return [].concat.apply([], chunks);
+            }
+          };
+          exports3.setTyped = function(on) {
+            if (on) {
+              exports3.Buf8 = Uint8Array;
+              exports3.Buf16 = Uint16Array;
+              exports3.Buf32 = Int32Array;
+              exports3.assign(exports3, fnTyped);
+            } else {
+              exports3.Buf8 = Array;
+              exports3.Buf16 = Array;
+              exports3.Buf32 = Array;
+              exports3.assign(exports3, fnUntyped);
+            }
+          };
+          exports3.setTyped(TYPED_OK);
+        },
+        {}
+      ],
+      2: [
+        function(require2, module3, exports3) {
+          "use strict";
+          var utils = require2("./common");
+          var STR_APPLY_OK = true;
+          var STR_APPLY_UIA_OK = true;
+          try {
+            String.fromCharCode.apply(null, [0]);
+          } catch (__) {
+            STR_APPLY_OK = false;
+          }
+          try {
+            String.fromCharCode.apply(null, new Uint8Array(1));
+          } catch (__) {
+            STR_APPLY_UIA_OK = false;
+          }
+          var _utf8len = new utils.Buf8(256);
+          for (var q = 0; q < 256; q++) {
+            _utf8len[q] = q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1;
+          }
+          _utf8len[254] = _utf8len[254] = 1;
+          exports3.string2buf = function(str) {
+            var buf, c, c2, m_pos, i, str_len = str.length, buf_len = 0;
+            for (m_pos = 0; m_pos < str_len; m_pos++) {
+              c = str.charCodeAt(m_pos);
+              if ((c & 64512) === 55296 && m_pos + 1 < str_len) {
+                c2 = str.charCodeAt(m_pos + 1);
+                if ((c2 & 64512) === 56320) {
+                  c = 65536 + (c - 55296 << 10) + (c2 - 56320);
+                  m_pos++;
+                }
+              }
+              buf_len += c < 128 ? 1 : c < 2048 ? 2 : c < 65536 ? 3 : 4;
+            }
+            buf = new utils.Buf8(buf_len);
+            for (i = 0, m_pos = 0; i < buf_len; m_pos++) {
+              c = str.charCodeAt(m_pos);
+              if ((c & 64512) === 55296 && m_pos + 1 < str_len) {
+                c2 = str.charCodeAt(m_pos + 1);
+                if ((c2 & 64512) === 56320) {
+                  c = 65536 + (c - 55296 << 10) + (c2 - 56320);
+                  m_pos++;
+                }
+              }
+              if (c < 128) {
+                buf[i++] = c;
+              } else if (c < 2048) {
+                buf[i++] = 192 | c >>> 6;
+                buf[i++] = 128 | c & 63;
+              } else if (c < 65536) {
+                buf[i++] = 224 | c >>> 12;
+                buf[i++] = 128 | c >>> 6 & 63;
+                buf[i++] = 128 | c & 63;
+              } else {
+                buf[i++] = 240 | c >>> 18;
+                buf[i++] = 128 | c >>> 12 & 63;
+                buf[i++] = 128 | c >>> 6 & 63;
+                buf[i++] = 128 | c & 63;
+              }
+            }
+            return buf;
+          };
+          function buf2binstring(buf, len) {
+            if (len < 65534) {
+              if (buf.subarray && STR_APPLY_UIA_OK || !buf.subarray && STR_APPLY_OK) {
+                return String.fromCharCode.apply(
+                  null,
+                  utils.shrinkBuf(buf, len)
+                );
+              }
+            }
+            var result = "";
+            for (var i = 0; i < len; i++) {
+              result += String.fromCharCode(buf[i]);
+            }
+            return result;
+          }
+          exports3.buf2binstring = function(buf) {
+            return buf2binstring(buf, buf.length);
+          };
+          exports3.binstring2buf = function(str) {
+            var buf = new utils.Buf8(str.length);
+            for (var i = 0, len = buf.length; i < len; i++) {
+              buf[i] = str.charCodeAt(i);
+            }
+            return buf;
+          };
+          exports3.buf2string = function(buf, max) {
+            var i, out, c, c_len;
+            var len = max || buf.length;
+            var utf16buf = new Array(len * 2);
+            for (out = 0, i = 0; i < len; ) {
+              c = buf[i++];
+              if (c < 128) {
+                utf16buf[out++] = c;
+                continue;
+              }
+              c_len = _utf8len[c];
+              if (c_len > 4) {
+                utf16buf[out++] = 65533;
+                i += c_len - 1;
+                continue;
+              }
+              c &= c_len === 2 ? 31 : c_len === 3 ? 15 : 7;
+              while (c_len > 1 && i < len) {
+                c = c << 6 | buf[i++] & 63;
+                c_len--;
+              }
+              if (c_len > 1) {
+                utf16buf[out++] = 65533;
+                continue;
+              }
+              if (c < 65536) {
+                utf16buf[out++] = c;
+              } else {
+                c -= 65536;
+                utf16buf[out++] = 55296 | c >> 10 & 1023;
+                utf16buf[out++] = 56320 | c & 1023;
+              }
+            }
+            return buf2binstring(utf16buf, out);
+          };
+          exports3.utf8border = function(buf, max) {
+            var pos;
+            max = max || buf.length;
+            if (max > buf.length) {
+              max = buf.length;
+            }
+            pos = max - 1;
+            while (pos >= 0 && (buf[pos] & 192) === 128) {
+              pos--;
+            }
+            if (pos < 0) {
+              return max;
+            }
+            if (pos === 0) {
+              return max;
+            }
+            return pos + _utf8len[buf[pos]] > max ? pos : max;
+          };
+        },
+        { "./common": 1 }
+      ],
+      3: [
+        function(require2, module3, exports3) {
+          "use strict";
+          function adler32(adler, buf, len, pos) {
+            var s1 = adler & 65535 | 0, s2 = adler >>> 16 & 65535 | 0, n = 0;
+            while (len !== 0) {
+              n = len > 2e3 ? 2e3 : len;
+              len -= n;
+              do {
+                s1 = s1 + buf[pos++] | 0;
+                s2 = s2 + s1 | 0;
+              } while (--n);
+              s1 %= 65521;
+              s2 %= 65521;
+            }
+            return s1 | s2 << 16 | 0;
+          }
+          module3.exports = adler32;
+        },
+        {}
+      ],
+      4: [
+        function(require2, module3, exports3) {
+          "use strict";
+          module3.exports = {
+            /* Allowed flush values; see deflate() and inflate() below for details */
+            Z_NO_FLUSH: 0,
+            Z_PARTIAL_FLUSH: 1,
+            Z_SYNC_FLUSH: 2,
+            Z_FULL_FLUSH: 3,
+            Z_FINISH: 4,
+            Z_BLOCK: 5,
+            Z_TREES: 6,
+            /* Return codes for the compression/decompression functions. Negative values
+             * are errors, positive values are used for special but normal events.
+             */
+            Z_OK: 0,
+            Z_STREAM_END: 1,
+            Z_NEED_DICT: 2,
+            Z_ERRNO: -1,
+            Z_STREAM_ERROR: -2,
+            Z_DATA_ERROR: -3,
+            //Z_MEM_ERROR:     -4,
+            Z_BUF_ERROR: -5,
+            //Z_VERSION_ERROR: -6,
+            /* compression levels */
+            Z_NO_COMPRESSION: 0,
+            Z_BEST_SPEED: 1,
+            Z_BEST_COMPRESSION: 9,
+            Z_DEFAULT_COMPRESSION: -1,
+            Z_FILTERED: 1,
+            Z_HUFFMAN_ONLY: 2,
+            Z_RLE: 3,
+            Z_FIXED: 4,
+            Z_DEFAULT_STRATEGY: 0,
+            /* Possible values of the data_type field (though see inflate()) */
+            Z_BINARY: 0,
+            Z_TEXT: 1,
+            //Z_ASCII:                1, // = Z_TEXT (deprecated)
+            Z_UNKNOWN: 2,
+            /* The deflate compression method */
+            Z_DEFLATED: 8
+            //Z_NULL:                 null // Use -1 or null inline, depending on var type
+          };
+        },
+        {}
+      ],
+      5: [
+        function(require2, module3, exports3) {
+          "use strict";
+          function makeTable() {
+            var c, table = [];
+            for (var n = 0; n < 256; n++) {
+              c = n;
+              for (var k = 0; k < 8; k++) {
+                c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+              }
+              table[n] = c;
+            }
+            return table;
+          }
+          var crcTable = makeTable();
+          function crc32(crc, buf, len, pos) {
+            var t = crcTable, end = pos + len;
+            crc ^= -1;
+            for (var i = pos; i < end; i++) {
+              crc = crc >>> 8 ^ t[(crc ^ buf[i]) & 255];
+            }
+            return crc ^ -1;
+          }
+          module3.exports = crc32;
+        },
+        {}
+      ],
+      6: [
+        function(require2, module3, exports3) {
+          "use strict";
+          function GZheader() {
+            this.text = 0;
+            this.time = 0;
+            this.xflags = 0;
+            this.os = 0;
+            this.extra = null;
+            this.extra_len = 0;
+            this.name = "";
+            this.comment = "";
+            this.hcrc = 0;
+            this.done = false;
+          }
+          module3.exports = GZheader;
+        },
+        {}
+      ],
+      7: [
+        function(require2, module3, exports3) {
+          "use strict";
+          var BAD = 30;
+          var TYPE = 12;
+          module3.exports = function inflate_fast(strm, start) {
+            var state;
+            var _in;
+            var last;
+            var _out;
+            var beg;
+            var end;
+            var dmax;
+            var wsize;
+            var whave;
+            var wnext;
+            var s_window;
+            var hold;
+            var bits;
+            var lcode;
+            var dcode;
+            var lmask;
+            var dmask;
+            var here;
+            var op;
+            var len;
+            var dist;
+            var from;
+            var from_source;
+            var input, output;
+            state = strm.state;
+            _in = strm.next_in;
+            input = strm.input;
+            last = _in + (strm.avail_in - 5);
+            _out = strm.next_out;
+            output = strm.output;
+            beg = _out - (start - strm.avail_out);
+            end = _out + (strm.avail_out - 257);
+            dmax = state.dmax;
+            wsize = state.wsize;
+            whave = state.whave;
+            wnext = state.wnext;
+            s_window = state.window;
+            hold = state.hold;
+            bits = state.bits;
+            lcode = state.lencode;
+            dcode = state.distcode;
+            lmask = (1 << state.lenbits) - 1;
+            dmask = (1 << state.distbits) - 1;
+            top: do {
+              if (bits < 15) {
+                hold += input[_in++] << bits;
+                bits += 8;
+                hold += input[_in++] << bits;
+                bits += 8;
+              }
+              here = lcode[hold & lmask];
+              dolen: for (; ; ) {
+                op = here >>> 24;
+                hold >>>= op;
+                bits -= op;
+                op = here >>> 16 & 255;
+                if (op === 0) {
+                  output[_out++] = here & 65535;
+                } else if (op & 16) {
+                  len = here & 65535;
+                  op &= 15;
+                  if (op) {
+                    if (bits < op) {
+                      hold += input[_in++] << bits;
+                      bits += 8;
+                    }
+                    len += hold & (1 << op) - 1;
+                    hold >>>= op;
+                    bits -= op;
+                  }
+                  if (bits < 15) {
+                    hold += input[_in++] << bits;
+                    bits += 8;
+                    hold += input[_in++] << bits;
+                    bits += 8;
+                  }
+                  here = dcode[hold & dmask];
+                  dodist: for (; ; ) {
+                    op = here >>> 24;
+                    hold >>>= op;
+                    bits -= op;
+                    op = here >>> 16 & 255;
+                    if (op & 16) {
+                      dist = here & 65535;
+                      op &= 15;
+                      if (bits < op) {
+                        hold += input[_in++] << bits;
+                        bits += 8;
+                        if (bits < op) {
+                          hold += input[_in++] << bits;
+                          bits += 8;
+                        }
+                      }
+                      dist += hold & (1 << op) - 1;
+                      if (dist > dmax) {
+                        strm.msg = "invalid distance too far back";
+                        state.mode = BAD;
+                        break top;
+                      }
+                      hold >>>= op;
+                      bits -= op;
+                      op = _out - beg;
+                      if (dist > op) {
+                        op = dist - op;
+                        if (op > whave) {
+                          if (state.sane) {
+                            strm.msg = "invalid distance too far back";
+                            state.mode = BAD;
+                            break top;
+                          }
+                        }
+                        from = 0;
+                        from_source = s_window;
+                        if (wnext === 0) {
+                          from += wsize - op;
+                          if (op < len) {
+                            len -= op;
+                            do {
+                              output[_out++] = s_window[from++];
+                            } while (--op);
+                            from = _out - dist;
+                            from_source = output;
+                          }
+                        } else if (wnext < op) {
+                          from += wsize + wnext - op;
+                          op -= wnext;
+                          if (op < len) {
+                            len -= op;
+                            do {
+                              output[_out++] = s_window[from++];
+                            } while (--op);
+                            from = 0;
+                            if (wnext < len) {
+                              op = wnext;
+                              len -= op;
+                              do {
+                                output[_out++] = s_window[from++];
+                              } while (--op);
+                              from = _out - dist;
+                              from_source = output;
+                            }
+                          }
+                        } else {
+                          from += wnext - op;
+                          if (op < len) {
+                            len -= op;
+                            do {
+                              output[_out++] = s_window[from++];
+                            } while (--op);
+                            from = _out - dist;
+                            from_source = output;
+                          }
+                        }
+                        while (len > 2) {
+                          output[_out++] = from_source[from++];
+                          output[_out++] = from_source[from++];
+                          output[_out++] = from_source[from++];
+                          len -= 3;
+                        }
+                        if (len) {
+                          output[_out++] = from_source[from++];
+                          if (len > 1) {
+                            output[_out++] = from_source[from++];
+                          }
+                        }
+                      } else {
+                        from = _out - dist;
+                        do {
+                          output[_out++] = output[from++];
+                          output[_out++] = output[from++];
+                          output[_out++] = output[from++];
+                          len -= 3;
+                        } while (len > 2);
+                        if (len) {
+                          output[_out++] = output[from++];
+                          if (len > 1) {
+                            output[_out++] = output[from++];
+                          }
+                        }
+                      }
+                    } else if ((op & 64) === 0) {
+                      here = dcode[(here & 65535) + (hold & (1 << op) - 1)];
+                      continue dodist;
+                    } else {
+                      strm.msg = "invalid distance code";
+                      state.mode = BAD;
+                      break top;
+                    }
+                    break;
+                  }
+                } else if ((op & 64) === 0) {
+                  here = lcode[(here & 65535) + (hold & (1 << op) - 1)];
+                  continue dolen;
+                } else if (op & 32) {
+                  state.mode = TYPE;
+                  break top;
+                } else {
+                  strm.msg = "invalid literal/length code";
+                  state.mode = BAD;
+                  break top;
+                }
+                break;
+              }
+            } while (_in < last && _out < end);
+            len = bits >> 3;
+            _in -= len;
+            bits -= len << 3;
+            hold &= (1 << bits) - 1;
+            strm.next_in = _in;
+            strm.next_out = _out;
+            strm.avail_in = _in < last ? 5 + (last - _in) : 5 - (_in - last);
+            strm.avail_out = _out < end ? 257 + (end - _out) : 257 - (_out - end);
+            state.hold = hold;
+            state.bits = bits;
+            return;
+          };
+        },
+        {}
+      ],
+      8: [
+        function(require2, module3, exports3) {
+          "use strict";
+          var utils = require2("../utils/common");
+          var adler32 = require2("./adler32");
+          var crc32 = require2("./crc32");
+          var inflate_fast = require2("./inffast");
+          var inflate_table = require2("./inftrees");
+          var CODES = 0;
+          var LENS = 1;
+          var DISTS = 2;
+          var Z_FINISH = 4;
+          var Z_BLOCK = 5;
+          var Z_TREES = 6;
+          var Z_OK = 0;
+          var Z_STREAM_END = 1;
+          var Z_NEED_DICT = 2;
+          var Z_STREAM_ERROR = -2;
+          var Z_DATA_ERROR = -3;
+          var Z_MEM_ERROR = -4;
+          var Z_BUF_ERROR = -5;
+          var Z_DEFLATED = 8;
+          var HEAD = 1;
+          var FLAGS = 2;
+          var TIME = 3;
+          var OS = 4;
+          var EXLEN = 5;
+          var EXTRA = 6;
+          var NAME = 7;
+          var COMMENT = 8;
+          var HCRC = 9;
+          var DICTID = 10;
+          var DICT = 11;
+          var TYPE = 12;
+          var TYPEDO = 13;
+          var STORED = 14;
+          var COPY_ = 15;
+          var COPY = 16;
+          var TABLE = 17;
+          var LENLENS = 18;
+          var CODELENS = 19;
+          var LEN_ = 20;
+          var LEN = 21;
+          var LENEXT = 22;
+          var DIST = 23;
+          var DISTEXT = 24;
+          var MATCH = 25;
+          var LIT = 26;
+          var CHECK = 27;
+          var LENGTH = 28;
+          var DONE = 29;
+          var BAD = 30;
+          var MEM = 31;
+          var SYNC = 32;
+          var ENOUGH_LENS = 852;
+          var ENOUGH_DISTS = 592;
+          var MAX_WBITS = 15;
+          var DEF_WBITS = MAX_WBITS;
+          function zswap32(q) {
+            return (q >>> 24 & 255) + (q >>> 8 & 65280) + ((q & 65280) << 8) + ((q & 255) << 24);
+          }
+          function InflateState() {
+            this.mode = 0;
+            this.last = false;
+            this.wrap = 0;
+            this.havedict = false;
+            this.flags = 0;
+            this.dmax = 0;
+            this.check = 0;
+            this.total = 0;
+            this.head = null;
+            this.wbits = 0;
+            this.wsize = 0;
+            this.whave = 0;
+            this.wnext = 0;
+            this.window = null;
+            this.hold = 0;
+            this.bits = 0;
+            this.length = 0;
+            this.offset = 0;
+            this.extra = 0;
+            this.lencode = null;
+            this.distcode = null;
+            this.lenbits = 0;
+            this.distbits = 0;
+            this.ncode = 0;
+            this.nlen = 0;
+            this.ndist = 0;
+            this.have = 0;
+            this.next = null;
+            this.lens = new utils.Buf16(
+              320
+            );
+            this.work = new utils.Buf16(
+              288
+            );
+            this.lendyn = null;
+            this.distdyn = null;
+            this.sane = 0;
+            this.back = 0;
+            this.was = 0;
+          }
+          function inflateResetKeep(strm) {
+            var state;
+            if (!strm || !strm.state) {
+              return Z_STREAM_ERROR;
+            }
+            state = strm.state;
+            strm.total_in = strm.total_out = state.total = 0;
+            strm.msg = "";
+            if (state.wrap) {
+              strm.adler = state.wrap & 1;
+            }
+            state.mode = HEAD;
+            state.last = 0;
+            state.havedict = 0;
+            state.dmax = 32768;
+            state.head = null;
+            state.hold = 0;
+            state.bits = 0;
+            state.lencode = state.lendyn = new utils.Buf32(
+              ENOUGH_LENS
+            );
+            state.distcode = state.distdyn = new utils.Buf32(
+              ENOUGH_DISTS
+            );
+            state.sane = 1;
+            state.back = -1;
+            return Z_OK;
+          }
+          function inflateReset(strm) {
+            var state;
+            if (!strm || !strm.state) {
+              return Z_STREAM_ERROR;
+            }
+            state = strm.state;
+            state.wsize = 0;
+            state.whave = 0;
+            state.wnext = 0;
+            return inflateResetKeep(strm);
+          }
+          function inflateReset2(strm, windowBits) {
+            var wrap;
+            var state;
+            if (!strm || !strm.state) {
+              return Z_STREAM_ERROR;
+            }
+            state = strm.state;
+            if (windowBits < 0) {
+              wrap = 0;
+              windowBits = -windowBits;
+            } else {
+              wrap = (windowBits >> 4) + 1;
+              if (windowBits < 48) {
+                windowBits &= 15;
+              }
+            }
+            if (windowBits && (windowBits < 8 || windowBits > 15)) {
+              return Z_STREAM_ERROR;
+            }
+            if (state.window !== null && state.wbits !== windowBits) {
+              state.window = null;
+            }
+            state.wrap = wrap;
+            state.wbits = windowBits;
+            return inflateReset(strm);
+          }
+          function inflateInit2(strm, windowBits) {
+            var ret;
+            var state;
+            if (!strm) {
+              return Z_STREAM_ERROR;
+            }
+            state = new InflateState();
+            strm.state = state;
+            state.window = null;
+            ret = inflateReset2(strm, windowBits);
+            if (ret !== Z_OK) {
+              strm.state = null;
+            }
+            return ret;
+          }
+          function inflateInit(strm) {
+            return inflateInit2(strm, DEF_WBITS);
+          }
+          var virgin = true;
+          var lenfix, distfix;
+          function fixedtables(state) {
+            if (virgin) {
+              var sym;
+              lenfix = new utils.Buf32(512);
+              distfix = new utils.Buf32(32);
+              sym = 0;
+              while (sym < 144) {
+                state.lens[sym++] = 8;
+              }
+              while (sym < 256) {
+                state.lens[sym++] = 9;
+              }
+              while (sym < 280) {
+                state.lens[sym++] = 7;
+              }
+              while (sym < 288) {
+                state.lens[sym++] = 8;
+              }
+              inflate_table(
+                LENS,
+                state.lens,
+                0,
+                288,
+                lenfix,
+                0,
+                state.work,
+                { bits: 9 }
+              );
+              sym = 0;
+              while (sym < 32) {
+                state.lens[sym++] = 5;
+              }
+              inflate_table(
+                DISTS,
+                state.lens,
+                0,
+                32,
+                distfix,
+                0,
+                state.work,
+                { bits: 5 }
+              );
+              virgin = false;
+            }
+            state.lencode = lenfix;
+            state.lenbits = 9;
+            state.distcode = distfix;
+            state.distbits = 5;
+          }
+          function updatewindow(strm, src, end, copy) {
+            var dist;
+            var state = strm.state;
+            if (state.window === null) {
+              state.wsize = 1 << state.wbits;
+              state.wnext = 0;
+              state.whave = 0;
+              state.window = new utils.Buf8(state.wsize);
+            }
+            if (copy >= state.wsize) {
+              utils.arraySet(
+                state.window,
+                src,
+                end - state.wsize,
+                state.wsize,
+                0
+              );
+              state.wnext = 0;
+              state.whave = state.wsize;
+            } else {
+              dist = state.wsize - state.wnext;
+              if (dist > copy) {
+                dist = copy;
+              }
+              utils.arraySet(
+                state.window,
+                src,
+                end - copy,
+                dist,
+                state.wnext
+              );
+              copy -= dist;
+              if (copy) {
+                utils.arraySet(
+                  state.window,
+                  src,
+                  end - copy,
+                  copy,
+                  0
+                );
+                state.wnext = copy;
+                state.whave = state.wsize;
+              } else {
+                state.wnext += dist;
+                if (state.wnext === state.wsize) {
+                  state.wnext = 0;
+                }
+                if (state.whave < state.wsize) {
+                  state.whave += dist;
+                }
+              }
+            }
+            return 0;
+          }
+          function inflate(strm, flush) {
+            var state;
+            var input, output;
+            var next;
+            var put;
+            var have, left;
+            var hold;
+            var bits;
+            var _in, _out;
+            var copy;
+            var from;
+            var from_source;
+            var here = 0;
+            var here_bits, here_op, here_val;
+            var last_bits, last_op, last_val;
+            var len;
+            var ret;
+            var hbuf = new utils.Buf8(
+              4
+            );
+            var opts;
+            var n;
+            var order = (
+              /* permutation of code lengths */
+              [
+                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 || !strm.input && strm.avail_in !== 0) {
+              return Z_STREAM_ERROR;
+            }
+            state = strm.state;
+            if (state.mode === TYPE) {
+              state.mode = TYPEDO;
+            }
+            put = strm.next_out;
+            output = strm.output;
+            left = strm.avail_out;
+            next = strm.next_in;
+            input = strm.input;
+            have = strm.avail_in;
+            hold = state.hold;
+            bits = state.bits;
+            _in = have;
+            _out = left;
+            ret = Z_OK;
+            inf_leave: for (; ; ) {
+              switch (state.mode) {
+                case HEAD:
+                  if (state.wrap === 0) {
+                    state.mode = TYPEDO;
+                    break;
+                  }
+                  while (bits < 16) {
+                    if (have === 0) {
+                      break inf_leave;
+                    }
+                    have--;
+                    hold += input[next++] << bits;
+                    bits += 8;
+                  }
+                  if (state.wrap & 2 && hold === 35615) {
+                    state.check = 0;
+                    hbuf[0] = hold & 255;
+                    hbuf[1] = hold >>> 8 & 255;
+                    state.check = crc32(
+                      state.check,
+                      hbuf,
+                      2,
+                      0
+                    );
+                    hold = 0;
+                    bits = 0;
+                    state.mode = FLAGS;
+                    break;
+                  }
+                  state.flags = 0;
+                  if (state.head) {
+                    state.head.done = false;
+                  }
+                  if (!(state.wrap & 1) || (((hold & 255) << 8) + (hold >> 8)) % 31) {
+                    strm.msg = "incorrect header check";
+                    state.mode = BAD;
+                    break;
+                  }
+                  if ((hold & 15) !== Z_DEFLATED) {
+                    strm.msg = "unknown compression method";
+                    state.mode = BAD;
+                    break;
+                  }
+                  hold >>>= 4;
+                  bits -= 4;
+                  len = (hold & 15) + 8;
+                  if (state.wbits === 0) {
+                    state.wbits = len;
+                  } else if (len > state.wbits) {
+                    strm.msg = "invalid window size";
+                    state.mode = BAD;
+                    break;
+                  }
+                  state.dmax = 1 << len;
+                  strm.adler = state.check = 1;
+                  state.mode = hold & 512 ? DICTID : TYPE;
+                  hold = 0;
+                  bits = 0;
+                  break;
+                case FLAGS:
+                  while (bits < 16) {
+                    if (have === 0) {
+                      break inf_leave;
+                    }
+                    have--;
+                    hold += input[next++] << bits;
+                    bits += 8;
+                  }
+                  state.flags = hold;
+                  if ((state.flags & 255) !== Z_DEFLATED) {
+                    strm.msg = "unknown compression method";
+                    state.mode = BAD;
+                    break;
+                  }
+                  if (state.flags & 57344) {
+                    strm.msg = "unknown header flags set";
+                    state.mode = BAD;
+                    break;
+                  }
+                  if (state.head) {
+                    state.head.text = hold >> 8 & 1;
+                  }
+                  if (state.flags & 512) {
+                    hbuf[0] = hold & 255;
+                    hbuf[1] = hold >>> 8 & 255;
+                    state.check = crc32(
+                      state.check,
+                      hbuf,
+                      2,
+                      0
+                    );
+                  }
+                  hold = 0;
+                  bits = 0;
+                  state.mode = TIME;
+                /* falls through */
+                case TIME:
+                  while (bits < 32) {
+                    if (have === 0) {
+                      break inf_leave;
+                    }
+                    have--;
+                    hold += input[next++] << bits;
+                    bits += 8;
+                  }
+                  if (state.head) {
+                    state.head.time = hold;
+                  }
+                  if (state.flags & 512) {
+                    hbuf[0] = hold & 255;
+                    hbuf[1] = hold >>> 8 & 255;
+                    hbuf[2] = hold >>> 16 & 255;
+                    hbuf[3] = hold >>> 24 & 255;
+                    state.check = crc32(
+                      state.check,
+                      hbuf,
+                      4,
+                      0
+                    );
+                  }
+                  hold = 0;
+                  bits = 0;
+                  state.mode = OS;
+                /* falls through */
+                case OS:
+                  while (bits < 16) {
+                    if (have === 0) {
+                      break inf_leave;
+                    }
+                    have--;
+                    hold += input[next++] << bits;
+                    bits += 8;
+                  }
+                  if (state.head) {
+                    state.head.xflags = hold & 255;
+                    state.head.os = hold >> 8;
+                  }
+                  if (state.flags & 512) {
+                    hbuf[0] = hold & 255;
+                    hbuf[1] = hold >>> 8 & 255;
+                    state.check = crc32(
+                      state.check,
+                      hbuf,
+                      2,
+                      0
+                    );
+                  }
+                  hold = 0;
+                  bits = 0;
+                  state.mode = EXLEN;
+                /* falls through */
+                case EXLEN:
+                  if (state.flags & 1024) {
+                    while (bits < 16) {
+                      if (have === 0) {
+                        break inf_leave;
+                      }
+                      have--;
+                      hold += input[next++] << bits;
+                      bits += 8;
+                    }
+                    state.length = hold;
+                    if (state.head) {
+                      state.head.extra_len = hold;
+                    }
+                    if (state.flags & 512) {
+                      hbuf[0] = hold & 255;
+                      hbuf[1] = hold >>> 8 & 255;
+                      state.check = crc32(
+                        state.check,
+                        hbuf,
+                        2,
+                        0
+                      );
+                    }
+                    hold = 0;
+                    bits = 0;
+                  } else if (state.head) {
+                    state.head.extra = null;
+                  }
+                  state.mode = EXTRA;
+                /* falls through */
+                case EXTRA:
+                  if (state.flags & 1024) {
+                    copy = state.length;
+                    if (copy > have) {
+                      copy = have;
+                    }
+                    if (copy) {
+                      if (state.head) {
+                        len = state.head.extra_len - state.length;
+                        if (!state.head.extra) {
+                          state.head.extra = new Array(
+                            state.head.extra_len
+                          );
+                        }
+                        utils.arraySet(
+                          state.head.extra,
+                          input,
+                          next,
+                          // extra field is limited to 65536 bytes
+                          // - no need for additional size check
+                          copy,
+                          /*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/
+                          len
+                        );
+                      }
+                      if (state.flags & 512) {
+                        state.check = crc32(
+                          state.check,
+                          input,
+                          copy,
+                          next
+                        );
+                      }
+                      have -= copy;
+                      next += copy;
+                      state.length -= copy;
+                    }
+                    if (state.length) {
+                      break inf_leave;
+                    }
+                  }
+                  state.length = 0;
+                  state.mode = NAME;
+                /* falls through */
+                case NAME:
+                  if (state.flags & 2048) {
+                    if (have === 0) {
+                      break inf_leave;
+                    }
+                    copy = 0;
+                    do {
+                      len = input[next + copy++];
+                      if (state.head && len && state.length < 65536) {
+                        state.head.name += String.fromCharCode(len);
+                      }
+                    } while (len && copy < have);
+                    if (state.flags & 512) {
+                      state.check = crc32(
+                        state.check,
+                        input,
+                        copy,
+                        next
+                      );
+                    }
+                    have -= copy;
+                    next += copy;
+                    if (len) {
+                      break inf_leave;
+                    }
+                  } else if (state.head) {
+                    state.head.name = null;
+                  }
+                  state.length = 0;
+                  state.mode = COMMENT;
+                /* falls through */
+                case COMMENT:
+                  if (state.flags & 4096) {
+                    if (have === 0) {
+                      break inf_leave;
+                    }
+                    copy = 0;
+                    do {
+                      len = input[next + copy++];
+                      if (state.head && len && state.length < 65536) {
+                        state.head.comment += String.fromCharCode(len);
+                      }
+                    } while (len && copy < have);
+                    if (state.flags & 512) {
+                      state.check = crc32(
+                        state.check,
+                        input,
+                        copy,
+                        next
+                      );
+                    }
+                    have -= copy;
+                    next += copy;
+                    if (len) {
+                      break inf_leave;
+                    }
+                  } else if (state.head) {
+                    state.head.comment = null;
+                  }
+                  state.mode = HCRC;
+                /* falls through */
+                case HCRC:
+                  if (state.flags & 512) {
+                    while (bits < 16) {
+                      if (have === 0) {
+                        break inf_leave;
+                      }
+                      have--;
+                      hold += input[next++] << bits;
+                      bits += 8;
+                    }
+                    if (hold !== (state.check & 65535)) {
+                      strm.msg = "header crc mismatch";
+                      state.mode = BAD;
+                      break;
+                    }
+                    hold = 0;
+                    bits = 0;
+                  }
+                  if (state.head) {
+                    state.head.hcrc = state.flags >> 9 & 1;
+                    state.head.done = true;
+                  }
+                  strm.adler = state.check = 0;
+                  state.mode = TYPE;
+                  break;
+                case DICTID:
+                  while (bits < 32) {
+                    if (have === 0) {
+                      break inf_leave;
+                    }
+                    have--;
+                    hold += input[next++] << bits;
+                    bits += 8;
+                  }
+                  strm.adler = state.check = zswap32(hold);
+                  hold = 0;
+                  bits = 0;
+                  state.mode = DICT;
+                /* falls through */
+                case DICT:
+                  if (state.havedict === 0) {
+                    strm.next_out = put;
+                    strm.avail_out = left;
+                    strm.next_in = next;
+                    strm.avail_in = have;
+                    state.hold = hold;
+                    state.bits = bits;
+                    return Z_NEED_DICT;
+                  }
+                  strm.adler = state.check = 1;
+                  state.mode = TYPE;
+                /* falls through */
+                case TYPE:
+                  if (flush === Z_BLOCK || flush === Z_TREES) {
+                    break inf_leave;
+                  }
+                /* falls through */
+                case TYPEDO:
+                  if (state.last) {
+                    hold >>>= bits & 7;
+                    bits -= bits & 7;
+                    state.mode = CHECK;
+                    break;
+                  }
+                  while (bits < 3) {
+                    if (have === 0) {
+                      break inf_leave;
+                    }
+                    have--;
+                    hold += input[next++] << bits;
+                    bits += 8;
+                  }
+                  state.last = hold & 1;
+                  hold >>>= 1;
+                  bits -= 1;
+                  switch (hold & 3) {
+                    case 0:
+                      state.mode = STORED;
+                      break;
+                    case 1:
+                      fixedtables(state);
+                      state.mode = LEN_;
+                      if (flush === Z_TREES) {
+                        hold >>>= 2;
+                        bits -= 2;
+                        break inf_leave;
+                      }
+                      break;
+                    case 2:
+                      state.mode = TABLE;
+                      break;
+                    case 3:
+                      strm.msg = "invalid block type";
+                      state.mode = BAD;
+                  }
+                  hold >>>= 2;
+                  bits -= 2;
+                  break;
+                case STORED:
+                  hold >>>= bits & 7;
+                  bits -= bits & 7;
+                  while (bits < 32) {
+                    if (have === 0) {
+                      break inf_leave;
+                    }
+                    have--;
+                    hold += input[next++] << bits;
+                    bits += 8;
+                  }
+                  if ((hold & 65535) !== (hold >>> 16 ^ 65535)) {
+                    strm.msg = "invalid stored block lengths";
+                    state.mode = BAD;
+                    break;
+                  }
+                  state.length = hold & 65535;
+                  hold = 0;
+                  bits = 0;
+                  state.mode = COPY_;
+                  if (flush === Z_TREES) {
+                    break inf_leave;
+                  }
+                /* falls through */
+                case COPY_:
+                  state.mode = COPY;
+                /* falls through */
+                case COPY:
+                  copy = state.length;
+                  if (copy) {
+                    if (copy > have) {
+                      copy = have;
+                    }
+                    if (copy > left) {
+                      copy = left;
+                    }
+                    if (copy === 0) {
+                      break inf_leave;
+                    }
+                    utils.arraySet(
+                      output,
+                      input,
+                      next,
+                      copy,
+                      put
+                    );
+                    have -= copy;
+                    next += copy;
+                    left -= copy;
+                    put += copy;
+                    state.length -= copy;
+                    break;
+                  }
+                  state.mode = TYPE;
+                  break;
+                case TABLE:
+                  while (bits < 14) {
+                    if (have === 0) {
+                      break inf_leave;
+                    }
+                    have--;
+                    hold += input[next++] << bits;
+                    bits += 8;
+                  }
+                  state.nlen = (hold & 31) + 257;
+                  hold >>>= 5;
+                  bits -= 5;
+                  state.ndist = (hold & 31) + 1;
+                  hold >>>= 5;
+                  bits -= 5;
+                  state.ncode = (hold & 15) + 4;
+                  hold >>>= 4;
+                  bits -= 4;
+                  if (state.nlen > 286 || state.ndist > 30) {
+                    strm.msg = "too many length or distance symbols";
+                    state.mode = BAD;
+                    break;
+                  }
+                  state.have = 0;
+                  state.mode = LENLENS;
+                /* falls through */
+                case LENLENS:
+                  while (state.have < state.ncode) {
+                    while (bits < 3) {
+                      if (have === 0) {
+                        break inf_leave;
+                      }
+                      have--;
+                      hold += input[next++] << bits;
+                      bits += 8;
+                    }
+                    state.lens[order[state.have++]] = hold & 7;
+                    hold >>>= 3;
+                    bits -= 3;
+                  }
+                  while (state.have < 19) {
+                    state.lens[order[state.have++]] = 0;
+                  }
+                  state.lencode = state.lendyn;
+                  state.lenbits = 7;
+                  opts = { bits: state.lenbits };
+                  ret = inflate_table(
+                    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;
+                    break;
+                  }
+                  state.have = 0;
+                  state.mode = CODELENS;
+                /* falls through */
+                case CODELENS:
+                  while (state.have < state.nlen + state.ndist) {
+                    for (; ; ) {
+                      here = state.lencode[hold & (1 << state.lenbits) - 1];
+                      here_bits = here >>> 24;
+                      here_op = here >>> 16 & 255;
+                      here_val = here & 65535;
+                      if (here_bits <= bits) {
+                        break;
+                      }
+                      if (have === 0) {
+                        break inf_leave;
+                      }
+                      have--;
+                      hold += input[next++] << bits;
+                      bits += 8;
+                    }
+                    if (here_val < 16) {
+                      hold >>>= here_bits;
+                      bits -= here_bits;
+                      state.lens[state.have++] = here_val;
+                    } else {
+                      if (here_val === 16) {
+                        n = here_bits + 2;
+                        while (bits < n) {
+                          if (have === 0) {
+                            break inf_leave;
+                          }
+                          have--;
+                          hold += input[next++] << bits;
+                          bits += 8;
+                        }
+                        hold >>>= here_bits;
+                        bits -= here_bits;
+                        if (state.have === 0) {
+                          strm.msg = "invalid bit length repeat";
+                          state.mode = BAD;
+                          break;
+                        }
+                        len = state.lens[state.have - 1];
+                        copy = 3 + (hold & 3);
+                        hold >>>= 2;
+                        bits -= 2;
+                      } else if (here_val === 17) {
+                        n = here_bits + 3;
+                        while (bits < n) {
+                          if (have === 0) {
+                            break inf_leave;
+                          }
+                          have--;
+                          hold += input[next++] << bits;
+                          bits += 8;
+                        }
+                        hold >>>= here_bits;
+                        bits -= here_bits;
+                        len = 0;
+                        copy = 3 + (hold & 7);
+                        hold >>>= 3;
+                        bits -= 3;
+                      } else {
+                        n = here_bits + 7;
+                        while (bits < n) {
+                          if (have === 0) {
+                            break inf_leave;
+                          }
+                          have--;
+                          hold += input[next++] << bits;
+                          bits += 8;
+                        }
+                        hold >>>= here_bits;
+                        bits -= here_bits;
+                        len = 0;
+                        copy = 11 + (hold & 127);
+                        hold >>>= 7;
+                        bits -= 7;
+                      }
+                      if (state.have + copy > state.nlen + state.ndist) {
+                        strm.msg = "invalid bit length repeat";
+                        state.mode = BAD;
+                        break;
+                      }
+                      while (copy--) {
+                        state.lens[state.have++] = len;
+                      }
+                    }
+                  }
+                  if (state.mode === BAD) {
+                    break;
+                  }
+                  if (state.lens[256] === 0) {
+                    strm.msg = "invalid code -- missing end-of-block";
+                    state.mode = BAD;
+                    break;
+                  }
+                  state.lenbits = 9;
+                  opts = { bits: state.lenbits };
+                  ret = inflate_table(
+                    LENS,
+                    state.lens,
+                    0,
+                    state.nlen,
+                    state.lencode,
+                    0,
+                    state.work,
+                    opts
+                  );
+                  state.lenbits = opts.bits;
+                  if (ret) {
+                    strm.msg = "invalid literal/lengths set";
+                    state.mode = BAD;
+                    break;
+                  }
+                  state.distbits = 6;
+                  state.distcode = state.distdyn;
+                  opts = { bits: state.distbits };
+                  ret = inflate_table(
+                    DISTS,
+                    state.lens,
+                    state.nlen,
+                    state.ndist,
+                    state.distcode,
+                    0,
+                    state.work,
+                    opts
+                  );
+                  state.distbits = opts.bits;
+                  if (ret) {
+                    strm.msg = "invalid distances set";
+                    state.mode = BAD;
+                    break;
+                  }
+                  state.mode = LEN_;
+                  if (flush === Z_TREES) {
+                    break inf_leave;
+                  }
+                /* falls through */
+                case LEN_:
+                  state.mode = LEN;
+                /* falls through */
+                case LEN:
+                  if (have >= 6 && left >= 258) {
+                    strm.next_out = put;
+                    strm.avail_out = left;
+                    strm.next_in = next;
+                    strm.avail_in = have;
+                    state.hold = hold;
+                    state.bits = bits;
+                    inflate_fast(strm, _out);
+                    put = strm.next_out;
+                    output = strm.output;
+                    left = strm.avail_out;
+                    next = strm.next_in;
+                    input = strm.input;
+                    have = strm.avail_in;
+                    hold = state.hold;
+                    bits = state.bits;
+                    if (state.mode === TYPE) {
+                      state.back = -1;
+                    }
+                    break;
+                  }
+                  state.back = 0;
+                  for (; ; ) {
+                    here = state.lencode[hold & (1 << state.lenbits) - 1];
+                    here_bits = here >>> 24;
+                    here_op = here >>> 16 & 255;
+                    here_val = here & 65535;
+                    if (here_bits <= bits) {
+                      break;
+                    }
+                    if (have === 0) {
+                      break inf_leave;
+                    }
+                    have--;
+                    hold += input[next++] << bits;
+                    bits += 8;
+                  }
+                  if (here_op && (here_op & 240) === 0) {
+                    last_bits = here_bits;
+                    last_op = here_op;
+                    last_val = here_val;
+                    for (; ; ) {
+                      here = state.lencode[last_val + ((hold & (1 << last_bits + last_op) - 1) >> last_bits)];
+                      here_bits = here >>> 24;
+                      here_op = here >>> 16 & 255;
+                      here_val = here & 65535;
+                      if (last_bits + here_bits <= bits) {
+                        break;
+                      }
+                      if (have === 0) {
+                        break inf_leave;
+                      }
+                      have--;
+                      hold += input[next++] << bits;
+                      bits += 8;
+                    }
+                    hold >>>= last_bits;
+                    bits -= last_bits;
+                    state.back += last_bits;
+                  }
+                  hold >>>= here_bits;
+                  bits -= here_bits;
+                  state.back += here_bits;
+                  state.length = here_val;
+                  if (here_op === 0) {
+                    state.mode = LIT;
+                    break;
+                  }
+                  if (here_op & 32) {
+                    state.back = -1;
+                    state.mode = TYPE;
+                    break;
+                  }
+                  if (here_op & 64) {
+                    strm.msg = "invalid literal/length code";
+                    state.mode = BAD;
+                    break;
+                  }
+                  state.extra = here_op & 15;
+                  state.mode = LENEXT;
+                /* falls through */
+                case LENEXT:
+                  if (state.extra) {
+                    n = state.extra;
+                    while (bits < n) {
+                      if (have === 0) {
+                        break inf_leave;
+                      }
+                      have--;
+                      hold += input[next++] << bits;
+                      bits += 8;
+                    }
+                    state.length += hold & (1 << state.extra) - 1;
+                    hold >>>= state.extra;
+                    bits -= state.extra;
+                    state.back += state.extra;
+                  }
+                  state.was = state.length;
+                  state.mode = DIST;
+                /* falls through */
+                case DIST:
+                  for (; ; ) {
+                    here = state.distcode[hold & (1 << state.distbits) - 1];
+                    here_bits = here >>> 24;
+                    here_op = here >>> 16 & 255;
+                    here_val = here & 65535;
+                    if (here_bits <= bits) {
+                      break;
+                    }
+                    if (have === 0) {
+                      break inf_leave;
+                    }
+                    have--;
+                    hold += input[next++] << bits;
+                    bits += 8;
+                  }
+                  if ((here_op & 240) === 0) {
+                    last_bits = here_bits;
+                    last_op = here_op;
+                    last_val = here_val;
+                    for (; ; ) {
+                      here = state.distcode[last_val + ((hold & (1 << last_bits + last_op) - 1) >> last_bits)];
+                      here_bits = here >>> 24;
+                      here_op = here >>> 16 & 255;
+                      here_val = here & 65535;
+                      if (last_bits + here_bits <= bits) {
+                        break;
+                      }
+                      if (have === 0) {
+                        break inf_leave;
+                      }
+                      have--;
+                      hold += input[next++] << bits;
+                      bits += 8;
+                    }
+                    hold >>>= last_bits;
+                    bits -= last_bits;
+                    state.back += last_bits;
+                  }
+                  hold >>>= here_bits;
+                  bits -= here_bits;
+                  state.back += here_bits;
+                  if (here_op & 64) {
+                    strm.msg = "invalid distance code";
+                    state.mode = BAD;
+                    break;
+                  }
+                  state.offset = here_val;
+                  state.extra = here_op & 15;
+                  state.mode = DISTEXT;
+                /* falls through */
+                case DISTEXT:
+                  if (state.extra) {
+                    n = state.extra;
+                    while (bits < n) {
+                      if (have === 0) {
+                        break inf_leave;
+                      }
+                      have--;
+                      hold += input[next++] << bits;
+                      bits += 8;
+                    }
+                    state.offset += hold & (1 << state.extra) - 1;
+                    hold >>>= state.extra;
+                    bits -= state.extra;
+                    state.back += state.extra;
+                  }
+                  if (state.offset > state.dmax) {
+                    strm.msg = "invalid distance too far back";
+                    state.mode = BAD;
+                    break;
+                  }
+                  state.mode = MATCH;
+                /* falls through */
+                case MATCH:
+                  if (left === 0) {
+                    break inf_leave;
+                  }
+                  copy = _out - left;
+                  if (state.offset > copy) {
+                    copy = state.offset - copy;
+                    if (copy > state.whave) {
+                      if (state.sane) {
+                        strm.msg = "invalid distance too far back";
+                        state.mode = BAD;
+                        break;
+                      }
+                    }
+                    if (copy > state.wnext) {
+                      copy -= state.wnext;
+                      from = state.wsize - copy;
+                    } else {
+                      from = state.wnext - copy;
+                    }
+                    if (copy > state.length) {
+                      copy = state.length;
+                    }
+                    from_source = state.window;
+                  } else {
+                    from_source = output;
+                    from = put - state.offset;
+                    copy = state.length;
+                  }
+                  if (copy > left) {
+                    copy = left;
+                  }
+                  left -= copy;
+                  state.length -= copy;
+                  do {
+                    output[put++] = from_source[from++];
+                  } while (--copy);
+                  if (state.length === 0) {
+                    state.mode = LEN;
+                  }
+                  break;
+                case LIT:
+                  if (left === 0) {
+                    break inf_leave;
+                  }
+                  output[put++] = state.length;
+                  left--;
+                  state.mode = LEN;
+                  break;
+                case CHECK:
+                  if (state.wrap) {
+                    while (bits < 32) {
+                      if (have === 0) {
+                        break inf_leave;
+                      }
+                      have--;
+                      hold |= input[next++] << bits;
+                      bits += 8;
+                    }
+                    _out -= left;
+                    strm.total_out += _out;
+                    state.total += _out;
+                    if (_out) {
+                      strm.adler = state.check = /*UPDATE(state.check, put - _out, _out);*/
+                      state.flags ? crc32(
+                        state.check,
+                        output,
+                        _out,
+                        put - _out
+                      ) : adler32(
+                        state.check,
+                        output,
+                        _out,
+                        put - _out
+                      );
+                    }
+                    _out = left;
+                    if ((state.flags ? hold : zswap32(hold)) !== state.check) {
+                      strm.msg = "incorrect data check";
+                      state.mode = BAD;
+                      break;
+                    }
+                    hold = 0;
+                    bits = 0;
+                  }
+                  state.mode = LENGTH;
+                /* falls through */
+                case LENGTH:
+                  if (state.wrap && state.flags) {
+                    while (bits < 32) {
+                      if (have === 0) {
+                        break inf_leave;
+                      }
+                      have--;
+                      hold += input[next++] << bits;
+                      bits += 8;
+                    }
+                    if (hold !== (state.total & 4294967295)) {
+                      strm.msg = "incorrect length check";
+                      state.mode = BAD;
+                      break;
+                    }
+                    hold = 0;
+                    bits = 0;
+                  }
+                  state.mode = DONE;
+                /* falls through */
+                case DONE:
+                  ret = Z_STREAM_END;
+                  break inf_leave;
+                case BAD:
+                  ret = Z_DATA_ERROR;
+                  break inf_leave;
+                case MEM:
+                  return Z_MEM_ERROR;
+                case SYNC:
+                /* falls through */
+                default:
+                  return Z_STREAM_ERROR;
+              }
+            }
+            strm.next_out = put;
+            strm.avail_out = left;
+            strm.next_in = next;
+            strm.avail_in = have;
+            state.hold = hold;
+            state.bits = bits;
+            if (state.wsize || _out !== strm.avail_out && state.mode < BAD && (state.mode < CHECK || flush !== Z_FINISH)) {
+              if (updatewindow(
+                strm,
+                strm.output,
+                strm.next_out,
+                _out - strm.avail_out
+              )) {
+                state.mode = MEM;
+                return Z_MEM_ERROR;
+              }
+            }
+            _in -= strm.avail_in;
+            _out -= strm.avail_out;
+            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);*/
+              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) + (state.mode === TYPE ? 128 : 0) + (state.mode === LEN_ || state.mode === COPY_ ? 256 : 0);
+            if ((_in === 0 && _out === 0 || flush === Z_FINISH) && ret === Z_OK) {
+              ret = Z_BUF_ERROR;
+            }
+            return ret;
+          }
+          function inflateEnd(strm) {
+            if (!strm || !strm.state) {
+              return Z_STREAM_ERROR;
+            }
+            var state = strm.state;
+            if (state.window) {
+              state.window = null;
+            }
+            strm.state = null;
+            return Z_OK;
+          }
+          function inflateGetHeader(strm, head) {
+            var state;
+            if (!strm || !strm.state) {
+              return Z_STREAM_ERROR;
+            }
+            state = strm.state;
+            if ((state.wrap & 2) === 0) {
+              return Z_STREAM_ERROR;
+            }
+            state.head = head;
+            head.done = false;
+            return Z_OK;
+          }
+          function inflateSetDictionary(strm, dictionary) {
+            var dictLength = dictionary.length;
+            var state;
+            var dictid;
+            var ret;
+            if (!strm || !strm.state) {
+              return Z_STREAM_ERROR;
+            }
+            state = strm.state;
+            if (state.wrap !== 0 && state.mode !== DICT) {
+              return Z_STREAM_ERROR;
+            }
+            if (state.mode === DICT) {
+              dictid = 1;
+              dictid = adler32(
+                dictid,
+                dictionary,
+                dictLength,
+                0
+              );
+              if (dictid !== state.check) {
+                return Z_DATA_ERROR;
+              }
+            }
+            ret = updatewindow(
+              strm,
+              dictionary,
+              dictLength,
+              dictLength
+            );
+            if (ret) {
+              state.mode = MEM;
+              return Z_MEM_ERROR;
+            }
+            state.havedict = 1;
+            return Z_OK;
+          }
+          exports3.inflateReset = inflateReset;
+          exports3.inflateReset2 = inflateReset2;
+          exports3.inflateResetKeep = inflateResetKeep;
+          exports3.inflateInit = inflateInit;
+          exports3.inflateInit2 = inflateInit2;
+          exports3.inflate = inflate;
+          exports3.inflateEnd = inflateEnd;
+          exports3.inflateGetHeader = inflateGetHeader;
+          exports3.inflateSetDictionary = inflateSetDictionary;
+          exports3.inflateInfo = "pako inflate (from Nodeca project)";
+        },
+        {
+          "../utils/common": 1,
+          "./adler32": 3,
+          "./crc32": 5,
+          "./inffast": 7,
+          "./inftrees": 9
+        }
+      ],
+      9: [
+        function(require2, module3, exports3) {
+          "use strict";
+          var utils = require2("../utils/common");
+          var MAXBITS = 15;
+          var ENOUGH_LENS = 852;
+          var ENOUGH_DISTS = 592;
+          var CODES = 0;
+          var LENS = 1;
+          var DISTS = 2;
+          var lbase = [
+            /* Length codes 257..285 base */
+            3,
+            4,
+            5,
+            6,
+            7,
+            8,
+            9,
+            10,
+            11,
+            13,
+            15,
+            17,
+            19,
+            23,
+            27,
+            31,
+            35,
+            43,
+            51,
+            59,
+            67,
+            83,
+            99,
+            115,
+            131,
+            163,
+            195,
+            227,
+            258,
+            0,
+            0
+          ];
+          var lext = [
+            /* Length codes 257..285 extra */
+            16,
+            16,
+            16,
+            16,
+            16,
+            16,
+            16,
+            16,
+            17,
+            17,
+            17,
+            17,
+            18,
+            18,
+            18,
+            18,
+            19,
+            19,
+            19,
+            19,
+            20,
+            20,
+            20,
+            20,
+            21,
+            21,
+            21,
+            21,
+            16,
+            72,
+            78
+          ];
+          var dbase = [
+            /* Distance codes 0..29 base */
+            1,
+            2,
+            3,
+            4,
+            5,
+            7,
+            9,
+            13,
+            17,
+            25,
+            33,
+            49,
+            65,
+            97,
+            129,
+            193,
+            257,
+            385,
+            513,
+            769,
+            1025,
+            1537,
+            2049,
+            3073,
+            4097,
+            6145,
+            8193,
+            12289,
+            16385,
+            24577,
+            0,
+            0
+          ];
+          var dext = [
+            /* Distance codes 0..29 extra */
+            16,
+            16,
+            16,
+            16,
+            17,
+            17,
+            18,
+            18,
+            19,
+            19,
+            20,
+            20,
+            21,
+            21,
+            22,
+            22,
+            23,
+            23,
+            24,
+            24,
+            25,
+            25,
+            26,
+            26,
+            27,
+            27,
+            28,
+            28,
+            29,
+            29,
+            64,
+            64
+          ];
+          module3.exports = function inflate_table(type, lens, lens_index, codes, table, table_index, work, opts) {
+            var bits = opts.bits;
+            var len = 0;
+            var sym = 0;
+            var min = 0, max = 0;
+            var root = 0;
+            var curr = 0;
+            var drop = 0;
+            var left = 0;
+            var used = 0;
+            var huff = 0;
+            var incr;
+            var fill;
+            var low;
+            var mask;
+            var next;
+            var base = null;
+            var base_index = 0;
+            var end;
+            var count = new utils.Buf16(MAXBITS + 1);
+            var offs = new utils.Buf16(MAXBITS + 1);
+            var extra = null;
+            var extra_index = 0;
+            var here_bits, here_op, here_val;
+            for (len = 0; len <= MAXBITS; len++) {
+              count[len] = 0;
+            }
+            for (sym = 0; sym < codes; sym++) {
+              count[lens[lens_index + sym]]++;
+            }
+            root = bits;
+            for (max = MAXBITS; max >= 1; max--) {
+              if (count[max] !== 0) {
+                break;
+              }
+            }
+            if (root > max) {
+              root = max;
+            }
+            if (max === 0) {
+              table[table_index++] = 1 << 24 | 64 << 16 | 0;
+              table[table_index++] = 1 << 24 | 64 << 16 | 0;
+              opts.bits = 1;
+              return 0;
+            }
+            for (min = 1; min < max; min++) {
+              if (count[min] !== 0) {
+                break;
+              }
+            }
+            if (root < min) {
+              root = min;
+            }
+            left = 1;
+            for (len = 1; len <= MAXBITS; len++) {
+              left <<= 1;
+              left -= count[len];
+              if (left < 0) {
+                return -1;
+              }
+            }
+            if (left > 0 && (type === CODES || max !== 1)) {
+              return -1;
+            }
+            offs[1] = 0;
+            for (len = 1; len < MAXBITS; len++) {
+              offs[len + 1] = offs[len] + count[len];
+            }
+            for (sym = 0; sym < codes; sym++) {
+              if (lens[lens_index + sym] !== 0) {
+                work[offs[lens[lens_index + sym]]++] = sym;
+              }
+            }
+            if (type === CODES) {
+              base = extra = work;
+              end = 19;
+            } else if (type === LENS) {
+              base = lbase;
+              base_index -= 257;
+              extra = lext;
+              extra_index -= 257;
+              end = 256;
+            } else {
+              base = dbase;
+              extra = dext;
+              end = -1;
+            }
+            huff = 0;
+            sym = 0;
+            len = min;
+            next = table_index;
+            curr = root;
+            drop = 0;
+            low = -1;
+            used = 1 << root;
+            mask = used - 1;
+            if (type === LENS && used > ENOUGH_LENS || type === DISTS && used > ENOUGH_DISTS) {
+              return 1;
+            }
+            for (; ; ) {
+              here_bits = len - drop;
+              if (work[sym] < end) {
+                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 {
+                here_op = 32 + 64;
+                here_val = 0;
+              }
+              incr = 1 << len - drop;
+              fill = 1 << curr;
+              min = fill;
+              do {
+                fill -= incr;
+                table[next + (huff >> drop) + fill] = here_bits << 24 | here_op << 16 | here_val | 0;
+              } while (fill !== 0);
+              incr = 1 << len - 1;
+              while (huff & incr) {
+                incr >>= 1;
+              }
+              if (incr !== 0) {
+                huff &= incr - 1;
+                huff += incr;
+              } else {
+                huff = 0;
+              }
+              sym++;
+              if (--count[len] === 0) {
+                if (len === max) {
+                  break;
+                }
+                len = lens[lens_index + work[sym]];
+              }
+              if (len > root && (huff & mask) !== low) {
+                if (drop === 0) {
+                  drop = root;
+                }
+                next += min;
+                curr = len - drop;
+                left = 1 << curr;
+                while (curr + drop < max) {
+                  left -= count[curr + drop];
+                  if (left <= 0) {
+                    break;
+                  }
+                  curr++;
+                  left <<= 1;
+                }
+                used += 1 << curr;
+                if (type === LENS && used > ENOUGH_LENS || type === DISTS && used > ENOUGH_DISTS) {
+                  return 1;
+                }
+                low = huff & mask;
+                table[low] = root << 24 | curr << 16 | next - table_index | 0;
+              }
+            }
+            if (huff !== 0) {
+              table[next + huff] = len - drop << 24 | 64 << 16 | 0;
+            }
+            opts.bits = root;
+            return 0;
+          };
+        },
+        { "../utils/common": 1 }
+      ],
+      10: [
+        function(require2, module3, exports3) {
+          "use strict";
+          module3.exports = {
+            2: "need dictionary",
+            1: "stream end",
+            0: "",
+            "-1": "file error",
+            "-2": "stream error",
+            "-3": "data error",
+            "-4": "insufficient memory",
+            "-5": "buffer error",
+            "-6": "incompatible version"
+          };
+        },
+        {}
+      ],
+      11: [
+        function(require2, module3, exports3) {
+          "use strict";
+          function ZStream() {
+            this.input = null;
+            this.next_in = 0;
+            this.avail_in = 0;
+            this.total_in = 0;
+            this.output = null;
+            this.next_out = 0;
+            this.avail_out = 0;
+            this.total_out = 0;
+            this.msg = "";
+            this.state = null;
+            this.data_type = 2;
+            this.adler = 0;
+          }
+          module3.exports = ZStream;
+        },
+        {}
+      ],
+      "/lib/inflate.js": [
+        function(require2, module3, exports3) {
+          "use strict";
+          var zlib_inflate = require2("./zlib/inflate");
+          var utils = require2("./utils/common");
+          var strings = require2("./utils/strings");
+          var c = require2("./zlib/constants");
+          var msg = require2("./zlib/messages");
+          var ZStream = require2("./zlib/zstream");
+          var GZheader = require2("./zlib/gzheader");
+          var toString = Object.prototype.toString;
+          function Inflate(options) {
+            if (!(this instanceof Inflate))
+              return new Inflate(options);
+            this.options = utils.assign(
+              {
+                chunkSize: 16384,
+                windowBits: 0,
+                to: ""
+              },
+              options || {}
+            );
+            var opt = this.options;
+            if (opt.raw && opt.windowBits >= 0 && opt.windowBits < 16) {
+              opt.windowBits = -opt.windowBits;
+              if (opt.windowBits === 0) {
+                opt.windowBits = -15;
+              }
+            }
+            if (opt.windowBits >= 0 && opt.windowBits < 16 && !(options && options.windowBits)) {
+              opt.windowBits += 32;
+            }
+            if (opt.windowBits > 15 && opt.windowBits < 48) {
+              if ((opt.windowBits & 15) === 0) {
+                opt.windowBits |= 15;
+              }
+            }
+            this.err = 0;
+            this.msg = "";
+            this.ended = false;
+            this.chunks = [];
+            this.strm = new ZStream();
+            this.strm.avail_out = 0;
+            var status = zlib_inflate.inflateInit2(
+              this.strm,
+              opt.windowBits
+            );
+            if (status !== c.Z_OK) {
+              throw new Error(msg[status]);
+            }
+            this.header = new GZheader();
+            zlib_inflate.inflateGetHeader(this.strm, this.header);
+            if (opt.dictionary) {
+              if (typeof opt.dictionary === "string") {
+                opt.dictionary = strings.string2buf(
+                  opt.dictionary
+                );
+              } else if (toString.call(opt.dictionary) === "[object ArrayBuffer]") {
+                opt.dictionary = new Uint8Array(
+                  opt.dictionary
+                );
+              }
+              if (opt.raw) {
+                status = zlib_inflate.inflateSetDictionary(
+                  this.strm,
+                  opt.dictionary
+                );
+                if (status !== c.Z_OK) {
+                  throw new Error(msg[status]);
+                }
+              }
+            }
+          }
+          Inflate.prototype.push = function(data, mode) {
+            var strm = this.strm;
+            var chunkSize = this.options.chunkSize;
+            var dictionary = this.options.dictionary;
+            var status, _mode;
+            var next_out_utf8, tail, utf8str;
+            var allowBufError = false;
+            if (this.ended) {
+              return false;
+            }
+            _mode = mode === ~~mode ? mode : mode === true ? c.Z_FINISH : c.Z_NO_FLUSH;
+            if (typeof data === "string") {
+              strm.input = strings.binstring2buf(data);
+            } else if (toString.call(data) === "[object ArrayBuffer]") {
+              strm.input = new Uint8Array(data);
+            } else {
+              strm.input = data;
+            }
+            strm.next_in = 0;
+            strm.avail_in = strm.input.length;
+            do {
+              if (strm.avail_out === 0) {
+                strm.output = new utils.Buf8(chunkSize);
+                strm.next_out = 0;
+                strm.avail_out = chunkSize;
+              }
+              status = zlib_inflate.inflate(
+                strm,
+                c.Z_NO_FLUSH
+              );
+              if (status === c.Z_NEED_DICT && dictionary) {
+                status = zlib_inflate.inflateSetDictionary(
+                  this.strm,
+                  dictionary
+                );
+              }
+              if (status === c.Z_BUF_ERROR && allowBufError === true) {
+                status = c.Z_OK;
+                allowBufError = false;
+              }
+              if (status !== c.Z_STREAM_END && status !== c.Z_OK) {
+                this.onEnd(status);
+                this.ended = true;
+                return false;
+              }
+              if (strm.next_out) {
+                if (strm.avail_out === 0 || status === c.Z_STREAM_END || strm.avail_in === 0 && (_mode === c.Z_FINISH || _mode === c.Z_SYNC_FLUSH)) {
+                  if (this.options.to === "string") {
+                    next_out_utf8 = strings.utf8border(
+                      strm.output,
+                      strm.next_out
+                    );
+                    tail = strm.next_out - next_out_utf8;
+                    utf8str = strings.buf2string(
+                      strm.output,
+                      next_out_utf8
+                    );
+                    strm.next_out = tail;
+                    strm.avail_out = chunkSize - tail;
+                    if (tail) {
+                      utils.arraySet(
+                        strm.output,
+                        strm.output,
+                        next_out_utf8,
+                        tail,
+                        0
+                      );
+                    }
+                    this.onData(utf8str);
+                  } else {
+                    this.onData(
+                      utils.shrinkBuf(
+                        strm.output,
+                        strm.next_out
+                      )
+                    );
+                  }
+                }
+              }
+              if (strm.avail_in === 0 && strm.avail_out === 0) {
+                allowBufError = true;
+              }
+            } while ((strm.avail_in > 0 || strm.avail_out === 0) && status !== c.Z_STREAM_END);
+            if (status === c.Z_STREAM_END) {
+              _mode = c.Z_FINISH;
+            }
+            if (_mode === c.Z_FINISH) {
+              status = zlib_inflate.inflateEnd(this.strm);
+              this.onEnd(status);
+              this.ended = true;
+              return status === c.Z_OK;
+            }
+            if (_mode === c.Z_SYNC_FLUSH) {
+              this.onEnd(c.Z_OK);
+              strm.avail_out = 0;
+              return true;
+            }
+            return true;
+          };
+          Inflate.prototype.onData = function(chunk) {
+            this.chunks.push(chunk);
+          };
+          Inflate.prototype.onEnd = function(status) {
+            if (status === c.Z_OK) {
+              if (this.options.to === "string") {
+                this.result = this.chunks.join("");
+              } else {
+                this.result = utils.flattenChunks(
+                  this.chunks
+                );
+              }
+            }
+            this.chunks = [];
+            this.err = status;
+            this.msg = this.strm.msg;
+          };
+          function inflate(input, options) {
+            var inflator = new Inflate(options);
+            inflator.push(input, true);
+            if (inflator.err) {
+              throw inflator.msg || msg[inflator.err];
+            }
+            return inflator.result;
+          }
+          function inflateRaw(input, options) {
+            options = options || {};
+            options.raw = true;
+            return inflate(input, options);
+          }
+          exports3.Inflate = Inflate;
+          exports3.inflate = inflate;
+          exports3.inflateRaw = inflateRaw;
+          exports3.ungzip = inflate;
+        },
+        {
+          "./utils/common": 1,
+          "./utils/strings": 2,
+          "./zlib/constants": 4,
+          "./zlib/gzheader": 6,
+          "./zlib/inflate": 8,
+          "./zlib/messages": 10,
+          "./zlib/zstream": 11
+        }
+      ]
+    },
+    {},
+    []
+  )("/lib/inflate.js");
+});
+//# sourceMappingURL=inflate.js.map