@genome-spy/core 0.63.0 → 0.65.0

package/dist/bundle/inflate-DRgHi_KK.js

@@ -0,0 +1,1050 @@
+var ce = 0, ve = 2, P = 4, I = 0, X = 1, ti = 2, ri = -5;
+function ni(i, a) {
+  return Object.prototype.hasOwnProperty.call(i, a);
+}
+function fi(i) {
+  for (var a = Array.prototype.slice.call(arguments, 1); a.length; ) {
+    var e = a.shift();
+    if (e) {
+      if (typeof e != "object")
+        throw new TypeError(e + "must be non-object");
+      for (var t in e)
+        ni(e, t) && (i[t] = e[t]);
+    }
+  }
+  return i;
+}
+function Ye(i, a) {
+  return i.length === a ? i : i.subarray ? i.subarray(0, a) : (i.length = a, i);
+}
+var F = {
+  arraySet: function(i, a, e, t, s) {
+    if (a.subarray && i.subarray) {
+      i.set(a.subarray(e, e + t), s);
+      return;
+    }
+    for (var r = 0; r < t; r++)
+      i[s + r] = a[e + r];
+  },
+  // Join array of chunks to single array.
+  flattenChunks: function(i) {
+    var a, e, t, s, r, d;
+    for (t = 0, a = 0, e = i.length; a < e; a++)
+      t += i[a].length;
+    for (d = new Uint8Array(t), s = 0, a = 0, e = i.length; a < e; a++)
+      r = i[a], d.set(r, s), s += r.length;
+    return d;
+  },
+  Buf8: function(i) {
+    return new Uint8Array(i);
+  },
+  Buf16: function(i) {
+    return new Uint16Array(i);
+  },
+  Buf32: function(i) {
+    return new Int32Array(i);
+  }
+}, G = {
+  arraySet: function(i, a, e, t, s) {
+    for (var r = 0; r < t; r++)
+      i[s + r] = a[e + r];
+  },
+  // Join array of chunks to single array.
+  flattenChunks: function(i) {
+    return [].concat.apply([], i);
+  },
+  Buf8: function(i) {
+    return new Array(i);
+  },
+  Buf16: function(i) {
+    return new Array(i);
+  },
+  Buf32: function(i) {
+    return new Array(i);
+  }
+};
+let M = () => {
+  const i = typeof Uint8Array < "u" && typeof Uint16Array < "u" && typeof Int32Array < "u";
+  return M = () => i, i;
+}, O = (i, a, e, t, s) => (O = M() ? F.arraySet : G.arraySet, O(i, a, e, t, s)), le = (i) => (le = M() ? F.flattenChunks : G.flattenChunks, le(i)), L = (i) => (L = M() ? F.Buf8 : G.Buf8, L(i)), Z = (i) => (Z = M() ? F.Buf16 : G.Buf16, Z(i)), H = (i) => (H = M() ? F.Buf32 : G.Buf32, H(i)), Pe = function() {
+  let i = !0;
+  try {
+    String.fromCharCode.apply(null, [0]);
+  } catch {
+    i = !1;
+  }
+  return Pe = () => i, i;
+}, Xe = function() {
+  let i = !0;
+  try {
+    String.fromCharCode.apply(null, new Uint8Array(1));
+  } catch {
+    i = !1;
+  }
+  return Xe = () => i, i;
+}, he = function(i) {
+  for (var a = L(256), e = 0; e < 256; e++)
+    a[e] = e >= 252 ? 6 : e >= 248 ? 5 : e >= 240 ? 4 : e >= 224 ? 3 : e >= 192 ? 2 : 1;
+  return a[254] = a[254] = 1, he = (t) => a[t], a[i];
+};
+function xe(i) {
+  var a, e, t, s, r, d = i.length, l = 0;
+  for (s = 0; s < d; s++)
+    e = i.charCodeAt(s), (e & 64512) === 55296 && s + 1 < d && (t = i.charCodeAt(s + 1), (t & 64512) === 56320 && (e = 65536 + (e - 55296 << 10) + (t - 56320), s++)), l += e < 128 ? 1 : e < 2048 ? 2 : e < 65536 ? 3 : 4;
+  for (a = new Uint8Array(l), r = 0, s = 0; r < l; s++)
+    e = i.charCodeAt(s), (e & 64512) === 55296 && s + 1 < d && (t = i.charCodeAt(s + 1), (t & 64512) === 56320 && (e = 65536 + (e - 55296 << 10) + (t - 56320), s++)), e < 128 ? a[r++] = e : e < 2048 ? (a[r++] = 192 | e >>> 6, a[r++] = 128 | e & 63) : e < 65536 ? (a[r++] = 224 | e >>> 12, a[r++] = 128 | e >>> 6 & 63, a[r++] = 128 | e & 63) : (a[r++] = 240 | e >>> 18, a[r++] = 128 | e >>> 12 & 63, a[r++] = 128 | e >>> 6 & 63, a[r++] = 128 | e & 63);
+  return a;
+}
+function li(i, a) {
+  if (a < 65534 && (i.subarray && Xe() || !i.subarray && Pe()))
+    return String.fromCharCode.apply(null, Ye(i, a));
+  for (var e = "", t = 0; t < a; t++)
+    e += String.fromCharCode(i[t]);
+  return e;
+}
+function oi(i) {
+  for (var a = new Uint8Array(i.length), e = 0, t = a.length; e < t; e++)
+    a[e] = i.charCodeAt(e);
+  return a;
+}
+function si(i, a) {
+  var e, t, s, r, d = a || i.length, l = new Array(d * 2);
+  for (t = 0, e = 0; e < d; ) {
+    if (s = i[e++], s < 128) {
+      l[t++] = s;
+      continue;
+    }
+    if (r = he(s), r > 4) {
+      l[t++] = 65533, e += r - 1;
+      continue;
+    }
+    for (s &= r === 2 ? 31 : r === 3 ? 15 : 7; r > 1 && e < d; )
+      s = s << 6 | i[e++] & 63, r--;
+    if (r > 1) {
+      l[t++] = 65533;
+      continue;
+    }
+    s < 65536 ? l[t++] = s : (s -= 65536, l[t++] = 55296 | s >> 10 & 1023, l[t++] = 56320 | s & 1023);
+  }
+  return li(l, t);
+}
+function hi(i, a) {
+  var e;
+  for (a = a || i.length, a > i.length && (a = i.length), e = a - 1; e >= 0 && (i[e] & 192) === 128; )
+    e--;
+  return e < 0 || e === 0 ? a : e + he(i[e]) > a ? e : a;
+}
+function di() {
+  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 = !1;
+}
+function oe(i, a, e, t) {
+  for (var s = i & 65535 | 0, r = i >>> 16 & 65535 | 0, d = 0; e !== 0; ) {
+    d = e > 2e3 ? 2e3 : e, e -= d;
+    do
+      s = s + a[t++] | 0, r = r + s | 0;
+    while (--d);
+    s %= 65521, r %= 65521;
+  }
+  return s | r << 16 | 0;
+}
+function ui() {
+  for (var i, a = [], e = 0; e < 256; e++) {
+    i = e;
+    for (var t = 0; t < 8; t++)
+      i = i & 1 ? 3988292384 ^ i >>> 1 : i >>> 1;
+    a[e] = i;
+  }
+  return a;
+}
+let Je = function() {
+  const i = ui();
+  return Je = () => i, i;
+};
+function D(i, a, e, t) {
+  var s = Je(), r = t + e;
+  i ^= -1;
+  for (var d = t; d < r; d++)
+    i = i >>> 8 ^ s[(i ^ a[d]) & 255];
+  return i ^ -1;
+}
+var J = 30, ci = 12;
+function vi(i, a) {
+  var e, t, s, r, d, l, p, n, f, y, c, o, v, C, k, x, _, b, h, g, T, u, S, E, w;
+  e = i.state, t = i.next_in, E = i.input, s = t + (i.avail_in - 5), r = i.next_out, w = i.output, d = r - (a - i.avail_out), l = r + (i.avail_out - 257), p = e.dmax, n = e.wsize, f = e.whave, y = e.wnext, c = e.window, o = e.hold, v = e.bits, C = e.lencode, k = e.distcode, x = (1 << e.lenbits) - 1, _ = (1 << e.distbits) - 1;
+  e: do {
+    v < 15 && (o += E[t++] << v, v += 8, o += E[t++] << v, v += 8), b = C[o & x];
+    i: for (; ; ) {
+      if (h = b >>> 24, o >>>= h, v -= h, h = b >>> 16 & 255, h === 0)
+        w[r++] = b & 65535;
+      else if (h & 16) {
+        g = b & 65535, h &= 15, h && (v < h && (o += E[t++] << v, v += 8), g += o & (1 << h) - 1, o >>>= h, v -= h), v < 15 && (o += E[t++] << v, v += 8, o += E[t++] << v, v += 8), b = k[o & _];
+        a: for (; ; ) {
+          if (h = b >>> 24, o >>>= h, v -= h, h = b >>> 16 & 255, h & 16) {
+            if (T = b & 65535, h &= 15, v < h && (o += E[t++] << v, v += 8, v < h && (o += E[t++] << v, v += 8)), T += o & (1 << h) - 1, T > p) {
+              i.msg = "invalid distance too far back", e.mode = J;
+              break e;
+            }
+            if (o >>>= h, v -= h, h = r - d, T > h) {
+              if (h = T - h, h > f && e.sane) {
+                i.msg = "invalid distance too far back", e.mode = J;
+                break e;
+              }
+              if (u = 0, S = c, y === 0) {
+                if (u += n - h, h < g) {
+                  g -= h;
+                  do
+                    w[r++] = c[u++];
+                  while (--h);
+                  u = r - T, S = w;
+                }
+              } else if (y < h) {
+                if (u += n + y - h, h -= y, h < g) {
+                  g -= h;
+                  do
+                    w[r++] = c[u++];
+                  while (--h);
+                  if (u = 0, y < g) {
+                    h = y, g -= h;
+                    do
+                      w[r++] = c[u++];
+                    while (--h);
+                    u = r - T, S = w;
+                  }
+                }
+              } else if (u += y - h, h < g) {
+                g -= h;
+                do
+                  w[r++] = c[u++];
+                while (--h);
+                u = r - T, S = w;
+              }
+              for (; g > 2; )
+                w[r++] = S[u++], w[r++] = S[u++], w[r++] = S[u++], g -= 3;
+              g && (w[r++] = S[u++], g > 1 && (w[r++] = S[u++]));
+            } else {
+              u = r - T;
+              do
+                w[r++] = w[u++], w[r++] = w[u++], w[r++] = w[u++], g -= 3;
+              while (g > 2);
+              g && (w[r++] = w[u++], g > 1 && (w[r++] = w[u++]));
+            }
+          } else if (h & 64) {
+            i.msg = "invalid distance code", e.mode = J;
+            break e;
+          } else {
+            b = k[(b & 65535) + (o & (1 << h) - 1)];
+            continue a;
+          }
+          break;
+        }
+      } else if (h & 64)
+        if (h & 32) {
+          e.mode = ci;
+          break e;
+        } else {
+          i.msg = "invalid literal/length code", e.mode = J;
+          break e;
+        }
+      else {
+        b = C[(b & 65535) + (o & (1 << h) - 1)];
+        continue i;
+      }
+      break;
+    }
+  } while (t < s && r < l);
+  g = v >> 3, t -= g, v -= g << 3, o &= (1 << v) - 1, i.next_in = t, i.next_out = r, i.avail_in = t < s ? 5 + (s - t) : 5 - (t - s), i.avail_out = r < l ? 257 + (l - r) : 257 - (r - l), e.hold = o, e.bits = v;
+}
+var z = 15, we = 852, be = 592, ke = 0, ee = 1, ge = 2, xi = [
+  /* 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
+], wi = [
+  /* 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
+], bi = [
+  /* 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
+], ki = [
+  /* 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
+];
+function $(i, a, e, t, s, r, d, l) {
+  var p = l.bits, n = 0, f = 0, y = 0, c = 0, o = 0, v = 0, C = 0, k = 0, x = 0, _ = 0, b, h, g, T, u, S = null, E = 0, w, m = Z(z + 1), R = Z(z + 1), j = null, de = 0, ue, K, Y;
+  for (n = 0; n <= z; n++)
+    m[n] = 0;
+  for (f = 0; f < t; f++)
+    m[a[e + f]]++;
+  for (o = p, c = z; c >= 1 && m[c] === 0; c--)
+    ;
+  if (o > c && (o = c), c === 0)
+    return s[r++] = 1 << 24 | 64 << 16 | 0, s[r++] = 1 << 24 | 64 << 16 | 0, l.bits = 1, 0;
+  for (y = 1; y < c && m[y] === 0; y++)
+    ;
+  for (o < y && (o = y), k = 1, n = 1; n <= z; n++)
+    if (k <<= 1, k -= m[n], k < 0)
+      return -1;
+  if (k > 0 && (i === ke || c !== 1))
+    return -1;
+  for (R[1] = 0, n = 1; n < z; n++)
+    R[n + 1] = R[n] + m[n];
+  for (f = 0; f < t; f++)
+    a[e + f] !== 0 && (d[R[a[e + f]]++] = f);
+  if (i === ke ? (S = j = d, w = 19) : i === ee ? (S = xi, E -= 257, j = wi, de -= 257, w = 256) : (S = bi, j = ki, w = -1), _ = 0, f = 0, n = y, u = r, v = o, C = 0, g = -1, x = 1 << o, T = x - 1, i === ee && x > we || i === ge && x > be)
+    return 1;
+  for (; ; ) {
+    ue = n - C, d[f] < w ? (K = 0, Y = d[f]) : d[f] > w ? (K = j[de + d[f]], Y = S[E + d[f]]) : (K = 96, Y = 0), b = 1 << n - C, h = 1 << v, y = h;
+    do
+      h -= b, s[u + (_ >> C) + h] = ue << 24 | K << 16 | Y | 0;
+    while (h !== 0);
+    for (b = 1 << n - 1; _ & b; )
+      b >>= 1;
+    if (b !== 0 ? (_ &= b - 1, _ += b) : _ = 0, f++, --m[n] === 0) {
+      if (n === c)
+        break;
+      n = a[e + d[f]];
+    }
+    if (n > o && (_ & T) !== g) {
+      for (C === 0 && (C = o), u += y, v = n - C, k = 1 << v; v + C < c && (k -= m[v + C], !(k <= 0)); )
+        v++, k <<= 1;
+      if (x += 1 << v, i === ee && x > we || i === ge && x > be)
+        return 1;
+      g = _ & T, s[g] = o << 24 | v << 16 | u - r | 0;
+    }
+  }
+  return _ !== 0 && (s[u + _] = n - C << 24 | 64 << 16 | 0), l.bits = o, 0;
+}
+var gi = 0, Qe = 1, Ve = 2, _e = 4, U = 0, _i = 1, pi = 2, B = -2, We = -3, qe = -4, Ei = -5, pe = 8, ei = 1, Ee = 2, ye = 3, Se = 4, Ae = 5, me = 6, Ce = 7, Te = 8, Be = 9, De = 10, W = 11, N = 12, ie = 13, Ne = 14, ae = 15, Oe = 16, Re = 17, Ie = 18, Ue = 19, Q = 20, V = 21, ze = 22, Le = 23, Ze = 24, He = 25, Me = 26, te = 27, $e = 28, Fe = 29, A = 30, ii = 31, yi = 32, Si = 852, Ai = 592;
+function Ge(i) {
+  return (i >>> 24 & 255) + (i >>> 8 & 65280) + ((i & 65280) << 8) + ((i & 255) << 24);
+}
+function mi() {
+  this.mode = 0, this.last = !1, this.wrap = 0, this.havedict = !1, 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 = Z(320), this.work = Z(288), this.lendyn = null, this.distdyn = null, this.sane = 0, this.back = 0, this.was = 0;
+}
+function Ci(i) {
+  var a;
+  return !i || !i.state ? B : (a = i.state, i.total_in = i.total_out = a.total = 0, i.msg = "", a.wrap && (i.adler = a.wrap & 1), a.mode = ei, a.last = 0, a.havedict = 0, a.dmax = 32768, a.head = null, a.hold = 0, a.bits = 0, a.lencode = a.lendyn = H(Si), a.distcode = a.distdyn = H(Ai), a.sane = 1, a.back = -1, U);
+}
+function Ti(i) {
+  var a;
+  return !i || !i.state ? B : (a = i.state, a.wsize = 0, a.whave = 0, a.wnext = 0, Ci(i));
+}
+function Bi(i, a) {
+  var e, t;
+  return !i || !i.state || (t = i.state, a < 0 ? (e = 0, a = -a) : (e = (a >> 4) + 1, a < 48 && (a &= 15)), a && (a < 8 || a > 15)) ? B : (t.window !== null && t.wbits !== a && (t.window = null), t.wrap = e, t.wbits = a, Ti(i));
+}
+function Di(i, a) {
+  var e, t;
+  return i ? (t = new mi(), i.state = t, t.window = null, e = Bi(i, a), e !== U && (i.state = null), e) : B;
+}
+var je = !0, re, ne;
+function Ni(i) {
+  if (je) {
+    var a;
+    for (re = H(512), ne = H(32), a = 0; a < 144; )
+      i.lens[a++] = 8;
+    for (; a < 256; )
+      i.lens[a++] = 9;
+    for (; a < 280; )
+      i.lens[a++] = 7;
+    for (; a < 288; )
+      i.lens[a++] = 8;
+    for ($(Qe, i.lens, 0, 288, re, 0, i.work, { bits: 9 }), a = 0; a < 32; )
+      i.lens[a++] = 5;
+    $(Ve, i.lens, 0, 32, ne, 0, i.work, {
+      bits: 5
+    }), je = !1;
+  }
+  i.lencode = re, i.lenbits = 9, i.distcode = ne, i.distbits = 5;
+}
+function ai(i, a, e, t) {
+  var s, r = i.state;
+  return r.window === null && (r.wsize = 1 << r.wbits, r.wnext = 0, r.whave = 0, r.window = L(r.wsize)), t >= r.wsize ? (O(r.window, a, e - r.wsize, r.wsize, 0), r.wnext = 0, r.whave = r.wsize) : (s = r.wsize - r.wnext, s > t && (s = t), O(r.window, a, e - t, s, r.wnext), t -= s, t ? (O(r.window, a, e - t, t, 0), r.wnext = t, r.whave = r.wsize) : (r.wnext += s, r.wnext === r.wsize && (r.wnext = 0), r.whave < r.wsize && (r.whave += s))), 0;
+}
+function Oi(i, a) {
+  var e, t, s, r, d, l, p, n, f, y, c, o, v, C, k = 0, x, _, b, h, g, T, u, S, E = L(4), w, m, R = (
+    /* permutation of code lengths */
+    [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]
+  );
+  if (!i || !i.state || !i.output || !i.input && i.avail_in !== 0)
+    return B;
+  e = i.state, e.mode === N && (e.mode = ie), d = i.next_out, s = i.output, p = i.avail_out, r = i.next_in, t = i.input, l = i.avail_in, n = e.hold, f = e.bits, y = l, c = p, S = U;
+  e: for (; ; )
+    switch (e.mode) {
+      case ei:
+        if (e.wrap === 0) {
+          e.mode = ie;
+          break;
+        }
+        for (; f < 16; ) {
+          if (l === 0)
+            break e;
+          l--, n += t[r++] << f, f += 8;
+        }
+        if (e.wrap & 2 && n === 35615) {
+          e.check = 0, E[0] = n & 255, E[1] = n >>> 8 & 255, e.check = D(e.check, E, 2, 0), n = 0, f = 0, e.mode = Ee;
+          break;
+        }
+        if (e.flags = 0, e.head && (e.head.done = !1), !(e.wrap & 1) || (((n & 255) << 8) + (n >> 8)) % 31) {
+          i.msg = "incorrect header check", e.mode = A;
+          break;
+        }
+        if ((n & 15) !== pe) {
+          i.msg = "unknown compression method", e.mode = A;
+          break;
+        }
+        if (n >>>= 4, f -= 4, u = (n & 15) + 8, e.wbits === 0)
+          e.wbits = u;
+        else if (u > e.wbits) {
+          i.msg = "invalid window size", e.mode = A;
+          break;
+        }
+        e.dmax = 1 << u, i.adler = e.check = 1, e.mode = n & 512 ? De : N, n = 0, f = 0;
+        break;
+      case Ee:
+        for (; f < 16; ) {
+          if (l === 0)
+            break e;
+          l--, n += t[r++] << f, f += 8;
+        }
+        if (e.flags = n, (e.flags & 255) !== pe) {
+          i.msg = "unknown compression method", e.mode = A;
+          break;
+        }
+        if (e.flags & 57344) {
+          i.msg = "unknown header flags set", e.mode = A;
+          break;
+        }
+        e.head && (e.head.text = n >> 8 & 1), e.flags & 512 && (E[0] = n & 255, E[1] = n >>> 8 & 255, e.check = D(e.check, E, 2, 0)), n = 0, f = 0, e.mode = ye;
+      /* falls through */
+      case ye:
+        for (; f < 32; ) {
+          if (l === 0)
+            break e;
+          l--, n += t[r++] << f, f += 8;
+        }
+        e.head && (e.head.time = n), e.flags & 512 && (E[0] = n & 255, E[1] = n >>> 8 & 255, E[2] = n >>> 16 & 255, E[3] = n >>> 24 & 255, e.check = D(e.check, E, 4, 0)), n = 0, f = 0, e.mode = Se;
+      /* falls through */
+      case Se:
+        for (; f < 16; ) {
+          if (l === 0)
+            break e;
+          l--, n += t[r++] << f, f += 8;
+        }
+        e.head && (e.head.xflags = n & 255, e.head.os = n >> 8), e.flags & 512 && (E[0] = n & 255, E[1] = n >>> 8 & 255, e.check = D(e.check, E, 2, 0)), n = 0, f = 0, e.mode = Ae;
+      /* falls through */
+      case Ae:
+        if (e.flags & 1024) {
+          for (; f < 16; ) {
+            if (l === 0)
+              break e;
+            l--, n += t[r++] << f, f += 8;
+          }
+          e.length = n, e.head && (e.head.extra_len = n), e.flags & 512 && (E[0] = n & 255, E[1] = n >>> 8 & 255, e.check = D(e.check, E, 2, 0)), n = 0, f = 0;
+        } else e.head && (e.head.extra = null);
+        e.mode = me;
+      /* falls through */
+      case me:
+        if (e.flags & 1024 && (o = e.length, o > l && (o = l), o && (e.head && (u = e.head.extra_len - e.length, e.head.extra || (e.head.extra = new Array(e.head.extra_len)), O(
+          e.head.extra,
+          t,
+          r,
+          // extra field is limited to 65536 bytes
+          // - no need for additional size check
+          o,
+          /*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/
+          u
+        )), e.flags & 512 && (e.check = D(e.check, t, o, r)), l -= o, r += o, e.length -= o), e.length))
+          break e;
+        e.length = 0, e.mode = Ce;
+      /* falls through */
+      case Ce:
+        if (e.flags & 2048) {
+          if (l === 0)
+            break e;
+          o = 0;
+          do
+            u = t[r + o++], e.head && u && e.length < 65536 && (e.head.name += String.fromCharCode(u));
+          while (u && o < l);
+          if (e.flags & 512 && (e.check = D(e.check, t, o, r)), l -= o, r += o, u)
+            break e;
+        } else e.head && (e.head.name = null);
+        e.length = 0, e.mode = Te;
+      /* falls through */
+      case Te:
+        if (e.flags & 4096) {
+          if (l === 0)
+            break e;
+          o = 0;
+          do
+            u = t[r + o++], e.head && u && e.length < 65536 && (e.head.comment += String.fromCharCode(u));
+          while (u && o < l);
+          if (e.flags & 512 && (e.check = D(e.check, t, o, r)), l -= o, r += o, u)
+            break e;
+        } else e.head && (e.head.comment = null);
+        e.mode = Be;
+      /* falls through */
+      case Be:
+        if (e.flags & 512) {
+          for (; f < 16; ) {
+            if (l === 0)
+              break e;
+            l--, n += t[r++] << f, f += 8;
+          }
+          if (n !== (e.check & 65535)) {
+            i.msg = "header crc mismatch", e.mode = A;
+            break;
+          }
+          n = 0, f = 0;
+        }
+        e.head && (e.head.hcrc = e.flags >> 9 & 1, e.head.done = !0), i.adler = e.check = 0, e.mode = N;
+        break;
+      case De:
+        for (; f < 32; ) {
+          if (l === 0)
+            break e;
+          l--, n += t[r++] << f, f += 8;
+        }
+        i.adler = e.check = Ge(n), n = 0, f = 0, e.mode = W;
+      /* falls through */
+      case W:
+        if (e.havedict === 0)
+          return i.next_out = d, i.avail_out = p, i.next_in = r, i.avail_in = l, e.hold = n, e.bits = f, pi;
+        i.adler = e.check = 1, e.mode = N;
+      /* falls through */
+      case N:
+      /* falls through */
+      case ie:
+        if (e.last) {
+          n >>>= f & 7, f -= f & 7, e.mode = te;
+          break;
+        }
+        for (; f < 3; ) {
+          if (l === 0)
+            break e;
+          l--, n += t[r++] << f, f += 8;
+        }
+        switch (e.last = n & 1, n >>>= 1, f -= 1, n & 3) {
+          case 0:
+            e.mode = Ne;
+            break;
+          case 1:
+            Ni(e), e.mode = Q;
+            break;
+          case 2:
+            e.mode = Re;
+            break;
+          case 3:
+            i.msg = "invalid block type", e.mode = A;
+        }
+        n >>>= 2, f -= 2;
+        break;
+      case Ne:
+        for (n >>>= f & 7, f -= f & 7; f < 32; ) {
+          if (l === 0)
+            break e;
+          l--, n += t[r++] << f, f += 8;
+        }
+        if ((n & 65535) !== (n >>> 16 ^ 65535)) {
+          i.msg = "invalid stored block lengths", e.mode = A;
+          break;
+        }
+        e.length = n & 65535, n = 0, f = 0, e.mode = ae;
+      /* falls through */
+      case ae:
+        e.mode = Oe;
+      /* falls through */
+      case Oe:
+        if (o = e.length, o) {
+          if (o > l && (o = l), o > p && (o = p), o === 0)
+            break e;
+          O(s, t, r, o, d), l -= o, r += o, p -= o, d += o, e.length -= o;
+          break;
+        }
+        e.mode = N;
+        break;
+      case Re:
+        for (; f < 14; ) {
+          if (l === 0)
+            break e;
+          l--, n += t[r++] << f, f += 8;
+        }
+        if (e.nlen = (n & 31) + 257, n >>>= 5, f -= 5, e.ndist = (n & 31) + 1, n >>>= 5, f -= 5, e.ncode = (n & 15) + 4, n >>>= 4, f -= 4, e.nlen > 286 || e.ndist > 30) {
+          i.msg = "too many length or distance symbols", e.mode = A;
+          break;
+        }
+        e.have = 0, e.mode = Ie;
+      /* falls through */
+      case Ie:
+        for (; e.have < e.ncode; ) {
+          for (; f < 3; ) {
+            if (l === 0)
+              break e;
+            l--, n += t[r++] << f, f += 8;
+          }
+          e.lens[R[e.have++]] = n & 7, n >>>= 3, f -= 3;
+        }
+        for (; e.have < 19; )
+          e.lens[R[e.have++]] = 0;
+        if (e.lencode = e.lendyn, e.lenbits = 7, w = { bits: e.lenbits }, S = $(gi, e.lens, 0, 19, e.lencode, 0, e.work, w), e.lenbits = w.bits, S) {
+          i.msg = "invalid code lengths set", e.mode = A;
+          break;
+        }
+        e.have = 0, e.mode = Ue;
+      /* falls through */
+      case Ue:
+        for (; e.have < e.nlen + e.ndist; ) {
+          for (; k = e.lencode[n & (1 << e.lenbits) - 1], x = k >>> 24, _ = k >>> 16 & 255, b = k & 65535, !(x <= f); ) {
+            if (l === 0)
+              break e;
+            l--, n += t[r++] << f, f += 8;
+          }
+          if (b < 16)
+            n >>>= x, f -= x, e.lens[e.have++] = b;
+          else {
+            if (b === 16) {
+              for (m = x + 2; f < m; ) {
+                if (l === 0)
+                  break e;
+                l--, n += t[r++] << f, f += 8;
+              }
+              if (n >>>= x, f -= x, e.have === 0) {
+                i.msg = "invalid bit length repeat", e.mode = A;
+                break;
+              }
+              u = e.lens[e.have - 1], o = 3 + (n & 3), n >>>= 2, f -= 2;
+            } else if (b === 17) {
+              for (m = x + 3; f < m; ) {
+                if (l === 0)
+                  break e;
+                l--, n += t[r++] << f, f += 8;
+              }
+              n >>>= x, f -= x, u = 0, o = 3 + (n & 7), n >>>= 3, f -= 3;
+            } else {
+              for (m = x + 7; f < m; ) {
+                if (l === 0)
+                  break e;
+                l--, n += t[r++] << f, f += 8;
+              }
+              n >>>= x, f -= x, u = 0, o = 11 + (n & 127), n >>>= 7, f -= 7;
+            }
+            if (e.have + o > e.nlen + e.ndist) {
+              i.msg = "invalid bit length repeat", e.mode = A;
+              break;
+            }
+            for (; o--; )
+              e.lens[e.have++] = u;
+          }
+        }
+        if (e.mode === A)
+          break;
+        if (e.lens[256] === 0) {
+          i.msg = "invalid code -- missing end-of-block", e.mode = A;
+          break;
+        }
+        if (e.lenbits = 9, w = { bits: e.lenbits }, S = $(Qe, e.lens, 0, e.nlen, e.lencode, 0, e.work, w), e.lenbits = w.bits, S) {
+          i.msg = "invalid literal/lengths set", e.mode = A;
+          break;
+        }
+        if (e.distbits = 6, e.distcode = e.distdyn, w = { bits: e.distbits }, S = $(Ve, e.lens, e.nlen, e.ndist, e.distcode, 0, e.work, w), e.distbits = w.bits, S) {
+          i.msg = "invalid distances set", e.mode = A;
+          break;
+        }
+        e.mode = Q;
+      /* falls through */
+      case Q:
+        e.mode = V;
+      /* falls through */
+      case V:
+        if (l >= 6 && p >= 258) {
+          i.next_out = d, i.avail_out = p, i.next_in = r, i.avail_in = l, e.hold = n, e.bits = f, vi(i, c), d = i.next_out, s = i.output, p = i.avail_out, r = i.next_in, t = i.input, l = i.avail_in, n = e.hold, f = e.bits, e.mode === N && (e.back = -1);
+          break;
+        }
+        for (e.back = 0; k = e.lencode[n & (1 << e.lenbits) - 1], x = k >>> 24, _ = k >>> 16 & 255, b = k & 65535, !(x <= f); ) {
+          if (l === 0)
+            break e;
+          l--, n += t[r++] << f, f += 8;
+        }
+        if (_ && !(_ & 240)) {
+          for (h = x, g = _, T = b; k = e.lencode[T + ((n & (1 << h + g) - 1) >> h)], x = k >>> 24, _ = k >>> 16 & 255, b = k & 65535, !(h + x <= f); ) {
+            if (l === 0)
+              break e;
+            l--, n += t[r++] << f, f += 8;
+          }
+          n >>>= h, f -= h, e.back += h;
+        }
+        if (n >>>= x, f -= x, e.back += x, e.length = b, _ === 0) {
+          e.mode = Me;
+          break;
+        }
+        if (_ & 32) {
+          e.back = -1, e.mode = N;
+          break;
+        }
+        if (_ & 64) {
+          i.msg = "invalid literal/length code", e.mode = A;
+          break;
+        }
+        e.extra = _ & 15, e.mode = ze;
+      /* falls through */
+      case ze:
+        if (e.extra) {
+          for (m = e.extra; f < m; ) {
+            if (l === 0)
+              break e;
+            l--, n += t[r++] << f, f += 8;
+          }
+          e.length += n & (1 << e.extra) - 1, n >>>= e.extra, f -= e.extra, e.back += e.extra;
+        }
+        e.was = e.length, e.mode = Le;
+      /* falls through */
+      case Le:
+        for (; k = e.distcode[n & (1 << e.distbits) - 1], x = k >>> 24, _ = k >>> 16 & 255, b = k & 65535, !(x <= f); ) {
+          if (l === 0)
+            break e;
+          l--, n += t[r++] << f, f += 8;
+        }
+        if (!(_ & 240)) {
+          for (h = x, g = _, T = b; k = e.distcode[T + ((n & (1 << h + g) - 1) >> h)], x = k >>> 24, _ = k >>> 16 & 255, b = k & 65535, !(h + x <= f); ) {
+            if (l === 0)
+              break e;
+            l--, n += t[r++] << f, f += 8;
+          }
+          n >>>= h, f -= h, e.back += h;
+        }
+        if (n >>>= x, f -= x, e.back += x, _ & 64) {
+          i.msg = "invalid distance code", e.mode = A;
+          break;
+        }
+        e.offset = b, e.extra = _ & 15, e.mode = Ze;
+      /* falls through */
+      case Ze:
+        if (e.extra) {
+          for (m = e.extra; f < m; ) {
+            if (l === 0)
+              break e;
+            l--, n += t[r++] << f, f += 8;
+          }
+          e.offset += n & (1 << e.extra) - 1, n >>>= e.extra, f -= e.extra, e.back += e.extra;
+        }
+        if (e.offset > e.dmax) {
+          i.msg = "invalid distance too far back", e.mode = A;
+          break;
+        }
+        e.mode = He;
+      /* falls through */
+      case He:
+        if (p === 0)
+          break e;
+        if (o = c - p, e.offset > o) {
+          if (o = e.offset - o, o > e.whave && e.sane) {
+            i.msg = "invalid distance too far back", e.mode = A;
+            break;
+          }
+          o > e.wnext ? (o -= e.wnext, v = e.wsize - o) : v = e.wnext - o, o > e.length && (o = e.length), C = e.window;
+        } else
+          C = s, v = d - e.offset, o = e.length;
+        o > p && (o = p), p -= o, e.length -= o;
+        do
+          s[d++] = C[v++];
+        while (--o);
+        e.length === 0 && (e.mode = V);
+        break;
+      case Me:
+        if (p === 0)
+          break e;
+        s[d++] = e.length, p--, e.mode = V;
+        break;
+      case te:
+        if (e.wrap) {
+          for (; f < 32; ) {
+            if (l === 0)
+              break e;
+            l--, n |= t[r++] << f, f += 8;
+          }
+          if (c -= p, i.total_out += c, e.total += c, c && (i.adler = e.check = /*UPDATE(state.check, put - _out, _out);*/
+          e.flags ? D(e.check, s, c, d - c) : oe(e.check, s, c, d - c)), c = p, (e.flags ? n : Ge(n)) !== e.check) {
+            i.msg = "incorrect data check", e.mode = A;
+            break;
+          }
+          n = 0, f = 0;
+        }
+        e.mode = $e;
+      /* falls through */
+      case $e:
+        if (e.wrap && e.flags) {
+          for (; f < 32; ) {
+            if (l === 0)
+              break e;
+            l--, n += t[r++] << f, f += 8;
+          }
+          if (n !== (e.total & 4294967295)) {
+            i.msg = "incorrect length check", e.mode = A;
+            break;
+          }
+          n = 0, f = 0;
+        }
+        e.mode = Fe;
+      /* falls through */
+      case Fe:
+        S = _i;
+        break e;
+      case A:
+        S = We;
+        break e;
+      case ii:
+        return qe;
+      case yi:
+      /* falls through */
+      default:
+        return B;
+    }
+  return i.next_out = d, i.avail_out = p, i.next_in = r, i.avail_in = l, e.hold = n, e.bits = f, (e.wsize || c !== i.avail_out && e.mode < A && (e.mode < te || a !== _e)) && ai(i, i.output, i.next_out, c - i.avail_out), y -= i.avail_in, c -= i.avail_out, i.total_in += y, i.total_out += c, e.total += c, e.wrap && c && (i.adler = e.check = /*UPDATE(state.check, strm.next_out - _out, _out);*/
+  e.flags ? D(e.check, s, c, i.next_out - c) : oe(e.check, s, c, i.next_out - c)), i.data_type = e.bits + (e.last ? 64 : 0) + (e.mode === N ? 128 : 0) + (e.mode === Q || e.mode === ae ? 256 : 0), (y === 0 && c === 0 || a === _e) && S === U && (S = Ei), S;
+}
+function Ri(i) {
+  if (!i || !i.state)
+    return B;
+  var a = i.state;
+  return a.window && (a.window = null), i.state = null, U;
+}
+function Ii(i, a) {
+  var e;
+  return !i || !i.state || (e = i.state, !(e.wrap & 2)) ? B : (e.head = a, a.done = !1, U);
+}
+function Ke(i, a) {
+  var e = a.length, t, s, r;
+  return !i || !i.state || (t = i.state, t.wrap !== 0 && t.mode !== W) ? B : t.mode === W && (s = 1, s = oe(s, a, e, 0), s !== t.check) ? We : (r = ai(i, a, e, e), r ? (t.mode = ii, qe) : (t.havedict = 1, U));
+}
+const se = {
+  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"
+};
+function Ui() {
+  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;
+}
+var fe = Object.prototype.toString;
+class q {
+  constructor(a) {
+    if (!(this instanceof q))
+      return new q(a);
+    this.options = fi({
+      chunkSize: 16384,
+      windowBits: 0,
+      to: ""
+    }, a || {});
+    var e = this.options;
+    e.raw && e.windowBits >= 0 && e.windowBits < 16 && (e.windowBits = -e.windowBits, e.windowBits === 0 && (e.windowBits = -15)), e.windowBits >= 0 && e.windowBits < 16 && !(a && a.windowBits) && (e.windowBits += 32), e.windowBits > 15 && e.windowBits < 48 && (e.windowBits & 15 || (e.windowBits |= 15)), this.err = 0, this.msg = "", this.ended = !1, this.chunks = [], this.strm = new Ui(), this.strm.avail_out = 0;
+    var t = Di(this.strm, e.windowBits);
+    if (t !== I)
+      throw new Error(se[t]);
+    if (this.header = new di(), Ii(this.strm, this.header), e.dictionary && (typeof e.dictionary == "string" ? e.dictionary = xe(e.dictionary) : fe.call(e.dictionary) === "[object ArrayBuffer]" && (e.dictionary = new Uint8Array(e.dictionary)), e.raw && (t = Ke(this.strm, e.dictionary), t !== I)))
+      throw new Error(se[t]);
+  }
+  /**
+   * Inflate#push(data[, mode]) -> Boolean
+   * - data (Uint8Array|Array|ArrayBuffer|String): input data
+   * - mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE modes.
+   *   See constants. Skipped or `false` means Z_NO_FLUSH, `true` means Z_FINISH.
+   *
+   * Sends input data to inflate pipe, generating [[Inflate#onData]] calls with
+   * new output chunks. Returns `true` on success. The last data block must have
+   * mode Z_FINISH (or `true`). That will flush internal pending buffers and call
+   * [[Inflate#onEnd]]. For interim explicit flushes (without ending the stream) you
+   * can use mode Z_SYNC_FLUSH, keeping the decompression context.
+   *
+   * On fail call [[Inflate#onEnd]] with error code and return false.
+   *
+   * We strongly recommend to use `Uint8Array` on input for best speed (output
+   * format is detected automatically). Also, don't skip last param and always
+   * use the same type in your code (boolean or number). That will improve JS speed.
+   *
+   * For regular `Array`-s make sure all elements are [0..255].
+   *
+   * ##### Example
+   *
+   * ```javascript
+   * push(chunk, false); // push one of data chunks
+   * ...
+   * push(chunk, true);  // push last chunk
+   * ```
+   **/
+  push(a, e) {
+    var t = this.strm, s = this.options.chunkSize, r = this.options.dictionary, d, l, p, n, f, y, c = !1;
+    if (this.ended)
+      return !1;
+    l = e === ~~e ? e : e === !0 ? P : ce, typeof a == "string" ? t.input = oi(a) : fe.call(a) === "[object ArrayBuffer]" ? t.input = new Uint8Array(a) : t.input = a, t.next_in = 0, t.avail_in = t.input.length;
+    do {
+      if (t.avail_out === 0 && (t.output = L(s), t.next_out = 0, t.avail_out = s), d = Oi(t, ce), d === ti && r && (typeof r == "string" ? y = xe(r) : fe.call(r) === "[object ArrayBuffer]" ? y = new Uint8Array(r) : y = r, d = Ke(this.strm, y)), d === ri && c === !0 && (d = I, c = !1), d !== X && d !== I)
+        return this.onEnd(d), this.ended = !0, !1;
+      t.next_out && (t.avail_out === 0 || d === X || t.avail_in === 0 && (l === P || l === ve)) && (this.options.to === "string" ? (p = hi(t.output, t.next_out), n = t.next_out - p, f = si(t.output, p), t.next_out = n, t.avail_out = s - n, n && O(t.output, t.output, p, n, 0), this.onData(f)) : this.onData(Ye(t.output, t.next_out))), t.avail_in === 0 && t.avail_out === 0 && (c = !0);
+    } while ((t.avail_in > 0 || t.avail_out === 0) && d !== X);
+    return d === X && (l = P), l === P ? (d = Ri(this.strm), this.onEnd(d), this.ended = !0, d === I) : (l === ve && (this.onEnd(I), t.avail_out = 0), !0);
+  }
+  /**
+   * Inflate#onData(chunk) -> Void
+   * - chunk (Uint8Array|Array|String): output data. Type of array depends
+   *   on js engine support. When string output requested, each chunk
+   *   will be string.
+   *
+   * By default, stores data blocks in `chunks[]` property and glue
+   * those in `onEnd`. Override this handler, if you need another behaviour.
+   **/
+  onData(a) {
+    this.chunks.push(a);
+  }
+  /**
+   * Inflate#onEnd(status) -> Void
+   * - status (Number): inflate status. 0 (Z_OK) on success,
+   *   other if not.
+   *
+   * Called either after you tell inflate that the input stream is
+   * complete (Z_FINISH) or should be flushed (Z_SYNC_FLUSH)
+   * or if an error happened. By default - join collected chunks,
+   * free memory and fill `results` / `err` properties.
+   **/
+  onEnd(a) {
+    a === I && (this.options.to === "string" ? this.result = this.chunks.join("") : this.result = le(this.chunks)), this.chunks = [], this.err = a, this.msg = this.strm.msg;
+  }
+}
+function zi(i, a) {
+  var e = new q(a);
+  if (e.push(i, !0), e.err)
+    throw e.msg || se[e.err];
+  return e.result;
+}
+function Li(i, a) {
+  return a = a || {}, a.raw = !0, zi(i, a);
+}
+export {
+  q as I,
+  ve as Z,
+  Li as i
+};