@wordpress/global-styles-ui 1.1.0

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

@@ -0,0 +1,2636 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var require_inflate = __commonJS({
+  "packages/global-styles-ui/src/font-library-modal/lib/inflate.js"(exports, module) {
+    (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");
+    });
+  }
+});
+export default require_inflate();
+//# sourceMappingURL=inflate.js.map