@genome-spy/core 0.64.0 → 0.66.1

package/dist/bundle/inflate-GtwLkvSP.js

@@ -0,0 +1,1048 @@
+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 H = () => {
+  const i = typeof Uint8Array < "u" && typeof Uint16Array < "u" && typeof Int32Array < "u";
+  return H = () => i, i;
+}, N = (i, a, e, t, s) => (N = H() ? F.arraySet : G.arraySet, N(i, a, e, t, s)), fe = (i) => (fe = H() ? F.flattenChunks : G.flattenChunks, fe(i)), z = (i) => (z = H() ? F.Buf8 : G.Buf8, z(i)), L = (i) => (L = H() ? F.Buf16 : G.Buf16, L(i)), Z = (i) => (Z = H() ? F.Buf32 : G.Buf32, Z(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 = z(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 le(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 B(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, $, n, f, E, c, o, v, m, k, x, _, b, h, g, C, u, y, p, w;
+  e = i.state, t = i.next_in, p = 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), $ = e.dmax, n = e.wsize, f = e.whave, E = e.wnext, c = e.window, o = e.hold, v = e.bits, m = e.lencode, k = e.distcode, x = (1 << e.lenbits) - 1, _ = (1 << e.distbits) - 1;
+  e: do {
+    v < 15 && (o += p[t++] << v, v += 8, o += p[t++] << v, v += 8), b = m[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 += p[t++] << v, v += 8), g += o & (1 << h) - 1, o >>>= h, v -= h), v < 15 && (o += p[t++] << v, v += 8, o += p[t++] << v, v += 8), b = k[o & _];
+        a: for (; ; ) {
+          if (h = b >>> 24, o >>>= h, v -= h, h = b >>> 16 & 255, h & 16) {
+            if (C = b & 65535, h &= 15, v < h && (o += p[t++] << v, v += 8, v < h && (o += p[t++] << v, v += 8)), C += o & (1 << h) - 1, C > $) {
+              i.msg = "invalid distance too far back", e.mode = J;
+              break e;
+            }
+            if (o >>>= h, v -= h, h = r - d, C > h) {
+              if (h = C - h, h > f && e.sane) {
+                i.msg = "invalid distance too far back", e.mode = J;
+                break e;
+              }
+              if (u = 0, y = c, E === 0) {
+                if (u += n - h, h < g) {
+                  g -= h;
+                  do
+                    w[r++] = c[u++];
+                  while (--h);
+                  u = r - C, y = w;
+                }
+              } else if (E < h) {
+                if (u += n + E - h, h -= E, h < g) {
+                  g -= h;
+                  do
+                    w[r++] = c[u++];
+                  while (--h);
+                  if (u = 0, E < g) {
+                    h = E, g -= h;
+                    do
+                      w[r++] = c[u++];
+                    while (--h);
+                    u = r - C, y = w;
+                  }
+                }
+              } else if (u += E - h, h < g) {
+                g -= h;
+                do
+                  w[r++] = c[u++];
+                while (--h);
+                u = r - C, y = w;
+              }
+              for (; g > 2; )
+                w[r++] = y[u++], w[r++] = y[u++], w[r++] = y[u++], g -= 3;
+              g && (w[r++] = y[u++], g > 1 && (w[r++] = y[u++]));
+            } else {
+              u = r - C;
+              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) === 0) {
+            b = k[(b & 65535) + (o & (1 << h) - 1)];
+            continue a;
+          } else {
+            i.msg = "invalid distance code", e.mode = J;
+            break e;
+          }
+          break;
+        }
+      } else if ((h & 64) === 0) {
+        b = m[(b & 65535) + (o & (1 << h) - 1)];
+        continue i;
+      } else if (h & 32) {
+        e.mode = ci;
+        break e;
+      } else {
+        i.msg = "invalid literal/length code", e.mode = J;
+        break e;
+      }
+      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 U = 15, we = 852, be = 592, ke = 0, q = 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 M(i, a, e, t, s, r, d, l) {
+  var $ = l.bits, n = 0, f = 0, E = 0, c = 0, o = 0, v = 0, m = 0, k = 0, x = 0, _ = 0, b, h, g, C, u, y = null, p = 0, w, A = L(U + 1), O = L(U + 1), j = null, de = 0, ue, K, Y;
+  for (n = 0; n <= U; n++)
+    A[n] = 0;
+  for (f = 0; f < t; f++)
+    A[a[e + f]]++;
+  for (o = $, c = U; c >= 1 && A[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 (E = 1; E < c && A[E] === 0; E++)
+    ;
+  for (o < E && (o = E), k = 1, n = 1; n <= U; n++)
+    if (k <<= 1, k -= A[n], k < 0)
+      return -1;
+  if (k > 0 && (i === ke || c !== 1))
+    return -1;
+  for (O[1] = 0, n = 1; n < U; n++)
+    O[n + 1] = O[n] + A[n];
+  for (f = 0; f < t; f++)
+    a[e + f] !== 0 && (d[O[a[e + f]]++] = f);
+  if (i === ke ? (y = j = d, w = 19) : i === q ? (y = xi, p -= 257, j = wi, de -= 257, w = 256) : (y = bi, j = ki, w = -1), _ = 0, f = 0, n = E, u = r, v = o, m = 0, g = -1, x = 1 << o, C = x - 1, i === q && x > we || i === ge && x > be)
+    return 1;
+  for (; ; ) {
+    ue = n - m, d[f] < w ? (K = 0, Y = d[f]) : d[f] > w ? (K = j[de + d[f]], Y = y[p + d[f]]) : (K = 96, Y = 0), b = 1 << n - m, h = 1 << v, E = h;
+    do
+      h -= b, s[u + (_ >> m) + 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++, --A[n] === 0) {
+      if (n === c)
+        break;
+      n = a[e + d[f]];
+    }
+    if (n > o && (_ & C) !== g) {
+      for (m === 0 && (m = o), u += E, v = n - m, k = 1 << v; v + m < c && (k -= A[v + m], !(k <= 0)); )
+        v++, k <<= 1;
+      if (x += 1 << v, i === q && x > we || i === ge && x > be)
+        return 1;
+      g = _ & C, s[g] = o << 24 | v << 16 | u - r | 0;
+    }
+  }
+  return _ !== 0 && (s[u + _] = n - m << 24 | 64 << 16 | 0), l.bits = o, 0;
+}
+var gi = 0, Qe = 1, Ve = 2, _e = 4, R = 0, _i = 1, $i = 2, T = -2, We = -3, qe = -4, pi = -5, $e = 8, ei = 1, pe = 2, Ee = 3, ye = 4, Se = 5, Ae = 6, me = 7, Ce = 8, Te = 9, Be = 10, W = 11, D = 12, ee = 13, De = 14, ie = 15, Ne = 16, Oe = 17, Ie = 18, Re = 19, Q = 20, V = 21, Ue = 22, ze = 23, Le = 24, Ze = 25, He = 26, ae = 27, Me = 28, Fe = 29, S = 30, ii = 31, Ei = 32, yi = 852, Si = 592;
+function Ge(i) {
+  return (i >>> 24 & 255) + (i >>> 8 & 65280) + ((i & 65280) << 8) + ((i & 255) << 24);
+}
+function Ai() {
+  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 = L(320), this.work = L(288), this.lendyn = null, this.distdyn = null, this.sane = 0, this.back = 0, this.was = 0;
+}
+function mi(i) {
+  var a;
+  return !i || !i.state ? T : (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 = Z(yi), a.distcode = a.distdyn = Z(Si), a.sane = 1, a.back = -1, R);
+}
+function Ci(i) {
+  var a;
+  return !i || !i.state ? T : (a = i.state, a.wsize = 0, a.whave = 0, a.wnext = 0, mi(i));
+}
+function Ti(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)) ? T : (t.window !== null && t.wbits !== a && (t.window = null), t.wrap = e, t.wbits = a, Ci(i));
+}
+function Bi(i, a) {
+  var e, t;
+  return i ? (t = new Ai(), i.state = t, t.window = null, e = Ti(i, a), e !== R && (i.state = null), e) : T;
+}
+var je = !0, te, re;
+function Di(i) {
+  if (je) {
+    var a;
+    for (te = Z(512), re = Z(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 (M(Qe, i.lens, 0, 288, te, 0, i.work, { bits: 9 }), a = 0; a < 32; )
+      i.lens[a++] = 5;
+    M(Ve, i.lens, 0, 32, re, 0, i.work, {
+      bits: 5
+    }), je = !1;
+  }
+  i.lencode = te, i.lenbits = 9, i.distcode = re, 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 = z(r.wsize)), t >= r.wsize ? (N(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), N(r.window, a, e - t, s, r.wnext), t -= s, t ? (N(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 Ni(i, a) {
+  var e, t, s, r, d, l, $, n, f, E, c, o, v, m, k = 0, x, _, b, h, g, C, u, y, p = z(4), w, A, O = (
+    /* 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 T;
+  e = i.state, e.mode === D && (e.mode = ee), d = i.next_out, s = i.output, $ = i.avail_out, r = i.next_in, t = i.input, l = i.avail_in, n = e.hold, f = e.bits, E = l, c = $, y = R;
+  e: for (; ; )
+    switch (e.mode) {
+      case ei:
+        if (e.wrap === 0) {
+          e.mode = ee;
+          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, p[0] = n & 255, p[1] = n >>> 8 & 255, e.check = B(e.check, p, 2, 0), n = 0, f = 0, e.mode = pe;
+          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 = S;
+          break;
+        }
+        if ((n & 15) !== $e) {
+          i.msg = "unknown compression method", e.mode = S;
+          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 = S;
+          break;
+        }
+        e.dmax = 1 << u, i.adler = e.check = 1, e.mode = n & 512 ? Be : D, n = 0, f = 0;
+        break;
+      case pe:
+        for (; f < 16; ) {
+          if (l === 0)
+            break e;
+          l--, n += t[r++] << f, f += 8;
+        }
+        if (e.flags = n, (e.flags & 255) !== $e) {
+          i.msg = "unknown compression method", e.mode = S;
+          break;
+        }
+        if (e.flags & 57344) {
+          i.msg = "unknown header flags set", e.mode = S;
+          break;
+        }
+        e.head && (e.head.text = n >> 8 & 1), e.flags & 512 && (p[0] = n & 255, p[1] = n >>> 8 & 255, e.check = B(e.check, p, 2, 0)), n = 0, f = 0, e.mode = Ee;
+      /* falls through */
+      case Ee:
+        for (; f < 32; ) {
+          if (l === 0)
+            break e;
+          l--, n += t[r++] << f, f += 8;
+        }
+        e.head && (e.head.time = n), e.flags & 512 && (p[0] = n & 255, p[1] = n >>> 8 & 255, p[2] = n >>> 16 & 255, p[3] = n >>> 24 & 255, e.check = B(e.check, p, 4, 0)), n = 0, f = 0, e.mode = ye;
+      /* falls through */
+      case ye:
+        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 && (p[0] = n & 255, p[1] = n >>> 8 & 255, e.check = B(e.check, p, 2, 0)), n = 0, f = 0, e.mode = Se;
+      /* falls through */
+      case Se:
+        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 && (p[0] = n & 255, p[1] = n >>> 8 & 255, e.check = B(e.check, p, 2, 0)), n = 0, f = 0;
+        } else e.head && (e.head.extra = null);
+        e.mode = Ae;
+      /* falls through */
+      case Ae:
+        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)), N(
+          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 = B(e.check, t, o, r)), l -= o, r += o, e.length -= o), e.length))
+          break e;
+        e.length = 0, e.mode = me;
+      /* falls through */
+      case me:
+        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 = B(e.check, t, o, r)), l -= o, r += o, u)
+            break e;
+        } else e.head && (e.head.name = null);
+        e.length = 0, e.mode = Ce;
+      /* falls through */
+      case Ce:
+        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 = B(e.check, t, o, r)), l -= o, r += o, u)
+            break e;
+        } else e.head && (e.head.comment = null);
+        e.mode = Te;
+      /* falls through */
+      case Te:
+        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 = S;
+            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 = D;
+        break;
+      case Be:
+        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 = $, i.next_in = r, i.avail_in = l, e.hold = n, e.bits = f, $i;
+        i.adler = e.check = 1, e.mode = D;
+      /* falls through */
+      case D:
+      /* falls through */
+      case ee:
+        if (e.last) {
+          n >>>= f & 7, f -= f & 7, e.mode = ae;
+          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 = De;
+            break;
+          case 1:
+            Di(e), e.mode = Q;
+            break;
+          case 2:
+            e.mode = Oe;
+            break;
+          case 3:
+            i.msg = "invalid block type", e.mode = S;
+        }
+        n >>>= 2, f -= 2;
+        break;
+      case De:
+        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 = S;
+          break;
+        }
+        e.length = n & 65535, n = 0, f = 0, e.mode = ie;
+      /* falls through */
+      case ie:
+        e.mode = Ne;
+      /* falls through */
+      case Ne:
+        if (o = e.length, o) {
+          if (o > l && (o = l), o > $ && (o = $), o === 0)
+            break e;
+          N(s, t, r, o, d), l -= o, r += o, $ -= o, d += o, e.length -= o;
+          break;
+        }
+        e.mode = D;
+        break;
+      case Oe:
+        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 = S;
+          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[O[e.have++]] = n & 7, n >>>= 3, f -= 3;
+        }
+        for (; e.have < 19; )
+          e.lens[O[e.have++]] = 0;
+        if (e.lencode = e.lendyn, e.lenbits = 7, w = { bits: e.lenbits }, y = M(gi, e.lens, 0, 19, e.lencode, 0, e.work, w), e.lenbits = w.bits, y) {
+          i.msg = "invalid code lengths set", e.mode = S;
+          break;
+        }
+        e.have = 0, e.mode = Re;
+      /* falls through */
+      case Re:
+        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 (A = x + 2; f < A; ) {
+                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 = S;
+                break;
+              }
+              u = e.lens[e.have - 1], o = 3 + (n & 3), n >>>= 2, f -= 2;
+            } else if (b === 17) {
+              for (A = x + 3; f < A; ) {
+                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 (A = x + 7; f < A; ) {
+                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 = S;
+              break;
+            }
+            for (; o--; )
+              e.lens[e.have++] = u;
+          }
+        }
+        if (e.mode === S)
+          break;
+        if (e.lens[256] === 0) {
+          i.msg = "invalid code -- missing end-of-block", e.mode = S;
+          break;
+        }
+        if (e.lenbits = 9, w = { bits: e.lenbits }, y = M(Qe, e.lens, 0, e.nlen, e.lencode, 0, e.work, w), e.lenbits = w.bits, y) {
+          i.msg = "invalid literal/lengths set", e.mode = S;
+          break;
+        }
+        if (e.distbits = 6, e.distcode = e.distdyn, w = { bits: e.distbits }, y = M(Ve, e.lens, e.nlen, e.ndist, e.distcode, 0, e.work, w), e.distbits = w.bits, y) {
+          i.msg = "invalid distances set", e.mode = S;
+          break;
+        }
+        e.mode = Q;
+      /* falls through */
+      case Q:
+        e.mode = V;
+      /* falls through */
+      case V:
+        if (l >= 6 && $ >= 258) {
+          i.next_out = d, i.avail_out = $, i.next_in = r, i.avail_in = l, e.hold = n, e.bits = f, vi(i, c), d = i.next_out, s = i.output, $ = i.avail_out, r = i.next_in, t = i.input, l = i.avail_in, n = e.hold, f = e.bits, e.mode === D && (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) === 0) {
+          for (h = x, g = _, C = b; k = e.lencode[C + ((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 = He;
+          break;
+        }
+        if (_ & 32) {
+          e.back = -1, e.mode = D;
+          break;
+        }
+        if (_ & 64) {
+          i.msg = "invalid literal/length code", e.mode = S;
+          break;
+        }
+        e.extra = _ & 15, e.mode = Ue;
+      /* falls through */
+      case Ue:
+        if (e.extra) {
+          for (A = e.extra; f < A; ) {
+            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 = ze;
+      /* falls through */
+      case ze:
+        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) === 0) {
+          for (h = x, g = _, C = b; k = e.distcode[C + ((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 = S;
+          break;
+        }
+        e.offset = b, e.extra = _ & 15, e.mode = Le;
+      /* falls through */
+      case Le:
+        if (e.extra) {
+          for (A = e.extra; f < A; ) {
+            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 = S;
+          break;
+        }
+        e.mode = Ze;
+      /* falls through */
+      case Ze:
+        if ($ === 0)
+          break e;
+        if (o = c - $, e.offset > o) {
+          if (o = e.offset - o, o > e.whave && e.sane) {
+            i.msg = "invalid distance too far back", e.mode = S;
+            break;
+          }
+          o > e.wnext ? (o -= e.wnext, v = e.wsize - o) : v = e.wnext - o, o > e.length && (o = e.length), m = e.window;
+        } else
+          m = s, v = d - e.offset, o = e.length;
+        o > $ && (o = $), $ -= o, e.length -= o;
+        do
+          s[d++] = m[v++];
+        while (--o);
+        e.length === 0 && (e.mode = V);
+        break;
+      case He:
+        if ($ === 0)
+          break e;
+        s[d++] = e.length, $--, e.mode = V;
+        break;
+      case ae:
+        if (e.wrap) {
+          for (; f < 32; ) {
+            if (l === 0)
+              break e;
+            l--, n |= t[r++] << f, f += 8;
+          }
+          if (c -= $, i.total_out += c, e.total += c, c && (i.adler = e.check = /*UPDATE(state.check, put - _out, _out);*/
+          e.flags ? B(e.check, s, c, d - c) : le(e.check, s, c, d - c)), c = $, (e.flags ? n : Ge(n)) !== e.check) {
+            i.msg = "incorrect data check", e.mode = S;
+            break;
+          }
+          n = 0, f = 0;
+        }
+        e.mode = Me;
+      /* falls through */
+      case Me:
+        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 = S;
+            break;
+          }
+          n = 0, f = 0;
+        }
+        e.mode = Fe;
+      /* falls through */
+      case Fe:
+        y = _i;
+        break e;
+      case S:
+        y = We;
+        break e;
+      case ii:
+        return qe;
+      case Ei:
+      /* falls through */
+      default:
+        return T;
+    }
+  return i.next_out = d, i.avail_out = $, i.next_in = r, i.avail_in = l, e.hold = n, e.bits = f, (e.wsize || c !== i.avail_out && e.mode < S && (e.mode < ae || a !== _e)) && ai(i, i.output, i.next_out, c - i.avail_out), E -= i.avail_in, c -= i.avail_out, i.total_in += E, i.total_out += c, e.total += c, e.wrap && c && (i.adler = e.check = /*UPDATE(state.check, strm.next_out - _out, _out);*/
+  e.flags ? B(e.check, s, c, i.next_out - c) : le(e.check, s, c, i.next_out - c)), i.data_type = e.bits + (e.last ? 64 : 0) + (e.mode === D ? 128 : 0) + (e.mode === Q || e.mode === ie ? 256 : 0), (E === 0 && c === 0 || a === _e) && y === R && (y = pi), y;
+}
+function Oi(i) {
+  if (!i || !i.state)
+    return T;
+  var a = i.state;
+  return a.window && (a.window = null), i.state = null, R;
+}
+function Ii(i, a) {
+  var e;
+  return !i || !i.state || (e = i.state, (e.wrap & 2) === 0) ? T : (e.head = a, a.done = !1, R);
+}
+function Ke(i, a) {
+  var e = a.length, t, s, r;
+  return !i || !i.state || (t = i.state, t.wrap !== 0 && t.mode !== W) ? T : t.mode === W && (s = 1, s = le(s, a, e, 0), s !== t.check) ? We : (r = ai(i, a, e, e), r ? (t.mode = ii, qe) : (t.havedict = 1, R));
+}
+const oe = {
+  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 Ri() {
+  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 ne = Object.prototype.toString;
+let Ui = class se {
+  constructor(a) {
+    if (!(this instanceof se))
+      return new se(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) === 0 && (e.windowBits |= 15), this.err = 0, this.msg = "", this.ended = !1, this.chunks = [], this.strm = new Ri(), this.strm.avail_out = 0;
+    var t = Bi(this.strm, e.windowBits);
+    if (t !== I)
+      throw new Error(oe[t]);
+    if (this.header = new di(), Ii(this.strm, this.header), e.dictionary && (typeof e.dictionary == "string" ? e.dictionary = xe(e.dictionary) : ne.call(e.dictionary) === "[object ArrayBuffer]" && (e.dictionary = new Uint8Array(e.dictionary)), e.raw && (t = Ke(this.strm, e.dictionary), t !== I)))
+      throw new Error(oe[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, $, n, f, E, c = !1;
+    if (this.ended)
+      return !1;
+    l = e === ~~e ? e : e === !0 ? P : ce, typeof a == "string" ? t.input = oi(a) : ne.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 = z(s), t.next_out = 0, t.avail_out = s), d = Ni(t, ce), d === ti && r && (typeof r == "string" ? E = xe(r) : ne.call(r) === "[object ArrayBuffer]" ? E = new Uint8Array(r) : E = r, d = Ke(this.strm, E)), 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" ? ($ = hi(t.output, t.next_out), n = t.next_out - $, f = si(t.output, $), t.next_out = n, t.avail_out = s - n, n && N(t.output, t.output, $, 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 = Oi(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 = fe(this.chunks)), this.chunks = [], this.err = a, this.msg = this.strm.msg;
+  }
+};
+function zi(i, a) {
+  var e = new Ui(a);
+  if (e.push(i, !0), e.err)
+    throw e.msg || oe[e.err];
+  return e.result;
+}
+function Li(i, a) {
+  return a = a || {}, a.raw = !0, zi(i, a);
+}
+export {
+  Ui as I,
+  ve as Z,
+  Li as i
+};