@genome-spy/app 0.57.0 → 0.58.1

package/dist/long-BviWyoZx.js

@@ -0,0 +1,2387 @@
+import { b as Nt } from "./index-BftNdA0O.js";
+import { g as Lt } from "./_commonjsHelpers-DjF3Plf2.js";
+var Qe = {}, dt;
+function Me() {
+  return dt || (dt = 1, function(x) {
+    var S = typeof Uint8Array < "u" && typeof Uint16Array < "u" && typeof Int32Array < "u";
+    function L(g, c) {
+      return Object.prototype.hasOwnProperty.call(g, c);
+    }
+    x.assign = function(g) {
+      for (var c = Array.prototype.slice.call(arguments, 1); c.length; ) {
+        var s = c.shift();
+        if (s) {
+          if (typeof s != "object")
+            throw new TypeError(s + "must be non-object");
+          for (var o in s)
+            L(s, o) && (g[o] = s[o]);
+        }
+      }
+      return g;
+    }, x.shrinkBuf = function(g, c) {
+      return g.length === c ? g : g.subarray ? g.subarray(0, c) : (g.length = c, g);
+    };
+    var w = {
+      arraySet: function(g, c, s, o, D) {
+        if (c.subarray && g.subarray) {
+          g.set(c.subarray(s, s + o), D);
+          return;
+        }
+        for (var y = 0; y < o; y++)
+          g[D + y] = c[s + y];
+      },
+      // Join array of chunks to single array.
+      flattenChunks: function(g) {
+        var c, s, o, D, y, N;
+        for (o = 0, c = 0, s = g.length; c < s; c++)
+          o += g[c].length;
+        for (N = new Uint8Array(o), D = 0, c = 0, s = g.length; c < s; c++)
+          y = g[c], N.set(y, D), D += y.length;
+        return N;
+      }
+    }, P = {
+      arraySet: function(g, c, s, o, D) {
+        for (var y = 0; y < o; y++)
+          g[D + y] = c[s + y];
+      },
+      // Join array of chunks to single array.
+      flattenChunks: function(g) {
+        return [].concat.apply([], g);
+      }
+    };
+    x.setTyped = function(g) {
+      g ? (x.Buf8 = Uint8Array, x.Buf16 = Uint16Array, x.Buf32 = Int32Array, x.assign(x, w)) : (x.Buf8 = Array, x.Buf16 = Array, x.Buf32 = Array, x.assign(x, P));
+    }, x.setTyped(S);
+  }(Qe)), Qe;
+}
+var We = {}, Oe = {}, qe = {}, st;
+function Dt() {
+  if (st) return qe;
+  st = 1;
+  var x = Me(), S = 4, L = 0, w = 1, P = 2;
+  function g(a) {
+    for (var b = a.length; --b >= 0; )
+      a[b] = 0;
+  }
+  var c = 0, s = 1, o = 2, D = 3, y = 258, N = 29, m = 256, T = m + 1 + N, C = 30, $ = 19, M = 2 * T + 1, A = 15, q = 16, I = 7, Y = 256, X = 16, K = 17, z = 18, H = (
+    /* extra bits for each length code */
+    [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0]
+  ), v = (
+    /* extra bits for each distance code */
+    [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13]
+  ), _ = (
+    /* extra bits for each bit length code */
+    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7]
+  ), r = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15], k = 512, F = new Array((T + 2) * 2);
+  g(F);
+  var G = new Array(C * 2);
+  g(G);
+  var j = new Array(k);
+  g(j);
+  var Q = new Array(y - D + 1);
+  g(Q);
+  var B = new Array(N);
+  g(B);
+  var ae = new Array(C);
+  g(ae);
+  function V(a, b, E, Z, f) {
+    this.static_tree = a, this.extra_bits = b, this.extra_base = E, this.elems = Z, this.max_length = f, this.has_stree = a && a.length;
+  }
+  var re, oe, ee;
+  function te(a, b) {
+    this.dyn_tree = a, this.max_code = 0, this.stat_desc = b;
+  }
+  function se(a) {
+    return a < 256 ? j[a] : j[256 + (a >>> 7)];
+  }
+  function ge(a, b) {
+    a.pending_buf[a.pending++] = b & 255, a.pending_buf[a.pending++] = b >>> 8 & 255;
+  }
+  function he(a, b, E) {
+    a.bi_valid > q - E ? (a.bi_buf |= b << a.bi_valid & 65535, ge(a, a.bi_buf), a.bi_buf = b >> q - a.bi_valid, a.bi_valid += E - q) : (a.bi_buf |= b << a.bi_valid & 65535, a.bi_valid += E);
+  }
+  function _e(a, b, E) {
+    he(
+      a,
+      E[b * 2],
+      E[b * 2 + 1]
+      /*.Len*/
+    );
+  }
+  function fe(a, b) {
+    var E = 0;
+    do
+      E |= a & 1, a >>>= 1, E <<= 1;
+    while (--b > 0);
+    return E >>> 1;
+  }
+  function be(a) {
+    a.bi_valid === 16 ? (ge(a, a.bi_buf), a.bi_buf = 0, a.bi_valid = 0) : a.bi_valid >= 8 && (a.pending_buf[a.pending++] = a.bi_buf & 255, a.bi_buf >>= 8, a.bi_valid -= 8);
+  }
+  function ye(a, b) {
+    var E = b.dyn_tree, Z = b.max_code, f = b.stat_desc.static_tree, d = b.stat_desc.has_stree, t = b.stat_desc.extra_bits, p = b.stat_desc.extra_base, W = b.stat_desc.max_length, e, l, u, i, n, h, U = 0;
+    for (i = 0; i <= A; i++)
+      a.bl_count[i] = 0;
+    for (E[a.heap[a.heap_max] * 2 + 1] = 0, e = a.heap_max + 1; e < M; e++)
+      l = a.heap[e], i = E[E[l * 2 + 1] * 2 + 1] + 1, i > W && (i = W, U++), E[l * 2 + 1] = i, !(l > Z) && (a.bl_count[i]++, n = 0, l >= p && (n = t[l - p]), h = E[l * 2], a.opt_len += h * (i + n), d && (a.static_len += h * (f[l * 2 + 1] + n)));
+    if (U !== 0) {
+      do {
+        for (i = W - 1; a.bl_count[i] === 0; )
+          i--;
+        a.bl_count[i]--, a.bl_count[i + 1] += 2, a.bl_count[W]--, U -= 2;
+      } while (U > 0);
+      for (i = W; i !== 0; i--)
+        for (l = a.bl_count[i]; l !== 0; )
+          u = a.heap[--e], !(u > Z) && (E[u * 2 + 1] !== i && (a.opt_len += (i - E[u * 2 + 1]) * E[u * 2], E[u * 2 + 1] = i), l--);
+    }
+  }
+  function me(a, b, E) {
+    var Z = new Array(A + 1), f = 0, d, t;
+    for (d = 1; d <= A; d++)
+      Z[d] = f = f + E[d - 1] << 1;
+    for (t = 0; t <= b; t++) {
+      var p = a[t * 2 + 1];
+      p !== 0 && (a[t * 2] = fe(Z[p]++, p));
+    }
+  }
+  function le() {
+    var a, b, E, Z, f, d = new Array(A + 1);
+    for (E = 0, Z = 0; Z < N - 1; Z++)
+      for (B[Z] = E, a = 0; a < 1 << H[Z]; a++)
+        Q[E++] = Z;
+    for (Q[E - 1] = Z, f = 0, Z = 0; Z < 16; Z++)
+      for (ae[Z] = f, a = 0; a < 1 << v[Z]; a++)
+        j[f++] = Z;
+    for (f >>= 7; Z < C; Z++)
+      for (ae[Z] = f << 7, a = 0; a < 1 << v[Z] - 7; a++)
+        j[256 + f++] = Z;
+    for (b = 0; b <= A; b++)
+      d[b] = 0;
+    for (a = 0; a <= 143; )
+      F[a * 2 + 1] = 8, a++, d[8]++;
+    for (; a <= 255; )
+      F[a * 2 + 1] = 9, a++, d[9]++;
+    for (; a <= 279; )
+      F[a * 2 + 1] = 7, a++, d[7]++;
+    for (; a <= 287; )
+      F[a * 2 + 1] = 8, a++, d[8]++;
+    for (me(F, T + 1, d), a = 0; a < C; a++)
+      G[a * 2 + 1] = 5, G[a * 2] = fe(a, 5);
+    re = new V(F, H, m + 1, T, A), oe = new V(G, v, 0, C, A), ee = new V(new Array(0), _, 0, $, I);
+  }
+  function ke(a) {
+    var b;
+    for (b = 0; b < T; b++)
+      a.dyn_ltree[b * 2] = 0;
+    for (b = 0; b < C; b++)
+      a.dyn_dtree[b * 2] = 0;
+    for (b = 0; b < $; b++)
+      a.bl_tree[b * 2] = 0;
+    a.dyn_ltree[Y * 2] = 1, a.opt_len = a.static_len = 0, a.last_lit = a.matches = 0;
+  }
+  function He(a) {
+    a.bi_valid > 8 ? ge(a, a.bi_buf) : a.bi_valid > 0 && (a.pending_buf[a.pending++] = a.bi_buf), a.bi_buf = 0, a.bi_valid = 0;
+  }
+  function Fe(a, b, E, Z) {
+    He(a), ge(a, E), ge(a, ~E), x.arraySet(a.pending_buf, a.window, b, E, a.pending), a.pending += E;
+  }
+  function Se(a, b, E, Z) {
+    var f = b * 2, d = E * 2;
+    return a[f] < a[d] || a[f] === a[d] && Z[b] <= Z[E];
+  }
+  function ue(a, b, E) {
+    for (var Z = a.heap[E], f = E << 1; f <= a.heap_len && (f < a.heap_len && Se(b, a.heap[f + 1], a.heap[f], a.depth) && f++, !Se(b, Z, a.heap[f], a.depth)); )
+      a.heap[E] = a.heap[f], E = f, f <<= 1;
+    a.heap[E] = Z;
+  }
+  function J(a, b, E) {
+    var Z, f, d = 0, t, p;
+    if (a.last_lit !== 0)
+      do
+        Z = a.pending_buf[a.d_buf + d * 2] << 8 | a.pending_buf[a.d_buf + d * 2 + 1], f = a.pending_buf[a.l_buf + d], d++, Z === 0 ? _e(a, f, b) : (t = Q[f], _e(a, t + m + 1, b), p = H[t], p !== 0 && (f -= B[t], he(a, f, p)), Z--, t = se(Z), _e(a, t, E), p = v[t], p !== 0 && (Z -= ae[t], he(a, Z, p)));
+      while (d < a.last_lit);
+    _e(a, Y, b);
+  }
+  function Te(a, b) {
+    var E = b.dyn_tree, Z = b.stat_desc.static_tree, f = b.stat_desc.has_stree, d = b.stat_desc.elems, t, p, W = -1, e;
+    for (a.heap_len = 0, a.heap_max = M, t = 0; t < d; t++)
+      E[t * 2] !== 0 ? (a.heap[++a.heap_len] = W = t, a.depth[t] = 0) : E[t * 2 + 1] = 0;
+    for (; a.heap_len < 2; )
+      e = a.heap[++a.heap_len] = W < 2 ? ++W : 0, E[e * 2] = 1, a.depth[e] = 0, a.opt_len--, f && (a.static_len -= Z[e * 2 + 1]);
+    for (b.max_code = W, t = a.heap_len >> 1; t >= 1; t--)
+      ue(a, E, t);
+    e = d;
+    do
+      t = a.heap[
+        1
+        /*SMALLEST*/
+      ], a.heap[
+        1
+        /*SMALLEST*/
+      ] = a.heap[a.heap_len--], ue(
+        a,
+        E,
+        1
+        /*SMALLEST*/
+      ), p = a.heap[
+        1
+        /*SMALLEST*/
+      ], a.heap[--a.heap_max] = t, a.heap[--a.heap_max] = p, E[e * 2] = E[t * 2] + E[p * 2], a.depth[e] = (a.depth[t] >= a.depth[p] ? a.depth[t] : a.depth[p]) + 1, E[t * 2 + 1] = E[p * 2 + 1] = e, a.heap[
+        1
+        /*SMALLEST*/
+      ] = e++, ue(
+        a,
+        E,
+        1
+        /*SMALLEST*/
+      );
+    while (a.heap_len >= 2);
+    a.heap[--a.heap_max] = a.heap[
+      1
+      /*SMALLEST*/
+    ], ye(a, b), me(E, W, a.bl_count);
+  }
+  function Ke(a, b, E) {
+    var Z, f = -1, d, t = b[0 * 2 + 1], p = 0, W = 7, e = 4;
+    for (t === 0 && (W = 138, e = 3), b[(E + 1) * 2 + 1] = 65535, Z = 0; Z <= E; Z++)
+      d = t, t = b[(Z + 1) * 2 + 1], !(++p < W && d === t) && (p < e ? a.bl_tree[d * 2] += p : d !== 0 ? (d !== f && a.bl_tree[d * 2]++, a.bl_tree[X * 2]++) : p <= 10 ? a.bl_tree[K * 2]++ : a.bl_tree[z * 2]++, p = 0, f = d, t === 0 ? (W = 138, e = 3) : d === t ? (W = 6, e = 3) : (W = 7, e = 4));
+  }
+  function Be(a, b, E) {
+    var Z, f = -1, d, t = b[0 * 2 + 1], p = 0, W = 7, e = 4;
+    for (t === 0 && (W = 138, e = 3), Z = 0; Z <= E; Z++)
+      if (d = t, t = b[(Z + 1) * 2 + 1], !(++p < W && d === t)) {
+        if (p < e)
+          do
+            _e(a, d, a.bl_tree);
+          while (--p !== 0);
+        else d !== 0 ? (d !== f && (_e(a, d, a.bl_tree), p--), _e(a, X, a.bl_tree), he(a, p - 3, 2)) : p <= 10 ? (_e(a, K, a.bl_tree), he(a, p - 3, 3)) : (_e(a, z, a.bl_tree), he(a, p - 11, 7));
+        p = 0, f = d, t === 0 ? (W = 138, e = 3) : d === t ? (W = 6, e = 3) : (W = 7, e = 4);
+      }
+  }
+  function ze(a) {
+    var b;
+    for (Ke(a, a.dyn_ltree, a.l_desc.max_code), Ke(a, a.dyn_dtree, a.d_desc.max_code), Te(a, a.bl_desc), b = $ - 1; b >= 3 && a.bl_tree[r[b] * 2 + 1] === 0; b--)
+      ;
+    return a.opt_len += 3 * (b + 1) + 5 + 5 + 4, b;
+  }
+  function Ye(a, b, E, Z) {
+    var f;
+    for (he(a, b - 257, 5), he(a, E - 1, 5), he(a, Z - 4, 4), f = 0; f < Z; f++)
+      he(a, a.bl_tree[r[f] * 2 + 1], 3);
+    Be(a, a.dyn_ltree, b - 1), Be(a, a.dyn_dtree, E - 1);
+  }
+  function Ce(a) {
+    var b = 4093624447, E;
+    for (E = 0; E <= 31; E++, b >>>= 1)
+      if (b & 1 && a.dyn_ltree[E * 2] !== 0)
+        return L;
+    if (a.dyn_ltree[9 * 2] !== 0 || a.dyn_ltree[10 * 2] !== 0 || a.dyn_ltree[13 * 2] !== 0)
+      return w;
+    for (E = 32; E < m; E++)
+      if (a.dyn_ltree[E * 2] !== 0)
+        return w;
+    return L;
+  }
+  var Re = !1;
+  function Xe(a) {
+    Re || (le(), Re = !0), a.l_desc = new te(a.dyn_ltree, re), a.d_desc = new te(a.dyn_dtree, oe), a.bl_desc = new te(a.bl_tree, ee), a.bi_buf = 0, a.bi_valid = 0, ke(a);
+  }
+  function Ue(a, b, E, Z) {
+    he(a, (c << 1) + (Z ? 1 : 0), 3), Fe(a, b, E);
+  }
+  function pe(a) {
+    he(a, s << 1, 3), _e(a, Y, F), be(a);
+  }
+  function Ie(a, b, E, Z) {
+    var f, d, t = 0;
+    a.level > 0 ? (a.strm.data_type === P && (a.strm.data_type = Ce(a)), Te(a, a.l_desc), Te(a, a.d_desc), t = ze(a), f = a.opt_len + 3 + 7 >>> 3, d = a.static_len + 3 + 7 >>> 3, d <= f && (f = d)) : f = d = E + 5, E + 4 <= f && b !== -1 ? Ue(a, b, E, Z) : a.strategy === S || d === f ? (he(a, (s << 1) + (Z ? 1 : 0), 3), J(a, F, G)) : (he(a, (o << 1) + (Z ? 1 : 0), 3), Ye(a, a.l_desc.max_code + 1, a.d_desc.max_code + 1, t + 1), J(a, a.dyn_ltree, a.dyn_dtree)), ke(a), Z && He(a);
+  }
+  function Ge(a, b, E) {
+    return a.pending_buf[a.d_buf + a.last_lit * 2] = b >>> 8 & 255, a.pending_buf[a.d_buf + a.last_lit * 2 + 1] = b & 255, a.pending_buf[a.l_buf + a.last_lit] = E & 255, a.last_lit++, b === 0 ? a.dyn_ltree[E * 2]++ : (a.matches++, b--, a.dyn_ltree[(Q[E] + m + 1) * 2]++, a.dyn_dtree[se(b) * 2]++), a.last_lit === a.lit_bufsize - 1;
+  }
+  return qe._tr_init = Xe, qe._tr_stored_block = Ue, qe._tr_flush_block = Ie, qe._tr_tally = Ge, qe._tr_align = pe, qe;
+}
+var et, ct;
+function At() {
+  if (ct) return et;
+  ct = 1;
+  function x(S, L, w, P) {
+    for (var g = S & 65535 | 0, c = S >>> 16 & 65535 | 0, s = 0; w !== 0; ) {
+      s = w > 2e3 ? 2e3 : w, w -= s;
+      do
+        g = g + L[P++] | 0, c = c + g | 0;
+      while (--s);
+      g %= 65521, c %= 65521;
+    }
+    return g | c << 16 | 0;
+  }
+  return et = x, et;
+}
+var tt, vt;
+function Rt() {
+  if (vt) return tt;
+  vt = 1;
+  function x() {
+    for (var w, P = [], g = 0; g < 256; g++) {
+      w = g;
+      for (var c = 0; c < 8; c++)
+        w = w & 1 ? 3988292384 ^ w >>> 1 : w >>> 1;
+      P[g] = w;
+    }
+    return P;
+  }
+  var S = x();
+  function L(w, P, g, c) {
+    var s = S, o = c + g;
+    w ^= -1;
+    for (var D = c; D < o; D++)
+      w = w >>> 8 ^ s[(w ^ P[D]) & 255];
+    return w ^ -1;
+  }
+  return tt = L, tt;
+}
+var it, gt;
+function ut() {
+  return gt || (gt = 1, it = {
+    2: "need dictionary",
+    /* Z_NEED_DICT       2  */
+    1: "stream end",
+    /* Z_STREAM_END      1  */
+    0: "",
+    /* Z_OK              0  */
+    "-1": "file error",
+    /* Z_ERRNO         (-1) */
+    "-2": "stream error",
+    /* Z_STREAM_ERROR  (-2) */
+    "-3": "data error",
+    /* Z_DATA_ERROR    (-3) */
+    "-4": "insufficient memory",
+    /* Z_MEM_ERROR     (-4) */
+    "-5": "buffer error",
+    /* Z_BUF_ERROR     (-5) */
+    "-6": "incompatible version"
+    /* Z_VERSION_ERROR (-6) */
+  }), it;
+}
+var wt;
+function Bt() {
+  if (wt) return Oe;
+  wt = 1;
+  var x = Me(), S = Dt(), L = At(), w = Rt(), P = ut(), g = 0, c = 1, s = 3, o = 4, D = 5, y = 0, N = 1, m = -2, T = -3, C = -5, $ = -1, M = 1, A = 2, q = 3, I = 4, Y = 0, X = 2, K = 8, z = 9, H = 15, v = 8, _ = 29, r = 256, k = r + 1 + _, F = 30, G = 19, j = 2 * k + 1, Q = 15, B = 3, ae = 258, V = ae + B + 1, re = 32, oe = 42, ee = 69, te = 73, se = 91, ge = 103, he = 113, _e = 666, fe = 1, be = 2, ye = 3, me = 4, le = 3;
+  function ke(e, l) {
+    return e.msg = P[l], l;
+  }
+  function He(e) {
+    return (e << 1) - (e > 4 ? 9 : 0);
+  }
+  function Fe(e) {
+    for (var l = e.length; --l >= 0; )
+      e[l] = 0;
+  }
+  function Se(e) {
+    var l = e.state, u = l.pending;
+    u > e.avail_out && (u = e.avail_out), u !== 0 && (x.arraySet(e.output, l.pending_buf, l.pending_out, u, e.next_out), e.next_out += u, l.pending_out += u, e.total_out += u, e.avail_out -= u, l.pending -= u, l.pending === 0 && (l.pending_out = 0));
+  }
+  function ue(e, l) {
+    S._tr_flush_block(e, e.block_start >= 0 ? e.block_start : -1, e.strstart - e.block_start, l), e.block_start = e.strstart, Se(e.strm);
+  }
+  function J(e, l) {
+    e.pending_buf[e.pending++] = l;
+  }
+  function Te(e, l) {
+    e.pending_buf[e.pending++] = l >>> 8 & 255, e.pending_buf[e.pending++] = l & 255;
+  }
+  function Ke(e, l, u, i) {
+    var n = e.avail_in;
+    return n > i && (n = i), n === 0 ? 0 : (e.avail_in -= n, x.arraySet(l, e.input, e.next_in, n, u), e.state.wrap === 1 ? e.adler = L(e.adler, l, n, u) : e.state.wrap === 2 && (e.adler = w(e.adler, l, n, u)), e.next_in += n, e.total_in += n, n);
+  }
+  function Be(e, l) {
+    var u = e.max_chain_length, i = e.strstart, n, h, U = e.prev_length, R = e.nice_match, O = e.strstart > e.w_size - V ? e.strstart - (e.w_size - V) : 0, ie = e.window, Le = e.w_mask, de = e.prev, ne = e.strstart + ae, ve = ie[i + U - 1], xe = ie[i + U];
+    e.prev_length >= e.good_match && (u >>= 2), R > e.lookahead && (R = e.lookahead);
+    do
+      if (n = l, !(ie[n + U] !== xe || ie[n + U - 1] !== ve || ie[n] !== ie[i] || ie[++n] !== ie[i + 1])) {
+        i += 2, n++;
+        do
+          ;
+        while (ie[++i] === ie[++n] && ie[++i] === ie[++n] && ie[++i] === ie[++n] && ie[++i] === ie[++n] && ie[++i] === ie[++n] && ie[++i] === ie[++n] && ie[++i] === ie[++n] && ie[++i] === ie[++n] && i < ne);
+        if (h = ae - (ne - i), i = ne - ae, h > U) {
+          if (e.match_start = l, U = h, h >= R)
+            break;
+          ve = ie[i + U - 1], xe = ie[i + U];
+        }
+      }
+    while ((l = de[l & Le]) > O && --u !== 0);
+    return U <= e.lookahead ? U : e.lookahead;
+  }
+  function ze(e) {
+    var l = e.w_size, u, i, n, h, U;
+    do {
+      if (h = e.window_size - e.lookahead - e.strstart, e.strstart >= l + (l - V)) {
+        x.arraySet(e.window, e.window, l, l, 0), e.match_start -= l, e.strstart -= l, e.block_start -= l, i = e.hash_size, u = i;
+        do
+          n = e.head[--u], e.head[u] = n >= l ? n - l : 0;
+        while (--i);
+        i = l, u = i;
+        do
+          n = e.prev[--u], e.prev[u] = n >= l ? n - l : 0;
+        while (--i);
+        h += l;
+      }
+      if (e.strm.avail_in === 0)
+        break;
+      if (i = Ke(e.strm, e.window, e.strstart + e.lookahead, h), e.lookahead += i, e.lookahead + e.insert >= B)
+        for (U = e.strstart - e.insert, e.ins_h = e.window[U], e.ins_h = (e.ins_h << e.hash_shift ^ e.window[U + 1]) & e.hash_mask; e.insert && (e.ins_h = (e.ins_h << e.hash_shift ^ e.window[U + B - 1]) & e.hash_mask, e.prev[U & e.w_mask] = e.head[e.ins_h], e.head[e.ins_h] = U, U++, e.insert--, !(e.lookahead + e.insert < B)); )
+          ;
+    } while (e.lookahead < V && e.strm.avail_in !== 0);
+  }
+  function Ye(e, l) {
+    var u = 65535;
+    for (u > e.pending_buf_size - 5 && (u = e.pending_buf_size - 5); ; ) {
+      if (e.lookahead <= 1) {
+        if (ze(e), e.lookahead === 0 && l === g)
+          return fe;
+        if (e.lookahead === 0)
+          break;
+      }
+      e.strstart += e.lookahead, e.lookahead = 0;
+      var i = e.block_start + u;
+      if ((e.strstart === 0 || e.strstart >= i) && (e.lookahead = e.strstart - i, e.strstart = i, ue(e, !1), e.strm.avail_out === 0) || e.strstart - e.block_start >= e.w_size - V && (ue(e, !1), e.strm.avail_out === 0))
+        return fe;
+    }
+    return e.insert = 0, l === o ? (ue(e, !0), e.strm.avail_out === 0 ? ye : me) : (e.strstart > e.block_start && (ue(e, !1), e.strm.avail_out === 0), fe);
+  }
+  function Ce(e, l) {
+    for (var u, i; ; ) {
+      if (e.lookahead < V) {
+        if (ze(e), e.lookahead < V && l === g)
+          return fe;
+        if (e.lookahead === 0)
+          break;
+      }
+      if (u = 0, e.lookahead >= B && (e.ins_h = (e.ins_h << e.hash_shift ^ e.window[e.strstart + B - 1]) & e.hash_mask, u = e.prev[e.strstart & e.w_mask] = e.head[e.ins_h], e.head[e.ins_h] = e.strstart), u !== 0 && e.strstart - u <= e.w_size - V && (e.match_length = Be(e, u)), e.match_length >= B)
+        if (i = S._tr_tally(e, e.strstart - e.match_start, e.match_length - B), e.lookahead -= e.match_length, e.match_length <= e.max_lazy_match && e.lookahead >= B) {
+          e.match_length--;
+          do
+            e.strstart++, e.ins_h = (e.ins_h << e.hash_shift ^ e.window[e.strstart + B - 1]) & e.hash_mask, u = e.prev[e.strstart & e.w_mask] = e.head[e.ins_h], e.head[e.ins_h] = e.strstart;
+          while (--e.match_length !== 0);
+          e.strstart++;
+        } else
+          e.strstart += e.match_length, e.match_length = 0, e.ins_h = e.window[e.strstart], e.ins_h = (e.ins_h << e.hash_shift ^ e.window[e.strstart + 1]) & e.hash_mask;
+      else
+        i = S._tr_tally(e, 0, e.window[e.strstart]), e.lookahead--, e.strstart++;
+      if (i && (ue(e, !1), e.strm.avail_out === 0))
+        return fe;
+    }
+    return e.insert = e.strstart < B - 1 ? e.strstart : B - 1, l === o ? (ue(e, !0), e.strm.avail_out === 0 ? ye : me) : e.last_lit && (ue(e, !1), e.strm.avail_out === 0) ? fe : be;
+  }
+  function Re(e, l) {
+    for (var u, i, n; ; ) {
+      if (e.lookahead < V) {
+        if (ze(e), e.lookahead < V && l === g)
+          return fe;
+        if (e.lookahead === 0)
+          break;
+      }
+      if (u = 0, e.lookahead >= B && (e.ins_h = (e.ins_h << e.hash_shift ^ e.window[e.strstart + B - 1]) & e.hash_mask, u = e.prev[e.strstart & e.w_mask] = e.head[e.ins_h], e.head[e.ins_h] = e.strstart), e.prev_length = e.match_length, e.prev_match = e.match_start, e.match_length = B - 1, u !== 0 && e.prev_length < e.max_lazy_match && e.strstart - u <= e.w_size - V && (e.match_length = Be(e, u), e.match_length <= 5 && (e.strategy === M || e.match_length === B && e.strstart - e.match_start > 4096) && (e.match_length = B - 1)), e.prev_length >= B && e.match_length <= e.prev_length) {
+        n = e.strstart + e.lookahead - B, i = S._tr_tally(e, e.strstart - 1 - e.prev_match, e.prev_length - B), e.lookahead -= e.prev_length - 1, e.prev_length -= 2;
+        do
+          ++e.strstart <= n && (e.ins_h = (e.ins_h << e.hash_shift ^ e.window[e.strstart + B - 1]) & e.hash_mask, u = e.prev[e.strstart & e.w_mask] = e.head[e.ins_h], e.head[e.ins_h] = e.strstart);
+        while (--e.prev_length !== 0);
+        if (e.match_available = 0, e.match_length = B - 1, e.strstart++, i && (ue(e, !1), e.strm.avail_out === 0))
+          return fe;
+      } else if (e.match_available) {
+        if (i = S._tr_tally(e, 0, e.window[e.strstart - 1]), i && ue(e, !1), e.strstart++, e.lookahead--, e.strm.avail_out === 0)
+          return fe;
+      } else
+        e.match_available = 1, e.strstart++, e.lookahead--;
+    }
+    return e.match_available && (i = S._tr_tally(e, 0, e.window[e.strstart - 1]), e.match_available = 0), e.insert = e.strstart < B - 1 ? e.strstart : B - 1, l === o ? (ue(e, !0), e.strm.avail_out === 0 ? ye : me) : e.last_lit && (ue(e, !1), e.strm.avail_out === 0) ? fe : be;
+  }
+  function Xe(e, l) {
+    for (var u, i, n, h, U = e.window; ; ) {
+      if (e.lookahead <= ae) {
+        if (ze(e), e.lookahead <= ae && l === g)
+          return fe;
+        if (e.lookahead === 0)
+          break;
+      }
+      if (e.match_length = 0, e.lookahead >= B && e.strstart > 0 && (n = e.strstart - 1, i = U[n], i === U[++n] && i === U[++n] && i === U[++n])) {
+        h = e.strstart + ae;
+        do
+          ;
+        while (i === U[++n] && i === U[++n] && i === U[++n] && i === U[++n] && i === U[++n] && i === U[++n] && i === U[++n] && i === U[++n] && n < h);
+        e.match_length = ae - (h - n), e.match_length > e.lookahead && (e.match_length = e.lookahead);
+      }
+      if (e.match_length >= B ? (u = S._tr_tally(e, 1, e.match_length - B), e.lookahead -= e.match_length, e.strstart += e.match_length, e.match_length = 0) : (u = S._tr_tally(e, 0, e.window[e.strstart]), e.lookahead--, e.strstart++), u && (ue(e, !1), e.strm.avail_out === 0))
+        return fe;
+    }
+    return e.insert = 0, l === o ? (ue(e, !0), e.strm.avail_out === 0 ? ye : me) : e.last_lit && (ue(e, !1), e.strm.avail_out === 0) ? fe : be;
+  }
+  function Ue(e, l) {
+    for (var u; ; ) {
+      if (e.lookahead === 0 && (ze(e), e.lookahead === 0)) {
+        if (l === g)
+          return fe;
+        break;
+      }
+      if (e.match_length = 0, u = S._tr_tally(e, 0, e.window[e.strstart]), e.lookahead--, e.strstart++, u && (ue(e, !1), e.strm.avail_out === 0))
+        return fe;
+    }
+    return e.insert = 0, l === o ? (ue(e, !0), e.strm.avail_out === 0 ? ye : me) : e.last_lit && (ue(e, !1), e.strm.avail_out === 0) ? fe : be;
+  }
+  function pe(e, l, u, i, n) {
+    this.good_length = e, this.max_lazy = l, this.nice_length = u, this.max_chain = i, this.func = n;
+  }
+  var Ie;
+  Ie = [
+    /*      good lazy nice chain */
+    new pe(0, 0, 0, 0, Ye),
+    /* 0 store only */
+    new pe(4, 4, 8, 4, Ce),
+    /* 1 max speed, no lazy matches */
+    new pe(4, 5, 16, 8, Ce),
+    /* 2 */
+    new pe(4, 6, 32, 32, Ce),
+    /* 3 */
+    new pe(4, 4, 16, 16, Re),
+    /* 4 lazy matches */
+    new pe(8, 16, 32, 32, Re),
+    /* 5 */
+    new pe(8, 16, 128, 128, Re),
+    /* 6 */
+    new pe(8, 32, 128, 256, Re),
+    /* 7 */
+    new pe(32, 128, 258, 1024, Re),
+    /* 8 */
+    new pe(32, 258, 258, 4096, Re)
+    /* 9 max compression */
+  ];
+  function Ge(e) {
+    e.window_size = 2 * e.w_size, Fe(e.head), e.max_lazy_match = Ie[e.level].max_lazy, e.good_match = Ie[e.level].good_length, e.nice_match = Ie[e.level].nice_length, e.max_chain_length = Ie[e.level].max_chain, e.strstart = 0, e.block_start = 0, e.lookahead = 0, e.insert = 0, e.match_length = e.prev_length = B - 1, e.match_available = 0, e.ins_h = 0;
+  }
+  function a() {
+    this.strm = null, this.status = 0, this.pending_buf = null, this.pending_buf_size = 0, this.pending_out = 0, this.pending = 0, this.wrap = 0, this.gzhead = null, this.gzindex = 0, this.method = K, this.last_flush = -1, this.w_size = 0, this.w_bits = 0, this.w_mask = 0, this.window = null, this.window_size = 0, this.prev = null, this.head = null, this.ins_h = 0, this.hash_size = 0, this.hash_bits = 0, this.hash_mask = 0, this.hash_shift = 0, this.block_start = 0, this.match_length = 0, this.prev_match = 0, this.match_available = 0, this.strstart = 0, this.match_start = 0, this.lookahead = 0, this.prev_length = 0, this.max_chain_length = 0, this.max_lazy_match = 0, this.level = 0, this.strategy = 0, this.good_match = 0, this.nice_match = 0, this.dyn_ltree = new x.Buf16(j * 2), this.dyn_dtree = new x.Buf16((2 * F + 1) * 2), this.bl_tree = new x.Buf16((2 * G + 1) * 2), Fe(this.dyn_ltree), Fe(this.dyn_dtree), Fe(this.bl_tree), this.l_desc = null, this.d_desc = null, this.bl_desc = null, this.bl_count = new x.Buf16(Q + 1), this.heap = new x.Buf16(2 * k + 1), Fe(this.heap), this.heap_len = 0, this.heap_max = 0, this.depth = new x.Buf16(2 * k + 1), Fe(this.depth), this.l_buf = 0, this.lit_bufsize = 0, this.last_lit = 0, this.d_buf = 0, this.opt_len = 0, this.static_len = 0, this.matches = 0, this.insert = 0, this.bi_buf = 0, this.bi_valid = 0;
+  }
+  function b(e) {
+    var l;
+    return !e || !e.state ? ke(e, m) : (e.total_in = e.total_out = 0, e.data_type = X, l = e.state, l.pending = 0, l.pending_out = 0, l.wrap < 0 && (l.wrap = -l.wrap), l.status = l.wrap ? oe : he, e.adler = l.wrap === 2 ? 0 : 1, l.last_flush = g, S._tr_init(l), y);
+  }
+  function E(e) {
+    var l = b(e);
+    return l === y && Ge(e.state), l;
+  }
+  function Z(e, l) {
+    return !e || !e.state || e.state.wrap !== 2 ? m : (e.state.gzhead = l, y);
+  }
+  function f(e, l, u, i, n, h) {
+    if (!e)
+      return m;
+    var U = 1;
+    if (l === $ && (l = 6), i < 0 ? (U = 0, i = -i) : i > 15 && (U = 2, i -= 16), n < 1 || n > z || u !== K || i < 8 || i > 15 || l < 0 || l > 9 || h < 0 || h > I)
+      return ke(e, m);
+    i === 8 && (i = 9);
+    var R = new a();
+    return e.state = R, R.strm = e, R.wrap = U, R.gzhead = null, R.w_bits = i, R.w_size = 1 << R.w_bits, R.w_mask = R.w_size - 1, R.hash_bits = n + 7, R.hash_size = 1 << R.hash_bits, R.hash_mask = R.hash_size - 1, R.hash_shift = ~~((R.hash_bits + B - 1) / B), R.window = new x.Buf8(R.w_size * 2), R.head = new x.Buf16(R.hash_size), R.prev = new x.Buf16(R.w_size), R.lit_bufsize = 1 << n + 6, R.pending_buf_size = R.lit_bufsize * 4, R.pending_buf = new x.Buf8(R.pending_buf_size), R.d_buf = 1 * R.lit_bufsize, R.l_buf = 3 * R.lit_bufsize, R.level = l, R.strategy = h, R.method = u, E(e);
+  }
+  function d(e, l) {
+    return f(e, l, K, H, v, Y);
+  }
+  function t(e, l) {
+    var u, i, n, h;
+    if (!e || !e.state || l > D || l < 0)
+      return e ? ke(e, m) : m;
+    if (i = e.state, !e.output || !e.input && e.avail_in !== 0 || i.status === _e && l !== o)
+      return ke(e, e.avail_out === 0 ? C : m);
+    if (i.strm = e, u = i.last_flush, i.last_flush = l, i.status === oe)
+      if (i.wrap === 2)
+        e.adler = 0, J(i, 31), J(i, 139), J(i, 8), i.gzhead ? (J(
+          i,
+          (i.gzhead.text ? 1 : 0) + (i.gzhead.hcrc ? 2 : 0) + (i.gzhead.extra ? 4 : 0) + (i.gzhead.name ? 8 : 0) + (i.gzhead.comment ? 16 : 0)
+        ), J(i, i.gzhead.time & 255), J(i, i.gzhead.time >> 8 & 255), J(i, i.gzhead.time >> 16 & 255), J(i, i.gzhead.time >> 24 & 255), J(i, i.level === 9 ? 2 : i.strategy >= A || i.level < 2 ? 4 : 0), J(i, i.gzhead.os & 255), i.gzhead.extra && i.gzhead.extra.length && (J(i, i.gzhead.extra.length & 255), J(i, i.gzhead.extra.length >> 8 & 255)), i.gzhead.hcrc && (e.adler = w(e.adler, i.pending_buf, i.pending, 0)), i.gzindex = 0, i.status = ee) : (J(i, 0), J(i, 0), J(i, 0), J(i, 0), J(i, 0), J(i, i.level === 9 ? 2 : i.strategy >= A || i.level < 2 ? 4 : 0), J(i, le), i.status = he);
+      else {
+        var U = K + (i.w_bits - 8 << 4) << 8, R = -1;
+        i.strategy >= A || i.level < 2 ? R = 0 : i.level < 6 ? R = 1 : i.level === 6 ? R = 2 : R = 3, U |= R << 6, i.strstart !== 0 && (U |= re), U += 31 - U % 31, i.status = he, Te(i, U), i.strstart !== 0 && (Te(i, e.adler >>> 16), Te(i, e.adler & 65535)), e.adler = 1;
+      }
+    if (i.status === ee)
+      if (i.gzhead.extra) {
+        for (n = i.pending; i.gzindex < (i.gzhead.extra.length & 65535) && !(i.pending === i.pending_buf_size && (i.gzhead.hcrc && i.pending > n && (e.adler = w(e.adler, i.pending_buf, i.pending - n, n)), Se(e), n = i.pending, i.pending === i.pending_buf_size)); )
+          J(i, i.gzhead.extra[i.gzindex] & 255), i.gzindex++;
+        i.gzhead.hcrc && i.pending > n && (e.adler = w(e.adler, i.pending_buf, i.pending - n, n)), i.gzindex === i.gzhead.extra.length && (i.gzindex = 0, i.status = te);
+      } else
+        i.status = te;
+    if (i.status === te)
+      if (i.gzhead.name) {
+        n = i.pending;
+        do {
+          if (i.pending === i.pending_buf_size && (i.gzhead.hcrc && i.pending > n && (e.adler = w(e.adler, i.pending_buf, i.pending - n, n)), Se(e), n = i.pending, i.pending === i.pending_buf_size)) {
+            h = 1;
+            break;
+          }
+          i.gzindex < i.gzhead.name.length ? h = i.gzhead.name.charCodeAt(i.gzindex++) & 255 : h = 0, J(i, h);
+        } while (h !== 0);
+        i.gzhead.hcrc && i.pending > n && (e.adler = w(e.adler, i.pending_buf, i.pending - n, n)), h === 0 && (i.gzindex = 0, i.status = se);
+      } else
+        i.status = se;
+    if (i.status === se)
+      if (i.gzhead.comment) {
+        n = i.pending;
+        do {
+          if (i.pending === i.pending_buf_size && (i.gzhead.hcrc && i.pending > n && (e.adler = w(e.adler, i.pending_buf, i.pending - n, n)), Se(e), n = i.pending, i.pending === i.pending_buf_size)) {
+            h = 1;
+            break;
+          }
+          i.gzindex < i.gzhead.comment.length ? h = i.gzhead.comment.charCodeAt(i.gzindex++) & 255 : h = 0, J(i, h);
+        } while (h !== 0);
+        i.gzhead.hcrc && i.pending > n && (e.adler = w(e.adler, i.pending_buf, i.pending - n, n)), h === 0 && (i.status = ge);
+      } else
+        i.status = ge;
+    if (i.status === ge && (i.gzhead.hcrc ? (i.pending + 2 > i.pending_buf_size && Se(e), i.pending + 2 <= i.pending_buf_size && (J(i, e.adler & 255), J(i, e.adler >> 8 & 255), e.adler = 0, i.status = he)) : i.status = he), i.pending !== 0) {
+      if (Se(e), e.avail_out === 0)
+        return i.last_flush = -1, y;
+    } else if (e.avail_in === 0 && He(l) <= He(u) && l !== o)
+      return ke(e, C);
+    if (i.status === _e && e.avail_in !== 0)
+      return ke(e, C);
+    if (e.avail_in !== 0 || i.lookahead !== 0 || l !== g && i.status !== _e) {
+      var O = i.strategy === A ? Ue(i, l) : i.strategy === q ? Xe(i, l) : Ie[i.level].func(i, l);
+      if ((O === ye || O === me) && (i.status = _e), O === fe || O === ye)
+        return e.avail_out === 0 && (i.last_flush = -1), y;
+      if (O === be && (l === c ? S._tr_align(i) : l !== D && (S._tr_stored_block(i, 0, 0, !1), l === s && (Fe(i.head), i.lookahead === 0 && (i.strstart = 0, i.block_start = 0, i.insert = 0))), Se(e), e.avail_out === 0))
+        return i.last_flush = -1, y;
+    }
+    return l !== o ? y : i.wrap <= 0 ? N : (i.wrap === 2 ? (J(i, e.adler & 255), J(i, e.adler >> 8 & 255), J(i, e.adler >> 16 & 255), J(i, e.adler >> 24 & 255), J(i, e.total_in & 255), J(i, e.total_in >> 8 & 255), J(i, e.total_in >> 16 & 255), J(i, e.total_in >> 24 & 255)) : (Te(i, e.adler >>> 16), Te(i, e.adler & 65535)), Se(e), i.wrap > 0 && (i.wrap = -i.wrap), i.pending !== 0 ? y : N);
+  }
+  function p(e) {
+    var l;
+    return !e || !e.state ? m : (l = e.state.status, l !== oe && l !== ee && l !== te && l !== se && l !== ge && l !== he && l !== _e ? ke(e, m) : (e.state = null, l === he ? ke(e, T) : y));
+  }
+  function W(e, l) {
+    var u = l.length, i, n, h, U, R, O, ie, Le;
+    if (!e || !e.state || (i = e.state, U = i.wrap, U === 2 || U === 1 && i.status !== oe || i.lookahead))
+      return m;
+    for (U === 1 && (e.adler = L(e.adler, l, u, 0)), i.wrap = 0, u >= i.w_size && (U === 0 && (Fe(i.head), i.strstart = 0, i.block_start = 0, i.insert = 0), Le = new x.Buf8(i.w_size), x.arraySet(Le, l, u - i.w_size, i.w_size, 0), l = Le, u = i.w_size), R = e.avail_in, O = e.next_in, ie = e.input, e.avail_in = u, e.next_in = 0, e.input = l, ze(i); i.lookahead >= B; ) {
+      n = i.strstart, h = i.lookahead - (B - 1);
+      do
+        i.ins_h = (i.ins_h << i.hash_shift ^ i.window[n + B - 1]) & i.hash_mask, i.prev[n & i.w_mask] = i.head[i.ins_h], i.head[i.ins_h] = n, n++;
+      while (--h);
+      i.strstart = n, i.lookahead = B - 1, ze(i);
+    }
+    return i.strstart += i.lookahead, i.block_start = i.strstart, i.insert = i.lookahead, i.lookahead = 0, i.match_length = i.prev_length = B - 1, i.match_available = 0, e.next_in = O, e.input = ie, e.avail_in = R, i.wrap = U, y;
+  }
+  return Oe.deflateInit = d, Oe.deflateInit2 = f, Oe.deflateReset = E, Oe.deflateResetKeep = b, Oe.deflateSetHeader = Z, Oe.deflate = t, Oe.deflateEnd = p, Oe.deflateSetDictionary = W, Oe.deflateInfo = "pako deflate (from Nodeca project)", Oe;
+}
+var Pe = {}, bt;
+function Ot() {
+  if (bt) return Pe;
+  bt = 1;
+  var x = Me(), S = !0, L = !0;
+  try {
+    String.fromCharCode.apply(null, [0]);
+  } catch {
+    S = !1;
+  }
+  try {
+    String.fromCharCode.apply(null, new Uint8Array(1));
+  } catch {
+    L = !1;
+  }
+  for (var w = new x.Buf8(256), P = 0; P < 256; P++)
+    w[P] = P >= 252 ? 6 : P >= 248 ? 5 : P >= 240 ? 4 : P >= 224 ? 3 : P >= 192 ? 2 : 1;
+  w[254] = w[254] = 1, Pe.string2buf = function(c) {
+    var s, o, D, y, N, m = c.length, T = 0;
+    for (y = 0; y < m; y++)
+      o = c.charCodeAt(y), (o & 64512) === 55296 && y + 1 < m && (D = c.charCodeAt(y + 1), (D & 64512) === 56320 && (o = 65536 + (o - 55296 << 10) + (D - 56320), y++)), T += o < 128 ? 1 : o < 2048 ? 2 : o < 65536 ? 3 : 4;
+    for (s = new x.Buf8(T), N = 0, y = 0; N < T; y++)
+      o = c.charCodeAt(y), (o & 64512) === 55296 && y + 1 < m && (D = c.charCodeAt(y + 1), (D & 64512) === 56320 && (o = 65536 + (o - 55296 << 10) + (D - 56320), y++)), o < 128 ? s[N++] = o : o < 2048 ? (s[N++] = 192 | o >>> 6, s[N++] = 128 | o & 63) : o < 65536 ? (s[N++] = 224 | o >>> 12, s[N++] = 128 | o >>> 6 & 63, s[N++] = 128 | o & 63) : (s[N++] = 240 | o >>> 18, s[N++] = 128 | o >>> 12 & 63, s[N++] = 128 | o >>> 6 & 63, s[N++] = 128 | o & 63);
+    return s;
+  };
+  function g(c, s) {
+    if (s < 65534 && (c.subarray && L || !c.subarray && S))
+      return String.fromCharCode.apply(null, x.shrinkBuf(c, s));
+    for (var o = "", D = 0; D < s; D++)
+      o += String.fromCharCode(c[D]);
+    return o;
+  }
+  return Pe.buf2binstring = function(c) {
+    return g(c, c.length);
+  }, Pe.binstring2buf = function(c) {
+    for (var s = new x.Buf8(c.length), o = 0, D = s.length; o < D; o++)
+      s[o] = c.charCodeAt(o);
+    return s;
+  }, Pe.buf2string = function(c, s) {
+    var o, D, y, N, m = s || c.length, T = new Array(m * 2);
+    for (D = 0, o = 0; o < m; ) {
+      if (y = c[o++], y < 128) {
+        T[D++] = y;
+        continue;
+      }
+      if (N = w[y], N > 4) {
+        T[D++] = 65533, o += N - 1;
+        continue;
+      }
+      for (y &= N === 2 ? 31 : N === 3 ? 15 : 7; N > 1 && o < m; )
+        y = y << 6 | c[o++] & 63, N--;
+      if (N > 1) {
+        T[D++] = 65533;
+        continue;
+      }
+      y < 65536 ? T[D++] = y : (y -= 65536, T[D++] = 55296 | y >> 10 & 1023, T[D++] = 56320 | y & 1023);
+    }
+    return g(T, D);
+  }, Pe.utf8border = function(c, s) {
+    var o;
+    for (s = s || c.length, s > c.length && (s = c.length), o = s - 1; o >= 0 && (c[o] & 192) === 128; )
+      o--;
+    return o < 0 || o === 0 ? s : o + w[c[o]] > s ? o : s;
+  }, Pe;
+}
+var at, pt;
+function It() {
+  if (pt) return at;
+  pt = 1;
+  function x() {
+    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;
+  }
+  return at = x, at;
+}
+var xt;
+function Ct() {
+  if (xt) return We;
+  xt = 1;
+  var x = Bt(), S = Me(), L = Ot(), w = ut(), P = It(), g = Object.prototype.toString, c = 0, s = 4, o = 0, D = 1, y = 2, N = -1, m = 0, T = 8;
+  function C(q) {
+    if (!(this instanceof C)) return new C(q);
+    this.options = S.assign({
+      level: N,
+      method: T,
+      chunkSize: 16384,
+      windowBits: 15,
+      memLevel: 8,
+      strategy: m,
+      to: ""
+    }, q || {});
+    var I = this.options;
+    I.raw && I.windowBits > 0 ? I.windowBits = -I.windowBits : I.gzip && I.windowBits > 0 && I.windowBits < 16 && (I.windowBits += 16), this.err = 0, this.msg = "", this.ended = !1, this.chunks = [], this.strm = new P(), this.strm.avail_out = 0;
+    var Y = x.deflateInit2(
+      this.strm,
+      I.level,
+      I.method,
+      I.windowBits,
+      I.memLevel,
+      I.strategy
+    );
+    if (Y !== o)
+      throw new Error(w[Y]);
+    if (I.header && x.deflateSetHeader(this.strm, I.header), I.dictionary) {
+      var X;
+      if (typeof I.dictionary == "string" ? X = L.string2buf(I.dictionary) : g.call(I.dictionary) === "[object ArrayBuffer]" ? X = new Uint8Array(I.dictionary) : X = I.dictionary, Y = x.deflateSetDictionary(this.strm, X), Y !== o)
+        throw new Error(w[Y]);
+      this._dict_set = !0;
+    }
+  }
+  C.prototype.push = function(q, I) {
+    var Y = this.strm, X = this.options.chunkSize, K, z;
+    if (this.ended)
+      return !1;
+    z = I === ~~I ? I : I === !0 ? s : c, typeof q == "string" ? Y.input = L.string2buf(q) : g.call(q) === "[object ArrayBuffer]" ? Y.input = new Uint8Array(q) : Y.input = q, Y.next_in = 0, Y.avail_in = Y.input.length;
+    do {
+      if (Y.avail_out === 0 && (Y.output = new S.Buf8(X), Y.next_out = 0, Y.avail_out = X), K = x.deflate(Y, z), K !== D && K !== o)
+        return this.onEnd(K), this.ended = !0, !1;
+      (Y.avail_out === 0 || Y.avail_in === 0 && (z === s || z === y)) && (this.options.to === "string" ? this.onData(L.buf2binstring(S.shrinkBuf(Y.output, Y.next_out))) : this.onData(S.shrinkBuf(Y.output, Y.next_out)));
+    } while ((Y.avail_in > 0 || Y.avail_out === 0) && K !== D);
+    return z === s ? (K = x.deflateEnd(this.strm), this.onEnd(K), this.ended = !0, K === o) : (z === y && (this.onEnd(o), Y.avail_out = 0), !0);
+  }, C.prototype.onData = function(q) {
+    this.chunks.push(q);
+  }, C.prototype.onEnd = function(q) {
+    q === o && (this.options.to === "string" ? this.result = this.chunks.join("") : this.result = S.flattenChunks(this.chunks)), this.chunks = [], this.err = q, this.msg = this.strm.msg;
+  };
+  function $(q, I) {
+    var Y = new C(I);
+    if (Y.push(q, !0), Y.err)
+      throw Y.msg || w[Y.err];
+    return Y.result;
+  }
+  function M(q, I) {
+    return I = I || {}, I.raw = !0, $(q, I);
+  }
+  function A(q, I) {
+    return I = I || {}, I.gzip = !0, $(q, I);
+  }
+  return We.Deflate = C, We.deflate = $, We.deflateRaw = M, We.gzip = A, We;
+}
+var je = {}, Ae = {}, rt, kt;
+function Ut() {
+  if (kt) return rt;
+  kt = 1;
+  var x = 30, S = 12;
+  return rt = function(w, P) {
+    var g, c, s, o, D, y, N, m, T, C, $, M, A, q, I, Y, X, K, z, H, v, _, r, k, F;
+    g = w.state, c = w.next_in, k = w.input, s = c + (w.avail_in - 5), o = w.next_out, F = w.output, D = o - (P - w.avail_out), y = o + (w.avail_out - 257), N = g.dmax, m = g.wsize, T = g.whave, C = g.wnext, $ = g.window, M = g.hold, A = g.bits, q = g.lencode, I = g.distcode, Y = (1 << g.lenbits) - 1, X = (1 << g.distbits) - 1;
+    e:
+      do {
+        A < 15 && (M += k[c++] << A, A += 8, M += k[c++] << A, A += 8), K = q[M & Y];
+        t:
+          for (; ; ) {
+            if (z = K >>> 24, M >>>= z, A -= z, z = K >>> 16 & 255, z === 0)
+              F[o++] = K & 65535;
+            else if (z & 16) {
+              H = K & 65535, z &= 15, z && (A < z && (M += k[c++] << A, A += 8), H += M & (1 << z) - 1, M >>>= z, A -= z), A < 15 && (M += k[c++] << A, A += 8, M += k[c++] << A, A += 8), K = I[M & X];
+              i:
+                for (; ; ) {
+                  if (z = K >>> 24, M >>>= z, A -= z, z = K >>> 16 & 255, z & 16) {
+                    if (v = K & 65535, z &= 15, A < z && (M += k[c++] << A, A += 8, A < z && (M += k[c++] << A, A += 8)), v += M & (1 << z) - 1, v > N) {
+                      w.msg = "invalid distance too far back", g.mode = x;
+                      break e;
+                    }
+                    if (M >>>= z, A -= z, z = o - D, v > z) {
+                      if (z = v - z, z > T && g.sane) {
+                        w.msg = "invalid distance too far back", g.mode = x;
+                        break e;
+                      }
+                      if (_ = 0, r = $, C === 0) {
+                        if (_ += m - z, z < H) {
+                          H -= z;
+                          do
+                            F[o++] = $[_++];
+                          while (--z);
+                          _ = o - v, r = F;
+                        }
+                      } else if (C < z) {
+                        if (_ += m + C - z, z -= C, z < H) {
+                          H -= z;
+                          do
+                            F[o++] = $[_++];
+                          while (--z);
+                          if (_ = 0, C < H) {
+                            z = C, H -= z;
+                            do
+                              F[o++] = $[_++];
+                            while (--z);
+                            _ = o - v, r = F;
+                          }
+                        }
+                      } else if (_ += C - z, z < H) {
+                        H -= z;
+                        do
+                          F[o++] = $[_++];
+                        while (--z);
+                        _ = o - v, r = F;
+                      }
+                      for (; H > 2; )
+                        F[o++] = r[_++], F[o++] = r[_++], F[o++] = r[_++], H -= 3;
+                      H && (F[o++] = r[_++], H > 1 && (F[o++] = r[_++]));
+                    } else {
+                      _ = o - v;
+                      do
+                        F[o++] = F[_++], F[o++] = F[_++], F[o++] = F[_++], H -= 3;
+                      while (H > 2);
+                      H && (F[o++] = F[_++], H > 1 && (F[o++] = F[_++]));
+                    }
+                  } else if (z & 64) {
+                    w.msg = "invalid distance code", g.mode = x;
+                    break e;
+                  } else {
+                    K = I[(K & 65535) + (M & (1 << z) - 1)];
+                    continue i;
+                  }
+                  break;
+                }
+            } else if (z & 64)
+              if (z & 32) {
+                g.mode = S;
+                break e;
+              } else {
+                w.msg = "invalid literal/length code", g.mode = x;
+                break e;
+              }
+            else {
+              K = q[(K & 65535) + (M & (1 << z) - 1)];
+              continue t;
+            }
+            break;
+          }
+      } while (c < s && o < y);
+    H = A >> 3, c -= H, A -= H << 3, M &= (1 << A) - 1, w.next_in = c, w.next_out = o, w.avail_in = c < s ? 5 + (s - c) : 5 - (c - s), w.avail_out = o < y ? 257 + (y - o) : 257 - (o - y), g.hold = M, g.bits = A;
+  }, rt;
+}
+var nt, Et;
+function Mt() {
+  if (Et) return nt;
+  Et = 1;
+  var x = Me(), S = 15, L = 852, w = 592, P = 0, g = 1, c = 2, s = [
+    /* 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
+  ], o = [
+    /* 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
+  ], D = [
+    /* 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
+  ], y = [
+    /* 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
+  ];
+  return nt = function(m, T, C, $, M, A, q, I) {
+    var Y = I.bits, X = 0, K = 0, z = 0, H = 0, v = 0, _ = 0, r = 0, k = 0, F = 0, G = 0, j, Q, B, ae, V, re = null, oe = 0, ee, te = new x.Buf16(S + 1), se = new x.Buf16(S + 1), ge = null, he = 0, _e, fe, be;
+    for (X = 0; X <= S; X++)
+      te[X] = 0;
+    for (K = 0; K < $; K++)
+      te[T[C + K]]++;
+    for (v = Y, H = S; H >= 1 && te[H] === 0; H--)
+      ;
+    if (v > H && (v = H), H === 0)
+      return M[A++] = 1 << 24 | 64 << 16 | 0, M[A++] = 1 << 24 | 64 << 16 | 0, I.bits = 1, 0;
+    for (z = 1; z < H && te[z] === 0; z++)
+      ;
+    for (v < z && (v = z), k = 1, X = 1; X <= S; X++)
+      if (k <<= 1, k -= te[X], k < 0)
+        return -1;
+    if (k > 0 && (m === P || H !== 1))
+      return -1;
+    for (se[1] = 0, X = 1; X < S; X++)
+      se[X + 1] = se[X] + te[X];
+    for (K = 0; K < $; K++)
+      T[C + K] !== 0 && (q[se[T[C + K]]++] = K);
+    if (m === P ? (re = ge = q, ee = 19) : m === g ? (re = s, oe -= 257, ge = o, he -= 257, ee = 256) : (re = D, ge = y, ee = -1), G = 0, K = 0, X = z, V = A, _ = v, r = 0, B = -1, F = 1 << v, ae = F - 1, m === g && F > L || m === c && F > w)
+      return 1;
+    for (; ; ) {
+      _e = X - r, q[K] < ee ? (fe = 0, be = q[K]) : q[K] > ee ? (fe = ge[he + q[K]], be = re[oe + q[K]]) : (fe = 96, be = 0), j = 1 << X - r, Q = 1 << _, z = Q;
+      do
+        Q -= j, M[V + (G >> r) + Q] = _e << 24 | fe << 16 | be | 0;
+      while (Q !== 0);
+      for (j = 1 << X - 1; G & j; )
+        j >>= 1;
+      if (j !== 0 ? (G &= j - 1, G += j) : G = 0, K++, --te[X] === 0) {
+        if (X === H)
+          break;
+        X = T[C + q[K]];
+      }
+      if (X > v && (G & ae) !== B) {
+        for (r === 0 && (r = v), V += z, _ = X - r, k = 1 << _; _ + r < H && (k -= te[_ + r], !(k <= 0)); )
+          _++, k <<= 1;
+        if (F += 1 << _, m === g && F > L || m === c && F > w)
+          return 1;
+        B = G & ae, M[B] = v << 24 | _ << 16 | V - A | 0;
+      }
+    }
+    return G !== 0 && (M[V + G] = X - r << 24 | 64 << 16 | 0), I.bits = v, 0;
+  }, nt;
+}
+var St;
+function Ht() {
+  if (St) return Ae;
+  St = 1;
+  var x = Me(), S = At(), L = Rt(), w = Ut(), P = Mt(), g = 0, c = 1, s = 2, o = 4, D = 5, y = 6, N = 0, m = 1, T = 2, C = -2, $ = -3, M = -4, A = -5, q = 8, I = 1, Y = 2, X = 3, K = 4, z = 5, H = 6, v = 7, _ = 8, r = 9, k = 10, F = 11, G = 12, j = 13, Q = 14, B = 15, ae = 16, V = 17, re = 18, oe = 19, ee = 20, te = 21, se = 22, ge = 23, he = 24, _e = 25, fe = 26, be = 27, ye = 28, me = 29, le = 30, ke = 31, He = 32, Fe = 852, Se = 592, ue = 15, J = ue;
+  function Te(f) {
+    return (f >>> 24 & 255) + (f >>> 8 & 65280) + ((f & 65280) << 8) + ((f & 255) << 24);
+  }
+  function Ke() {
+    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 = new x.Buf16(320), this.work = new x.Buf16(288), this.lendyn = null, this.distdyn = null, this.sane = 0, this.back = 0, this.was = 0;
+  }
+  function Be(f) {
+    var d;
+    return !f || !f.state ? C : (d = f.state, f.total_in = f.total_out = d.total = 0, f.msg = "", d.wrap && (f.adler = d.wrap & 1), d.mode = I, d.last = 0, d.havedict = 0, d.dmax = 32768, d.head = null, d.hold = 0, d.bits = 0, d.lencode = d.lendyn = new x.Buf32(Fe), d.distcode = d.distdyn = new x.Buf32(Se), d.sane = 1, d.back = -1, N);
+  }
+  function ze(f) {
+    var d;
+    return !f || !f.state ? C : (d = f.state, d.wsize = 0, d.whave = 0, d.wnext = 0, Be(f));
+  }
+  function Ye(f, d) {
+    var t, p;
+    return !f || !f.state || (p = f.state, d < 0 ? (t = 0, d = -d) : (t = (d >> 4) + 1, d < 48 && (d &= 15)), d && (d < 8 || d > 15)) ? C : (p.window !== null && p.wbits !== d && (p.window = null), p.wrap = t, p.wbits = d, ze(f));
+  }
+  function Ce(f, d) {
+    var t, p;
+    return f ? (p = new Ke(), f.state = p, p.window = null, t = Ye(f, d), t !== N && (f.state = null), t) : C;
+  }
+  function Re(f) {
+    return Ce(f, J);
+  }
+  var Xe = !0, Ue, pe;
+  function Ie(f) {
+    if (Xe) {
+      var d;
+      for (Ue = new x.Buf32(512), pe = new x.Buf32(32), d = 0; d < 144; )
+        f.lens[d++] = 8;
+      for (; d < 256; )
+        f.lens[d++] = 9;
+      for (; d < 280; )
+        f.lens[d++] = 7;
+      for (; d < 288; )
+        f.lens[d++] = 8;
+      for (P(c, f.lens, 0, 288, Ue, 0, f.work, { bits: 9 }), d = 0; d < 32; )
+        f.lens[d++] = 5;
+      P(s, f.lens, 0, 32, pe, 0, f.work, { bits: 5 }), Xe = !1;
+    }
+    f.lencode = Ue, f.lenbits = 9, f.distcode = pe, f.distbits = 5;
+  }
+  function Ge(f, d, t, p) {
+    var W, e = f.state;
+    return e.window === null && (e.wsize = 1 << e.wbits, e.wnext = 0, e.whave = 0, e.window = new x.Buf8(e.wsize)), p >= e.wsize ? (x.arraySet(e.window, d, t - e.wsize, e.wsize, 0), e.wnext = 0, e.whave = e.wsize) : (W = e.wsize - e.wnext, W > p && (W = p), x.arraySet(e.window, d, t - p, W, e.wnext), p -= W, p ? (x.arraySet(e.window, d, t - p, p, 0), e.wnext = p, e.whave = e.wsize) : (e.wnext += W, e.wnext === e.wsize && (e.wnext = 0), e.whave < e.wsize && (e.whave += W))), 0;
+  }
+  function a(f, d) {
+    var t, p, W, e, l, u, i, n, h, U, R, O, ie, Le, de = 0, ne, ve, xe, Ee, Ve, $e, ce, Ne, we = new x.Buf8(4), De, Ze, _t = (
+      /* permutation of code lengths */
+      [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]
+    );
+    if (!f || !f.state || !f.output || !f.input && f.avail_in !== 0)
+      return C;
+    t = f.state, t.mode === G && (t.mode = j), l = f.next_out, W = f.output, i = f.avail_out, e = f.next_in, p = f.input, u = f.avail_in, n = t.hold, h = t.bits, U = u, R = i, Ne = N;
+    e:
+      for (; ; )
+        switch (t.mode) {
+          case I:
+            if (t.wrap === 0) {
+              t.mode = j;
+              break;
+            }
+            for (; h < 16; ) {
+              if (u === 0)
+                break e;
+              u--, n += p[e++] << h, h += 8;
+            }
+            if (t.wrap & 2 && n === 35615) {
+              t.check = 0, we[0] = n & 255, we[1] = n >>> 8 & 255, t.check = L(t.check, we, 2, 0), n = 0, h = 0, t.mode = Y;
+              break;
+            }
+            if (t.flags = 0, t.head && (t.head.done = !1), !(t.wrap & 1) || /* check if zlib header allowed */
+            (((n & 255) << 8) + (n >> 8)) % 31) {
+              f.msg = "incorrect header check", t.mode = le;
+              break;
+            }
+            if ((n & 15) !== q) {
+              f.msg = "unknown compression method", t.mode = le;
+              break;
+            }
+            if (n >>>= 4, h -= 4, ce = (n & 15) + 8, t.wbits === 0)
+              t.wbits = ce;
+            else if (ce > t.wbits) {
+              f.msg = "invalid window size", t.mode = le;
+              break;
+            }
+            t.dmax = 1 << ce, f.adler = t.check = 1, t.mode = n & 512 ? k : G, n = 0, h = 0;
+            break;
+          case Y:
+            for (; h < 16; ) {
+              if (u === 0)
+                break e;
+              u--, n += p[e++] << h, h += 8;
+            }
+            if (t.flags = n, (t.flags & 255) !== q) {
+              f.msg = "unknown compression method", t.mode = le;
+              break;
+            }
+            if (t.flags & 57344) {
+              f.msg = "unknown header flags set", t.mode = le;
+              break;
+            }
+            t.head && (t.head.text = n >> 8 & 1), t.flags & 512 && (we[0] = n & 255, we[1] = n >>> 8 & 255, t.check = L(t.check, we, 2, 0)), n = 0, h = 0, t.mode = X;
+          /* falls through */
+          case X:
+            for (; h < 32; ) {
+              if (u === 0)
+                break e;
+              u--, n += p[e++] << h, h += 8;
+            }
+            t.head && (t.head.time = n), t.flags & 512 && (we[0] = n & 255, we[1] = n >>> 8 & 255, we[2] = n >>> 16 & 255, we[3] = n >>> 24 & 255, t.check = L(t.check, we, 4, 0)), n = 0, h = 0, t.mode = K;
+          /* falls through */
+          case K:
+            for (; h < 16; ) {
+              if (u === 0)
+                break e;
+              u--, n += p[e++] << h, h += 8;
+            }
+            t.head && (t.head.xflags = n & 255, t.head.os = n >> 8), t.flags & 512 && (we[0] = n & 255, we[1] = n >>> 8 & 255, t.check = L(t.check, we, 2, 0)), n = 0, h = 0, t.mode = z;
+          /* falls through */
+          case z:
+            if (t.flags & 1024) {
+              for (; h < 16; ) {
+                if (u === 0)
+                  break e;
+                u--, n += p[e++] << h, h += 8;
+              }
+              t.length = n, t.head && (t.head.extra_len = n), t.flags & 512 && (we[0] = n & 255, we[1] = n >>> 8 & 255, t.check = L(t.check, we, 2, 0)), n = 0, h = 0;
+            } else t.head && (t.head.extra = null);
+            t.mode = H;
+          /* falls through */
+          case H:
+            if (t.flags & 1024 && (O = t.length, O > u && (O = u), O && (t.head && (ce = t.head.extra_len - t.length, t.head.extra || (t.head.extra = new Array(t.head.extra_len)), x.arraySet(
+              t.head.extra,
+              p,
+              e,
+              // 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,*/
+              ce
+            )), t.flags & 512 && (t.check = L(t.check, p, O, e)), u -= O, e += O, t.length -= O), t.length))
+              break e;
+            t.length = 0, t.mode = v;
+          /* falls through */
+          case v:
+            if (t.flags & 2048) {
+              if (u === 0)
+                break e;
+              O = 0;
+              do
+                ce = p[e + O++], t.head && ce && t.length < 65536 && (t.head.name += String.fromCharCode(ce));
+              while (ce && O < u);
+              if (t.flags & 512 && (t.check = L(t.check, p, O, e)), u -= O, e += O, ce)
+                break e;
+            } else t.head && (t.head.name = null);
+            t.length = 0, t.mode = _;
+          /* falls through */
+          case _:
+            if (t.flags & 4096) {
+              if (u === 0)
+                break e;
+              O = 0;
+              do
+                ce = p[e + O++], t.head && ce && t.length < 65536 && (t.head.comment += String.fromCharCode(ce));
+              while (ce && O < u);
+              if (t.flags & 512 && (t.check = L(t.check, p, O, e)), u -= O, e += O, ce)
+                break e;
+            } else t.head && (t.head.comment = null);
+            t.mode = r;
+          /* falls through */
+          case r:
+            if (t.flags & 512) {
+              for (; h < 16; ) {
+                if (u === 0)
+                  break e;
+                u--, n += p[e++] << h, h += 8;
+              }
+              if (n !== (t.check & 65535)) {
+                f.msg = "header crc mismatch", t.mode = le;
+                break;
+              }
+              n = 0, h = 0;
+            }
+            t.head && (t.head.hcrc = t.flags >> 9 & 1, t.head.done = !0), f.adler = t.check = 0, t.mode = G;
+            break;
+          case k:
+            for (; h < 32; ) {
+              if (u === 0)
+                break e;
+              u--, n += p[e++] << h, h += 8;
+            }
+            f.adler = t.check = Te(n), n = 0, h = 0, t.mode = F;
+          /* falls through */
+          case F:
+            if (t.havedict === 0)
+              return f.next_out = l, f.avail_out = i, f.next_in = e, f.avail_in = u, t.hold = n, t.bits = h, T;
+            f.adler = t.check = 1, t.mode = G;
+          /* falls through */
+          case G:
+            if (d === D || d === y)
+              break e;
+          /* falls through */
+          case j:
+            if (t.last) {
+              n >>>= h & 7, h -= h & 7, t.mode = be;
+              break;
+            }
+            for (; h < 3; ) {
+              if (u === 0)
+                break e;
+              u--, n += p[e++] << h, h += 8;
+            }
+            switch (t.last = n & 1, n >>>= 1, h -= 1, n & 3) {
+              case 0:
+                t.mode = Q;
+                break;
+              case 1:
+                if (Ie(t), t.mode = ee, d === y) {
+                  n >>>= 2, h -= 2;
+                  break e;
+                }
+                break;
+              case 2:
+                t.mode = V;
+                break;
+              case 3:
+                f.msg = "invalid block type", t.mode = le;
+            }
+            n >>>= 2, h -= 2;
+            break;
+          case Q:
+            for (n >>>= h & 7, h -= h & 7; h < 32; ) {
+              if (u === 0)
+                break e;
+              u--, n += p[e++] << h, h += 8;
+            }
+            if ((n & 65535) !== (n >>> 16 ^ 65535)) {
+              f.msg = "invalid stored block lengths", t.mode = le;
+              break;
+            }
+            if (t.length = n & 65535, n = 0, h = 0, t.mode = B, d === y)
+              break e;
+          /* falls through */
+          case B:
+            t.mode = ae;
+          /* falls through */
+          case ae:
+            if (O = t.length, O) {
+              if (O > u && (O = u), O > i && (O = i), O === 0)
+                break e;
+              x.arraySet(W, p, e, O, l), u -= O, e += O, i -= O, l += O, t.length -= O;
+              break;
+            }
+            t.mode = G;
+            break;
+          case V:
+            for (; h < 14; ) {
+              if (u === 0)
+                break e;
+              u--, n += p[e++] << h, h += 8;
+            }
+            if (t.nlen = (n & 31) + 257, n >>>= 5, h -= 5, t.ndist = (n & 31) + 1, n >>>= 5, h -= 5, t.ncode = (n & 15) + 4, n >>>= 4, h -= 4, t.nlen > 286 || t.ndist > 30) {
+              f.msg = "too many length or distance symbols", t.mode = le;
+              break;
+            }
+            t.have = 0, t.mode = re;
+          /* falls through */
+          case re:
+            for (; t.have < t.ncode; ) {
+              for (; h < 3; ) {
+                if (u === 0)
+                  break e;
+                u--, n += p[e++] << h, h += 8;
+              }
+              t.lens[_t[t.have++]] = n & 7, n >>>= 3, h -= 3;
+            }
+            for (; t.have < 19; )
+              t.lens[_t[t.have++]] = 0;
+            if (t.lencode = t.lendyn, t.lenbits = 7, De = { bits: t.lenbits }, Ne = P(g, t.lens, 0, 19, t.lencode, 0, t.work, De), t.lenbits = De.bits, Ne) {
+              f.msg = "invalid code lengths set", t.mode = le;
+              break;
+            }
+            t.have = 0, t.mode = oe;
+          /* falls through */
+          case oe:
+            for (; t.have < t.nlen + t.ndist; ) {
+              for (; de = t.lencode[n & (1 << t.lenbits) - 1], ne = de >>> 24, ve = de >>> 16 & 255, xe = de & 65535, !(ne <= h); ) {
+                if (u === 0)
+                  break e;
+                u--, n += p[e++] << h, h += 8;
+              }
+              if (xe < 16)
+                n >>>= ne, h -= ne, t.lens[t.have++] = xe;
+              else {
+                if (xe === 16) {
+                  for (Ze = ne + 2; h < Ze; ) {
+                    if (u === 0)
+                      break e;
+                    u--, n += p[e++] << h, h += 8;
+                  }
+                  if (n >>>= ne, h -= ne, t.have === 0) {
+                    f.msg = "invalid bit length repeat", t.mode = le;
+                    break;
+                  }
+                  ce = t.lens[t.have - 1], O = 3 + (n & 3), n >>>= 2, h -= 2;
+                } else if (xe === 17) {
+                  for (Ze = ne + 3; h < Ze; ) {
+                    if (u === 0)
+                      break e;
+                    u--, n += p[e++] << h, h += 8;
+                  }
+                  n >>>= ne, h -= ne, ce = 0, O = 3 + (n & 7), n >>>= 3, h -= 3;
+                } else {
+                  for (Ze = ne + 7; h < Ze; ) {
+                    if (u === 0)
+                      break e;
+                    u--, n += p[e++] << h, h += 8;
+                  }
+                  n >>>= ne, h -= ne, ce = 0, O = 11 + (n & 127), n >>>= 7, h -= 7;
+                }
+                if (t.have + O > t.nlen + t.ndist) {
+                  f.msg = "invalid bit length repeat", t.mode = le;
+                  break;
+                }
+                for (; O--; )
+                  t.lens[t.have++] = ce;
+              }
+            }
+            if (t.mode === le)
+              break;
+            if (t.lens[256] === 0) {
+              f.msg = "invalid code -- missing end-of-block", t.mode = le;
+              break;
+            }
+            if (t.lenbits = 9, De = { bits: t.lenbits }, Ne = P(c, t.lens, 0, t.nlen, t.lencode, 0, t.work, De), t.lenbits = De.bits, Ne) {
+              f.msg = "invalid literal/lengths set", t.mode = le;
+              break;
+            }
+            if (t.distbits = 6, t.distcode = t.distdyn, De = { bits: t.distbits }, Ne = P(s, t.lens, t.nlen, t.ndist, t.distcode, 0, t.work, De), t.distbits = De.bits, Ne) {
+              f.msg = "invalid distances set", t.mode = le;
+              break;
+            }
+            if (t.mode = ee, d === y)
+              break e;
+          /* falls through */
+          case ee:
+            t.mode = te;
+          /* falls through */
+          case te:
+            if (u >= 6 && i >= 258) {
+              f.next_out = l, f.avail_out = i, f.next_in = e, f.avail_in = u, t.hold = n, t.bits = h, w(f, R), l = f.next_out, W = f.output, i = f.avail_out, e = f.next_in, p = f.input, u = f.avail_in, n = t.hold, h = t.bits, t.mode === G && (t.back = -1);
+              break;
+            }
+            for (t.back = 0; de = t.lencode[n & (1 << t.lenbits) - 1], ne = de >>> 24, ve = de >>> 16 & 255, xe = de & 65535, !(ne <= h); ) {
+              if (u === 0)
+                break e;
+              u--, n += p[e++] << h, h += 8;
+            }
+            if (ve && !(ve & 240)) {
+              for (Ee = ne, Ve = ve, $e = xe; de = t.lencode[$e + ((n & (1 << Ee + Ve) - 1) >> Ee)], ne = de >>> 24, ve = de >>> 16 & 255, xe = de & 65535, !(Ee + ne <= h); ) {
+                if (u === 0)
+                  break e;
+                u--, n += p[e++] << h, h += 8;
+              }
+              n >>>= Ee, h -= Ee, t.back += Ee;
+            }
+            if (n >>>= ne, h -= ne, t.back += ne, t.length = xe, ve === 0) {
+              t.mode = fe;
+              break;
+            }
+            if (ve & 32) {
+              t.back = -1, t.mode = G;
+              break;
+            }
+            if (ve & 64) {
+              f.msg = "invalid literal/length code", t.mode = le;
+              break;
+            }
+            t.extra = ve & 15, t.mode = se;
+          /* falls through */
+          case se:
+            if (t.extra) {
+              for (Ze = t.extra; h < Ze; ) {
+                if (u === 0)
+                  break e;
+                u--, n += p[e++] << h, h += 8;
+              }
+              t.length += n & (1 << t.extra) - 1, n >>>= t.extra, h -= t.extra, t.back += t.extra;
+            }
+            t.was = t.length, t.mode = ge;
+          /* falls through */
+          case ge:
+            for (; de = t.distcode[n & (1 << t.distbits) - 1], ne = de >>> 24, ve = de >>> 16 & 255, xe = de & 65535, !(ne <= h); ) {
+              if (u === 0)
+                break e;
+              u--, n += p[e++] << h, h += 8;
+            }
+            if (!(ve & 240)) {
+              for (Ee = ne, Ve = ve, $e = xe; de = t.distcode[$e + ((n & (1 << Ee + Ve) - 1) >> Ee)], ne = de >>> 24, ve = de >>> 16 & 255, xe = de & 65535, !(Ee + ne <= h); ) {
+                if (u === 0)
+                  break e;
+                u--, n += p[e++] << h, h += 8;
+              }
+              n >>>= Ee, h -= Ee, t.back += Ee;
+            }
+            if (n >>>= ne, h -= ne, t.back += ne, ve & 64) {
+              f.msg = "invalid distance code", t.mode = le;
+              break;
+            }
+            t.offset = xe, t.extra = ve & 15, t.mode = he;
+          /* falls through */
+          case he:
+            if (t.extra) {
+              for (Ze = t.extra; h < Ze; ) {
+                if (u === 0)
+                  break e;
+                u--, n += p[e++] << h, h += 8;
+              }
+              t.offset += n & (1 << t.extra) - 1, n >>>= t.extra, h -= t.extra, t.back += t.extra;
+            }
+            if (t.offset > t.dmax) {
+              f.msg = "invalid distance too far back", t.mode = le;
+              break;
+            }
+            t.mode = _e;
+          /* falls through */
+          case _e:
+            if (i === 0)
+              break e;
+            if (O = R - i, t.offset > O) {
+              if (O = t.offset - O, O > t.whave && t.sane) {
+                f.msg = "invalid distance too far back", t.mode = le;
+                break;
+              }
+              O > t.wnext ? (O -= t.wnext, ie = t.wsize - O) : ie = t.wnext - O, O > t.length && (O = t.length), Le = t.window;
+            } else
+              Le = W, ie = l - t.offset, O = t.length;
+            O > i && (O = i), i -= O, t.length -= O;
+            do
+              W[l++] = Le[ie++];
+            while (--O);
+            t.length === 0 && (t.mode = te);
+            break;
+          case fe:
+            if (i === 0)
+              break e;
+            W[l++] = t.length, i--, t.mode = te;
+            break;
+          case be:
+            if (t.wrap) {
+              for (; h < 32; ) {
+                if (u === 0)
+                  break e;
+                u--, n |= p[e++] << h, h += 8;
+              }
+              if (R -= i, f.total_out += R, t.total += R, R && (f.adler = t.check = /*UPDATE(state.check, put - _out, _out);*/
+              t.flags ? L(t.check, W, R, l - R) : S(t.check, W, R, l - R)), R = i, (t.flags ? n : Te(n)) !== t.check) {
+                f.msg = "incorrect data check", t.mode = le;
+                break;
+              }
+              n = 0, h = 0;
+            }
+            t.mode = ye;
+          /* falls through */
+          case ye:
+            if (t.wrap && t.flags) {
+              for (; h < 32; ) {
+                if (u === 0)
+                  break e;
+                u--, n += p[e++] << h, h += 8;
+              }
+              if (n !== (t.total & 4294967295)) {
+                f.msg = "incorrect length check", t.mode = le;
+                break;
+              }
+              n = 0, h = 0;
+            }
+            t.mode = me;
+          /* falls through */
+          case me:
+            Ne = m;
+            break e;
+          case le:
+            Ne = $;
+            break e;
+          case ke:
+            return M;
+          case He:
+          /* falls through */
+          default:
+            return C;
+        }
+    return f.next_out = l, f.avail_out = i, f.next_in = e, f.avail_in = u, t.hold = n, t.bits = h, (t.wsize || R !== f.avail_out && t.mode < le && (t.mode < be || d !== o)) && Ge(f, f.output, f.next_out, R - f.avail_out), U -= f.avail_in, R -= f.avail_out, f.total_in += U, f.total_out += R, t.total += R, t.wrap && R && (f.adler = t.check = /*UPDATE(state.check, strm.next_out - _out, _out);*/
+    t.flags ? L(t.check, W, R, f.next_out - R) : S(t.check, W, R, f.next_out - R)), f.data_type = t.bits + (t.last ? 64 : 0) + (t.mode === G ? 128 : 0) + (t.mode === ee || t.mode === B ? 256 : 0), (U === 0 && R === 0 || d === o) && Ne === N && (Ne = A), Ne;
+  }
+  function b(f) {
+    if (!f || !f.state)
+      return C;
+    var d = f.state;
+    return d.window && (d.window = null), f.state = null, N;
+  }
+  function E(f, d) {
+    var t;
+    return !f || !f.state || (t = f.state, !(t.wrap & 2)) ? C : (t.head = d, d.done = !1, N);
+  }
+  function Z(f, d) {
+    var t = d.length, p, W, e;
+    return !f || !f.state || (p = f.state, p.wrap !== 0 && p.mode !== F) ? C : p.mode === F && (W = 1, W = S(W, d, t, 0), W !== p.check) ? $ : (e = Ge(f, d, t, t), e ? (p.mode = ke, M) : (p.havedict = 1, N));
+  }
+  return Ae.inflateReset = ze, Ae.inflateReset2 = Ye, Ae.inflateResetKeep = Be, Ae.inflateInit = Re, Ae.inflateInit2 = Ce, Ae.inflate = a, Ae.inflateEnd = b, Ae.inflateGetHeader = E, Ae.inflateSetDictionary = Z, Ae.inflateInfo = "pako inflate (from Nodeca project)", Ae;
+}
+var ft, yt;
+function Zt() {
+  return yt || (yt = 1, ft = {
+    /* 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
+  }), ft;
+}
+var ht, mt;
+function qt() {
+  if (mt) return ht;
+  mt = 1;
+  function x() {
+    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;
+  }
+  return ht = x, ht;
+}
+var Ft;
+function Pt() {
+  if (Ft) return je;
+  Ft = 1;
+  var x = Ht(), S = Me(), L = Ot(), w = Zt(), P = ut(), g = It(), c = qt(), s = Object.prototype.toString;
+  function o(N) {
+    if (!(this instanceof o)) return new o(N);
+    this.options = S.assign({
+      chunkSize: 16384,
+      windowBits: 0,
+      to: ""
+    }, N || {});
+    var m = this.options;
+    m.raw && m.windowBits >= 0 && m.windowBits < 16 && (m.windowBits = -m.windowBits, m.windowBits === 0 && (m.windowBits = -15)), m.windowBits >= 0 && m.windowBits < 16 && !(N && N.windowBits) && (m.windowBits += 32), m.windowBits > 15 && m.windowBits < 48 && (m.windowBits & 15 || (m.windowBits |= 15)), this.err = 0, this.msg = "", this.ended = !1, this.chunks = [], this.strm = new g(), this.strm.avail_out = 0;
+    var T = x.inflateInit2(
+      this.strm,
+      m.windowBits
+    );
+    if (T !== w.Z_OK)
+      throw new Error(P[T]);
+    if (this.header = new c(), x.inflateGetHeader(this.strm, this.header), m.dictionary && (typeof m.dictionary == "string" ? m.dictionary = L.string2buf(m.dictionary) : s.call(m.dictionary) === "[object ArrayBuffer]" && (m.dictionary = new Uint8Array(m.dictionary)), m.raw && (T = x.inflateSetDictionary(this.strm, m.dictionary), T !== w.Z_OK)))
+      throw new Error(P[T]);
+  }
+  o.prototype.push = function(N, m) {
+    var T = this.strm, C = this.options.chunkSize, $ = this.options.dictionary, M, A, q, I, Y, X = !1;
+    if (this.ended)
+      return !1;
+    A = m === ~~m ? m : m === !0 ? w.Z_FINISH : w.Z_NO_FLUSH, typeof N == "string" ? T.input = L.binstring2buf(N) : s.call(N) === "[object ArrayBuffer]" ? T.input = new Uint8Array(N) : T.input = N, T.next_in = 0, T.avail_in = T.input.length;
+    do {
+      if (T.avail_out === 0 && (T.output = new S.Buf8(C), T.next_out = 0, T.avail_out = C), M = x.inflate(T, w.Z_NO_FLUSH), M === w.Z_NEED_DICT && $ && (M = x.inflateSetDictionary(this.strm, $)), M === w.Z_BUF_ERROR && X === !0 && (M = w.Z_OK, X = !1), M !== w.Z_STREAM_END && M !== w.Z_OK)
+        return this.onEnd(M), this.ended = !0, !1;
+      T.next_out && (T.avail_out === 0 || M === w.Z_STREAM_END || T.avail_in === 0 && (A === w.Z_FINISH || A === w.Z_SYNC_FLUSH)) && (this.options.to === "string" ? (q = L.utf8border(T.output, T.next_out), I = T.next_out - q, Y = L.buf2string(T.output, q), T.next_out = I, T.avail_out = C - I, I && S.arraySet(T.output, T.output, q, I, 0), this.onData(Y)) : this.onData(S.shrinkBuf(T.output, T.next_out))), T.avail_in === 0 && T.avail_out === 0 && (X = !0);
+    } while ((T.avail_in > 0 || T.avail_out === 0) && M !== w.Z_STREAM_END);
+    return M === w.Z_STREAM_END && (A = w.Z_FINISH), A === w.Z_FINISH ? (M = x.inflateEnd(this.strm), this.onEnd(M), this.ended = !0, M === w.Z_OK) : (A === w.Z_SYNC_FLUSH && (this.onEnd(w.Z_OK), T.avail_out = 0), !0);
+  }, o.prototype.onData = function(N) {
+    this.chunks.push(N);
+  }, o.prototype.onEnd = function(N) {
+    N === w.Z_OK && (this.options.to === "string" ? this.result = this.chunks.join("") : this.result = S.flattenChunks(this.chunks)), this.chunks = [], this.err = N, this.msg = this.strm.msg;
+  };
+  function D(N, m) {
+    var T = new o(m);
+    if (T.push(N, !0), T.err)
+      throw T.msg || P[T.err];
+    return T.result;
+  }
+  function y(N, m) {
+    return m = m || {}, m.raw = !0, D(N, m);
+  }
+  return je.Inflate = o, je.inflate = D, je.inflateRaw = y, je.ungzip = D, je;
+}
+var lt, Tt;
+function Kt() {
+  if (Tt) return lt;
+  Tt = 1;
+  var x = Me().assign, S = Ct(), L = Pt(), w = Zt(), P = {};
+  return x(P, S, L, w), lt = P, lt;
+}
+var Je = Kt();
+async function jt(x) {
+  try {
+    let S, L = 0, w = 0;
+    const P = [];
+    let g = 0, c;
+    do {
+      const o = x.subarray(L);
+      if (c = new Je.Inflate(), { strm: S } = c, c.push(o, Je.Z_SYNC_FLUSH), c.err)
+        throw new Error(c.msg);
+      L += S.next_in, P[w] = c.result, g += P[w].length, w += 1;
+    } while (S.avail_in);
+    const s = new Uint8Array(g);
+    for (let o = 0, D = 0; o < P.length; o++)
+      s.set(P[o], D), D += P[o].length;
+    return Nt.Buffer.from(s);
+  } catch (S) {
+    throw /incorrect header check/.exec(`${S}`) ? new Error("problem decompressing block: incorrect gzip header check") : S;
+  }
+}
+async function Vt(x, S) {
+  try {
+    let L;
+    const { minv: w, maxv: P } = S;
+    let g = w.blockPosition, c = w.dataPosition;
+    const s = [], o = [], D = [];
+    let y = 0, N = 0;
+    do {
+      const C = x.subarray(g - w.blockPosition), $ = new Je.Inflate();
+      if ({ strm: L } = $, $.push(C, Je.Z_SYNC_FLUSH), $.err)
+        throw new Error($.msg);
+      const M = $.result;
+      s.push(M);
+      let A = M.length;
+      o.push(g), D.push(c), s.length === 1 && w.dataPosition && (s[0] = s[0].subarray(w.dataPosition), A = s[0].length);
+      const q = g;
+      if (g += L.next_in, c += A, q >= P.blockPosition) {
+        s[N] = s[N].subarray(0, P.blockPosition === w.blockPosition ? P.dataPosition - w.dataPosition + 1 : P.dataPosition + 1), o.push(g), D.push(c), y += s[N].length;
+        break;
+      }
+      y += s[N].length, N++;
+    } while (L.avail_in);
+    const m = new Uint8Array(y);
+    for (let C = 0, $ = 0; C < s.length; C++)
+      m.set(s[C], $), $ += s[C].length;
+    return { buffer: Nt.Buffer.from(m), cpositions: o, dpositions: D };
+  } catch (L) {
+    throw /incorrect header check/.exec(`${L}`) ? new Error("problem decompressing block: incorrect gzip header check") : L;
+  }
+}
+var ot, zt;
+function Yt() {
+  if (zt) return ot;
+  zt = 1, ot = S;
+  var x = null;
+  try {
+    x = new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([
+      0,
+      97,
+      115,
+      109,
+      1,
+      0,
+      0,
+      0,
+      1,
+      13,
+      2,
+      96,
+      0,
+      1,
+      127,
+      96,
+      4,
+      127,
+      127,
+      127,
+      127,
+      1,
+      127,
+      3,
+      7,
+      6,
+      0,
+      1,
+      1,
+      1,
+      1,
+      1,
+      6,
+      6,
+      1,
+      127,
+      1,
+      65,
+      0,
+      11,
+      7,
+      50,
+      6,
+      3,
+      109,
+      117,
+      108,
+      0,
+      1,
+      5,
+      100,
+      105,
+      118,
+      95,
+      115,
+      0,
+      2,
+      5,
+      100,
+      105,
+      118,
+      95,
+      117,
+      0,
+      3,
+      5,
+      114,
+      101,
+      109,
+      95,
+      115,
+      0,
+      4,
+      5,
+      114,
+      101,
+      109,
+      95,
+      117,
+      0,
+      5,
+      8,
+      103,
+      101,
+      116,
+      95,
+      104,
+      105,
+      103,
+      104,
+      0,
+      0,
+      10,
+      191,
+      1,
+      6,
+      4,
+      0,
+      35,
+      0,
+      11,
+      36,
+      1,
+      1,
+      126,
+      32,
+      0,
+      173,
+      32,
+      1,
+      173,
+      66,
+      32,
+      134,
+      132,
+      32,
+      2,
+      173,
+      32,
+      3,
+      173,
+      66,
+      32,
+      134,
+      132,
+      126,
+      34,
+      4,
+      66,
+      32,
+      135,
+      167,
+      36,
+      0,
+      32,
+      4,
+      167,
+      11,
+      36,
+      1,
+      1,
+      126,
+      32,
+      0,
+      173,
+      32,
+      1,
+      173,
+      66,
+      32,
+      134,
+      132,
+      32,
+      2,
+      173,
+      32,
+      3,
+      173,
+      66,
+      32,
+      134,
+      132,
+      127,
+      34,
+      4,
+      66,
+      32,
+      135,
+      167,
+      36,
+      0,
+      32,
+      4,
+      167,
+      11,
+      36,
+      1,
+      1,
+      126,
+      32,
+      0,
+      173,
+      32,
+      1,
+      173,
+      66,
+      32,
+      134,
+      132,
+      32,
+      2,
+      173,
+      32,
+      3,
+      173,
+      66,
+      32,
+      134,
+      132,
+      128,
+      34,
+      4,
+      66,
+      32,
+      135,
+      167,
+      36,
+      0,
+      32,
+      4,
+      167,
+      11,
+      36,
+      1,
+      1,
+      126,
+      32,
+      0,
+      173,
+      32,
+      1,
+      173,
+      66,
+      32,
+      134,
+      132,
+      32,
+      2,
+      173,
+      32,
+      3,
+      173,
+      66,
+      32,
+      134,
+      132,
+      129,
+      34,
+      4,
+      66,
+      32,
+      135,
+      167,
+      36,
+      0,
+      32,
+      4,
+      167,
+      11,
+      36,
+      1,
+      1,
+      126,
+      32,
+      0,
+      173,
+      32,
+      1,
+      173,
+      66,
+      32,
+      134,
+      132,
+      32,
+      2,
+      173,
+      32,
+      3,
+      173,
+      66,
+      32,
+      134,
+      132,
+      130,
+      34,
+      4,
+      66,
+      32,
+      135,
+      167,
+      36,
+      0,
+      32,
+      4,
+      167,
+      11
+    ])), {}).exports;
+  } catch {
+  }
+  function S(_, r, k) {
+    this.low = _ | 0, this.high = r | 0, this.unsigned = !!k;
+  }
+  S.prototype.__isLong__, Object.defineProperty(S.prototype, "__isLong__", { value: !0 });
+  function L(_) {
+    return (_ && _.__isLong__) === !0;
+  }
+  S.isLong = L;
+  var w = {}, P = {};
+  function g(_, r) {
+    var k, F, G;
+    return r ? (_ >>>= 0, (G = 0 <= _ && _ < 256) && (F = P[_], F) ? F : (k = s(_, (_ | 0) < 0 ? -1 : 0, !0), G && (P[_] = k), k)) : (_ |= 0, (G = -128 <= _ && _ < 128) && (F = w[_], F) ? F : (k = s(_, _ < 0 ? -1 : 0, !1), G && (w[_] = k), k));
+  }
+  S.fromInt = g;
+  function c(_, r) {
+    if (isNaN(_))
+      return r ? q : A;
+    if (r) {
+      if (_ < 0)
+        return q;
+      if (_ >= C)
+        return z;
+    } else {
+      if (_ <= -$)
+        return H;
+      if (_ + 1 >= $)
+        return K;
+    }
+    return _ < 0 ? c(-_, r).neg() : s(_ % T | 0, _ / T | 0, r);
+  }
+  S.fromNumber = c;
+  function s(_, r, k) {
+    return new S(_, r, k);
+  }
+  S.fromBits = s;
+  var o = Math.pow;
+  function D(_, r, k) {
+    if (_.length === 0)
+      throw Error("empty string");
+    if (_ === "NaN" || _ === "Infinity" || _ === "+Infinity" || _ === "-Infinity")
+      return A;
+    if (typeof r == "number" ? (k = r, r = !1) : r = !!r, k = k || 10, k < 2 || 36 < k)
+      throw RangeError("radix");
+    var F;
+    if ((F = _.indexOf("-")) > 0)
+      throw Error("interior hyphen");
+    if (F === 0)
+      return D(_.substring(1), r, k).neg();
+    for (var G = c(o(k, 8)), j = A, Q = 0; Q < _.length; Q += 8) {
+      var B = Math.min(8, _.length - Q), ae = parseInt(_.substring(Q, Q + B), k);
+      if (B < 8) {
+        var V = c(o(k, B));
+        j = j.mul(V).add(c(ae));
+      } else
+        j = j.mul(G), j = j.add(c(ae));
+    }
+    return j.unsigned = r, j;
+  }
+  S.fromString = D;
+  function y(_, r) {
+    return typeof _ == "number" ? c(_, r) : typeof _ == "string" ? D(_, r) : s(_.low, _.high, typeof r == "boolean" ? r : _.unsigned);
+  }
+  S.fromValue = y;
+  var N = 65536, m = 1 << 24, T = N * N, C = T * T, $ = C / 2, M = g(m), A = g(0);
+  S.ZERO = A;
+  var q = g(0, !0);
+  S.UZERO = q;
+  var I = g(1);
+  S.ONE = I;
+  var Y = g(1, !0);
+  S.UONE = Y;
+  var X = g(-1);
+  S.NEG_ONE = X;
+  var K = s(-1, 2147483647, !1);
+  S.MAX_VALUE = K;
+  var z = s(-1, -1, !0);
+  S.MAX_UNSIGNED_VALUE = z;
+  var H = s(0, -2147483648, !1);
+  S.MIN_VALUE = H;
+  var v = S.prototype;
+  return v.toInt = function() {
+    return this.unsigned ? this.low >>> 0 : this.low;
+  }, v.toNumber = function() {
+    return this.unsigned ? (this.high >>> 0) * T + (this.low >>> 0) : this.high * T + (this.low >>> 0);
+  }, v.toString = function(r) {
+    if (r = r || 10, r < 2 || 36 < r)
+      throw RangeError("radix");
+    if (this.isZero())
+      return "0";
+    if (this.isNegative())
+      if (this.eq(H)) {
+        var k = c(r), F = this.div(k), G = F.mul(k).sub(this);
+        return F.toString(r) + G.toInt().toString(r);
+      } else
+        return "-" + this.neg().toString(r);
+    for (var j = c(o(r, 6), this.unsigned), Q = this, B = ""; ; ) {
+      var ae = Q.div(j), V = Q.sub(ae.mul(j)).toInt() >>> 0, re = V.toString(r);
+      if (Q = ae, Q.isZero())
+        return re + B;
+      for (; re.length < 6; )
+        re = "0" + re;
+      B = "" + re + B;
+    }
+  }, v.getHighBits = function() {
+    return this.high;
+  }, v.getHighBitsUnsigned = function() {
+    return this.high >>> 0;
+  }, v.getLowBits = function() {
+    return this.low;
+  }, v.getLowBitsUnsigned = function() {
+    return this.low >>> 0;
+  }, v.getNumBitsAbs = function() {
+    if (this.isNegative())
+      return this.eq(H) ? 64 : this.neg().getNumBitsAbs();
+    for (var r = this.high != 0 ? this.high : this.low, k = 31; k > 0 && !(r & 1 << k); k--)
+      ;
+    return this.high != 0 ? k + 33 : k + 1;
+  }, v.isZero = function() {
+    return this.high === 0 && this.low === 0;
+  }, v.eqz = v.isZero, v.isNegative = function() {
+    return !this.unsigned && this.high < 0;
+  }, v.isPositive = function() {
+    return this.unsigned || this.high >= 0;
+  }, v.isOdd = function() {
+    return (this.low & 1) === 1;
+  }, v.isEven = function() {
+    return (this.low & 1) === 0;
+  }, v.equals = function(r) {
+    return L(r) || (r = y(r)), this.unsigned !== r.unsigned && this.high >>> 31 === 1 && r.high >>> 31 === 1 ? !1 : this.high === r.high && this.low === r.low;
+  }, v.eq = v.equals, v.notEquals = function(r) {
+    return !this.eq(
+      /* validates */
+      r
+    );
+  }, v.neq = v.notEquals, v.ne = v.notEquals, v.lessThan = function(r) {
+    return this.comp(
+      /* validates */
+      r
+    ) < 0;
+  }, v.lt = v.lessThan, v.lessThanOrEqual = function(r) {
+    return this.comp(
+      /* validates */
+      r
+    ) <= 0;
+  }, v.lte = v.lessThanOrEqual, v.le = v.lessThanOrEqual, v.greaterThan = function(r) {
+    return this.comp(
+      /* validates */
+      r
+    ) > 0;
+  }, v.gt = v.greaterThan, v.greaterThanOrEqual = function(r) {
+    return this.comp(
+      /* validates */
+      r
+    ) >= 0;
+  }, v.gte = v.greaterThanOrEqual, v.ge = v.greaterThanOrEqual, v.compare = function(r) {
+    if (L(r) || (r = y(r)), this.eq(r))
+      return 0;
+    var k = this.isNegative(), F = r.isNegative();
+    return k && !F ? -1 : !k && F ? 1 : this.unsigned ? r.high >>> 0 > this.high >>> 0 || r.high === this.high && r.low >>> 0 > this.low >>> 0 ? -1 : 1 : this.sub(r).isNegative() ? -1 : 1;
+  }, v.comp = v.compare, v.negate = function() {
+    return !this.unsigned && this.eq(H) ? H : this.not().add(I);
+  }, v.neg = v.negate, v.add = function(r) {
+    L(r) || (r = y(r));
+    var k = this.high >>> 16, F = this.high & 65535, G = this.low >>> 16, j = this.low & 65535, Q = r.high >>> 16, B = r.high & 65535, ae = r.low >>> 16, V = r.low & 65535, re = 0, oe = 0, ee = 0, te = 0;
+    return te += j + V, ee += te >>> 16, te &= 65535, ee += G + ae, oe += ee >>> 16, ee &= 65535, oe += F + B, re += oe >>> 16, oe &= 65535, re += k + Q, re &= 65535, s(ee << 16 | te, re << 16 | oe, this.unsigned);
+  }, v.subtract = function(r) {
+    return L(r) || (r = y(r)), this.add(r.neg());
+  }, v.sub = v.subtract, v.multiply = function(r) {
+    if (this.isZero())
+      return A;
+    if (L(r) || (r = y(r)), x) {
+      var k = x.mul(
+        this.low,
+        this.high,
+        r.low,
+        r.high
+      );
+      return s(k, x.get_high(), this.unsigned);
+    }
+    if (r.isZero())
+      return A;
+    if (this.eq(H))
+      return r.isOdd() ? H : A;
+    if (r.eq(H))
+      return this.isOdd() ? H : A;
+    if (this.isNegative())
+      return r.isNegative() ? this.neg().mul(r.neg()) : this.neg().mul(r).neg();
+    if (r.isNegative())
+      return this.mul(r.neg()).neg();
+    if (this.lt(M) && r.lt(M))
+      return c(this.toNumber() * r.toNumber(), this.unsigned);
+    var F = this.high >>> 16, G = this.high & 65535, j = this.low >>> 16, Q = this.low & 65535, B = r.high >>> 16, ae = r.high & 65535, V = r.low >>> 16, re = r.low & 65535, oe = 0, ee = 0, te = 0, se = 0;
+    return se += Q * re, te += se >>> 16, se &= 65535, te += j * re, ee += te >>> 16, te &= 65535, te += Q * V, ee += te >>> 16, te &= 65535, ee += G * re, oe += ee >>> 16, ee &= 65535, ee += j * V, oe += ee >>> 16, ee &= 65535, ee += Q * ae, oe += ee >>> 16, ee &= 65535, oe += F * re + G * V + j * ae + Q * B, oe &= 65535, s(te << 16 | se, oe << 16 | ee, this.unsigned);
+  }, v.mul = v.multiply, v.divide = function(r) {
+    if (L(r) || (r = y(r)), r.isZero())
+      throw Error("division by zero");
+    if (x) {
+      if (!this.unsigned && this.high === -2147483648 && r.low === -1 && r.high === -1)
+        return this;
+      var k = (this.unsigned ? x.div_u : x.div_s)(
+        this.low,
+        this.high,
+        r.low,
+        r.high
+      );
+      return s(k, x.get_high(), this.unsigned);
+    }
+    if (this.isZero())
+      return this.unsigned ? q : A;
+    var F, G, j;
+    if (this.unsigned) {
+      if (r.unsigned || (r = r.toUnsigned()), r.gt(this))
+        return q;
+      if (r.gt(this.shru(1)))
+        return Y;
+      j = q;
+    } else {
+      if (this.eq(H)) {
+        if (r.eq(I) || r.eq(X))
+          return H;
+        if (r.eq(H))
+          return I;
+        var Q = this.shr(1);
+        return F = Q.div(r).shl(1), F.eq(A) ? r.isNegative() ? I : X : (G = this.sub(r.mul(F)), j = F.add(G.div(r)), j);
+      } else if (r.eq(H))
+        return this.unsigned ? q : A;
+      if (this.isNegative())
+        return r.isNegative() ? this.neg().div(r.neg()) : this.neg().div(r).neg();
+      if (r.isNegative())
+        return this.div(r.neg()).neg();
+      j = A;
+    }
+    for (G = this; G.gte(r); ) {
+      F = Math.max(1, Math.floor(G.toNumber() / r.toNumber()));
+      for (var B = Math.ceil(Math.log(F) / Math.LN2), ae = B <= 48 ? 1 : o(2, B - 48), V = c(F), re = V.mul(r); re.isNegative() || re.gt(G); )
+        F -= ae, V = c(F, this.unsigned), re = V.mul(r);
+      V.isZero() && (V = I), j = j.add(V), G = G.sub(re);
+    }
+    return j;
+  }, v.div = v.divide, v.modulo = function(r) {
+    if (L(r) || (r = y(r)), x) {
+      var k = (this.unsigned ? x.rem_u : x.rem_s)(
+        this.low,
+        this.high,
+        r.low,
+        r.high
+      );
+      return s(k, x.get_high(), this.unsigned);
+    }
+    return this.sub(this.div(r).mul(r));
+  }, v.mod = v.modulo, v.rem = v.modulo, v.not = function() {
+    return s(~this.low, ~this.high, this.unsigned);
+  }, v.and = function(r) {
+    return L(r) || (r = y(r)), s(this.low & r.low, this.high & r.high, this.unsigned);
+  }, v.or = function(r) {
+    return L(r) || (r = y(r)), s(this.low | r.low, this.high | r.high, this.unsigned);
+  }, v.xor = function(r) {
+    return L(r) || (r = y(r)), s(this.low ^ r.low, this.high ^ r.high, this.unsigned);
+  }, v.shiftLeft = function(r) {
+    return L(r) && (r = r.toInt()), (r &= 63) === 0 ? this : r < 32 ? s(this.low << r, this.high << r | this.low >>> 32 - r, this.unsigned) : s(0, this.low << r - 32, this.unsigned);
+  }, v.shl = v.shiftLeft, v.shiftRight = function(r) {
+    return L(r) && (r = r.toInt()), (r &= 63) === 0 ? this : r < 32 ? s(this.low >>> r | this.high << 32 - r, this.high >> r, this.unsigned) : s(this.high >> r - 32, this.high >= 0 ? 0 : -1, this.unsigned);
+  }, v.shr = v.shiftRight, v.shiftRightUnsigned = function(r) {
+    if (L(r) && (r = r.toInt()), r &= 63, r === 0)
+      return this;
+    var k = this.high;
+    if (r < 32) {
+      var F = this.low;
+      return s(F >>> r | k << 32 - r, k >>> r, this.unsigned);
+    } else return r === 32 ? s(k, 0, this.unsigned) : s(k >>> r - 32, 0, this.unsigned);
+  }, v.shru = v.shiftRightUnsigned, v.shr_u = v.shiftRightUnsigned, v.toSigned = function() {
+    return this.unsigned ? s(this.low, this.high, !1) : this;
+  }, v.toUnsigned = function() {
+    return this.unsigned ? this : s(this.low, this.high, !0);
+  }, v.toBytes = function(r) {
+    return r ? this.toBytesLE() : this.toBytesBE();
+  }, v.toBytesLE = function() {
+    var r = this.high, k = this.low;
+    return [
+      k & 255,
+      k >>> 8 & 255,
+      k >>> 16 & 255,
+      k >>> 24,
+      r & 255,
+      r >>> 8 & 255,
+      r >>> 16 & 255,
+      r >>> 24
+    ];
+  }, v.toBytesBE = function() {
+    var r = this.high, k = this.low;
+    return [
+      r >>> 24,
+      r >>> 16 & 255,
+      r >>> 8 & 255,
+      r & 255,
+      k >>> 24,
+      k >>> 16 & 255,
+      k >>> 8 & 255,
+      k & 255
+    ];
+  }, S.fromBytes = function(r, k, F) {
+    return F ? S.fromBytesLE(r, k) : S.fromBytesBE(r, k);
+  }, S.fromBytesLE = function(r, k) {
+    return new S(
+      r[0] | r[1] << 8 | r[2] << 16 | r[3] << 24,
+      r[4] | r[5] << 8 | r[6] << 16 | r[7] << 24,
+      k
+    );
+  }, S.fromBytesBE = function(r, k) {
+    return new S(
+      r[4] << 24 | r[5] << 16 | r[6] << 8 | r[7],
+      r[0] << 24 | r[1] << 16 | r[2] << 8 | r[3],
+      k
+    );
+  }, ot;
+}
+var Xt = Yt();
+const $t = /* @__PURE__ */ Lt(Xt);
+export {
+  $t as L,
+  Vt as a,
+  jt as u
+};