@genome-spy/app 0.57.0 → 0.58.1

package/dist/index-DS2hvLgl.js

@@ -0,0 +1,3425 @@
+import { b as ee } from "./index-BftNdA0O.js";
+import { A as Kn, L as Gn } from "./index-CCJIjehY.js";
+import { L as nr } from "./__vite-browser-external-C--ziKoh.js";
+import { R as ir } from "./remoteFile-BuaqFGWk.js";
+const Yn = BigInt(32);
+function rr(e, n, t) {
+  const i = +!!t, a = +!t;
+  return BigInt(e.getInt32(n, t) * a + e.getInt32(n + 4, t) * i) << Yn | BigInt(e.getUint32(n, t) * i + e.getUint32(n + 4, t) * a);
+}
+function ar(e, n, t) {
+  const i = e.getUint32(n, t), a = e.getUint32(n + 4, t), r = +!!t, o = +!t;
+  return BigInt(i * o + a * r) << Yn | BigInt(i * r + a * o);
+}
+"getBigInt64" in DataView || (DataView.prototype.getBigInt64 = function(e, n) {
+  return rr(this, e, n);
+});
+"getBigUint64" in DataView || (DataView.prototype.getBigUint64 = function(e, n) {
+  return ar(this, e, n);
+});
+class be {
+  constructor(n) {
+    this.ranges = n;
+  }
+  get min() {
+    return this.ranges[0].min;
+  }
+  get max() {
+    return this.ranges.at(-1).max;
+  }
+  contains(n) {
+    for (const t of this.ranges)
+      if (t.min <= n && t.max >= n)
+        return !0;
+    return !1;
+  }
+  isContiguous() {
+    return this.ranges.length > 1;
+  }
+  getRanges() {
+    return this.ranges.map((n) => new be([{ min: n.min, max: n.max }]));
+  }
+  toString() {
+    return this.ranges.map((n) => `[${n.min}-${n.max}]`).join(",");
+  }
+  union(n) {
+    const t = [...this.getRanges(), ...n.getRanges()].sort((r, o) => r.min < o.min ? -1 : r.min > o.min ? 1 : r.max < o.max ? -1 : o.max > r.max ? 1 : 0), i = [];
+    let a = t[0];
+    for (const r of t)
+      r.min > a.max + 1 ? (i.push(a), a = r) : r.max > a.max && (a = new be([{ min: a.min, max: r.max }]));
+    return i.push(a), i.length === 1 ? i[0] : new be(i);
+  }
+}
+/*! pako 2.1.0 https://github.com/nodeca/pako @license (MIT AND Zlib) */
+const or = 4, qt = 0, en = 1, lr = 2;
+function ve(e) {
+  let n = e.length;
+  for (; --n >= 0; )
+    e[n] = 0;
+}
+const sr = 0, jn = 1, cr = 2, fr = 3, ur = 258, Ht = 29, He = 256, Ue = He + 1 + Ht, ge = 30, Pt = 19, Xn = 2 * Ue + 1, oe = 15, ut = 16, hr = 7, Vt = 256, Wn = 16, Jn = 17, Qn = 18, Ot = (
+  /* extra bits for each length code */
+  new Uint8Array([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])
+), qe = (
+  /* extra bits for each distance code */
+  new Uint8Array([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])
+), dr = (
+  /* extra bits for each bit length code */
+  new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7])
+), qn = new Uint8Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]), _r = 512, J = new Array((Ue + 2) * 2);
+ve(J);
+const ze = new Array(ge * 2);
+ve(ze);
+const Be = new Array(_r);
+ve(Be);
+const De = new Array(ur - fr + 1);
+ve(De);
+const Kt = new Array(Ht);
+ve(Kt);
+const et = new Array(ge);
+ve(et);
+function ht(e, n, t, i, a) {
+  this.static_tree = e, this.extra_bits = n, this.extra_base = t, this.elems = i, this.max_length = a, this.has_stree = e && e.length;
+}
+let ei, ti, ni;
+function dt(e, n) {
+  this.dyn_tree = e, this.max_code = 0, this.stat_desc = n;
+}
+const ii = (e) => e < 256 ? Be[e] : Be[256 + (e >>> 7)], Ne = (e, n) => {
+  e.pending_buf[e.pending++] = n & 255, e.pending_buf[e.pending++] = n >>> 8 & 255;
+}, M = (e, n, t) => {
+  e.bi_valid > ut - t ? (e.bi_buf |= n << e.bi_valid & 65535, Ne(e, e.bi_buf), e.bi_buf = n >> ut - e.bi_valid, e.bi_valid += t - ut) : (e.bi_buf |= n << e.bi_valid & 65535, e.bi_valid += t);
+}, Y = (e, n, t) => {
+  M(
+    e,
+    t[n * 2],
+    t[n * 2 + 1]
+    /*.Len*/
+  );
+}, ri = (e, n) => {
+  let t = 0;
+  do
+    t |= e & 1, e >>>= 1, t <<= 1;
+  while (--n > 0);
+  return t >>> 1;
+}, br = (e) => {
+  e.bi_valid === 16 ? (Ne(e, e.bi_buf), e.bi_buf = 0, e.bi_valid = 0) : e.bi_valid >= 8 && (e.pending_buf[e.pending++] = e.bi_buf & 255, e.bi_buf >>= 8, e.bi_valid -= 8);
+}, gr = (e, n) => {
+  const t = n.dyn_tree, i = n.max_code, a = n.stat_desc.static_tree, r = n.stat_desc.has_stree, o = n.stat_desc.extra_bits, s = n.stat_desc.extra_base, f = n.stat_desc.max_length;
+  let l, c, w, h, u, d, g = 0;
+  for (h = 0; h <= oe; h++)
+    e.bl_count[h] = 0;
+  for (t[e.heap[e.heap_max] * 2 + 1] = 0, l = e.heap_max + 1; l < Xn; l++)
+    c = e.heap[l], h = t[t[c * 2 + 1] * 2 + 1] + 1, h > f && (h = f, g++), t[c * 2 + 1] = h, !(c > i) && (e.bl_count[h]++, u = 0, c >= s && (u = o[c - s]), d = t[c * 2], e.opt_len += d * (h + u), r && (e.static_len += d * (a[c * 2 + 1] + u)));
+  if (g !== 0) {
+    do {
+      for (h = f - 1; e.bl_count[h] === 0; )
+        h--;
+      e.bl_count[h]--, e.bl_count[h + 1] += 2, e.bl_count[f]--, g -= 2;
+    } while (g > 0);
+    for (h = f; h !== 0; h--)
+      for (c = e.bl_count[h]; c !== 0; )
+        w = e.heap[--l], !(w > i) && (t[w * 2 + 1] !== h && (e.opt_len += (h - t[w * 2 + 1]) * t[w * 2], t[w * 2 + 1] = h), c--);
+  }
+}, ai = (e, n, t) => {
+  const i = new Array(oe + 1);
+  let a = 0, r, o;
+  for (r = 1; r <= oe; r++)
+    a = a + t[r - 1] << 1, i[r] = a;
+  for (o = 0; o <= n; o++) {
+    let s = e[o * 2 + 1];
+    s !== 0 && (e[o * 2] = ri(i[s]++, s));
+  }
+}, wr = () => {
+  let e, n, t, i, a;
+  const r = new Array(oe + 1);
+  for (t = 0, i = 0; i < Ht - 1; i++)
+    for (Kt[i] = t, e = 0; e < 1 << Ot[i]; e++)
+      De[t++] = i;
+  for (De[t - 1] = i, a = 0, i = 0; i < 16; i++)
+    for (et[i] = a, e = 0; e < 1 << qe[i]; e++)
+      Be[a++] = i;
+  for (a >>= 7; i < ge; i++)
+    for (et[i] = a << 7, e = 0; e < 1 << qe[i] - 7; e++)
+      Be[256 + a++] = i;
+  for (n = 0; n <= oe; n++)
+    r[n] = 0;
+  for (e = 0; e <= 143; )
+    J[e * 2 + 1] = 8, e++, r[8]++;
+  for (; e <= 255; )
+    J[e * 2 + 1] = 9, e++, r[9]++;
+  for (; e <= 279; )
+    J[e * 2 + 1] = 7, e++, r[7]++;
+  for (; e <= 287; )
+    J[e * 2 + 1] = 8, e++, r[8]++;
+  for (ai(J, Ue + 1, r), e = 0; e < ge; e++)
+    ze[e * 2 + 1] = 5, ze[e * 2] = ri(e, 5);
+  ei = new ht(J, Ot, He + 1, Ue, oe), ti = new ht(ze, qe, 0, ge, oe), ni = new ht(new Array(0), dr, 0, Pt, hr);
+}, oi = (e) => {
+  let n;
+  for (n = 0; n < Ue; n++)
+    e.dyn_ltree[n * 2] = 0;
+  for (n = 0; n < ge; n++)
+    e.dyn_dtree[n * 2] = 0;
+  for (n = 0; n < Pt; n++)
+    e.bl_tree[n * 2] = 0;
+  e.dyn_ltree[Vt * 2] = 1, e.opt_len = e.static_len = 0, e.sym_next = e.matches = 0;
+}, li = (e) => {
+  e.bi_valid > 8 ? Ne(e, e.bi_buf) : e.bi_valid > 0 && (e.pending_buf[e.pending++] = e.bi_buf), e.bi_buf = 0, e.bi_valid = 0;
+}, tn = (e, n, t, i) => {
+  const a = n * 2, r = t * 2;
+  return e[a] < e[r] || e[a] === e[r] && i[n] <= i[t];
+}, _t = (e, n, t) => {
+  const i = e.heap[t];
+  let a = t << 1;
+  for (; a <= e.heap_len && (a < e.heap_len && tn(n, e.heap[a + 1], e.heap[a], e.depth) && a++, !tn(n, i, e.heap[a], e.depth)); )
+    e.heap[t] = e.heap[a], t = a, a <<= 1;
+  e.heap[t] = i;
+}, nn = (e, n, t) => {
+  let i, a, r = 0, o, s;
+  if (e.sym_next !== 0)
+    do
+      i = e.pending_buf[e.sym_buf + r++] & 255, i += (e.pending_buf[e.sym_buf + r++] & 255) << 8, a = e.pending_buf[e.sym_buf + r++], i === 0 ? Y(e, a, n) : (o = De[a], Y(e, o + He + 1, n), s = Ot[o], s !== 0 && (a -= Kt[o], M(e, a, s)), i--, o = ii(i), Y(e, o, t), s = qe[o], s !== 0 && (i -= et[o], M(e, i, s)));
+    while (r < e.sym_next);
+  Y(e, Vt, n);
+}, Rt = (e, n) => {
+  const t = n.dyn_tree, i = n.stat_desc.static_tree, a = n.stat_desc.has_stree, r = n.stat_desc.elems;
+  let o, s, f = -1, l;
+  for (e.heap_len = 0, e.heap_max = Xn, o = 0; o < r; o++)
+    t[o * 2] !== 0 ? (e.heap[++e.heap_len] = f = o, e.depth[o] = 0) : t[o * 2 + 1] = 0;
+  for (; e.heap_len < 2; )
+    l = e.heap[++e.heap_len] = f < 2 ? ++f : 0, t[l * 2] = 1, e.depth[l] = 0, e.opt_len--, a && (e.static_len -= i[l * 2 + 1]);
+  for (n.max_code = f, o = e.heap_len >> 1; o >= 1; o--)
+    _t(e, t, o);
+  l = r;
+  do
+    o = e.heap[
+      1
+      /*SMALLEST*/
+    ], e.heap[
+      1
+      /*SMALLEST*/
+    ] = e.heap[e.heap_len--], _t(
+      e,
+      t,
+      1
+      /*SMALLEST*/
+    ), s = e.heap[
+      1
+      /*SMALLEST*/
+    ], e.heap[--e.heap_max] = o, e.heap[--e.heap_max] = s, t[l * 2] = t[o * 2] + t[s * 2], e.depth[l] = (e.depth[o] >= e.depth[s] ? e.depth[o] : e.depth[s]) + 1, t[o * 2 + 1] = t[s * 2 + 1] = l, e.heap[
+      1
+      /*SMALLEST*/
+    ] = l++, _t(
+      e,
+      t,
+      1
+      /*SMALLEST*/
+    );
+  while (e.heap_len >= 2);
+  e.heap[--e.heap_max] = e.heap[
+    1
+    /*SMALLEST*/
+  ], gr(e, n), ai(t, f, e.bl_count);
+}, rn = (e, n, t) => {
+  let i, a = -1, r, o = n[0 * 2 + 1], s = 0, f = 7, l = 4;
+  for (o === 0 && (f = 138, l = 3), n[(t + 1) * 2 + 1] = 65535, i = 0; i <= t; i++)
+    r = o, o = n[(i + 1) * 2 + 1], !(++s < f && r === o) && (s < l ? e.bl_tree[r * 2] += s : r !== 0 ? (r !== a && e.bl_tree[r * 2]++, e.bl_tree[Wn * 2]++) : s <= 10 ? e.bl_tree[Jn * 2]++ : e.bl_tree[Qn * 2]++, s = 0, a = r, o === 0 ? (f = 138, l = 3) : r === o ? (f = 6, l = 3) : (f = 7, l = 4));
+}, an = (e, n, t) => {
+  let i, a = -1, r, o = n[0 * 2 + 1], s = 0, f = 7, l = 4;
+  for (o === 0 && (f = 138, l = 3), i = 0; i <= t; i++)
+    if (r = o, o = n[(i + 1) * 2 + 1], !(++s < f && r === o)) {
+      if (s < l)
+        do
+          Y(e, r, e.bl_tree);
+        while (--s !== 0);
+      else r !== 0 ? (r !== a && (Y(e, r, e.bl_tree), s--), Y(e, Wn, e.bl_tree), M(e, s - 3, 2)) : s <= 10 ? (Y(e, Jn, e.bl_tree), M(e, s - 3, 3)) : (Y(e, Qn, e.bl_tree), M(e, s - 11, 7));
+      s = 0, a = r, o === 0 ? (f = 138, l = 3) : r === o ? (f = 6, l = 3) : (f = 7, l = 4);
+    }
+}, pr = (e) => {
+  let n;
+  for (rn(e, e.dyn_ltree, e.l_desc.max_code), rn(e, e.dyn_dtree, e.d_desc.max_code), Rt(e, e.bl_desc), n = Pt - 1; n >= 3 && e.bl_tree[qn[n] * 2 + 1] === 0; n--)
+    ;
+  return e.opt_len += 3 * (n + 1) + 5 + 5 + 4, n;
+}, mr = (e, n, t, i) => {
+  let a;
+  for (M(e, n - 257, 5), M(e, t - 1, 5), M(e, i - 4, 4), a = 0; a < i; a++)
+    M(e, e.bl_tree[qn[a] * 2 + 1], 3);
+  an(e, e.dyn_ltree, n - 1), an(e, e.dyn_dtree, t - 1);
+}, yr = (e) => {
+  let n = 4093624447, t;
+  for (t = 0; t <= 31; t++, n >>>= 1)
+    if (n & 1 && e.dyn_ltree[t * 2] !== 0)
+      return qt;
+  if (e.dyn_ltree[9 * 2] !== 0 || e.dyn_ltree[10 * 2] !== 0 || e.dyn_ltree[13 * 2] !== 0)
+    return en;
+  for (t = 32; t < He; t++)
+    if (e.dyn_ltree[t * 2] !== 0)
+      return en;
+  return qt;
+};
+let on = !1;
+const vr = (e) => {
+  on || (wr(), on = !0), e.l_desc = new dt(e.dyn_ltree, ei), e.d_desc = new dt(e.dyn_dtree, ti), e.bl_desc = new dt(e.bl_tree, ni), e.bi_buf = 0, e.bi_valid = 0, oi(e);
+}, si = (e, n, t, i) => {
+  M(e, (sr << 1) + (i ? 1 : 0), 3), li(e), Ne(e, t), Ne(e, ~t), t && e.pending_buf.set(e.window.subarray(n, n + t), e.pending), e.pending += t;
+}, kr = (e) => {
+  M(e, jn << 1, 3), Y(e, Vt, J), br(e);
+}, Er = (e, n, t, i) => {
+  let a, r, o = 0;
+  e.level > 0 ? (e.strm.data_type === lr && (e.strm.data_type = yr(e)), Rt(e, e.l_desc), Rt(e, e.d_desc), o = pr(e), a = e.opt_len + 3 + 7 >>> 3, r = e.static_len + 3 + 7 >>> 3, r <= a && (a = r)) : a = r = t + 5, t + 4 <= a && n !== -1 ? si(e, n, t, i) : e.strategy === or || r === a ? (M(e, (jn << 1) + (i ? 1 : 0), 3), nn(e, J, ze)) : (M(e, (cr << 1) + (i ? 1 : 0), 3), mr(e, e.l_desc.max_code + 1, e.d_desc.max_code + 1, o + 1), nn(e, e.dyn_ltree, e.dyn_dtree)), oi(e), i && li(e);
+}, xr = (e, n, t) => (e.pending_buf[e.sym_buf + e.sym_next++] = n, e.pending_buf[e.sym_buf + e.sym_next++] = n >> 8, e.pending_buf[e.sym_buf + e.sym_next++] = t, n === 0 ? e.dyn_ltree[t * 2]++ : (e.matches++, n--, e.dyn_ltree[(De[t] + He + 1) * 2]++, e.dyn_dtree[ii(n) * 2]++), e.sym_next === e.sym_end);
+var Sr = vr, Ar = si, Ir = Er, Tr = xr, zr = kr, Or = {
+  _tr_init: Sr,
+  _tr_stored_block: Ar,
+  _tr_flush_block: Ir,
+  _tr_tally: Tr,
+  _tr_align: zr
+};
+const Rr = (e, n, t, i) => {
+  let a = e & 65535 | 0, r = e >>> 16 & 65535 | 0, o = 0;
+  for (; t !== 0; ) {
+    o = t > 2e3 ? 2e3 : t, t -= o;
+    do
+      a = a + n[i++] | 0, r = r + a | 0;
+    while (--o);
+    a %= 65521, r %= 65521;
+  }
+  return a | r << 16 | 0;
+};
+var Le = Rr;
+const Ur = () => {
+  let e, n = [];
+  for (var t = 0; t < 256; t++) {
+    e = t;
+    for (var i = 0; i < 8; i++)
+      e = e & 1 ? 3988292384 ^ e >>> 1 : e >>> 1;
+    n[t] = e;
+  }
+  return n;
+}, Br = new Uint32Array(Ur()), Dr = (e, n, t, i) => {
+  const a = Br, r = i + t;
+  e ^= -1;
+  for (let o = i; o < r; o++)
+    e = e >>> 8 ^ a[(e ^ n[o]) & 255];
+  return e ^ -1;
+};
+var N = Dr, pe = {
+  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) */
+}, Pe = {
+  /* 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
+};
+const { _tr_init: Nr, _tr_stored_block: Ut, _tr_flush_block: Lr, _tr_tally: ne, _tr_align: Zr } = Or, {
+  Z_NO_FLUSH: ie,
+  Z_PARTIAL_FLUSH: Cr,
+  Z_FULL_FLUSH: Fr,
+  Z_FINISH: P,
+  Z_BLOCK: ln,
+  Z_OK: L,
+  Z_STREAM_END: sn,
+  Z_STREAM_ERROR: j,
+  Z_DATA_ERROR: Mr,
+  Z_BUF_ERROR: bt,
+  Z_DEFAULT_COMPRESSION: $r,
+  Z_FILTERED: Hr,
+  Z_HUFFMAN_ONLY: Ge,
+  Z_RLE: Pr,
+  Z_FIXED: Vr,
+  Z_DEFAULT_STRATEGY: Kr,
+  Z_UNKNOWN: Gr,
+  Z_DEFLATED: rt
+} = Pe, Yr = 9, jr = 15, Xr = 8, Wr = 29, Jr = 256, Bt = Jr + 1 + Wr, Qr = 30, qr = 19, ea = 2 * Bt + 1, ta = 15, T = 3, te = 258, X = te + T + 1, na = 32, me = 42, Gt = 57, Dt = 69, Nt = 73, Lt = 91, Zt = 103, le = 113, Ie = 666, C = 1, ke = 2, fe = 3, Ee = 4, ia = 3, se = (e, n) => (e.msg = pe[n], n), cn = (e) => e * 2 - (e > 4 ? 9 : 0), q = (e) => {
+  let n = e.length;
+  for (; --n >= 0; )
+    e[n] = 0;
+}, ra = (e) => {
+  let n, t, i, a = e.w_size;
+  n = e.hash_size, i = n;
+  do
+    t = e.head[--i], e.head[i] = t >= a ? t - a : 0;
+  while (--n);
+  n = a, i = n;
+  do
+    t = e.prev[--i], e.prev[i] = t >= a ? t - a : 0;
+  while (--n);
+};
+let aa = (e, n, t) => (n << e.hash_shift ^ t) & e.hash_mask, re = aa;
+const $ = (e) => {
+  const n = e.state;
+  let t = n.pending;
+  t > e.avail_out && (t = e.avail_out), t !== 0 && (e.output.set(n.pending_buf.subarray(n.pending_out, n.pending_out + t), e.next_out), e.next_out += t, n.pending_out += t, e.total_out += t, e.avail_out -= t, n.pending -= t, n.pending === 0 && (n.pending_out = 0));
+}, H = (e, n) => {
+  Lr(e, e.block_start >= 0 ? e.block_start : -1, e.strstart - e.block_start, n), e.block_start = e.strstart, $(e.strm);
+}, z = (e, n) => {
+  e.pending_buf[e.pending++] = n;
+}, Ae = (e, n) => {
+  e.pending_buf[e.pending++] = n >>> 8 & 255, e.pending_buf[e.pending++] = n & 255;
+}, Ct = (e, n, t, i) => {
+  let a = e.avail_in;
+  return a > i && (a = i), a === 0 ? 0 : (e.avail_in -= a, n.set(e.input.subarray(e.next_in, e.next_in + a), t), e.state.wrap === 1 ? e.adler = Le(e.adler, n, a, t) : e.state.wrap === 2 && (e.adler = N(e.adler, n, a, t)), e.next_in += a, e.total_in += a, a);
+}, ci = (e, n) => {
+  let t = e.max_chain_length, i = e.strstart, a, r, o = e.prev_length, s = e.nice_match;
+  const f = e.strstart > e.w_size - X ? e.strstart - (e.w_size - X) : 0, l = e.window, c = e.w_mask, w = e.prev, h = e.strstart + te;
+  let u = l[i + o - 1], d = l[i + o];
+  e.prev_length >= e.good_match && (t >>= 2), s > e.lookahead && (s = e.lookahead);
+  do
+    if (a = n, !(l[a + o] !== d || l[a + o - 1] !== u || l[a] !== l[i] || l[++a] !== l[i + 1])) {
+      i += 2, a++;
+      do
+        ;
+      while (l[++i] === l[++a] && l[++i] === l[++a] && l[++i] === l[++a] && l[++i] === l[++a] && l[++i] === l[++a] && l[++i] === l[++a] && l[++i] === l[++a] && l[++i] === l[++a] && i < h);
+      if (r = te - (h - i), i = h - te, r > o) {
+        if (e.match_start = n, o = r, r >= s)
+          break;
+        u = l[i + o - 1], d = l[i + o];
+      }
+    }
+  while ((n = w[n & c]) > f && --t !== 0);
+  return o <= e.lookahead ? o : e.lookahead;
+}, ye = (e) => {
+  const n = e.w_size;
+  let t, i, a;
+  do {
+    if (i = e.window_size - e.lookahead - e.strstart, e.strstart >= n + (n - X) && (e.window.set(e.window.subarray(n, n + n - i), 0), e.match_start -= n, e.strstart -= n, e.block_start -= n, e.insert > e.strstart && (e.insert = e.strstart), ra(e), i += n), e.strm.avail_in === 0)
+      break;
+    if (t = Ct(e.strm, e.window, e.strstart + e.lookahead, i), e.lookahead += t, e.lookahead + e.insert >= T)
+      for (a = e.strstart - e.insert, e.ins_h = e.window[a], e.ins_h = re(e, e.ins_h, e.window[a + 1]); e.insert && (e.ins_h = re(e, e.ins_h, e.window[a + T - 1]), e.prev[a & e.w_mask] = e.head[e.ins_h], e.head[e.ins_h] = a, a++, e.insert--, !(e.lookahead + e.insert < T)); )
+        ;
+  } while (e.lookahead < X && e.strm.avail_in !== 0);
+}, fi = (e, n) => {
+  let t = e.pending_buf_size - 5 > e.w_size ? e.w_size : e.pending_buf_size - 5, i, a, r, o = 0, s = e.strm.avail_in;
+  do {
+    if (i = 65535, r = e.bi_valid + 42 >> 3, e.strm.avail_out < r || (r = e.strm.avail_out - r, a = e.strstart - e.block_start, i > a + e.strm.avail_in && (i = a + e.strm.avail_in), i > r && (i = r), i < t && (i === 0 && n !== P || n === ie || i !== a + e.strm.avail_in)))
+      break;
+    o = n === P && i === a + e.strm.avail_in ? 1 : 0, Ut(e, 0, 0, o), e.pending_buf[e.pending - 4] = i, e.pending_buf[e.pending - 3] = i >> 8, e.pending_buf[e.pending - 2] = ~i, e.pending_buf[e.pending - 1] = ~i >> 8, $(e.strm), a && (a > i && (a = i), e.strm.output.set(e.window.subarray(e.block_start, e.block_start + a), e.strm.next_out), e.strm.next_out += a, e.strm.avail_out -= a, e.strm.total_out += a, e.block_start += a, i -= a), i && (Ct(e.strm, e.strm.output, e.strm.next_out, i), e.strm.next_out += i, e.strm.avail_out -= i, e.strm.total_out += i);
+  } while (o === 0);
+  return s -= e.strm.avail_in, s && (s >= e.w_size ? (e.matches = 2, e.window.set(e.strm.input.subarray(e.strm.next_in - e.w_size, e.strm.next_in), 0), e.strstart = e.w_size, e.insert = e.strstart) : (e.window_size - e.strstart <= s && (e.strstart -= e.w_size, e.window.set(e.window.subarray(e.w_size, e.w_size + e.strstart), 0), e.matches < 2 && e.matches++, e.insert > e.strstart && (e.insert = e.strstart)), e.window.set(e.strm.input.subarray(e.strm.next_in - s, e.strm.next_in), e.strstart), e.strstart += s, e.insert += s > e.w_size - e.insert ? e.w_size - e.insert : s), e.block_start = e.strstart), e.high_water < e.strstart && (e.high_water = e.strstart), o ? Ee : n !== ie && n !== P && e.strm.avail_in === 0 && e.strstart === e.block_start ? ke : (r = e.window_size - e.strstart, e.strm.avail_in > r && e.block_start >= e.w_size && (e.block_start -= e.w_size, e.strstart -= e.w_size, e.window.set(e.window.subarray(e.w_size, e.w_size + e.strstart), 0), e.matches < 2 && e.matches++, r += e.w_size, e.insert > e.strstart && (e.insert = e.strstart)), r > e.strm.avail_in && (r = e.strm.avail_in), r && (Ct(e.strm, e.window, e.strstart, r), e.strstart += r, e.insert += r > e.w_size - e.insert ? e.w_size - e.insert : r), e.high_water < e.strstart && (e.high_water = e.strstart), r = e.bi_valid + 42 >> 3, r = e.pending_buf_size - r > 65535 ? 65535 : e.pending_buf_size - r, t = r > e.w_size ? e.w_size : r, a = e.strstart - e.block_start, (a >= t || (a || n === P) && n !== ie && e.strm.avail_in === 0 && a <= r) && (i = a > r ? r : a, o = n === P && e.strm.avail_in === 0 && i === a ? 1 : 0, Ut(e, e.block_start, i, o), e.block_start += i, $(e.strm)), o ? fe : C);
+}, gt = (e, n) => {
+  let t, i;
+  for (; ; ) {
+    if (e.lookahead < X) {
+      if (ye(e), e.lookahead < X && n === ie)
+        return C;
+      if (e.lookahead === 0)
+        break;
+    }
+    if (t = 0, e.lookahead >= T && (e.ins_h = re(e, e.ins_h, e.window[e.strstart + T - 1]), t = e.prev[e.strstart & e.w_mask] = e.head[e.ins_h], e.head[e.ins_h] = e.strstart), t !== 0 && e.strstart - t <= e.w_size - X && (e.match_length = ci(e, t)), e.match_length >= T)
+      if (i = ne(e, e.strstart - e.match_start, e.match_length - T), e.lookahead -= e.match_length, e.match_length <= e.max_lazy_match && e.lookahead >= T) {
+        e.match_length--;
+        do
+          e.strstart++, e.ins_h = re(e, e.ins_h, e.window[e.strstart + T - 1]), t = 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 = re(e, e.ins_h, e.window[e.strstart + 1]);
+    else
+      i = ne(e, 0, e.window[e.strstart]), e.lookahead--, e.strstart++;
+    if (i && (H(e, !1), e.strm.avail_out === 0))
+      return C;
+  }
+  return e.insert = e.strstart < T - 1 ? e.strstart : T - 1, n === P ? (H(e, !0), e.strm.avail_out === 0 ? fe : Ee) : e.sym_next && (H(e, !1), e.strm.avail_out === 0) ? C : ke;
+}, de = (e, n) => {
+  let t, i, a;
+  for (; ; ) {
+    if (e.lookahead < X) {
+      if (ye(e), e.lookahead < X && n === ie)
+        return C;
+      if (e.lookahead === 0)
+        break;
+    }
+    if (t = 0, e.lookahead >= T && (e.ins_h = re(e, e.ins_h, e.window[e.strstart + T - 1]), t = 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 = T - 1, t !== 0 && e.prev_length < e.max_lazy_match && e.strstart - t <= e.w_size - X && (e.match_length = ci(e, t), e.match_length <= 5 && (e.strategy === Hr || e.match_length === T && e.strstart - e.match_start > 4096) && (e.match_length = T - 1)), e.prev_length >= T && e.match_length <= e.prev_length) {
+      a = e.strstart + e.lookahead - T, i = ne(e, e.strstart - 1 - e.prev_match, e.prev_length - T), e.lookahead -= e.prev_length - 1, e.prev_length -= 2;
+      do
+        ++e.strstart <= a && (e.ins_h = re(e, e.ins_h, e.window[e.strstart + T - 1]), t = 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 = T - 1, e.strstart++, i && (H(e, !1), e.strm.avail_out === 0))
+        return C;
+    } else if (e.match_available) {
+      if (i = ne(e, 0, e.window[e.strstart - 1]), i && H(e, !1), e.strstart++, e.lookahead--, e.strm.avail_out === 0)
+        return C;
+    } else
+      e.match_available = 1, e.strstart++, e.lookahead--;
+  }
+  return e.match_available && (i = ne(e, 0, e.window[e.strstart - 1]), e.match_available = 0), e.insert = e.strstart < T - 1 ? e.strstart : T - 1, n === P ? (H(e, !0), e.strm.avail_out === 0 ? fe : Ee) : e.sym_next && (H(e, !1), e.strm.avail_out === 0) ? C : ke;
+}, oa = (e, n) => {
+  let t, i, a, r;
+  const o = e.window;
+  for (; ; ) {
+    if (e.lookahead <= te) {
+      if (ye(e), e.lookahead <= te && n === ie)
+        return C;
+      if (e.lookahead === 0)
+        break;
+    }
+    if (e.match_length = 0, e.lookahead >= T && e.strstart > 0 && (a = e.strstart - 1, i = o[a], i === o[++a] && i === o[++a] && i === o[++a])) {
+      r = e.strstart + te;
+      do
+        ;
+      while (i === o[++a] && i === o[++a] && i === o[++a] && i === o[++a] && i === o[++a] && i === o[++a] && i === o[++a] && i === o[++a] && a < r);
+      e.match_length = te - (r - a), e.match_length > e.lookahead && (e.match_length = e.lookahead);
+    }
+    if (e.match_length >= T ? (t = ne(e, 1, e.match_length - T), e.lookahead -= e.match_length, e.strstart += e.match_length, e.match_length = 0) : (t = ne(e, 0, e.window[e.strstart]), e.lookahead--, e.strstart++), t && (H(e, !1), e.strm.avail_out === 0))
+      return C;
+  }
+  return e.insert = 0, n === P ? (H(e, !0), e.strm.avail_out === 0 ? fe : Ee) : e.sym_next && (H(e, !1), e.strm.avail_out === 0) ? C : ke;
+}, la = (e, n) => {
+  let t;
+  for (; ; ) {
+    if (e.lookahead === 0 && (ye(e), e.lookahead === 0)) {
+      if (n === ie)
+        return C;
+      break;
+    }
+    if (e.match_length = 0, t = ne(e, 0, e.window[e.strstart]), e.lookahead--, e.strstart++, t && (H(e, !1), e.strm.avail_out === 0))
+      return C;
+  }
+  return e.insert = 0, n === P ? (H(e, !0), e.strm.avail_out === 0 ? fe : Ee) : e.sym_next && (H(e, !1), e.strm.avail_out === 0) ? C : ke;
+};
+function G(e, n, t, i, a) {
+  this.good_length = e, this.max_lazy = n, this.nice_length = t, this.max_chain = i, this.func = a;
+}
+const Te = [
+  /*      good lazy nice chain */
+  new G(0, 0, 0, 0, fi),
+  /* 0 store only */
+  new G(4, 4, 8, 4, gt),
+  /* 1 max speed, no lazy matches */
+  new G(4, 5, 16, 8, gt),
+  /* 2 */
+  new G(4, 6, 32, 32, gt),
+  /* 3 */
+  new G(4, 4, 16, 16, de),
+  /* 4 lazy matches */
+  new G(8, 16, 32, 32, de),
+  /* 5 */
+  new G(8, 16, 128, 128, de),
+  /* 6 */
+  new G(8, 32, 128, 256, de),
+  /* 7 */
+  new G(32, 128, 258, 1024, de),
+  /* 8 */
+  new G(32, 258, 258, 4096, de)
+  /* 9 max compression */
+], sa = (e) => {
+  e.window_size = 2 * e.w_size, q(e.head), e.max_lazy_match = Te[e.level].max_lazy, e.good_match = Te[e.level].good_length, e.nice_match = Te[e.level].nice_length, e.max_chain_length = Te[e.level].max_chain, e.strstart = 0, e.block_start = 0, e.lookahead = 0, e.insert = 0, e.match_length = e.prev_length = T - 1, e.match_available = 0, e.ins_h = 0;
+};
+function ca() {
+  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 = rt, 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 Uint16Array(ea * 2), this.dyn_dtree = new Uint16Array((2 * Qr + 1) * 2), this.bl_tree = new Uint16Array((2 * qr + 1) * 2), q(this.dyn_ltree), q(this.dyn_dtree), q(this.bl_tree), this.l_desc = null, this.d_desc = null, this.bl_desc = null, this.bl_count = new Uint16Array(ta + 1), this.heap = new Uint16Array(2 * Bt + 1), q(this.heap), this.heap_len = 0, this.heap_max = 0, this.depth = new Uint16Array(2 * Bt + 1), q(this.depth), this.sym_buf = 0, this.lit_bufsize = 0, this.sym_next = 0, this.sym_end = 0, this.opt_len = 0, this.static_len = 0, this.matches = 0, this.insert = 0, this.bi_buf = 0, this.bi_valid = 0;
+}
+const Ve = (e) => {
+  if (!e)
+    return 1;
+  const n = e.state;
+  return !n || n.strm !== e || n.status !== me && //#ifdef GZIP
+  n.status !== Gt && //#endif
+  n.status !== Dt && n.status !== Nt && n.status !== Lt && n.status !== Zt && n.status !== le && n.status !== Ie ? 1 : 0;
+}, ui = (e) => {
+  if (Ve(e))
+    return se(e, j);
+  e.total_in = e.total_out = 0, e.data_type = Gr;
+  const n = e.state;
+  return n.pending = 0, n.pending_out = 0, n.wrap < 0 && (n.wrap = -n.wrap), n.status = //#ifdef GZIP
+  n.wrap === 2 ? Gt : (
+    //#endif
+    n.wrap ? me : le
+  ), e.adler = n.wrap === 2 ? 0 : 1, n.last_flush = -2, Nr(n), L;
+}, hi = (e) => {
+  const n = ui(e);
+  return n === L && sa(e.state), n;
+}, fa = (e, n) => Ve(e) || e.state.wrap !== 2 ? j : (e.state.gzhead = n, L), di = (e, n, t, i, a, r) => {
+  if (!e)
+    return j;
+  let o = 1;
+  if (n === $r && (n = 6), i < 0 ? (o = 0, i = -i) : i > 15 && (o = 2, i -= 16), a < 1 || a > Yr || t !== rt || i < 8 || i > 15 || n < 0 || n > 9 || r < 0 || r > Vr || i === 8 && o !== 1)
+    return se(e, j);
+  i === 8 && (i = 9);
+  const s = new ca();
+  return e.state = s, s.strm = e, s.status = me, s.wrap = o, s.gzhead = null, s.w_bits = i, s.w_size = 1 << s.w_bits, s.w_mask = s.w_size - 1, s.hash_bits = a + 7, s.hash_size = 1 << s.hash_bits, s.hash_mask = s.hash_size - 1, s.hash_shift = ~~((s.hash_bits + T - 1) / T), s.window = new Uint8Array(s.w_size * 2), s.head = new Uint16Array(s.hash_size), s.prev = new Uint16Array(s.w_size), s.lit_bufsize = 1 << a + 6, s.pending_buf_size = s.lit_bufsize * 4, s.pending_buf = new Uint8Array(s.pending_buf_size), s.sym_buf = s.lit_bufsize, s.sym_end = (s.lit_bufsize - 1) * 3, s.level = n, s.strategy = r, s.method = t, hi(e);
+}, ua = (e, n) => di(e, n, rt, jr, Xr, Kr), ha = (e, n) => {
+  if (Ve(e) || n > ln || n < 0)
+    return e ? se(e, j) : j;
+  const t = e.state;
+  if (!e.output || e.avail_in !== 0 && !e.input || t.status === Ie && n !== P)
+    return se(e, e.avail_out === 0 ? bt : j);
+  const i = t.last_flush;
+  if (t.last_flush = n, t.pending !== 0) {
+    if ($(e), e.avail_out === 0)
+      return t.last_flush = -1, L;
+  } else if (e.avail_in === 0 && cn(n) <= cn(i) && n !== P)
+    return se(e, bt);
+  if (t.status === Ie && e.avail_in !== 0)
+    return se(e, bt);
+  if (t.status === me && t.wrap === 0 && (t.status = le), t.status === me) {
+    let a = rt + (t.w_bits - 8 << 4) << 8, r = -1;
+    if (t.strategy >= Ge || t.level < 2 ? r = 0 : t.level < 6 ? r = 1 : t.level === 6 ? r = 2 : r = 3, a |= r << 6, t.strstart !== 0 && (a |= na), a += 31 - a % 31, Ae(t, a), t.strstart !== 0 && (Ae(t, e.adler >>> 16), Ae(t, e.adler & 65535)), e.adler = 1, t.status = le, $(e), t.pending !== 0)
+      return t.last_flush = -1, L;
+  }
+  if (t.status === Gt) {
+    if (e.adler = 0, z(t, 31), z(t, 139), z(t, 8), t.gzhead)
+      z(
+        t,
+        (t.gzhead.text ? 1 : 0) + (t.gzhead.hcrc ? 2 : 0) + (t.gzhead.extra ? 4 : 0) + (t.gzhead.name ? 8 : 0) + (t.gzhead.comment ? 16 : 0)
+      ), z(t, t.gzhead.time & 255), z(t, t.gzhead.time >> 8 & 255), z(t, t.gzhead.time >> 16 & 255), z(t, t.gzhead.time >> 24 & 255), z(t, t.level === 9 ? 2 : t.strategy >= Ge || t.level < 2 ? 4 : 0), z(t, t.gzhead.os & 255), t.gzhead.extra && t.gzhead.extra.length && (z(t, t.gzhead.extra.length & 255), z(t, t.gzhead.extra.length >> 8 & 255)), t.gzhead.hcrc && (e.adler = N(e.adler, t.pending_buf, t.pending, 0)), t.gzindex = 0, t.status = Dt;
+    else if (z(t, 0), z(t, 0), z(t, 0), z(t, 0), z(t, 0), z(t, t.level === 9 ? 2 : t.strategy >= Ge || t.level < 2 ? 4 : 0), z(t, ia), t.status = le, $(e), t.pending !== 0)
+      return t.last_flush = -1, L;
+  }
+  if (t.status === Dt) {
+    if (t.gzhead.extra) {
+      let a = t.pending, r = (t.gzhead.extra.length & 65535) - t.gzindex;
+      for (; t.pending + r > t.pending_buf_size; ) {
+        let s = t.pending_buf_size - t.pending;
+        if (t.pending_buf.set(t.gzhead.extra.subarray(t.gzindex, t.gzindex + s), t.pending), t.pending = t.pending_buf_size, t.gzhead.hcrc && t.pending > a && (e.adler = N(e.adler, t.pending_buf, t.pending - a, a)), t.gzindex += s, $(e), t.pending !== 0)
+          return t.last_flush = -1, L;
+        a = 0, r -= s;
+      }
+      let o = new Uint8Array(t.gzhead.extra);
+      t.pending_buf.set(o.subarray(t.gzindex, t.gzindex + r), t.pending), t.pending += r, t.gzhead.hcrc && t.pending > a && (e.adler = N(e.adler, t.pending_buf, t.pending - a, a)), t.gzindex = 0;
+    }
+    t.status = Nt;
+  }
+  if (t.status === Nt) {
+    if (t.gzhead.name) {
+      let a = t.pending, r;
+      do {
+        if (t.pending === t.pending_buf_size) {
+          if (t.gzhead.hcrc && t.pending > a && (e.adler = N(e.adler, t.pending_buf, t.pending - a, a)), $(e), t.pending !== 0)
+            return t.last_flush = -1, L;
+          a = 0;
+        }
+        t.gzindex < t.gzhead.name.length ? r = t.gzhead.name.charCodeAt(t.gzindex++) & 255 : r = 0, z(t, r);
+      } while (r !== 0);
+      t.gzhead.hcrc && t.pending > a && (e.adler = N(e.adler, t.pending_buf, t.pending - a, a)), t.gzindex = 0;
+    }
+    t.status = Lt;
+  }
+  if (t.status === Lt) {
+    if (t.gzhead.comment) {
+      let a = t.pending, r;
+      do {
+        if (t.pending === t.pending_buf_size) {
+          if (t.gzhead.hcrc && t.pending > a && (e.adler = N(e.adler, t.pending_buf, t.pending - a, a)), $(e), t.pending !== 0)
+            return t.last_flush = -1, L;
+          a = 0;
+        }
+        t.gzindex < t.gzhead.comment.length ? r = t.gzhead.comment.charCodeAt(t.gzindex++) & 255 : r = 0, z(t, r);
+      } while (r !== 0);
+      t.gzhead.hcrc && t.pending > a && (e.adler = N(e.adler, t.pending_buf, t.pending - a, a));
+    }
+    t.status = Zt;
+  }
+  if (t.status === Zt) {
+    if (t.gzhead.hcrc) {
+      if (t.pending + 2 > t.pending_buf_size && ($(e), t.pending !== 0))
+        return t.last_flush = -1, L;
+      z(t, e.adler & 255), z(t, e.adler >> 8 & 255), e.adler = 0;
+    }
+    if (t.status = le, $(e), t.pending !== 0)
+      return t.last_flush = -1, L;
+  }
+  if (e.avail_in !== 0 || t.lookahead !== 0 || n !== ie && t.status !== Ie) {
+    let a = t.level === 0 ? fi(t, n) : t.strategy === Ge ? la(t, n) : t.strategy === Pr ? oa(t, n) : Te[t.level].func(t, n);
+    if ((a === fe || a === Ee) && (t.status = Ie), a === C || a === fe)
+      return e.avail_out === 0 && (t.last_flush = -1), L;
+    if (a === ke && (n === Cr ? Zr(t) : n !== ln && (Ut(t, 0, 0, !1), n === Fr && (q(t.head), t.lookahead === 0 && (t.strstart = 0, t.block_start = 0, t.insert = 0))), $(e), e.avail_out === 0))
+      return t.last_flush = -1, L;
+  }
+  return n !== P ? L : t.wrap <= 0 ? sn : (t.wrap === 2 ? (z(t, e.adler & 255), z(t, e.adler >> 8 & 255), z(t, e.adler >> 16 & 255), z(t, e.adler >> 24 & 255), z(t, e.total_in & 255), z(t, e.total_in >> 8 & 255), z(t, e.total_in >> 16 & 255), z(t, e.total_in >> 24 & 255)) : (Ae(t, e.adler >>> 16), Ae(t, e.adler & 65535)), $(e), t.wrap > 0 && (t.wrap = -t.wrap), t.pending !== 0 ? L : sn);
+}, da = (e) => {
+  if (Ve(e))
+    return j;
+  const n = e.state.status;
+  return e.state = null, n === le ? se(e, Mr) : L;
+}, _a = (e, n) => {
+  let t = n.length;
+  if (Ve(e))
+    return j;
+  const i = e.state, a = i.wrap;
+  if (a === 2 || a === 1 && i.status !== me || i.lookahead)
+    return j;
+  if (a === 1 && (e.adler = Le(e.adler, n, t, 0)), i.wrap = 0, t >= i.w_size) {
+    a === 0 && (q(i.head), i.strstart = 0, i.block_start = 0, i.insert = 0);
+    let f = new Uint8Array(i.w_size);
+    f.set(n.subarray(t - i.w_size, t), 0), n = f, t = i.w_size;
+  }
+  const r = e.avail_in, o = e.next_in, s = e.input;
+  for (e.avail_in = t, e.next_in = 0, e.input = n, ye(i); i.lookahead >= T; ) {
+    let f = i.strstart, l = i.lookahead - (T - 1);
+    do
+      i.ins_h = re(i, i.ins_h, i.window[f + T - 1]), i.prev[f & i.w_mask] = i.head[i.ins_h], i.head[i.ins_h] = f, f++;
+    while (--l);
+    i.strstart = f, i.lookahead = T - 1, ye(i);
+  }
+  return i.strstart += i.lookahead, i.block_start = i.strstart, i.insert = i.lookahead, i.lookahead = 0, i.match_length = i.prev_length = T - 1, i.match_available = 0, e.next_in = o, e.input = s, e.avail_in = r, i.wrap = a, L;
+};
+var ba = ua, ga = di, wa = hi, pa = ui, ma = fa, ya = ha, va = da, ka = _a, Ea = "pako deflate (from Nodeca project)", Oe = {
+  deflateInit: ba,
+  deflateInit2: ga,
+  deflateReset: wa,
+  deflateResetKeep: pa,
+  deflateSetHeader: ma,
+  deflate: ya,
+  deflateEnd: va,
+  deflateSetDictionary: ka,
+  deflateInfo: Ea
+};
+const xa = (e, n) => Object.prototype.hasOwnProperty.call(e, n);
+var Sa = function(e) {
+  const n = Array.prototype.slice.call(arguments, 1);
+  for (; n.length; ) {
+    const t = n.shift();
+    if (t) {
+      if (typeof t != "object")
+        throw new TypeError(t + "must be non-object");
+      for (const i in t)
+        xa(t, i) && (e[i] = t[i]);
+    }
+  }
+  return e;
+}, Aa = (e) => {
+  let n = 0;
+  for (let i = 0, a = e.length; i < a; i++)
+    n += e[i].length;
+  const t = new Uint8Array(n);
+  for (let i = 0, a = 0, r = e.length; i < r; i++) {
+    let o = e[i];
+    t.set(o, a), a += o.length;
+  }
+  return t;
+}, at = {
+  assign: Sa,
+  flattenChunks: Aa
+};
+let _i = !0;
+try {
+  String.fromCharCode.apply(null, new Uint8Array(1));
+} catch {
+  _i = !1;
+}
+const Ze = new Uint8Array(256);
+for (let e = 0; e < 256; e++)
+  Ze[e] = e >= 252 ? 6 : e >= 248 ? 5 : e >= 240 ? 4 : e >= 224 ? 3 : e >= 192 ? 2 : 1;
+Ze[254] = Ze[254] = 1;
+var Ia = (e) => {
+  if (typeof TextEncoder == "function" && TextEncoder.prototype.encode)
+    return new TextEncoder().encode(e);
+  let n, t, i, a, r, o = e.length, s = 0;
+  for (a = 0; a < o; a++)
+    t = e.charCodeAt(a), (t & 64512) === 55296 && a + 1 < o && (i = e.charCodeAt(a + 1), (i & 64512) === 56320 && (t = 65536 + (t - 55296 << 10) + (i - 56320), a++)), s += t < 128 ? 1 : t < 2048 ? 2 : t < 65536 ? 3 : 4;
+  for (n = new Uint8Array(s), r = 0, a = 0; r < s; a++)
+    t = e.charCodeAt(a), (t & 64512) === 55296 && a + 1 < o && (i = e.charCodeAt(a + 1), (i & 64512) === 56320 && (t = 65536 + (t - 55296 << 10) + (i - 56320), a++)), t < 128 ? n[r++] = t : t < 2048 ? (n[r++] = 192 | t >>> 6, n[r++] = 128 | t & 63) : t < 65536 ? (n[r++] = 224 | t >>> 12, n[r++] = 128 | t >>> 6 & 63, n[r++] = 128 | t & 63) : (n[r++] = 240 | t >>> 18, n[r++] = 128 | t >>> 12 & 63, n[r++] = 128 | t >>> 6 & 63, n[r++] = 128 | t & 63);
+  return n;
+};
+const Ta = (e, n) => {
+  if (n < 65534 && e.subarray && _i)
+    return String.fromCharCode.apply(null, e.length === n ? e : e.subarray(0, n));
+  let t = "";
+  for (let i = 0; i < n; i++)
+    t += String.fromCharCode(e[i]);
+  return t;
+};
+var za = (e, n) => {
+  const t = n || e.length;
+  if (typeof TextDecoder == "function" && TextDecoder.prototype.decode)
+    return new TextDecoder().decode(e.subarray(0, n));
+  let i, a;
+  const r = new Array(t * 2);
+  for (a = 0, i = 0; i < t; ) {
+    let o = e[i++];
+    if (o < 128) {
+      r[a++] = o;
+      continue;
+    }
+    let s = Ze[o];
+    if (s > 4) {
+      r[a++] = 65533, i += s - 1;
+      continue;
+    }
+    for (o &= s === 2 ? 31 : s === 3 ? 15 : 7; s > 1 && i < t; )
+      o = o << 6 | e[i++] & 63, s--;
+    if (s > 1) {
+      r[a++] = 65533;
+      continue;
+    }
+    o < 65536 ? r[a++] = o : (o -= 65536, r[a++] = 55296 | o >> 10 & 1023, r[a++] = 56320 | o & 1023);
+  }
+  return Ta(r, a);
+}, Oa = (e, n) => {
+  n = n || e.length, n > e.length && (n = e.length);
+  let t = n - 1;
+  for (; t >= 0 && (e[t] & 192) === 128; )
+    t--;
+  return t < 0 || t === 0 ? n : t + Ze[e[t]] > n ? t : n;
+}, Ce = {
+  string2buf: Ia,
+  buf2string: za,
+  utf8border: Oa
+};
+function Ra() {
+  this.input = null, this.next_in = 0, this.avail_in = 0, this.total_in = 0, this.output = null, this.next_out = 0, this.avail_out = 0, this.total_out = 0, this.msg = "", this.state = null, this.data_type = 2, this.adler = 0;
+}
+var bi = Ra;
+const gi = Object.prototype.toString, {
+  Z_NO_FLUSH: Ua,
+  Z_SYNC_FLUSH: Ba,
+  Z_FULL_FLUSH: Da,
+  Z_FINISH: Na,
+  Z_OK: tt,
+  Z_STREAM_END: La,
+  Z_DEFAULT_COMPRESSION: Za,
+  Z_DEFAULT_STRATEGY: Ca,
+  Z_DEFLATED: Fa
+} = Pe;
+function Yt(e) {
+  this.options = at.assign({
+    level: Za,
+    method: Fa,
+    chunkSize: 16384,
+    windowBits: 15,
+    memLevel: 8,
+    strategy: Ca
+  }, e || {});
+  let n = this.options;
+  n.raw && n.windowBits > 0 ? n.windowBits = -n.windowBits : n.gzip && n.windowBits > 0 && n.windowBits < 16 && (n.windowBits += 16), this.err = 0, this.msg = "", this.ended = !1, this.chunks = [], this.strm = new bi(), this.strm.avail_out = 0;
+  let t = Oe.deflateInit2(
+    this.strm,
+    n.level,
+    n.method,
+    n.windowBits,
+    n.memLevel,
+    n.strategy
+  );
+  if (t !== tt)
+    throw new Error(pe[t]);
+  if (n.header && Oe.deflateSetHeader(this.strm, n.header), n.dictionary) {
+    let i;
+    if (typeof n.dictionary == "string" ? i = Ce.string2buf(n.dictionary) : gi.call(n.dictionary) === "[object ArrayBuffer]" ? i = new Uint8Array(n.dictionary) : i = n.dictionary, t = Oe.deflateSetDictionary(this.strm, i), t !== tt)
+      throw new Error(pe[t]);
+    this._dict_set = !0;
+  }
+}
+Yt.prototype.push = function(e, n) {
+  const t = this.strm, i = this.options.chunkSize;
+  let a, r;
+  if (this.ended)
+    return !1;
+  for (n === ~~n ? r = n : r = n === !0 ? Na : Ua, typeof e == "string" ? t.input = Ce.string2buf(e) : gi.call(e) === "[object ArrayBuffer]" ? t.input = new Uint8Array(e) : t.input = e, t.next_in = 0, t.avail_in = t.input.length; ; ) {
+    if (t.avail_out === 0 && (t.output = new Uint8Array(i), t.next_out = 0, t.avail_out = i), (r === Ba || r === Da) && t.avail_out <= 6) {
+      this.onData(t.output.subarray(0, t.next_out)), t.avail_out = 0;
+      continue;
+    }
+    if (a = Oe.deflate(t, r), a === La)
+      return t.next_out > 0 && this.onData(t.output.subarray(0, t.next_out)), a = Oe.deflateEnd(this.strm), this.onEnd(a), this.ended = !0, a === tt;
+    if (t.avail_out === 0) {
+      this.onData(t.output);
+      continue;
+    }
+    if (r > 0 && t.next_out > 0) {
+      this.onData(t.output.subarray(0, t.next_out)), t.avail_out = 0;
+      continue;
+    }
+    if (t.avail_in === 0) break;
+  }
+  return !0;
+};
+Yt.prototype.onData = function(e) {
+  this.chunks.push(e);
+};
+Yt.prototype.onEnd = function(e) {
+  e === tt && (this.result = at.flattenChunks(this.chunks)), this.chunks = [], this.err = e, this.msg = this.strm.msg;
+};
+const Ye = 16209, Ma = 16191;
+var $a = function(n, t) {
+  let i, a, r, o, s, f, l, c, w, h, u, d, g, v, k, E, A, b, x, I, p, S, _, y;
+  const m = n.state;
+  i = n.next_in, _ = n.input, a = i + (n.avail_in - 5), r = n.next_out, y = n.output, o = r - (t - n.avail_out), s = r + (n.avail_out - 257), f = m.dmax, l = m.wsize, c = m.whave, w = m.wnext, h = m.window, u = m.hold, d = m.bits, g = m.lencode, v = m.distcode, k = (1 << m.lenbits) - 1, E = (1 << m.distbits) - 1;
+  e:
+    do {
+      d < 15 && (u += _[i++] << d, d += 8, u += _[i++] << d, d += 8), A = g[u & k];
+      t:
+        for (; ; ) {
+          if (b = A >>> 24, u >>>= b, d -= b, b = A >>> 16 & 255, b === 0)
+            y[r++] = A & 65535;
+          else if (b & 16) {
+            x = A & 65535, b &= 15, b && (d < b && (u += _[i++] << d, d += 8), x += u & (1 << b) - 1, u >>>= b, d -= b), d < 15 && (u += _[i++] << d, d += 8, u += _[i++] << d, d += 8), A = v[u & E];
+            n:
+              for (; ; ) {
+                if (b = A >>> 24, u >>>= b, d -= b, b = A >>> 16 & 255, b & 16) {
+                  if (I = A & 65535, b &= 15, d < b && (u += _[i++] << d, d += 8, d < b && (u += _[i++] << d, d += 8)), I += u & (1 << b) - 1, I > f) {
+                    n.msg = "invalid distance too far back", m.mode = Ye;
+                    break e;
+                  }
+                  if (u >>>= b, d -= b, b = r - o, I > b) {
+                    if (b = I - b, b > c && m.sane) {
+                      n.msg = "invalid distance too far back", m.mode = Ye;
+                      break e;
+                    }
+                    if (p = 0, S = h, w === 0) {
+                      if (p += l - b, b < x) {
+                        x -= b;
+                        do
+                          y[r++] = h[p++];
+                        while (--b);
+                        p = r - I, S = y;
+                      }
+                    } else if (w < b) {
+                      if (p += l + w - b, b -= w, b < x) {
+                        x -= b;
+                        do
+                          y[r++] = h[p++];
+                        while (--b);
+                        if (p = 0, w < x) {
+                          b = w, x -= b;
+                          do
+                            y[r++] = h[p++];
+                          while (--b);
+                          p = r - I, S = y;
+                        }
+                      }
+                    } else if (p += w - b, b < x) {
+                      x -= b;
+                      do
+                        y[r++] = h[p++];
+                      while (--b);
+                      p = r - I, S = y;
+                    }
+                    for (; x > 2; )
+                      y[r++] = S[p++], y[r++] = S[p++], y[r++] = S[p++], x -= 3;
+                    x && (y[r++] = S[p++], x > 1 && (y[r++] = S[p++]));
+                  } else {
+                    p = r - I;
+                    do
+                      y[r++] = y[p++], y[r++] = y[p++], y[r++] = y[p++], x -= 3;
+                    while (x > 2);
+                    x && (y[r++] = y[p++], x > 1 && (y[r++] = y[p++]));
+                  }
+                } else if (b & 64) {
+                  n.msg = "invalid distance code", m.mode = Ye;
+                  break e;
+                } else {
+                  A = v[(A & 65535) + (u & (1 << b) - 1)];
+                  continue n;
+                }
+                break;
+              }
+          } else if (b & 64)
+            if (b & 32) {
+              m.mode = Ma;
+              break e;
+            } else {
+              n.msg = "invalid literal/length code", m.mode = Ye;
+              break e;
+            }
+          else {
+            A = g[(A & 65535) + (u & (1 << b) - 1)];
+            continue t;
+          }
+          break;
+        }
+    } while (i < a && r < s);
+  x = d >> 3, i -= x, d -= x << 3, u &= (1 << d) - 1, n.next_in = i, n.next_out = r, n.avail_in = i < a ? 5 + (a - i) : 5 - (i - a), n.avail_out = r < s ? 257 + (s - r) : 257 - (r - s), m.hold = u, m.bits = d;
+};
+const _e = 15, fn = 852, un = 592, hn = 0, wt = 1, dn = 2, Ha = new Uint16Array([
+  /* 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
+]), Pa = new Uint8Array([
+  /* 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
+]), Va = new Uint16Array([
+  /* 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
+]), Ka = new Uint8Array([
+  /* 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
+]), Ga = (e, n, t, i, a, r, o, s) => {
+  const f = s.bits;
+  let l = 0, c = 0, w = 0, h = 0, u = 0, d = 0, g = 0, v = 0, k = 0, E = 0, A, b, x, I, p, S = null, _;
+  const y = new Uint16Array(_e + 1), m = new Uint16Array(_e + 1);
+  let U = null, Z, B, O;
+  for (l = 0; l <= _e; l++)
+    y[l] = 0;
+  for (c = 0; c < i; c++)
+    y[n[t + c]]++;
+  for (u = f, h = _e; h >= 1 && y[h] === 0; h--)
+    ;
+  if (u > h && (u = h), h === 0)
+    return a[r++] = 1 << 24 | 64 << 16 | 0, a[r++] = 1 << 24 | 64 << 16 | 0, s.bits = 1, 0;
+  for (w = 1; w < h && y[w] === 0; w++)
+    ;
+  for (u < w && (u = w), v = 1, l = 1; l <= _e; l++)
+    if (v <<= 1, v -= y[l], v < 0)
+      return -1;
+  if (v > 0 && (e === hn || h !== 1))
+    return -1;
+  for (m[1] = 0, l = 1; l < _e; l++)
+    m[l + 1] = m[l] + y[l];
+  for (c = 0; c < i; c++)
+    n[t + c] !== 0 && (o[m[n[t + c]]++] = c);
+  if (e === hn ? (S = U = o, _ = 20) : e === wt ? (S = Ha, U = Pa, _ = 257) : (S = Va, U = Ka, _ = 0), E = 0, c = 0, l = w, p = r, d = u, g = 0, x = -1, k = 1 << u, I = k - 1, e === wt && k > fn || e === dn && k > un)
+    return 1;
+  for (; ; ) {
+    Z = l - g, o[c] + 1 < _ ? (B = 0, O = o[c]) : o[c] >= _ ? (B = U[o[c] - _], O = S[o[c] - _]) : (B = 96, O = 0), A = 1 << l - g, b = 1 << d, w = b;
+    do
+      b -= A, a[p + (E >> g) + b] = Z << 24 | B << 16 | O | 0;
+    while (b !== 0);
+    for (A = 1 << l - 1; E & A; )
+      A >>= 1;
+    if (A !== 0 ? (E &= A - 1, E += A) : E = 0, c++, --y[l] === 0) {
+      if (l === h)
+        break;
+      l = n[t + o[c]];
+    }
+    if (l > u && (E & I) !== x) {
+      for (g === 0 && (g = u), p += w, d = l - g, v = 1 << d; d + g < h && (v -= y[d + g], !(v <= 0)); )
+        d++, v <<= 1;
+      if (k += 1 << d, e === wt && k > fn || e === dn && k > un)
+        return 1;
+      x = E & I, a[x] = u << 24 | d << 16 | p - r | 0;
+    }
+  }
+  return E !== 0 && (a[p + E] = l - g << 24 | 64 << 16 | 0), s.bits = u, 0;
+};
+var Re = Ga;
+const Ya = 0, wi = 1, pi = 2, {
+  Z_FINISH: _n,
+  Z_BLOCK: ja,
+  Z_TREES: je,
+  Z_OK: ue,
+  Z_STREAM_END: Xa,
+  Z_NEED_DICT: Wa,
+  Z_STREAM_ERROR: V,
+  Z_DATA_ERROR: mi,
+  Z_MEM_ERROR: yi,
+  Z_BUF_ERROR: Ja,
+  Z_DEFLATED: bn
+} = Pe, ot = 16180, gn = 16181, wn = 16182, pn = 16183, mn = 16184, yn = 16185, vn = 16186, kn = 16187, En = 16188, xn = 16189, nt = 16190, W = 16191, pt = 16192, Sn = 16193, mt = 16194, An = 16195, In = 16196, Tn = 16197, zn = 16198, Xe = 16199, We = 16200, On = 16201, Rn = 16202, Un = 16203, Bn = 16204, Dn = 16205, yt = 16206, Nn = 16207, Ln = 16208, R = 16209, vi = 16210, ki = 16211, Qa = 852, qa = 592, eo = 15, to = eo, Zn = (e) => (e >>> 24 & 255) + (e >>> 8 & 65280) + ((e & 65280) << 8) + ((e & 255) << 24);
+function no() {
+  this.strm = null, 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 Uint16Array(320), this.work = new Uint16Array(288), this.lendyn = null, this.distdyn = null, this.sane = 0, this.back = 0, this.was = 0;
+}
+const he = (e) => {
+  if (!e)
+    return 1;
+  const n = e.state;
+  return !n || n.strm !== e || n.mode < ot || n.mode > ki ? 1 : 0;
+}, Ei = (e) => {
+  if (he(e))
+    return V;
+  const n = e.state;
+  return e.total_in = e.total_out = n.total = 0, e.msg = "", n.wrap && (e.adler = n.wrap & 1), n.mode = ot, n.last = 0, n.havedict = 0, n.flags = -1, n.dmax = 32768, n.head = null, n.hold = 0, n.bits = 0, n.lencode = n.lendyn = new Int32Array(Qa), n.distcode = n.distdyn = new Int32Array(qa), n.sane = 1, n.back = -1, ue;
+}, xi = (e) => {
+  if (he(e))
+    return V;
+  const n = e.state;
+  return n.wsize = 0, n.whave = 0, n.wnext = 0, Ei(e);
+}, Si = (e, n) => {
+  let t;
+  if (he(e))
+    return V;
+  const i = e.state;
+  return n < 0 ? (t = 0, n = -n) : (t = (n >> 4) + 5, n < 48 && (n &= 15)), n && (n < 8 || n > 15) ? V : (i.window !== null && i.wbits !== n && (i.window = null), i.wrap = t, i.wbits = n, xi(e));
+}, Ai = (e, n) => {
+  if (!e)
+    return V;
+  const t = new no();
+  e.state = t, t.strm = e, t.window = null, t.mode = ot;
+  const i = Si(e, n);
+  return i !== ue && (e.state = null), i;
+}, io = (e) => Ai(e, to);
+let Cn = !0, vt, kt;
+const ro = (e) => {
+  if (Cn) {
+    vt = new Int32Array(512), kt = new Int32Array(32);
+    let n = 0;
+    for (; n < 144; )
+      e.lens[n++] = 8;
+    for (; n < 256; )
+      e.lens[n++] = 9;
+    for (; n < 280; )
+      e.lens[n++] = 7;
+    for (; n < 288; )
+      e.lens[n++] = 8;
+    for (Re(wi, e.lens, 0, 288, vt, 0, e.work, { bits: 9 }), n = 0; n < 32; )
+      e.lens[n++] = 5;
+    Re(pi, e.lens, 0, 32, kt, 0, e.work, { bits: 5 }), Cn = !1;
+  }
+  e.lencode = vt, e.lenbits = 9, e.distcode = kt, e.distbits = 5;
+}, Ii = (e, n, t, i) => {
+  let a;
+  const r = e.state;
+  return r.window === null && (r.wsize = 1 << r.wbits, r.wnext = 0, r.whave = 0, r.window = new Uint8Array(r.wsize)), i >= r.wsize ? (r.window.set(n.subarray(t - r.wsize, t), 0), r.wnext = 0, r.whave = r.wsize) : (a = r.wsize - r.wnext, a > i && (a = i), r.window.set(n.subarray(t - i, t - i + a), r.wnext), i -= a, i ? (r.window.set(n.subarray(t - i, t), 0), r.wnext = i, r.whave = r.wsize) : (r.wnext += a, r.wnext === r.wsize && (r.wnext = 0), r.whave < r.wsize && (r.whave += a))), 0;
+}, ao = (e, n) => {
+  let t, i, a, r, o, s, f, l, c, w, h, u, d, g, v = 0, k, E, A, b, x, I, p, S;
+  const _ = new Uint8Array(4);
+  let y, m;
+  const U = (
+    /* permutation of code lengths */
+    new Uint8Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15])
+  );
+  if (he(e) || !e.output || !e.input && e.avail_in !== 0)
+    return V;
+  t = e.state, t.mode === W && (t.mode = pt), o = e.next_out, a = e.output, f = e.avail_out, r = e.next_in, i = e.input, s = e.avail_in, l = t.hold, c = t.bits, w = s, h = f, S = ue;
+  e:
+    for (; ; )
+      switch (t.mode) {
+        case ot:
+          if (t.wrap === 0) {
+            t.mode = pt;
+            break;
+          }
+          for (; c < 16; ) {
+            if (s === 0)
+              break e;
+            s--, l += i[r++] << c, c += 8;
+          }
+          if (t.wrap & 2 && l === 35615) {
+            t.wbits === 0 && (t.wbits = 15), t.check = 0, _[0] = l & 255, _[1] = l >>> 8 & 255, t.check = N(t.check, _, 2, 0), l = 0, c = 0, t.mode = gn;
+            break;
+          }
+          if (t.head && (t.head.done = !1), !(t.wrap & 1) || /* check if zlib header allowed */
+          (((l & 255) << 8) + (l >> 8)) % 31) {
+            e.msg = "incorrect header check", t.mode = R;
+            break;
+          }
+          if ((l & 15) !== bn) {
+            e.msg = "unknown compression method", t.mode = R;
+            break;
+          }
+          if (l >>>= 4, c -= 4, p = (l & 15) + 8, t.wbits === 0 && (t.wbits = p), p > 15 || p > t.wbits) {
+            e.msg = "invalid window size", t.mode = R;
+            break;
+          }
+          t.dmax = 1 << t.wbits, t.flags = 0, e.adler = t.check = 1, t.mode = l & 512 ? xn : W, l = 0, c = 0;
+          break;
+        case gn:
+          for (; c < 16; ) {
+            if (s === 0)
+              break e;
+            s--, l += i[r++] << c, c += 8;
+          }
+          if (t.flags = l, (t.flags & 255) !== bn) {
+            e.msg = "unknown compression method", t.mode = R;
+            break;
+          }
+          if (t.flags & 57344) {
+            e.msg = "unknown header flags set", t.mode = R;
+            break;
+          }
+          t.head && (t.head.text = l >> 8 & 1), t.flags & 512 && t.wrap & 4 && (_[0] = l & 255, _[1] = l >>> 8 & 255, t.check = N(t.check, _, 2, 0)), l = 0, c = 0, t.mode = wn;
+        /* falls through */
+        case wn:
+          for (; c < 32; ) {
+            if (s === 0)
+              break e;
+            s--, l += i[r++] << c, c += 8;
+          }
+          t.head && (t.head.time = l), t.flags & 512 && t.wrap & 4 && (_[0] = l & 255, _[1] = l >>> 8 & 255, _[2] = l >>> 16 & 255, _[3] = l >>> 24 & 255, t.check = N(t.check, _, 4, 0)), l = 0, c = 0, t.mode = pn;
+        /* falls through */
+        case pn:
+          for (; c < 16; ) {
+            if (s === 0)
+              break e;
+            s--, l += i[r++] << c, c += 8;
+          }
+          t.head && (t.head.xflags = l & 255, t.head.os = l >> 8), t.flags & 512 && t.wrap & 4 && (_[0] = l & 255, _[1] = l >>> 8 & 255, t.check = N(t.check, _, 2, 0)), l = 0, c = 0, t.mode = mn;
+        /* falls through */
+        case mn:
+          if (t.flags & 1024) {
+            for (; c < 16; ) {
+              if (s === 0)
+                break e;
+              s--, l += i[r++] << c, c += 8;
+            }
+            t.length = l, t.head && (t.head.extra_len = l), t.flags & 512 && t.wrap & 4 && (_[0] = l & 255, _[1] = l >>> 8 & 255, t.check = N(t.check, _, 2, 0)), l = 0, c = 0;
+          } else t.head && (t.head.extra = null);
+          t.mode = yn;
+        /* falls through */
+        case yn:
+          if (t.flags & 1024 && (u = t.length, u > s && (u = s), u && (t.head && (p = t.head.extra_len - t.length, t.head.extra || (t.head.extra = new Uint8Array(t.head.extra_len)), t.head.extra.set(
+            i.subarray(
+              r,
+              // extra field is limited to 65536 bytes
+              // - no need for additional size check
+              r + u
+            ),
+            /*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/
+            p
+          )), t.flags & 512 && t.wrap & 4 && (t.check = N(t.check, i, u, r)), s -= u, r += u, t.length -= u), t.length))
+            break e;
+          t.length = 0, t.mode = vn;
+        /* falls through */
+        case vn:
+          if (t.flags & 2048) {
+            if (s === 0)
+              break e;
+            u = 0;
+            do
+              p = i[r + u++], t.head && p && t.length < 65536 && (t.head.name += String.fromCharCode(p));
+            while (p && u < s);
+            if (t.flags & 512 && t.wrap & 4 && (t.check = N(t.check, i, u, r)), s -= u, r += u, p)
+              break e;
+          } else t.head && (t.head.name = null);
+          t.length = 0, t.mode = kn;
+        /* falls through */
+        case kn:
+          if (t.flags & 4096) {
+            if (s === 0)
+              break e;
+            u = 0;
+            do
+              p = i[r + u++], t.head && p && t.length < 65536 && (t.head.comment += String.fromCharCode(p));
+            while (p && u < s);
+            if (t.flags & 512 && t.wrap & 4 && (t.check = N(t.check, i, u, r)), s -= u, r += u, p)
+              break e;
+          } else t.head && (t.head.comment = null);
+          t.mode = En;
+        /* falls through */
+        case En:
+          if (t.flags & 512) {
+            for (; c < 16; ) {
+              if (s === 0)
+                break e;
+              s--, l += i[r++] << c, c += 8;
+            }
+            if (t.wrap & 4 && l !== (t.check & 65535)) {
+              e.msg = "header crc mismatch", t.mode = R;
+              break;
+            }
+            l = 0, c = 0;
+          }
+          t.head && (t.head.hcrc = t.flags >> 9 & 1, t.head.done = !0), e.adler = t.check = 0, t.mode = W;
+          break;
+        case xn:
+          for (; c < 32; ) {
+            if (s === 0)
+              break e;
+            s--, l += i[r++] << c, c += 8;
+          }
+          e.adler = t.check = Zn(l), l = 0, c = 0, t.mode = nt;
+        /* falls through */
+        case nt:
+          if (t.havedict === 0)
+            return e.next_out = o, e.avail_out = f, e.next_in = r, e.avail_in = s, t.hold = l, t.bits = c, Wa;
+          e.adler = t.check = 1, t.mode = W;
+        /* falls through */
+        case W:
+          if (n === ja || n === je)
+            break e;
+        /* falls through */
+        case pt:
+          if (t.last) {
+            l >>>= c & 7, c -= c & 7, t.mode = yt;
+            break;
+          }
+          for (; c < 3; ) {
+            if (s === 0)
+              break e;
+            s--, l += i[r++] << c, c += 8;
+          }
+          switch (t.last = l & 1, l >>>= 1, c -= 1, l & 3) {
+            case 0:
+              t.mode = Sn;
+              break;
+            case 1:
+              if (ro(t), t.mode = Xe, n === je) {
+                l >>>= 2, c -= 2;
+                break e;
+              }
+              break;
+            case 2:
+              t.mode = In;
+              break;
+            case 3:
+              e.msg = "invalid block type", t.mode = R;
+          }
+          l >>>= 2, c -= 2;
+          break;
+        case Sn:
+          for (l >>>= c & 7, c -= c & 7; c < 32; ) {
+            if (s === 0)
+              break e;
+            s--, l += i[r++] << c, c += 8;
+          }
+          if ((l & 65535) !== (l >>> 16 ^ 65535)) {
+            e.msg = "invalid stored block lengths", t.mode = R;
+            break;
+          }
+          if (t.length = l & 65535, l = 0, c = 0, t.mode = mt, n === je)
+            break e;
+        /* falls through */
+        case mt:
+          t.mode = An;
+        /* falls through */
+        case An:
+          if (u = t.length, u) {
+            if (u > s && (u = s), u > f && (u = f), u === 0)
+              break e;
+            a.set(i.subarray(r, r + u), o), s -= u, r += u, f -= u, o += u, t.length -= u;
+            break;
+          }
+          t.mode = W;
+          break;
+        case In:
+          for (; c < 14; ) {
+            if (s === 0)
+              break e;
+            s--, l += i[r++] << c, c += 8;
+          }
+          if (t.nlen = (l & 31) + 257, l >>>= 5, c -= 5, t.ndist = (l & 31) + 1, l >>>= 5, c -= 5, t.ncode = (l & 15) + 4, l >>>= 4, c -= 4, t.nlen > 286 || t.ndist > 30) {
+            e.msg = "too many length or distance symbols", t.mode = R;
+            break;
+          }
+          t.have = 0, t.mode = Tn;
+        /* falls through */
+        case Tn:
+          for (; t.have < t.ncode; ) {
+            for (; c < 3; ) {
+              if (s === 0)
+                break e;
+              s--, l += i[r++] << c, c += 8;
+            }
+            t.lens[U[t.have++]] = l & 7, l >>>= 3, c -= 3;
+          }
+          for (; t.have < 19; )
+            t.lens[U[t.have++]] = 0;
+          if (t.lencode = t.lendyn, t.lenbits = 7, y = { bits: t.lenbits }, S = Re(Ya, t.lens, 0, 19, t.lencode, 0, t.work, y), t.lenbits = y.bits, S) {
+            e.msg = "invalid code lengths set", t.mode = R;
+            break;
+          }
+          t.have = 0, t.mode = zn;
+        /* falls through */
+        case zn:
+          for (; t.have < t.nlen + t.ndist; ) {
+            for (; v = t.lencode[l & (1 << t.lenbits) - 1], k = v >>> 24, E = v >>> 16 & 255, A = v & 65535, !(k <= c); ) {
+              if (s === 0)
+                break e;
+              s--, l += i[r++] << c, c += 8;
+            }
+            if (A < 16)
+              l >>>= k, c -= k, t.lens[t.have++] = A;
+            else {
+              if (A === 16) {
+                for (m = k + 2; c < m; ) {
+                  if (s === 0)
+                    break e;
+                  s--, l += i[r++] << c, c += 8;
+                }
+                if (l >>>= k, c -= k, t.have === 0) {
+                  e.msg = "invalid bit length repeat", t.mode = R;
+                  break;
+                }
+                p = t.lens[t.have - 1], u = 3 + (l & 3), l >>>= 2, c -= 2;
+              } else if (A === 17) {
+                for (m = k + 3; c < m; ) {
+                  if (s === 0)
+                    break e;
+                  s--, l += i[r++] << c, c += 8;
+                }
+                l >>>= k, c -= k, p = 0, u = 3 + (l & 7), l >>>= 3, c -= 3;
+              } else {
+                for (m = k + 7; c < m; ) {
+                  if (s === 0)
+                    break e;
+                  s--, l += i[r++] << c, c += 8;
+                }
+                l >>>= k, c -= k, p = 0, u = 11 + (l & 127), l >>>= 7, c -= 7;
+              }
+              if (t.have + u > t.nlen + t.ndist) {
+                e.msg = "invalid bit length repeat", t.mode = R;
+                break;
+              }
+              for (; u--; )
+                t.lens[t.have++] = p;
+            }
+          }
+          if (t.mode === R)
+            break;
+          if (t.lens[256] === 0) {
+            e.msg = "invalid code -- missing end-of-block", t.mode = R;
+            break;
+          }
+          if (t.lenbits = 9, y = { bits: t.lenbits }, S = Re(wi, t.lens, 0, t.nlen, t.lencode, 0, t.work, y), t.lenbits = y.bits, S) {
+            e.msg = "invalid literal/lengths set", t.mode = R;
+            break;
+          }
+          if (t.distbits = 6, t.distcode = t.distdyn, y = { bits: t.distbits }, S = Re(pi, t.lens, t.nlen, t.ndist, t.distcode, 0, t.work, y), t.distbits = y.bits, S) {
+            e.msg = "invalid distances set", t.mode = R;
+            break;
+          }
+          if (t.mode = Xe, n === je)
+            break e;
+        /* falls through */
+        case Xe:
+          t.mode = We;
+        /* falls through */
+        case We:
+          if (s >= 6 && f >= 258) {
+            e.next_out = o, e.avail_out = f, e.next_in = r, e.avail_in = s, t.hold = l, t.bits = c, $a(e, h), o = e.next_out, a = e.output, f = e.avail_out, r = e.next_in, i = e.input, s = e.avail_in, l = t.hold, c = t.bits, t.mode === W && (t.back = -1);
+            break;
+          }
+          for (t.back = 0; v = t.lencode[l & (1 << t.lenbits) - 1], k = v >>> 24, E = v >>> 16 & 255, A = v & 65535, !(k <= c); ) {
+            if (s === 0)
+              break e;
+            s--, l += i[r++] << c, c += 8;
+          }
+          if (E && !(E & 240)) {
+            for (b = k, x = E, I = A; v = t.lencode[I + ((l & (1 << b + x) - 1) >> b)], k = v >>> 24, E = v >>> 16 & 255, A = v & 65535, !(b + k <= c); ) {
+              if (s === 0)
+                break e;
+              s--, l += i[r++] << c, c += 8;
+            }
+            l >>>= b, c -= b, t.back += b;
+          }
+          if (l >>>= k, c -= k, t.back += k, t.length = A, E === 0) {
+            t.mode = Dn;
+            break;
+          }
+          if (E & 32) {
+            t.back = -1, t.mode = W;
+            break;
+          }
+          if (E & 64) {
+            e.msg = "invalid literal/length code", t.mode = R;
+            break;
+          }
+          t.extra = E & 15, t.mode = On;
+        /* falls through */
+        case On:
+          if (t.extra) {
+            for (m = t.extra; c < m; ) {
+              if (s === 0)
+                break e;
+              s--, l += i[r++] << c, c += 8;
+            }
+            t.length += l & (1 << t.extra) - 1, l >>>= t.extra, c -= t.extra, t.back += t.extra;
+          }
+          t.was = t.length, t.mode = Rn;
+        /* falls through */
+        case Rn:
+          for (; v = t.distcode[l & (1 << t.distbits) - 1], k = v >>> 24, E = v >>> 16 & 255, A = v & 65535, !(k <= c); ) {
+            if (s === 0)
+              break e;
+            s--, l += i[r++] << c, c += 8;
+          }
+          if (!(E & 240)) {
+            for (b = k, x = E, I = A; v = t.distcode[I + ((l & (1 << b + x) - 1) >> b)], k = v >>> 24, E = v >>> 16 & 255, A = v & 65535, !(b + k <= c); ) {
+              if (s === 0)
+                break e;
+              s--, l += i[r++] << c, c += 8;
+            }
+            l >>>= b, c -= b, t.back += b;
+          }
+          if (l >>>= k, c -= k, t.back += k, E & 64) {
+            e.msg = "invalid distance code", t.mode = R;
+            break;
+          }
+          t.offset = A, t.extra = E & 15, t.mode = Un;
+        /* falls through */
+        case Un:
+          if (t.extra) {
+            for (m = t.extra; c < m; ) {
+              if (s === 0)
+                break e;
+              s--, l += i[r++] << c, c += 8;
+            }
+            t.offset += l & (1 << t.extra) - 1, l >>>= t.extra, c -= t.extra, t.back += t.extra;
+          }
+          if (t.offset > t.dmax) {
+            e.msg = "invalid distance too far back", t.mode = R;
+            break;
+          }
+          t.mode = Bn;
+        /* falls through */
+        case Bn:
+          if (f === 0)
+            break e;
+          if (u = h - f, t.offset > u) {
+            if (u = t.offset - u, u > t.whave && t.sane) {
+              e.msg = "invalid distance too far back", t.mode = R;
+              break;
+            }
+            u > t.wnext ? (u -= t.wnext, d = t.wsize - u) : d = t.wnext - u, u > t.length && (u = t.length), g = t.window;
+          } else
+            g = a, d = o - t.offset, u = t.length;
+          u > f && (u = f), f -= u, t.length -= u;
+          do
+            a[o++] = g[d++];
+          while (--u);
+          t.length === 0 && (t.mode = We);
+          break;
+        case Dn:
+          if (f === 0)
+            break e;
+          a[o++] = t.length, f--, t.mode = We;
+          break;
+        case yt:
+          if (t.wrap) {
+            for (; c < 32; ) {
+              if (s === 0)
+                break e;
+              s--, l |= i[r++] << c, c += 8;
+            }
+            if (h -= f, e.total_out += h, t.total += h, t.wrap & 4 && h && (e.adler = t.check = /*UPDATE_CHECK(state.check, put - _out, _out);*/
+            t.flags ? N(t.check, a, h, o - h) : Le(t.check, a, h, o - h)), h = f, t.wrap & 4 && (t.flags ? l : Zn(l)) !== t.check) {
+              e.msg = "incorrect data check", t.mode = R;
+              break;
+            }
+            l = 0, c = 0;
+          }
+          t.mode = Nn;
+        /* falls through */
+        case Nn:
+          if (t.wrap && t.flags) {
+            for (; c < 32; ) {
+              if (s === 0)
+                break e;
+              s--, l += i[r++] << c, c += 8;
+            }
+            if (t.wrap & 4 && l !== (t.total & 4294967295)) {
+              e.msg = "incorrect length check", t.mode = R;
+              break;
+            }
+            l = 0, c = 0;
+          }
+          t.mode = Ln;
+        /* falls through */
+        case Ln:
+          S = Xa;
+          break e;
+        case R:
+          S = mi;
+          break e;
+        case vi:
+          return yi;
+        case ki:
+        /* falls through */
+        default:
+          return V;
+      }
+  return e.next_out = o, e.avail_out = f, e.next_in = r, e.avail_in = s, t.hold = l, t.bits = c, (t.wsize || h !== e.avail_out && t.mode < R && (t.mode < yt || n !== _n)) && Ii(e, e.output, e.next_out, h - e.avail_out), w -= e.avail_in, h -= e.avail_out, e.total_in += w, e.total_out += h, t.total += h, t.wrap & 4 && h && (e.adler = t.check = /*UPDATE_CHECK(state.check, strm.next_out - _out, _out);*/
+  t.flags ? N(t.check, a, h, e.next_out - h) : Le(t.check, a, h, e.next_out - h)), e.data_type = t.bits + (t.last ? 64 : 0) + (t.mode === W ? 128 : 0) + (t.mode === Xe || t.mode === mt ? 256 : 0), (w === 0 && h === 0 || n === _n) && S === ue && (S = Ja), S;
+}, oo = (e) => {
+  if (he(e))
+    return V;
+  let n = e.state;
+  return n.window && (n.window = null), e.state = null, ue;
+}, lo = (e, n) => {
+  if (he(e))
+    return V;
+  const t = e.state;
+  return t.wrap & 2 ? (t.head = n, n.done = !1, ue) : V;
+}, so = (e, n) => {
+  const t = n.length;
+  let i, a, r;
+  return he(e) || (i = e.state, i.wrap !== 0 && i.mode !== nt) ? V : i.mode === nt && (a = 1, a = Le(a, n, t, 0), a !== i.check) ? mi : (r = Ii(e, n, t, t), r ? (i.mode = vi, yi) : (i.havedict = 1, ue));
+};
+var co = xi, fo = Si, uo = Ei, ho = io, _o = Ai, bo = ao, go = oo, wo = lo, po = so, mo = "pako inflate (from Nodeca project)", Q = {
+  inflateReset: co,
+  inflateReset2: fo,
+  inflateResetKeep: uo,
+  inflateInit: ho,
+  inflateInit2: _o,
+  inflate: bo,
+  inflateEnd: go,
+  inflateGetHeader: wo,
+  inflateSetDictionary: po,
+  inflateInfo: mo
+};
+function yo() {
+  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;
+}
+var vo = yo;
+const Ti = Object.prototype.toString, {
+  Z_NO_FLUSH: ko,
+  Z_FINISH: Eo,
+  Z_OK: Fe,
+  Z_STREAM_END: Et,
+  Z_NEED_DICT: xt,
+  Z_STREAM_ERROR: xo,
+  Z_DATA_ERROR: Fn,
+  Z_MEM_ERROR: So
+} = Pe;
+function Ke(e) {
+  this.options = at.assign({
+    chunkSize: 1024 * 64,
+    windowBits: 15,
+    to: ""
+  }, e || {});
+  const n = this.options;
+  n.raw && n.windowBits >= 0 && n.windowBits < 16 && (n.windowBits = -n.windowBits, n.windowBits === 0 && (n.windowBits = -15)), n.windowBits >= 0 && n.windowBits < 16 && !(e && e.windowBits) && (n.windowBits += 32), n.windowBits > 15 && n.windowBits < 48 && (n.windowBits & 15 || (n.windowBits |= 15)), this.err = 0, this.msg = "", this.ended = !1, this.chunks = [], this.strm = new bi(), this.strm.avail_out = 0;
+  let t = Q.inflateInit2(
+    this.strm,
+    n.windowBits
+  );
+  if (t !== Fe)
+    throw new Error(pe[t]);
+  if (this.header = new vo(), Q.inflateGetHeader(this.strm, this.header), n.dictionary && (typeof n.dictionary == "string" ? n.dictionary = Ce.string2buf(n.dictionary) : Ti.call(n.dictionary) === "[object ArrayBuffer]" && (n.dictionary = new Uint8Array(n.dictionary)), n.raw && (t = Q.inflateSetDictionary(this.strm, n.dictionary), t !== Fe)))
+    throw new Error(pe[t]);
+}
+Ke.prototype.push = function(e, n) {
+  const t = this.strm, i = this.options.chunkSize, a = this.options.dictionary;
+  let r, o, s;
+  if (this.ended) return !1;
+  for (n === ~~n ? o = n : o = n === !0 ? Eo : ko, Ti.call(e) === "[object ArrayBuffer]" ? t.input = new Uint8Array(e) : t.input = e, t.next_in = 0, t.avail_in = t.input.length; ; ) {
+    for (t.avail_out === 0 && (t.output = new Uint8Array(i), t.next_out = 0, t.avail_out = i), r = Q.inflate(t, o), r === xt && a && (r = Q.inflateSetDictionary(t, a), r === Fe ? r = Q.inflate(t, o) : r === Fn && (r = xt)); t.avail_in > 0 && r === Et && t.state.wrap > 0 && e[t.next_in] !== 0; )
+      Q.inflateReset(t), r = Q.inflate(t, o);
+    switch (r) {
+      case xo:
+      case Fn:
+      case xt:
+      case So:
+        return this.onEnd(r), this.ended = !0, !1;
+    }
+    if (s = t.avail_out, t.next_out && (t.avail_out === 0 || r === Et))
+      if (this.options.to === "string") {
+        let f = Ce.utf8border(t.output, t.next_out), l = t.next_out - f, c = Ce.buf2string(t.output, f);
+        t.next_out = l, t.avail_out = i - l, l && t.output.set(t.output.subarray(f, f + l), 0), this.onData(c);
+      } else
+        this.onData(t.output.length === t.next_out ? t.output : t.output.subarray(0, t.next_out));
+    if (!(r === Fe && s === 0)) {
+      if (r === Et)
+        return r = Q.inflateEnd(this.strm), this.onEnd(r), this.ended = !0, !0;
+      if (t.avail_in === 0) break;
+    }
+  }
+  return !0;
+};
+Ke.prototype.onData = function(e) {
+  this.chunks.push(e);
+};
+Ke.prototype.onEnd = function(e) {
+  e === Fe && (this.options.to === "string" ? this.result = this.chunks.join("") : this.result = at.flattenChunks(this.chunks)), this.chunks = [], this.err = e, this.msg = this.strm.msg;
+};
+function jt(e, n) {
+  const t = new Ke(n);
+  if (t.push(e), t.err) throw t.msg || pe[t.err];
+  return t.result;
+}
+function Ao(e, n) {
+  return n = n || {}, n.raw = !0, jt(e, n);
+}
+var Io = Ke, To = jt, zo = Ao, Oo = jt, Ro = Pe, Uo = {
+  Inflate: Io,
+  inflate: To,
+  inflateRaw: zo,
+  ungzip: Oo,
+  constants: Ro
+};
+const { Inflate: Il, inflate: Tl, inflateRaw: Bo, ungzip: zl } = Uo;
+var Do = Bo;
+function No(e) {
+  return Do(e.subarray(2));
+}
+class Lo extends Error {
+  constructor(n) {
+    super(n), this.code = "ERR_ABORTED";
+  }
+}
+function Zo(e) {
+  e.sort((a, r) => a.offset - r.offset);
+  const n = [];
+  let t, i;
+  for (const a of e)
+    t && i && a.offset - i <= 2e3 ? (t.length = t.length + a.length - i + a.offset, t.blocks.push(a)) : n.push(t = {
+      blocks: [a],
+      length: a.length,
+      offset: a.offset
+    }), i = t.offset + t.length;
+  return n;
+}
+function Je(e) {
+  if (e && e.aborted)
+    if (typeof DOMException > "u") {
+      const n = new Lo("aborted");
+      throw n.code = "ERR_ABORTED", n;
+    } else
+      throw new DOMException("aborted", "AbortError");
+}
+const St = typeof TextDecoder < "u" ? new TextDecoder("utf8") : void 0;
+function At(e, n, t, i) {
+  return e < i && n >= t;
+}
+class zi {
+  constructor(n, t, i, a, r, o) {
+    if (this.bbi = n, this.refsByName = t, this.cirTreeOffset = i, this.isBigEndian = a, this.isCompressed = r, this.blockType = o, this.featureCache = new Kn({
+      cache: new Gn({ maxSize: 1e3 }),
+      fill: async (s, f) => {
+        const l = s.length, c = s.offset, { buffer: w } = await this.bbi.read(ee.Buffer.alloc(l), 0, l, c, {
+          signal: f
+        });
+        return w;
+      }
+    }), !(i >= 0))
+      throw new Error("invalid cirTreeOffset!");
+  }
+  async readWigData(n, t, i, a, r) {
+    try {
+      const { refsByName: o, bbi: s, cirTreeOffset: f, isBigEndian: l } = this, c = o[n];
+      c === void 0 && a.complete();
+      const w = { chrId: c, start: t, end: i };
+      this.cirTreePromise || (this.cirTreePromise = s.read(ee.Buffer.alloc(48), 0, 48, f, r));
+      const { buffer: h } = await this.cirTreePromise, u = l ? h.readUInt32BE(4) : h.readUInt32LE(4);
+      let d = [], g = 0;
+      const v = !0, k = (x, I, p) => {
+        try {
+          const _ = x.subarray(I), y = new DataView(_.buffer, _.byteOffset, _.length);
+          let m = 0;
+          const U = y.getUint8(m);
+          m += 2;
+          const Z = y.getUint16(m, v);
+          if (m += 2, U === 1) {
+            const B = [];
+            for (let O = 0; O < Z; O++) {
+              const F = y.getUint32(m, v);
+              m += 4;
+              const ae = y.getUint32(m, v);
+              m += 4;
+              const lt = y.getUint32(m, v);
+              m += 4;
+              const st = y.getUint32(m, v);
+              m += 4;
+              const ct = Number(y.getBigUint64(m, v));
+              m += 8;
+              const ft = Number(y.getBigUint64(m, v));
+              m += 8, B.push({
+                startChrom: F,
+                startBase: ae,
+                endBase: st,
+                endChrom: lt,
+                blockOffset: ct,
+                blockSize: ft,
+                offset: m
+              });
+            }
+            d = d.concat(B.filter((O) => E(O)).map((O) => ({
+              offset: O.blockOffset,
+              length: O.blockSize
+            })));
+          } else if (U === 0) {
+            const B = [];
+            for (let F = 0; F < Z; F++) {
+              const ae = y.getUint32(m, v);
+              m += 4;
+              const lt = y.getUint32(m, v);
+              m += 4;
+              const st = y.getUint32(m, v);
+              m += 4;
+              const ct = y.getUint32(m, v);
+              m += 4;
+              const ft = Number(y.getBigUint64(m, v));
+              m += 8, B.push({
+                startChrom: ae,
+                startBase: lt,
+                endChrom: st,
+                endBase: ct,
+                blockOffset: ft,
+                offset: m
+              });
+            }
+            const O = B.filter((F) => E(F)).map((F) => F.blockOffset);
+            O.length > 0 && b(O, p + 1);
+          }
+        } catch (S) {
+          a.error(S);
+        }
+      }, E = (x) => {
+        const { startChrom: I, startBase: p, endChrom: S, endBase: _ } = x;
+        return (I < c || I === c && p <= i) && (S > c || S === c && _ >= t);
+      }, A = async (x, I, p) => {
+        try {
+          const S = I.max - I.min, _ = I.min, y = await this.featureCache.get(`${S}_${_}`, { length: S, offset: _ }, r == null ? void 0 : r.signal);
+          for (const m of x)
+            I.contains(m) && (k(y, m - _, p), g -= 1, g === 0 && this.readFeatures(a, d, {
+              ...r,
+              request: w
+            }).catch((U) => {
+              a.error(U);
+            }));
+        } catch (S) {
+          a.error(S);
+        }
+      }, b = (x, I) => {
+        try {
+          g += x.length;
+          const p = 4 + u * 32;
+          let S = new be([
+            {
+              min: x[0],
+              max: x[0] + p
+            }
+          ]);
+          for (let _ = 1; _ < x.length; _ += 1) {
+            const y = new be([
+              {
+                min: x[_],
+                max: x[_] + p
+              }
+            ]);
+            S = S.union(y);
+          }
+          S.getRanges().map((_) => A(x, _, I));
+        } catch (p) {
+          a.error(p);
+        }
+      };
+      b([Number(f) + 48], 1);
+      return;
+    } catch (o) {
+      a.error(o);
+    }
+  }
+  parseSummaryBlock(n, t, i) {
+    const a = [];
+    let r = t;
+    const o = new DataView(n.buffer, n.byteOffset, n.length);
+    for (; r < n.byteLength; ) {
+      const s = o.getUint32(r, !0);
+      r += 4;
+      const f = o.getUint32(r, !0);
+      r += 4;
+      const l = o.getUint32(r, !0);
+      r += 4;
+      const c = o.getUint32(r, !0);
+      r += 4;
+      const w = o.getFloat32(r, !0);
+      r += 4;
+      const h = o.getFloat32(r, !0);
+      r += 4;
+      const u = o.getFloat32(r, !0);
+      r += 4, r += 4, (!i || s === i.chrId && At(f, l, i.start, i.end)) && a.push({
+        start: f,
+        end: l,
+        maxScore: h,
+        minScore: w,
+        summary: !0,
+        score: u / (c || 1)
+      });
+    }
+    return a;
+  }
+  parseBigBedBlock(n, t, i, a) {
+    var r;
+    const o = [];
+    let s = t;
+    const f = !0, l = n, c = new DataView(l.buffer, l.byteOffset, l.length);
+    for (; s < n.byteLength; ) {
+      const w = s, h = c.getUint32(s, f);
+      s += 4;
+      const u = c.getInt32(s, f);
+      s += 4;
+      const d = c.getInt32(s, f);
+      s += 4;
+      let g = s;
+      for (; g < n.length && n[g] !== 0; g++)
+        ;
+      const v = n.subarray(s, g), k = (r = St == null ? void 0 : St.decode(v)) !== null && r !== void 0 ? r : v.toString();
+      s = g + 1, o.push({
+        chromId: h,
+        start: u,
+        end: d,
+        rest: k,
+        uniqueId: `bb-${i + w}`
+      });
+    }
+    return a ? o.filter((w) => At(w.start, w.end, a.start, a.end)) : o;
+  }
+  parseBigWigBlock(n, t, i) {
+    const a = n.subarray(t), r = new DataView(a.buffer, a.byteOffset, a.length);
+    let o = 0;
+    o += 4;
+    const s = r.getInt32(o, !0);
+    o += 8;
+    const f = r.getUint32(o, !0);
+    o += 4;
+    const l = r.getUint32(o, !0);
+    o += 4;
+    const c = r.getUint8(o);
+    o += 2;
+    const w = r.getUint16(o, !0);
+    o += 2;
+    const h = new Array(w);
+    switch (c) {
+      case 1: {
+        for (let u = 0; u < w; u++) {
+          const d = r.getInt32(o, !0);
+          o += 4;
+          const g = r.getInt32(o, !0);
+          o += 4;
+          const v = r.getFloat32(o, !0);
+          o += 4, h[u] = {
+            start: d,
+            end: g,
+            score: v
+          };
+        }
+        break;
+      }
+      case 2: {
+        for (let u = 0; u < w; u++) {
+          const d = r.getInt32(o, !0);
+          o += 4;
+          const g = r.getFloat32(o, !0);
+          o += 4, h[u] = {
+            score: g,
+            start: d,
+            end: d + l
+          };
+        }
+        break;
+      }
+      case 3: {
+        for (let u = 0; u < w; u++) {
+          const d = r.getFloat32(o, !0);
+          o += 4;
+          const g = s + u * f;
+          h[u] = {
+            score: d,
+            start: g,
+            end: g + l
+          };
+        }
+        break;
+      }
+    }
+    return i ? h.filter((u) => At(u.start, u.end, i.start, i.end)) : h;
+  }
+  async readFeatures(n, t, i = {}) {
+    try {
+      const { blockType: a, isCompressed: r } = this, { signal: o, request: s } = i, f = Zo(t);
+      Je(o), await Promise.all(f.map(async (l) => {
+        Je(o);
+        const { length: c, offset: w } = l, h = await this.featureCache.get(`${c}_${w}`, l, o);
+        for (const u of l.blocks) {
+          Je(o);
+          let d = Number(u.offset) - Number(l.offset), g = h;
+          switch (r && (g = No(h.subarray(d)), d = 0), Je(o), a) {
+            case "summary": {
+              n.next(this.parseSummaryBlock(g, d, s));
+              break;
+            }
+            case "bigwig": {
+              n.next(this.parseBigWigBlock(g, d, s));
+              break;
+            }
+            case "bigbed": {
+              n.next(this.parseBigBedBlock(g, d, Number(u.offset) * 256, s));
+              break;
+            }
+            default:
+              console.warn(`Don't know what to do with ${a}`);
+          }
+        }
+      })), n.complete();
+    } catch (a) {
+      n.error(a);
+    }
+  }
+}
+var Ft = function(e, n) {
+  return Ft = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(t, i) {
+    t.__proto__ = i;
+  } || function(t, i) {
+    for (var a in i) Object.prototype.hasOwnProperty.call(i, a) && (t[a] = i[a]);
+  }, Ft(e, n);
+};
+function Xt(e, n) {
+  if (typeof n != "function" && n !== null)
+    throw new TypeError("Class extends value " + String(n) + " is not a constructor or null");
+  Ft(e, n);
+  function t() {
+    this.constructor = e;
+  }
+  e.prototype = n === null ? Object.create(n) : (t.prototype = n.prototype, new t());
+}
+function Co(e, n, t, i) {
+  function a(r) {
+    return r instanceof t ? r : new t(function(o) {
+      o(r);
+    });
+  }
+  return new (t || (t = Promise))(function(r, o) {
+    function s(c) {
+      try {
+        l(i.next(c));
+      } catch (w) {
+        o(w);
+      }
+    }
+    function f(c) {
+      try {
+        l(i.throw(c));
+      } catch (w) {
+        o(w);
+      }
+    }
+    function l(c) {
+      c.done ? r(c.value) : a(c.value).then(s, f);
+    }
+    l((i = i.apply(e, n || [])).next());
+  });
+}
+function Oi(e, n) {
+  var t = { label: 0, sent: function() {
+    if (r[0] & 1) throw r[1];
+    return r[1];
+  }, trys: [], ops: [] }, i, a, r, o = Object.create((typeof Iterator == "function" ? Iterator : Object).prototype);
+  return o.next = s(0), o.throw = s(1), o.return = s(2), typeof Symbol == "function" && (o[Symbol.iterator] = function() {
+    return this;
+  }), o;
+  function s(l) {
+    return function(c) {
+      return f([l, c]);
+    };
+  }
+  function f(l) {
+    if (i) throw new TypeError("Generator is already executing.");
+    for (; o && (o = 0, l[0] && (t = 0)), t; ) try {
+      if (i = 1, a && (r = l[0] & 2 ? a.return : l[0] ? a.throw || ((r = a.return) && r.call(a), 0) : a.next) && !(r = r.call(a, l[1])).done) return r;
+      switch (a = 0, r && (l = [l[0] & 2, r.value]), l[0]) {
+        case 0:
+        case 1:
+          r = l;
+          break;
+        case 4:
+          return t.label++, { value: l[1], done: !1 };
+        case 5:
+          t.label++, a = l[1], l = [0];
+          continue;
+        case 7:
+          l = t.ops.pop(), t.trys.pop();
+          continue;
+        default:
+          if (r = t.trys, !(r = r.length > 0 && r[r.length - 1]) && (l[0] === 6 || l[0] === 2)) {
+            t = 0;
+            continue;
+          }
+          if (l[0] === 3 && (!r || l[1] > r[0] && l[1] < r[3])) {
+            t.label = l[1];
+            break;
+          }
+          if (l[0] === 6 && t.label < r[1]) {
+            t.label = r[1], r = l;
+            break;
+          }
+          if (r && t.label < r[2]) {
+            t.label = r[2], t.ops.push(l);
+            break;
+          }
+          r[2] && t.ops.pop(), t.trys.pop();
+          continue;
+      }
+      l = n.call(e, t);
+    } catch (c) {
+      l = [6, c], a = 0;
+    } finally {
+      i = r = 0;
+    }
+    if (l[0] & 5) throw l[1];
+    return { value: l[0] ? l[1] : void 0, done: !0 };
+  }
+}
+function Me(e) {
+  var n = typeof Symbol == "function" && Symbol.iterator, t = n && e[n], i = 0;
+  if (t) return t.call(e);
+  if (e && typeof e.length == "number") return {
+    next: function() {
+      return e && i >= e.length && (e = void 0), { value: e && e[i++], done: !e };
+    }
+  };
+  throw new TypeError(n ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function Mt(e, n) {
+  var t = typeof Symbol == "function" && e[Symbol.iterator];
+  if (!t) return e;
+  var i = t.call(e), a, r = [], o;
+  try {
+    for (; (n === void 0 || n-- > 0) && !(a = i.next()).done; ) r.push(a.value);
+  } catch (s) {
+    o = { error: s };
+  } finally {
+    try {
+      a && !a.done && (t = i.return) && t.call(i);
+    } finally {
+      if (o) throw o.error;
+    }
+  }
+  return r;
+}
+function $t(e, n, t) {
+  if (t || arguments.length === 2) for (var i = 0, a = n.length, r; i < a; i++)
+    (r || !(i in n)) && (r || (r = Array.prototype.slice.call(n, 0, i)), r[i] = n[i]);
+  return e.concat(r || Array.prototype.slice.call(n));
+}
+function we(e) {
+  return this instanceof we ? (this.v = e, this) : new we(e);
+}
+function Fo(e, n, t) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var i = t.apply(e, n || []), a, r = [];
+  return a = Object.create((typeof AsyncIterator == "function" ? AsyncIterator : Object).prototype), s("next"), s("throw"), s("return", o), a[Symbol.asyncIterator] = function() {
+    return this;
+  }, a;
+  function o(u) {
+    return function(d) {
+      return Promise.resolve(d).then(u, w);
+    };
+  }
+  function s(u, d) {
+    i[u] && (a[u] = function(g) {
+      return new Promise(function(v, k) {
+        r.push([u, g, v, k]) > 1 || f(u, g);
+      });
+    }, d && (a[u] = d(a[u])));
+  }
+  function f(u, d) {
+    try {
+      l(i[u](d));
+    } catch (g) {
+      h(r[0][3], g);
+    }
+  }
+  function l(u) {
+    u.value instanceof we ? Promise.resolve(u.value.v).then(c, w) : h(r[0][2], u);
+  }
+  function c(u) {
+    f("next", u);
+  }
+  function w(u) {
+    f("throw", u);
+  }
+  function h(u, d) {
+    u(d), r.shift(), r.length && f(r[0][0], r[0][1]);
+  }
+}
+function Mo(e) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var n = e[Symbol.asyncIterator], t;
+  return n ? n.call(e) : (e = typeof Me == "function" ? Me(e) : e[Symbol.iterator](), t = {}, i("next"), i("throw"), i("return"), t[Symbol.asyncIterator] = function() {
+    return this;
+  }, t);
+  function i(r) {
+    t[r] = e[r] && function(o) {
+      return new Promise(function(s, f) {
+        o = e[r](o), a(s, f, o.done, o.value);
+      });
+    };
+  }
+  function a(r, o, s, f) {
+    Promise.resolve(f).then(function(l) {
+      r({ value: l, done: s });
+    }, o);
+  }
+}
+function D(e) {
+  return typeof e == "function";
+}
+function Ri(e) {
+  var n = function(i) {
+    Error.call(i), i.stack = new Error().stack;
+  }, t = e(n);
+  return t.prototype = Object.create(Error.prototype), t.prototype.constructor = t, t;
+}
+var It = Ri(function(e) {
+  return function(t) {
+    e(this), this.message = t ? t.length + ` errors occurred during unsubscription:
+` + t.map(function(i, a) {
+      return a + 1 + ") " + i.toString();
+    }).join(`
+  `) : "", this.name = "UnsubscriptionError", this.errors = t;
+  };
+});
+function Mn(e, n) {
+  if (e) {
+    var t = e.indexOf(n);
+    0 <= t && e.splice(t, 1);
+  }
+}
+var Wt = function() {
+  function e(n) {
+    this.initialTeardown = n, this.closed = !1, this._parentage = null, this._finalizers = null;
+  }
+  return e.prototype.unsubscribe = function() {
+    var n, t, i, a, r;
+    if (!this.closed) {
+      this.closed = !0;
+      var o = this._parentage;
+      if (o)
+        if (this._parentage = null, Array.isArray(o))
+          try {
+            for (var s = Me(o), f = s.next(); !f.done; f = s.next()) {
+              var l = f.value;
+              l.remove(this);
+            }
+          } catch (g) {
+            n = { error: g };
+          } finally {
+            try {
+              f && !f.done && (t = s.return) && t.call(s);
+            } finally {
+              if (n) throw n.error;
+            }
+          }
+        else
+          o.remove(this);
+      var c = this.initialTeardown;
+      if (D(c))
+        try {
+          c();
+        } catch (g) {
+          r = g instanceof It ? g.errors : [g];
+        }
+      var w = this._finalizers;
+      if (w) {
+        this._finalizers = null;
+        try {
+          for (var h = Me(w), u = h.next(); !u.done; u = h.next()) {
+            var d = u.value;
+            try {
+              $n(d);
+            } catch (g) {
+              r = r ?? [], g instanceof It ? r = $t($t([], Mt(r)), Mt(g.errors)) : r.push(g);
+            }
+          }
+        } catch (g) {
+          i = { error: g };
+        } finally {
+          try {
+            u && !u.done && (a = h.return) && a.call(h);
+          } finally {
+            if (i) throw i.error;
+          }
+        }
+      }
+      if (r)
+        throw new It(r);
+    }
+  }, e.prototype.add = function(n) {
+    var t;
+    if (n && n !== this)
+      if (this.closed)
+        $n(n);
+      else {
+        if (n instanceof e) {
+          if (n.closed || n._hasParent(this))
+            return;
+          n._addParent(this);
+        }
+        (this._finalizers = (t = this._finalizers) !== null && t !== void 0 ? t : []).push(n);
+      }
+  }, e.prototype._hasParent = function(n) {
+    var t = this._parentage;
+    return t === n || Array.isArray(t) && t.includes(n);
+  }, e.prototype._addParent = function(n) {
+    var t = this._parentage;
+    this._parentage = Array.isArray(t) ? (t.push(n), t) : t ? [t, n] : n;
+  }, e.prototype._removeParent = function(n) {
+    var t = this._parentage;
+    t === n ? this._parentage = null : Array.isArray(t) && Mn(t, n);
+  }, e.prototype.remove = function(n) {
+    var t = this._finalizers;
+    t && Mn(t, n), n instanceof e && n._removeParent(this);
+  }, e.EMPTY = function() {
+    var n = new e();
+    return n.closed = !0, n;
+  }(), e;
+}();
+Wt.EMPTY;
+function Ui(e) {
+  return e instanceof Wt || e && "closed" in e && D(e.remove) && D(e.add) && D(e.unsubscribe);
+}
+function $n(e) {
+  D(e) ? e() : e.unsubscribe();
+}
+var Bi = {
+  onUnhandledError: null,
+  onStoppedNotification: null,
+  Promise: void 0,
+  useDeprecatedSynchronousErrorHandling: !1,
+  useDeprecatedNextContext: !1
+}, Di = {
+  setTimeout: function(e, n) {
+    for (var t = [], i = 2; i < arguments.length; i++)
+      t[i - 2] = arguments[i];
+    return setTimeout.apply(void 0, $t([e, n], Mt(t)));
+  },
+  clearTimeout: function(e) {
+    var n = Di.delegate;
+    return ((n == null ? void 0 : n.clearTimeout) || clearTimeout)(e);
+  },
+  delegate: void 0
+};
+function Ni(e) {
+  Di.setTimeout(function() {
+    throw e;
+  });
+}
+function Hn() {
+}
+function $o(e) {
+  e();
+}
+var Jt = function(e) {
+  Xt(n, e);
+  function n(t) {
+    var i = e.call(this) || this;
+    return i.isStopped = !1, t ? (i.destination = t, Ui(t) && t.add(i)) : i.destination = Ko, i;
+  }
+  return n.create = function(t, i, a) {
+    return new it(t, i, a);
+  }, n.prototype.next = function(t) {
+    this.isStopped || this._next(t);
+  }, n.prototype.error = function(t) {
+    this.isStopped || (this.isStopped = !0, this._error(t));
+  }, n.prototype.complete = function() {
+    this.isStopped || (this.isStopped = !0, this._complete());
+  }, n.prototype.unsubscribe = function() {
+    this.closed || (this.isStopped = !0, e.prototype.unsubscribe.call(this), this.destination = null);
+  }, n.prototype._next = function(t) {
+    this.destination.next(t);
+  }, n.prototype._error = function(t) {
+    try {
+      this.destination.error(t);
+    } finally {
+      this.unsubscribe();
+    }
+  }, n.prototype._complete = function() {
+    try {
+      this.destination.complete();
+    } finally {
+      this.unsubscribe();
+    }
+  }, n;
+}(Wt), Ho = Function.prototype.bind;
+function Tt(e, n) {
+  return Ho.call(e, n);
+}
+var Po = function() {
+  function e(n) {
+    this.partialObserver = n;
+  }
+  return e.prototype.next = function(n) {
+    var t = this.partialObserver;
+    if (t.next)
+      try {
+        t.next(n);
+      } catch (i) {
+        Qe(i);
+      }
+  }, e.prototype.error = function(n) {
+    var t = this.partialObserver;
+    if (t.error)
+      try {
+        t.error(n);
+      } catch (i) {
+        Qe(i);
+      }
+    else
+      Qe(n);
+  }, e.prototype.complete = function() {
+    var n = this.partialObserver;
+    if (n.complete)
+      try {
+        n.complete();
+      } catch (t) {
+        Qe(t);
+      }
+  }, e;
+}(), it = function(e) {
+  Xt(n, e);
+  function n(t, i, a) {
+    var r = e.call(this) || this, o;
+    if (D(t) || !t)
+      o = {
+        next: t ?? void 0,
+        error: i ?? void 0,
+        complete: a ?? void 0
+      };
+    else {
+      var s;
+      r && Bi.useDeprecatedNextContext ? (s = Object.create(t), s.unsubscribe = function() {
+        return r.unsubscribe();
+      }, o = {
+        next: t.next && Tt(t.next, s),
+        error: t.error && Tt(t.error, s),
+        complete: t.complete && Tt(t.complete, s)
+      }) : o = t;
+    }
+    return r.destination = new Po(o), r;
+  }
+  return n;
+}(Jt);
+function Qe(e) {
+  Ni(e);
+}
+function Vo(e) {
+  throw e;
+}
+var Ko = {
+  closed: !0,
+  next: Hn,
+  error: Vo,
+  complete: Hn
+}, Qt = function() {
+  return typeof Symbol == "function" && Symbol.observable || "@@observable";
+}();
+function Li(e) {
+  return e;
+}
+function Go(e) {
+  return e.length === 0 ? Li : e.length === 1 ? e[0] : function(t) {
+    return e.reduce(function(i, a) {
+      return a(i);
+    }, t);
+  };
+}
+var K = function() {
+  function e(n) {
+    n && (this._subscribe = n);
+  }
+  return e.prototype.lift = function(n) {
+    var t = new e();
+    return t.source = this, t.operator = n, t;
+  }, e.prototype.subscribe = function(n, t, i) {
+    var a = this, r = jo(n) ? n : new it(n, t, i);
+    return $o(function() {
+      var o = a, s = o.operator, f = o.source;
+      r.add(s ? s.call(r, f) : f ? a._subscribe(r) : a._trySubscribe(r));
+    }), r;
+  }, e.prototype._trySubscribe = function(n) {
+    try {
+      return this._subscribe(n);
+    } catch (t) {
+      n.error(t);
+    }
+  }, e.prototype.forEach = function(n, t) {
+    var i = this;
+    return t = Pn(t), new t(function(a, r) {
+      var o = new it({
+        next: function(s) {
+          try {
+            n(s);
+          } catch (f) {
+            r(f), o.unsubscribe();
+          }
+        },
+        error: r,
+        complete: a
+      });
+      i.subscribe(o);
+    });
+  }, e.prototype._subscribe = function(n) {
+    var t;
+    return (t = this.source) === null || t === void 0 ? void 0 : t.subscribe(n);
+  }, e.prototype[Qt] = function() {
+    return this;
+  }, e.prototype.pipe = function() {
+    for (var n = [], t = 0; t < arguments.length; t++)
+      n[t] = arguments[t];
+    return Go(n)(this);
+  }, e.prototype.toPromise = function(n) {
+    var t = this;
+    return n = Pn(n), new n(function(i, a) {
+      var r;
+      t.subscribe(function(o) {
+        return r = o;
+      }, function(o) {
+        return a(o);
+      }, function() {
+        return i(r);
+      });
+    });
+  }, e.create = function(n) {
+    return new e(n);
+  }, e;
+}();
+function Pn(e) {
+  var n;
+  return (n = e ?? Bi.Promise) !== null && n !== void 0 ? n : Promise;
+}
+function Yo(e) {
+  return e && D(e.next) && D(e.error) && D(e.complete);
+}
+function jo(e) {
+  return e && e instanceof Jt || Yo(e) && Ui(e);
+}
+function Xo(e) {
+  return D(e == null ? void 0 : e.lift);
+}
+function xe(e) {
+  return function(n) {
+    if (Xo(n))
+      return n.lift(function(t) {
+        try {
+          return e(t, this);
+        } catch (i) {
+          this.error(i);
+        }
+      });
+    throw new TypeError("Unable to lift unknown Observable type");
+  };
+}
+function $e(e, n, t, i, a) {
+  return new Wo(e, n, t, i, a);
+}
+var Wo = function(e) {
+  Xt(n, e);
+  function n(t, i, a, r, o, s) {
+    var f = e.call(this, t) || this;
+    return f.onFinalize = o, f.shouldUnsubscribe = s, f._next = i ? function(l) {
+      try {
+        i(l);
+      } catch (c) {
+        t.error(c);
+      }
+    } : e.prototype._next, f._error = r ? function(l) {
+      try {
+        r(l);
+      } catch (c) {
+        t.error(c);
+      } finally {
+        this.unsubscribe();
+      }
+    } : e.prototype._error, f._complete = a ? function() {
+      try {
+        a();
+      } catch (l) {
+        t.error(l);
+      } finally {
+        this.unsubscribe();
+      }
+    } : e.prototype._complete, f;
+  }
+  return n.prototype.unsubscribe = function() {
+    var t;
+    if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+      var i = this.closed;
+      e.prototype.unsubscribe.call(this), !i && ((t = this.onFinalize) === null || t === void 0 || t.call(this));
+    }
+  }, n;
+}(Jt), Jo = new K(function(e) {
+  return e.complete();
+});
+function Qo(e) {
+  return e && D(e.schedule);
+}
+function Zi(e) {
+  return e[e.length - 1];
+}
+function qo(e) {
+  return Qo(Zi(e)) ? e.pop() : void 0;
+}
+function el(e, n) {
+  return typeof Zi(e) == "number" ? e.pop() : n;
+}
+var Ci = function(e) {
+  return e && typeof e.length == "number" && typeof e != "function";
+};
+function Fi(e) {
+  return D(e == null ? void 0 : e.then);
+}
+function Mi(e) {
+  return D(e[Qt]);
+}
+function $i(e) {
+  return Symbol.asyncIterator && D(e == null ? void 0 : e[Symbol.asyncIterator]);
+}
+function Hi(e) {
+  return new TypeError("You provided " + (e !== null && typeof e == "object" ? "an invalid object" : "'" + e + "'") + " where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.");
+}
+function tl() {
+  return typeof Symbol != "function" || !Symbol.iterator ? "@@iterator" : Symbol.iterator;
+}
+var Pi = tl();
+function Vi(e) {
+  return D(e == null ? void 0 : e[Pi]);
+}
+function Ki(e) {
+  return Fo(this, arguments, function() {
+    var t, i, a, r;
+    return Oi(this, function(o) {
+      switch (o.label) {
+        case 0:
+          t = e.getReader(), o.label = 1;
+        case 1:
+          o.trys.push([1, , 9, 10]), o.label = 2;
+        case 2:
+          return [4, we(t.read())];
+        case 3:
+          return i = o.sent(), a = i.value, r = i.done, r ? [4, we(void 0)] : [3, 5];
+        case 4:
+          return [2, o.sent()];
+        case 5:
+          return [4, we(a)];
+        case 6:
+          return [4, o.sent()];
+        case 7:
+          return o.sent(), [3, 2];
+        case 8:
+          return [3, 10];
+        case 9:
+          return t.releaseLock(), [7];
+        case 10:
+          return [2];
+      }
+    });
+  });
+}
+function Gi(e) {
+  return D(e == null ? void 0 : e.getReader);
+}
+function Se(e) {
+  if (e instanceof K)
+    return e;
+  if (e != null) {
+    if (Mi(e))
+      return nl(e);
+    if (Ci(e))
+      return il(e);
+    if (Fi(e))
+      return rl(e);
+    if ($i(e))
+      return Yi(e);
+    if (Vi(e))
+      return al(e);
+    if (Gi(e))
+      return ol(e);
+  }
+  throw Hi(e);
+}
+function nl(e) {
+  return new K(function(n) {
+    var t = e[Qt]();
+    if (D(t.subscribe))
+      return t.subscribe(n);
+    throw new TypeError("Provided object does not correctly implement Symbol.observable");
+  });
+}
+function il(e) {
+  return new K(function(n) {
+    for (var t = 0; t < e.length && !n.closed; t++)
+      n.next(e[t]);
+    n.complete();
+  });
+}
+function rl(e) {
+  return new K(function(n) {
+    e.then(function(t) {
+      n.closed || (n.next(t), n.complete());
+    }, function(t) {
+      return n.error(t);
+    }).then(null, Ni);
+  });
+}
+function al(e) {
+  return new K(function(n) {
+    var t, i;
+    try {
+      for (var a = Me(e), r = a.next(); !r.done; r = a.next()) {
+        var o = r.value;
+        if (n.next(o), n.closed)
+          return;
+      }
+    } catch (s) {
+      t = { error: s };
+    } finally {
+      try {
+        r && !r.done && (i = a.return) && i.call(a);
+      } finally {
+        if (t) throw t.error;
+      }
+    }
+    n.complete();
+  });
+}
+function Yi(e) {
+  return new K(function(n) {
+    ll(e, n).catch(function(t) {
+      return n.error(t);
+    });
+  });
+}
+function ol(e) {
+  return Yi(Ki(e));
+}
+function ll(e, n) {
+  var t, i, a, r;
+  return Co(this, void 0, void 0, function() {
+    var o, s;
+    return Oi(this, function(f) {
+      switch (f.label) {
+        case 0:
+          f.trys.push([0, 5, 6, 11]), t = Mo(e), f.label = 1;
+        case 1:
+          return [4, t.next()];
+        case 2:
+          if (i = f.sent(), !!i.done) return [3, 4];
+          if (o = i.value, n.next(o), n.closed)
+            return [2];
+          f.label = 3;
+        case 3:
+          return [3, 1];
+        case 4:
+          return [3, 11];
+        case 5:
+          return s = f.sent(), a = { error: s }, [3, 11];
+        case 6:
+          return f.trys.push([6, , 9, 10]), i && !i.done && (r = t.return) ? [4, r.call(t)] : [3, 8];
+        case 7:
+          f.sent(), f.label = 8;
+        case 8:
+          return [3, 10];
+        case 9:
+          if (a) throw a.error;
+          return [7];
+        case 10:
+          return [7];
+        case 11:
+          return n.complete(), [2];
+      }
+    });
+  });
+}
+function ce(e, n, t, i, a) {
+  i === void 0 && (i = 0), a === void 0 && (a = !1);
+  var r = n.schedule(function() {
+    t(), a ? e.add(this.schedule(null, i)) : this.unsubscribe();
+  }, i);
+  if (e.add(r), !a)
+    return r;
+}
+function ji(e, n) {
+  return n === void 0 && (n = 0), xe(function(t, i) {
+    t.subscribe($e(i, function(a) {
+      return ce(i, e, function() {
+        return i.next(a);
+      }, n);
+    }, function() {
+      return ce(i, e, function() {
+        return i.complete();
+      }, n);
+    }, function(a) {
+      return ce(i, e, function() {
+        return i.error(a);
+      }, n);
+    }));
+  });
+}
+function Xi(e, n) {
+  return n === void 0 && (n = 0), xe(function(t, i) {
+    i.add(e.schedule(function() {
+      return t.subscribe(i);
+    }, n));
+  });
+}
+function sl(e, n) {
+  return Se(e).pipe(Xi(n), ji(n));
+}
+function cl(e, n) {
+  return Se(e).pipe(Xi(n), ji(n));
+}
+function fl(e, n) {
+  return new K(function(t) {
+    var i = 0;
+    return n.schedule(function() {
+      i === e.length ? t.complete() : (t.next(e[i++]), t.closed || this.schedule());
+    });
+  });
+}
+function ul(e, n) {
+  return new K(function(t) {
+    var i;
+    return ce(t, n, function() {
+      i = e[Pi](), ce(t, n, function() {
+        var a, r, o;
+        try {
+          a = i.next(), r = a.value, o = a.done;
+        } catch (s) {
+          t.error(s);
+          return;
+        }
+        o ? t.complete() : t.next(r);
+      }, 0, !0);
+    }), function() {
+      return D(i == null ? void 0 : i.return) && i.return();
+    };
+  });
+}
+function Wi(e, n) {
+  if (!e)
+    throw new Error("Iterable cannot be null");
+  return new K(function(t) {
+    ce(t, n, function() {
+      var i = e[Symbol.asyncIterator]();
+      ce(t, n, function() {
+        i.next().then(function(a) {
+          a.done ? t.complete() : t.next(a.value);
+        });
+      }, 0, !0);
+    });
+  });
+}
+function hl(e, n) {
+  return Wi(Ki(e), n);
+}
+function dl(e, n) {
+  if (e != null) {
+    if (Mi(e))
+      return sl(e, n);
+    if (Ci(e))
+      return fl(e, n);
+    if (Fi(e))
+      return cl(e, n);
+    if ($i(e))
+      return Wi(e, n);
+    if (Vi(e))
+      return ul(e, n);
+    if (Gi(e))
+      return hl(e, n);
+  }
+  throw Hi(e);
+}
+function _l(e, n) {
+  return n ? dl(e, n) : Se(e);
+}
+var bl = Ri(function(e) {
+  return function() {
+    e(this), this.name = "EmptyError", this.message = "no elements in sequence";
+  };
+});
+function Ji(e, n) {
+  return new Promise(function(t, i) {
+    var a = new it({
+      next: function(r) {
+        t(r), a.unsubscribe();
+      },
+      error: i,
+      complete: function() {
+        i(new bl());
+      }
+    });
+    e.subscribe(a);
+  });
+}
+function Qi(e, n) {
+  return xe(function(t, i) {
+    var a = 0;
+    t.subscribe($e(i, function(r) {
+      i.next(e.call(n, r, a++));
+    }));
+  });
+}
+function gl(e, n, t, i, a, r, o, s) {
+  var f = [], l = 0, c = 0, w = !1, h = function() {
+    w && !f.length && !l && n.complete();
+  }, u = function(g) {
+    return l < i ? d(g) : f.push(g);
+  }, d = function(g) {
+    l++;
+    var v = !1;
+    Se(t(g, c++)).subscribe($e(n, function(k) {
+      n.next(k);
+    }, function() {
+      v = !0;
+    }, void 0, function() {
+      if (v)
+        try {
+          l--;
+          for (var k = function() {
+            var E = f.shift();
+            o || d(E);
+          }; f.length && l < i; )
+            k();
+          h();
+        } catch (E) {
+          n.error(E);
+        }
+    }));
+  };
+  return e.subscribe($e(n, u, function() {
+    w = !0, h();
+  })), function() {
+  };
+}
+function qi(e, n, t) {
+  return t === void 0 && (t = 1 / 0), D(n) ? qi(function(i, a) {
+    return Qi(function(r, o) {
+      return n(i, r, a, o);
+    })(Se(e(i, a)));
+  }, t) : (typeof n == "number" && (t = n), xe(function(i, a) {
+    return gl(i, a, e, t);
+  }));
+}
+function wl(e) {
+  return e === void 0 && (e = 1 / 0), qi(Li, e);
+}
+function pl() {
+  for (var e = [], n = 0; n < arguments.length; n++)
+    e[n] = arguments[n];
+  var t = qo(e), i = el(e, 1 / 0), a = e;
+  return a.length ? a.length === 1 ? Se(a[0]) : wl(i)(_l(a, t)) : Jo;
+}
+function ml(e, n, t, i, a) {
+  return function(r, o) {
+    var s = t, f = n, l = 0;
+    r.subscribe($e(o, function(c) {
+      var w = l++;
+      f = s ? e(f, c, w) : (s = !0, c);
+    }, function() {
+      s && o.next(f), o.complete();
+    }));
+  };
+}
+function er(e, n) {
+  return xe(ml(e, n, arguments.length >= 2, !1, !0));
+}
+var yl = function(e, n) {
+  return e.push(n), e;
+};
+function vl() {
+  return xe(function(e, n) {
+    er(yl, [])(e).subscribe(n);
+  });
+}
+const Vn = -2003829722, zt = -2021002517;
+class tr {
+  getHeader(n) {
+    return this.headerP || (this.headerP = this._getHeader(n).catch((t) => {
+      throw this.headerP = void 0, t;
+    })), this.headerP;
+  }
+  /*
+   * @param filehandle - a filehandle from generic-filehandle or implementing
+   * something similar to the node10 fs.promises API
+   *
+   * @param path - a Local file path as a string
+   *
+   * @param url - a URL string
+   *
+   * @param renameRefSeqs - an optional method to rename the internal reference
+   * sequences using a mapping function
+   */
+  constructor(n) {
+    const { filehandle: t, renameRefSeqs: i = (o) => o, path: a, url: r } = n;
+    if (this.renameRefSeqs = i, t)
+      this.bbi = t;
+    else if (r)
+      this.bbi = new ir(r);
+    else if (a)
+      this.bbi = new nr(a);
+    else
+      throw new Error("no file given");
+  }
+  async _getHeader(n) {
+    const t = await this._getMainHeader(n), i = await this._readChromTree(t, n);
+    return { ...t, ...i };
+  }
+  async _getMainHeader(n, t = 2e3) {
+    const { buffer: a } = await this.bbi.read(ee.Buffer.alloc(t), 0, t, 0, n), r = this._isBigEndian(a), o = a, s = new DataView(o.buffer, o.byteOffset, o.length);
+    let f = 0;
+    const l = s.getInt32(f, !0);
+    f += 4;
+    const c = s.getUint16(f, !0);
+    f += 2;
+    const w = s.getUint16(f, !0);
+    f += 2;
+    const h = Number(s.getBigUint64(f, !0));
+    f += 8;
+    const u = Number(s.getBigUint64(f, !0));
+    f += 8;
+    const d = Number(s.getBigUint64(f, !0));
+    f += 8;
+    const g = s.getUint16(f, !0);
+    f += 2;
+    const v = s.getUint16(f, !0);
+    f += 2;
+    const k = Number(s.getBigUint64(f, !0));
+    f += 8;
+    const E = Number(s.getBigUint64(f, !0));
+    f += 8;
+    const A = s.getUint32(f, !0);
+    f += 4;
+    const b = Number(s.getBigUint64(f, !0));
+    f += 8;
+    const x = [];
+    for (let S = 0; S < w; S++) {
+      const _ = s.getUint32(f, !0);
+      f += 4;
+      const y = s.getUint32(f, !0);
+      f += 4;
+      const m = Number(s.getBigUint64(f, !0));
+      f += 8;
+      const U = Number(s.getBigUint64(f, !0));
+      f += 8, x.push({ reductionLevel: _, reserved: y, dataOffset: m, indexOffset: U });
+    }
+    const I = l === zt ? "bigbed" : "bigwig";
+    if (k > t || E > t - 8 * 5)
+      return this._getMainHeader(n, t * 2);
+    let p;
+    if (E) {
+      const S = a.subarray(Number(E));
+      let _ = 0;
+      const y = new DataView(S.buffer, S.byteOffset, S.length), m = Number(y.getBigUint64(_, !0));
+      _ += 8;
+      const U = y.getFloat64(_, !0);
+      _ += 8;
+      const Z = y.getFloat64(_, !0);
+      _ += 8;
+      const B = y.getFloat64(_, !0);
+      _ += 8;
+      const O = y.getFloat64(_, !0);
+      _ += 8, p = {
+        scoreMin: U,
+        scoreMax: Z,
+        scoreSum: B,
+        scoreSumSquares: O,
+        basesCovered: m
+      };
+    } else
+      throw new Error("no stats");
+    return {
+      zoomLevels: x,
+      magic: l,
+      extHeaderOffset: b,
+      numZoomLevels: w,
+      fieldCount: g,
+      totalSummary: p,
+      definedFieldCount: v,
+      uncompressBufSize: A,
+      asOffset: k,
+      chromTreeOffset: h,
+      totalSummaryOffset: E,
+      unzoomedDataOffset: u,
+      unzoomedIndexOffset: d,
+      fileType: I,
+      version: c,
+      isBigEndian: r,
+      autoSql: k ? a.subarray(k, a.indexOf(0, k)).toString() : ""
+    };
+  }
+  _isBigEndian(n) {
+    let t = n.readInt32LE(0);
+    if (t === Vn || t === zt)
+      return !1;
+    if (t = n.readInt32BE(0), t === Vn || t === zt)
+      return !0;
+    throw new Error("not a BigWig/BigBed file");
+  }
+  // todo: add progress if long running
+  async _readChromTree(n, t) {
+    const a = !n.isBigEndian, r = [], o = {};
+    let s = n.unzoomedDataOffset;
+    const f = n.chromTreeOffset;
+    for (; s % 4 !== 0; )
+      s += 1;
+    const l = s - f, { buffer: c } = await this.bbi.read(ee.Buffer.alloc(l), 0, l, Number(f), t), w = c, h = new DataView(w.buffer, w.byteOffset, w.length);
+    let u = 0;
+    u += 4, u += 4;
+    const d = h.getUint32(u, a);
+    u += 4, u += 4, u += 8;
+    const g = 32, v = async (k) => {
+      let E = k;
+      if (E >= c.length)
+        throw new Error("reading beyond end of buffer");
+      const A = h.getUint8(E);
+      E += 2;
+      const b = h.getUint16(E, a);
+      if (E += 2, A)
+        for (let x = 0; x < b; x++) {
+          const I = c.subarray(E, E + d).toString().replaceAll("\0", "");
+          E += d;
+          const p = h.getUint32(E, a);
+          E += 4;
+          const S = h.getUint32(E, a);
+          E += 4;
+          const _ = { name: I, id: p, length: S };
+          o[this.renameRefSeqs(I)] = p, r[p] = _;
+        }
+      else {
+        const x = [];
+        for (let I = 0; I < b; I++) {
+          E += d;
+          const p = Number(h.getBigUint64(E, a));
+          E += 8, x.push(v(Number(p) - Number(f)));
+        }
+        await Promise.all(x);
+      }
+    };
+    return await v(g), {
+      refsByName: o,
+      refsByNumber: r
+    };
+  }
+  /*
+   * fetches the "unzoomed" view of the bigwig data. this is the default for bigbed
+   * @param abortSignal - a signal to optionally abort this operation
+   */
+  async getUnzoomedView(n) {
+    const { unzoomedIndexOffset: t, refsByName: i, uncompressBufSize: a, isBigEndian: r, fileType: o } = await this.getHeader(n);
+    return new zi(this.bbi, i, t, r, a > 0, o);
+  }
+  /**
+   * Gets features from a BigWig file
+   *
+   * @param refName - The chromosome name
+   * @param start - The start of a region
+   * @param end - The end of a region
+   * @param opts - An object containing basesPerSpan (e.g. pixels per basepair) or scale used to infer the zoomLevel to use
+   */
+  async getFeatureStream(n, t, i, a) {
+    await this.getHeader(a);
+    const r = this.renameRefSeqs(n);
+    let o;
+    const { basesPerSpan: s, scale: f } = a || {};
+    return s ? o = await this.getView(1 / s, a) : f ? o = await this.getView(f, a) : o = await this.getView(1, a), new K((l) => {
+      o.readWigData(r, t, i, l, a).catch((c) => {
+        l.error(c);
+      });
+    });
+  }
+  async getFeatures(n, t, i, a) {
+    const r = await this.getFeatureStream(n, t, i, a);
+    return (await Ji(r.pipe(vl()))).flat();
+  }
+}
+class Ol extends tr {
+  /**
+   * Retrieves a BlockView of a specific zoomLevel
+   *
+   * @param scale - number
+   *
+   * @param opts - An object containing basesPerSpan (e.g. pixels per basepair)
+   * or scale used to infer the zoomLevel to use
+   */
+  async getView(n, t) {
+    const { zoomLevels: i, refsByName: a, isBigEndian: r, uncompressBufSize: o } = await this.getHeader(t), s = 1 / n, f = i.length - 1;
+    for (let l = f; l >= 0; l -= 1) {
+      const c = i[l];
+      if (c && c.reductionLevel <= 2 * s)
+        return new zi(this.bbi, a, c.indexOffset, r, o > 0, "summary");
+    }
+    return this.getUnzoomedView(t);
+  }
+}
+function kl(e) {
+  return e.filter((n) => !!n);
+}
+class Rl extends tr {
+  constructor() {
+    super(...arguments), this.readIndicesCache = new Kn({
+      cache: new Gn({ maxSize: 1 }),
+      fill: (n, t) => this._readIndices({ ...n, signal: t })
+    });
+  }
+  readIndices(n = {}) {
+    const { signal: t, ...i } = n;
+    return this.readIndicesCache.get(JSON.stringify(i), n, t);
+  }
+  /*
+   * retrieve unzoomed view for any scale
+   */
+  async getView(n, t) {
+    return this.getUnzoomedView(t);
+  }
+  /*
+   * parse the bigbed extraIndex fields
+   *
+   *
+   * @return a Promise for an array of Index data structure since there can be
+   * multiple extraIndexes in a bigbed, see bedToBigBed documentation
+   */
+  async _readIndices(n) {
+    const { extHeaderOffset: t, isBigEndian: i } = await this.getHeader(n), { buffer: a } = await this.bbi.read(ee.Buffer.alloc(64), 0, 64, Number(t)), r = !i, o = a, s = new DataView(o.buffer, o.byteOffset, o.length);
+    let f = 0;
+    f += 2;
+    const l = s.getUint16(f, r);
+    f += 2;
+    const c = Number(s.getBigUint64(f, r));
+    if (f += 8, l === 0)
+      return [];
+    const w = 20, h = w * l, { buffer: u } = await this.bbi.read(ee.Buffer.alloc(h), 0, h, Number(c)), d = [];
+    for (let g = 0; g < l; g += 1) {
+      const v = u.subarray(g * w), k = new DataView(v.buffer, v.byteOffset, v.length);
+      let E = 0;
+      const A = k.getInt16(E, r);
+      E += 2;
+      const b = k.getInt16(E, r);
+      E += 2;
+      const x = Number(k.getBigUint64(E, r));
+      E += 12;
+      const I = k.getInt16(E, r);
+      d.push({ type: A, fieldcount: b, offset: Number(x), field: I });
+    }
+    return d;
+  }
+  /*
+   * perform a search in the bigbed extraIndex to find which blocks in the
+   * bigbed data to look for the actual feature data
+   *
+   * @param name - the name to search for
+   * @param opts - a SearchOptions argument with optional signal
+   * @return a Promise for an array of bigbed block Loc entries
+   */
+  async searchExtraIndexBlocks(n, t = {}) {
+    const { isBigEndian: i } = await this.getHeader(t), a = await this.readIndices(t);
+    if (a.length === 0)
+      return [];
+    const r = a.map(async (o) => {
+      const { offset: s, field: f } = o, { buffer: l } = await this.bbi.read(ee.Buffer.alloc(32), 0, 32, s, t), c = !i, w = l, h = new DataView(w.buffer, w.byteOffset, w.length);
+      let u = 0;
+      u += 4;
+      const d = h.getInt32(u, c);
+      u += 4;
+      const g = h.getInt32(u, c);
+      u += 4;
+      const v = h.getInt32(u, c);
+      u += 4, u += 8;
+      const k = async (A) => {
+        const b = Number(A), x = 4 + d * (g + v), { buffer: I } = await this.bbi.read(ee.Buffer.alloc(x), 0, x, b, t), p = I, S = new DataView(p.buffer, p.byteOffset, p.length);
+        let _ = 0;
+        const y = S.getInt8(_);
+        _ += 2;
+        const m = S.getInt16(_, c);
+        _ += 2;
+        const U = [];
+        if (y === 0) {
+          const Z = [];
+          for (let O = 0; O < m; O++) {
+            const F = p.subarray(_, _ + g).toString().replaceAll("\0", "");
+            _ += g;
+            const ae = Number(S.getBigUint64(_, c));
+            _ += 8, Z.push({ key: F, offset: ae });
+          }
+          let B = 0;
+          for (const { key: O, offset: F } of Z) {
+            if (n.localeCompare(O) < 0 && B)
+              return k(B);
+            B = F;
+          }
+          return k(B);
+        } else if (y === 1) {
+          for (let Z = 0; Z < m; Z++) {
+            const B = p.subarray(_, _ + g).toString().replaceAll("\0", "");
+            _ += g;
+            const O = Number(S.getBigUint64(_, c));
+            _ += 8;
+            const F = S.getUint32(_, c);
+            _ += 4;
+            const ae = S.getUint32(_, c);
+            _ += 4, U.push({ key: B, offset: O, length: F, reserved: ae });
+          }
+          for (const Z of U)
+            if (Z.key === n)
+              return { ...Z, field: f };
+          return;
+        }
+      };
+      return k(s + 32);
+    });
+    return kl(await Promise.all(r));
+  }
+  /*
+   * retrieve the features from the bigbed data that were found through the
+   * lookup of the extraIndex note that there can be multiple extraIndex, see
+   * the BigBed specification and the -extraIndex argument to bedToBigBed
+   *
+   * @param name - the name to search for
+   * @param opts - a SearchOptions argument with optional signal
+   * @return a Promise for an array of Feature
+   */
+  async searchExtraIndex(n, t = {}) {
+    const i = await this.searchExtraIndexBlocks(n, t);
+    if (i.length === 0)
+      return [];
+    const a = await this.getUnzoomedView(t), r = i.map((s) => new K((f) => {
+      a.readFeatures(f, [s], t).catch((l) => {
+        f.error(l);
+      });
+    }).pipe(er((f, l) => f.concat(l)), Qi((f) => {
+      for (const l of f)
+        l.field = s.field;
+      return f;
+    })));
+    return (await Ji(pl(...r))).filter((s) => {
+      var f;
+      return ((f = s.rest) === null || f === void 0 ? void 0 : f.split("	")[(s.field || 0) - 3]) === n;
+    });
+  }
+}
+export {
+  Rl as BigBed,
+  Ol as BigWig
+};