@genome-spy/app 0.58.3 → 0.60.0

package/dist/index-Bg7C4Xat.js

@@ -0,0 +1,2750 @@
+import { b as z } from "./index-BftNdA0O.js";
+import { A as pt, L as vt } from "./index-CCJIjehY.js";
+import { L as un } from "./__vite-browser-external-C--ziKoh.js";
+import { R as hn } from "./remoteFile-BuaqFGWk.js";
+const _t = BigInt(32);
+function dn(t, n, e) {
+  const i = +!!e, o = +!e;
+  return BigInt(t.getInt32(n, e) * o + t.getInt32(n + 4, e) * i) << _t | BigInt(t.getUint32(n, e) * i + t.getUint32(n + 4, e) * o);
+}
+function bn(t, n, e) {
+  const i = t.getUint32(n, e), o = t.getUint32(n + 4, e), r = +!!e, s = +!e;
+  return BigInt(i * s + o * r) << _t | BigInt(i * r + o * s);
+}
+"getBigInt64" in DataView || (DataView.prototype.getBigInt64 = function(t, n) {
+  return dn(this, t, n);
+});
+"getBigUint64" in DataView || (DataView.prototype.getBigUint64 = function(t, n) {
+  return bn(this, t, n);
+});
+class j {
+  constructor(n) {
+    this.ranges = n;
+  }
+  get min() {
+    return this.ranges[0].min;
+  }
+  get max() {
+    return this.ranges.at(-1).max;
+  }
+  contains(n) {
+    for (const e of this.ranges)
+      if (e.min <= n && e.max >= n)
+        return !0;
+    return !1;
+  }
+  isContiguous() {
+    return this.ranges.length > 1;
+  }
+  getRanges() {
+    return this.ranges.map((n) => new j([{ min: n.min, max: n.max }]));
+  }
+  toString() {
+    return this.ranges.map((n) => `[${n.min}-${n.max}]`).join(",");
+  }
+  union(n) {
+    const e = [...this.getRanges(), ...n.getRanges()].sort((r, s) => r.min < s.min ? -1 : r.min > s.min ? 1 : r.max < s.max ? -1 : s.max > r.max ? 1 : 0), i = [];
+    let o = e[0];
+    for (const r of e)
+      r.min > o.max + 1 ? (i.push(o), o = r) : r.max > o.max && (o = new j([{ min: o.min, max: r.max }]));
+    return i.push(o), i.length === 1 ? i[0] : new j(i);
+  }
+}
+/*! pako 2.1.0 https://github.com/nodeca/pako @license (MIT AND Zlib) */
+function K(t) {
+  let n = t.length;
+  for (; --n >= 0; )
+    t[n] = 0;
+}
+const gn = 3, wn = 258, kt = 29, mn = 256, yn = mn + 1 + kt, xt = 30, pn = 512, vn = new Array((yn + 2) * 2);
+K(vn);
+const _n = new Array(xt * 2);
+K(_n);
+const kn = new Array(pn);
+K(kn);
+const xn = new Array(wn - gn + 1);
+K(xn);
+const En = new Array(kt);
+K(En);
+const Sn = new Array(xt);
+K(Sn);
+const In = (t, n, e, i) => {
+  let o = t & 65535 | 0, r = t >>> 16 & 65535 | 0, s = 0;
+  for (; e !== 0; ) {
+    s = e > 2e3 ? 2e3 : e, e -= s;
+    do
+      o = o + n[i++] | 0, r = r + o | 0;
+    while (--s);
+    o %= 65521, r %= 65521;
+  }
+  return o | r << 16 | 0;
+};
+var Be = In;
+const On = () => {
+  let t, n = [];
+  for (var e = 0; e < 256; e++) {
+    t = e;
+    for (var i = 0; i < 8; i++)
+      t = t & 1 ? 3988292384 ^ t >>> 1 : t >>> 1;
+    n[e] = t;
+  }
+  return n;
+}, Bn = new Uint32Array(On()), An = (t, n, e, i) => {
+  const o = Bn, r = i + e;
+  t ^= -1;
+  for (let s = i; s < r; s++)
+    t = t >>> 8 ^ o[(t ^ n[s]) & 255];
+  return t ^ -1;
+};
+var P = An, Ae = {
+  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) */
+}, Et = {
+  /* Allowed flush values; see deflate() and inflate() below for details */
+  Z_NO_FLUSH: 0,
+  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_STREAM_ERROR: -2,
+  Z_DATA_ERROR: -3,
+  Z_MEM_ERROR: -4,
+  Z_BUF_ERROR: -5,
+  /* The deflate compression method */
+  Z_DEFLATED: 8
+  //Z_NULL:                 null // Use -1 or null inline, depending on var type
+};
+const Tn = (t, n) => Object.prototype.hasOwnProperty.call(t, n);
+var Un = function(t) {
+  const n = Array.prototype.slice.call(arguments, 1);
+  for (; n.length; ) {
+    const e = n.shift();
+    if (e) {
+      if (typeof e != "object")
+        throw new TypeError(e + "must be non-object");
+      for (const i in e)
+        Tn(e, i) && (t[i] = e[i]);
+    }
+  }
+  return t;
+}, Rn = (t) => {
+  let n = 0;
+  for (let i = 0, o = t.length; i < o; i++)
+    n += t[i].length;
+  const e = new Uint8Array(n);
+  for (let i = 0, o = 0, r = t.length; i < r; i++) {
+    let s = t[i];
+    e.set(s, o), o += s.length;
+  }
+  return e;
+}, St = {
+  assign: Un,
+  flattenChunks: Rn
+};
+let It = !0;
+try {
+  String.fromCharCode.apply(null, new Uint8Array(1));
+} catch {
+  It = !1;
+}
+const Q = new Uint8Array(256);
+for (let t = 0; t < 256; t++)
+  Q[t] = t >= 252 ? 6 : t >= 248 ? 5 : t >= 240 ? 4 : t >= 224 ? 3 : t >= 192 ? 2 : 1;
+Q[254] = Q[254] = 1;
+var Dn = (t) => {
+  if (typeof TextEncoder == "function" && TextEncoder.prototype.encode)
+    return new TextEncoder().encode(t);
+  let n, e, i, o, r, s = t.length, f = 0;
+  for (o = 0; o < s; o++)
+    e = t.charCodeAt(o), (e & 64512) === 55296 && o + 1 < s && (i = t.charCodeAt(o + 1), (i & 64512) === 56320 && (e = 65536 + (e - 55296 << 10) + (i - 56320), o++)), f += e < 128 ? 1 : e < 2048 ? 2 : e < 65536 ? 3 : 4;
+  for (n = new Uint8Array(f), r = 0, o = 0; r < f; o++)
+    e = t.charCodeAt(o), (e & 64512) === 55296 && o + 1 < s && (i = t.charCodeAt(o + 1), (i & 64512) === 56320 && (e = 65536 + (e - 55296 << 10) + (i - 56320), o++)), e < 128 ? n[r++] = e : e < 2048 ? (n[r++] = 192 | e >>> 6, n[r++] = 128 | e & 63) : e < 65536 ? (n[r++] = 224 | e >>> 12, n[r++] = 128 | e >>> 6 & 63, n[r++] = 128 | e & 63) : (n[r++] = 240 | e >>> 18, n[r++] = 128 | e >>> 12 & 63, n[r++] = 128 | e >>> 6 & 63, n[r++] = 128 | e & 63);
+  return n;
+};
+const Nn = (t, n) => {
+  if (n < 65534 && t.subarray && It)
+    return String.fromCharCode.apply(null, t.length === n ? t : t.subarray(0, n));
+  let e = "";
+  for (let i = 0; i < n; i++)
+    e += String.fromCharCode(t[i]);
+  return e;
+};
+var Cn = (t, n) => {
+  const e = n || t.length;
+  if (typeof TextDecoder == "function" && TextDecoder.prototype.decode)
+    return new TextDecoder().decode(t.subarray(0, n));
+  let i, o;
+  const r = new Array(e * 2);
+  for (o = 0, i = 0; i < e; ) {
+    let s = t[i++];
+    if (s < 128) {
+      r[o++] = s;
+      continue;
+    }
+    let f = Q[s];
+    if (f > 4) {
+      r[o++] = 65533, i += f - 1;
+      continue;
+    }
+    for (s &= f === 2 ? 31 : f === 3 ? 15 : 7; f > 1 && i < e; )
+      s = s << 6 | t[i++] & 63, f--;
+    if (f > 1) {
+      r[o++] = 65533;
+      continue;
+    }
+    s < 65536 ? r[o++] = s : (s -= 65536, r[o++] = 55296 | s >> 10 & 1023, r[o++] = 56320 | s & 1023);
+  }
+  return Nn(r, o);
+}, Ln = (t, n) => {
+  n = n || t.length, n > t.length && (n = t.length);
+  let e = n - 1;
+  for (; e >= 0 && (t[e] & 192) === 128; )
+    e--;
+  return e < 0 || e === 0 ? n : e + Q[t[e]] > n ? e : n;
+}, Te = {
+  string2buf: Dn,
+  buf2string: Cn,
+  utf8border: Ln
+};
+function Pn() {
+  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 Fn = Pn;
+const ne = 16209, Mn = 16191;
+var zn = function(n, e) {
+  let i, o, r, s, f, u, a, c, v, d, l, h, w, _, k, x, I, g, E, O, m, S, b, p;
+  const y = n.state;
+  i = n.next_in, b = n.input, o = i + (n.avail_in - 5), r = n.next_out, p = n.output, s = r - (e - n.avail_out), f = r + (n.avail_out - 257), u = y.dmax, a = y.wsize, c = y.whave, v = y.wnext, d = y.window, l = y.hold, h = y.bits, w = y.lencode, _ = y.distcode, k = (1 << y.lenbits) - 1, x = (1 << y.distbits) - 1;
+  e:
+    do {
+      h < 15 && (l += b[i++] << h, h += 8, l += b[i++] << h, h += 8), I = w[l & k];
+      t:
+        for (; ; ) {
+          if (g = I >>> 24, l >>>= g, h -= g, g = I >>> 16 & 255, g === 0)
+            p[r++] = I & 65535;
+          else if (g & 16) {
+            E = I & 65535, g &= 15, g && (h < g && (l += b[i++] << h, h += 8), E += l & (1 << g) - 1, l >>>= g, h -= g), h < 15 && (l += b[i++] << h, h += 8, l += b[i++] << h, h += 8), I = _[l & x];
+            n:
+              for (; ; ) {
+                if (g = I >>> 24, l >>>= g, h -= g, g = I >>> 16 & 255, g & 16) {
+                  if (O = I & 65535, g &= 15, h < g && (l += b[i++] << h, h += 8, h < g && (l += b[i++] << h, h += 8)), O += l & (1 << g) - 1, O > u) {
+                    n.msg = "invalid distance too far back", y.mode = ne;
+                    break e;
+                  }
+                  if (l >>>= g, h -= g, g = r - s, O > g) {
+                    if (g = O - g, g > c && y.sane) {
+                      n.msg = "invalid distance too far back", y.mode = ne;
+                      break e;
+                    }
+                    if (m = 0, S = d, v === 0) {
+                      if (m += a - g, g < E) {
+                        E -= g;
+                        do
+                          p[r++] = d[m++];
+                        while (--g);
+                        m = r - O, S = p;
+                      }
+                    } else if (v < g) {
+                      if (m += a + v - g, g -= v, g < E) {
+                        E -= g;
+                        do
+                          p[r++] = d[m++];
+                        while (--g);
+                        if (m = 0, v < E) {
+                          g = v, E -= g;
+                          do
+                            p[r++] = d[m++];
+                          while (--g);
+                          m = r - O, S = p;
+                        }
+                      }
+                    } else if (m += v - g, g < E) {
+                      E -= g;
+                      do
+                        p[r++] = d[m++];
+                      while (--g);
+                      m = r - O, S = p;
+                    }
+                    for (; E > 2; )
+                      p[r++] = S[m++], p[r++] = S[m++], p[r++] = S[m++], E -= 3;
+                    E && (p[r++] = S[m++], E > 1 && (p[r++] = S[m++]));
+                  } else {
+                    m = r - O;
+                    do
+                      p[r++] = p[m++], p[r++] = p[m++], p[r++] = p[m++], E -= 3;
+                    while (E > 2);
+                    E && (p[r++] = p[m++], E > 1 && (p[r++] = p[m++]));
+                  }
+                } else if (g & 64) {
+                  n.msg = "invalid distance code", y.mode = ne;
+                  break e;
+                } else {
+                  I = _[(I & 65535) + (l & (1 << g) - 1)];
+                  continue n;
+                }
+                break;
+              }
+          } else if (g & 64)
+            if (g & 32) {
+              y.mode = Mn;
+              break e;
+            } else {
+              n.msg = "invalid literal/length code", y.mode = ne;
+              break e;
+            }
+          else {
+            I = w[(I & 65535) + (l & (1 << g) - 1)];
+            continue t;
+          }
+          break;
+        }
+    } while (i < o && r < f);
+  E = h >> 3, i -= E, h -= E << 3, l &= (1 << h) - 1, n.next_in = i, n.next_out = r, n.avail_in = i < o ? 5 + (o - i) : 5 - (i - o), n.avail_out = r < f ? 257 + (f - r) : 257 - (r - f), y.hold = l, y.bits = h;
+};
+const G = 15, Fe = 852, Me = 592, ze = 0, we = 1, Ze = 2, Zn = 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
+]), $n = 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
+]), Hn = 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
+]), Vn = 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
+]), Gn = (t, n, e, i, o, r, s, f) => {
+  const u = f.bits;
+  let a = 0, c = 0, v = 0, d = 0, l = 0, h = 0, w = 0, _ = 0, k = 0, x = 0, I, g, E, O, m, S = null, b;
+  const p = new Uint16Array(G + 1), y = new Uint16Array(G + 1);
+  let T = null, D, U, B;
+  for (a = 0; a <= G; a++)
+    p[a] = 0;
+  for (c = 0; c < i; c++)
+    p[n[e + c]]++;
+  for (l = u, d = G; d >= 1 && p[d] === 0; d--)
+    ;
+  if (l > d && (l = d), d === 0)
+    return o[r++] = 1 << 24 | 64 << 16 | 0, o[r++] = 1 << 24 | 64 << 16 | 0, f.bits = 1, 0;
+  for (v = 1; v < d && p[v] === 0; v++)
+    ;
+  for (l < v && (l = v), _ = 1, a = 1; a <= G; a++)
+    if (_ <<= 1, _ -= p[a], _ < 0)
+      return -1;
+  if (_ > 0 && (t === ze || d !== 1))
+    return -1;
+  for (y[1] = 0, a = 1; a < G; a++)
+    y[a + 1] = y[a] + p[a];
+  for (c = 0; c < i; c++)
+    n[e + c] !== 0 && (s[y[n[e + c]]++] = c);
+  if (t === ze ? (S = T = s, b = 20) : t === we ? (S = Zn, T = $n, b = 257) : (S = Hn, T = Vn, b = 0), x = 0, c = 0, a = v, m = r, h = l, w = 0, E = -1, k = 1 << l, O = k - 1, t === we && k > Fe || t === Ze && k > Me)
+    return 1;
+  for (; ; ) {
+    D = a - w, s[c] + 1 < b ? (U = 0, B = s[c]) : s[c] >= b ? (U = T[s[c] - b], B = S[s[c] - b]) : (U = 96, B = 0), I = 1 << a - w, g = 1 << h, v = g;
+    do
+      g -= I, o[m + (x >> w) + g] = D << 24 | U << 16 | B | 0;
+    while (g !== 0);
+    for (I = 1 << a - 1; x & I; )
+      I >>= 1;
+    if (I !== 0 ? (x &= I - 1, x += I) : x = 0, c++, --p[a] === 0) {
+      if (a === d)
+        break;
+      a = n[e + s[c]];
+    }
+    if (a > l && (x & O) !== E) {
+      for (w === 0 && (w = l), m += v, h = a - w, _ = 1 << h; h + w < d && (_ -= p[h + w], !(_ <= 0)); )
+        h++, _ <<= 1;
+      if (k += 1 << h, t === we && k > Fe || t === Ze && k > Me)
+        return 1;
+      E = x & O, o[E] = l << 24 | h << 16 | m - r | 0;
+    }
+  }
+  return x !== 0 && (o[m + x] = a - w << 24 | 64 << 16 | 0), f.bits = l, 0;
+};
+var J = Gn;
+const jn = 0, Ot = 1, Bt = 2, {
+  Z_FINISH: $e,
+  Z_BLOCK: Yn,
+  Z_TREES: re,
+  Z_OK: H,
+  Z_STREAM_END: Kn,
+  Z_NEED_DICT: Wn,
+  Z_STREAM_ERROR: C,
+  Z_DATA_ERROR: At,
+  Z_MEM_ERROR: Tt,
+  Z_BUF_ERROR: Xn,
+  Z_DEFLATED: He
+} = Et, le = 16180, Ve = 16181, Ge = 16182, je = 16183, Ye = 16184, Ke = 16185, We = 16186, Xe = 16187, Je = 16188, Qe = 16189, ce = 16190, F = 16191, me = 16192, qe = 16193, ye = 16194, et = 16195, tt = 16196, nt = 16197, rt = 16198, ie = 16199, oe = 16200, it = 16201, ot = 16202, at = 16203, st = 16204, ct = 16205, pe = 16206, ft = 16207, lt = 16208, A = 16209, Ut = 16210, Rt = 16211, Jn = 852, Qn = 592, qn = 15, er = qn, ut = (t) => (t >>> 24 & 255) + (t >>> 8 & 65280) + ((t & 65280) << 8) + ((t & 255) << 24);
+function tr() {
+  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 V = (t) => {
+  if (!t)
+    return 1;
+  const n = t.state;
+  return !n || n.strm !== t || n.mode < le || n.mode > Rt ? 1 : 0;
+}, Dt = (t) => {
+  if (V(t))
+    return C;
+  const n = t.state;
+  return t.total_in = t.total_out = n.total = 0, t.msg = "", n.wrap && (t.adler = n.wrap & 1), n.mode = le, 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(Jn), n.distcode = n.distdyn = new Int32Array(Qn), n.sane = 1, n.back = -1, H;
+}, Nt = (t) => {
+  if (V(t))
+    return C;
+  const n = t.state;
+  return n.wsize = 0, n.whave = 0, n.wnext = 0, Dt(t);
+}, Ct = (t, n) => {
+  let e;
+  if (V(t))
+    return C;
+  const i = t.state;
+  return n < 0 ? (e = 0, n = -n) : (e = (n >> 4) + 5, n < 48 && (n &= 15)), n && (n < 8 || n > 15) ? C : (i.window !== null && i.wbits !== n && (i.window = null), i.wrap = e, i.wbits = n, Nt(t));
+}, Lt = (t, n) => {
+  if (!t)
+    return C;
+  const e = new tr();
+  t.state = e, e.strm = t, e.window = null, e.mode = le;
+  const i = Ct(t, n);
+  return i !== H && (t.state = null), i;
+}, nr = (t) => Lt(t, er);
+let ht = !0, ve, _e;
+const rr = (t) => {
+  if (ht) {
+    ve = new Int32Array(512), _e = new Int32Array(32);
+    let n = 0;
+    for (; n < 144; )
+      t.lens[n++] = 8;
+    for (; n < 256; )
+      t.lens[n++] = 9;
+    for (; n < 280; )
+      t.lens[n++] = 7;
+    for (; n < 288; )
+      t.lens[n++] = 8;
+    for (J(Ot, t.lens, 0, 288, ve, 0, t.work, { bits: 9 }), n = 0; n < 32; )
+      t.lens[n++] = 5;
+    J(Bt, t.lens, 0, 32, _e, 0, t.work, { bits: 5 }), ht = !1;
+  }
+  t.lencode = ve, t.lenbits = 9, t.distcode = _e, t.distbits = 5;
+}, Pt = (t, n, e, i) => {
+  let o;
+  const r = t.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(e - r.wsize, e), 0), r.wnext = 0, r.whave = r.wsize) : (o = r.wsize - r.wnext, o > i && (o = i), r.window.set(n.subarray(e - i, e - i + o), r.wnext), i -= o, i ? (r.window.set(n.subarray(e - i, e), 0), r.wnext = i, r.whave = r.wsize) : (r.wnext += o, r.wnext === r.wsize && (r.wnext = 0), r.whave < r.wsize && (r.whave += o))), 0;
+}, ir = (t, n) => {
+  let e, i, o, r, s, f, u, a, c, v, d, l, h, w, _ = 0, k, x, I, g, E, O, m, S;
+  const b = new Uint8Array(4);
+  let p, y;
+  const T = (
+    /* 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 (V(t) || !t.output || !t.input && t.avail_in !== 0)
+    return C;
+  e = t.state, e.mode === F && (e.mode = me), s = t.next_out, o = t.output, u = t.avail_out, r = t.next_in, i = t.input, f = t.avail_in, a = e.hold, c = e.bits, v = f, d = u, S = H;
+  e:
+    for (; ; )
+      switch (e.mode) {
+        case le:
+          if (e.wrap === 0) {
+            e.mode = me;
+            break;
+          }
+          for (; c < 16; ) {
+            if (f === 0)
+              break e;
+            f--, a += i[r++] << c, c += 8;
+          }
+          if (e.wrap & 2 && a === 35615) {
+            e.wbits === 0 && (e.wbits = 15), e.check = 0, b[0] = a & 255, b[1] = a >>> 8 & 255, e.check = P(e.check, b, 2, 0), a = 0, c = 0, e.mode = Ve;
+            break;
+          }
+          if (e.head && (e.head.done = !1), !(e.wrap & 1) || /* check if zlib header allowed */
+          (((a & 255) << 8) + (a >> 8)) % 31) {
+            t.msg = "incorrect header check", e.mode = A;
+            break;
+          }
+          if ((a & 15) !== He) {
+            t.msg = "unknown compression method", e.mode = A;
+            break;
+          }
+          if (a >>>= 4, c -= 4, m = (a & 15) + 8, e.wbits === 0 && (e.wbits = m), m > 15 || m > e.wbits) {
+            t.msg = "invalid window size", e.mode = A;
+            break;
+          }
+          e.dmax = 1 << e.wbits, e.flags = 0, t.adler = e.check = 1, e.mode = a & 512 ? Qe : F, a = 0, c = 0;
+          break;
+        case Ve:
+          for (; c < 16; ) {
+            if (f === 0)
+              break e;
+            f--, a += i[r++] << c, c += 8;
+          }
+          if (e.flags = a, (e.flags & 255) !== He) {
+            t.msg = "unknown compression method", e.mode = A;
+            break;
+          }
+          if (e.flags & 57344) {
+            t.msg = "unknown header flags set", e.mode = A;
+            break;
+          }
+          e.head && (e.head.text = a >> 8 & 1), e.flags & 512 && e.wrap & 4 && (b[0] = a & 255, b[1] = a >>> 8 & 255, e.check = P(e.check, b, 2, 0)), a = 0, c = 0, e.mode = Ge;
+        /* falls through */
+        case Ge:
+          for (; c < 32; ) {
+            if (f === 0)
+              break e;
+            f--, a += i[r++] << c, c += 8;
+          }
+          e.head && (e.head.time = a), e.flags & 512 && e.wrap & 4 && (b[0] = a & 255, b[1] = a >>> 8 & 255, b[2] = a >>> 16 & 255, b[3] = a >>> 24 & 255, e.check = P(e.check, b, 4, 0)), a = 0, c = 0, e.mode = je;
+        /* falls through */
+        case je:
+          for (; c < 16; ) {
+            if (f === 0)
+              break e;
+            f--, a += i[r++] << c, c += 8;
+          }
+          e.head && (e.head.xflags = a & 255, e.head.os = a >> 8), e.flags & 512 && e.wrap & 4 && (b[0] = a & 255, b[1] = a >>> 8 & 255, e.check = P(e.check, b, 2, 0)), a = 0, c = 0, e.mode = Ye;
+        /* falls through */
+        case Ye:
+          if (e.flags & 1024) {
+            for (; c < 16; ) {
+              if (f === 0)
+                break e;
+              f--, a += i[r++] << c, c += 8;
+            }
+            e.length = a, e.head && (e.head.extra_len = a), e.flags & 512 && e.wrap & 4 && (b[0] = a & 255, b[1] = a >>> 8 & 255, e.check = P(e.check, b, 2, 0)), a = 0, c = 0;
+          } else e.head && (e.head.extra = null);
+          e.mode = Ke;
+        /* falls through */
+        case Ke:
+          if (e.flags & 1024 && (l = e.length, l > f && (l = f), l && (e.head && (m = e.head.extra_len - e.length, e.head.extra || (e.head.extra = new Uint8Array(e.head.extra_len)), e.head.extra.set(
+            i.subarray(
+              r,
+              // extra field is limited to 65536 bytes
+              // - no need for additional size check
+              r + l
+            ),
+            /*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/
+            m
+          )), e.flags & 512 && e.wrap & 4 && (e.check = P(e.check, i, l, r)), f -= l, r += l, e.length -= l), e.length))
+            break e;
+          e.length = 0, e.mode = We;
+        /* falls through */
+        case We:
+          if (e.flags & 2048) {
+            if (f === 0)
+              break e;
+            l = 0;
+            do
+              m = i[r + l++], e.head && m && e.length < 65536 && (e.head.name += String.fromCharCode(m));
+            while (m && l < f);
+            if (e.flags & 512 && e.wrap & 4 && (e.check = P(e.check, i, l, r)), f -= l, r += l, m)
+              break e;
+          } else e.head && (e.head.name = null);
+          e.length = 0, e.mode = Xe;
+        /* falls through */
+        case Xe:
+          if (e.flags & 4096) {
+            if (f === 0)
+              break e;
+            l = 0;
+            do
+              m = i[r + l++], e.head && m && e.length < 65536 && (e.head.comment += String.fromCharCode(m));
+            while (m && l < f);
+            if (e.flags & 512 && e.wrap & 4 && (e.check = P(e.check, i, l, r)), f -= l, r += l, m)
+              break e;
+          } else e.head && (e.head.comment = null);
+          e.mode = Je;
+        /* falls through */
+        case Je:
+          if (e.flags & 512) {
+            for (; c < 16; ) {
+              if (f === 0)
+                break e;
+              f--, a += i[r++] << c, c += 8;
+            }
+            if (e.wrap & 4 && a !== (e.check & 65535)) {
+              t.msg = "header crc mismatch", e.mode = A;
+              break;
+            }
+            a = 0, c = 0;
+          }
+          e.head && (e.head.hcrc = e.flags >> 9 & 1, e.head.done = !0), t.adler = e.check = 0, e.mode = F;
+          break;
+        case Qe:
+          for (; c < 32; ) {
+            if (f === 0)
+              break e;
+            f--, a += i[r++] << c, c += 8;
+          }
+          t.adler = e.check = ut(a), a = 0, c = 0, e.mode = ce;
+        /* falls through */
+        case ce:
+          if (e.havedict === 0)
+            return t.next_out = s, t.avail_out = u, t.next_in = r, t.avail_in = f, e.hold = a, e.bits = c, Wn;
+          t.adler = e.check = 1, e.mode = F;
+        /* falls through */
+        case F:
+          if (n === Yn || n === re)
+            break e;
+        /* falls through */
+        case me:
+          if (e.last) {
+            a >>>= c & 7, c -= c & 7, e.mode = pe;
+            break;
+          }
+          for (; c < 3; ) {
+            if (f === 0)
+              break e;
+            f--, a += i[r++] << c, c += 8;
+          }
+          switch (e.last = a & 1, a >>>= 1, c -= 1, a & 3) {
+            case 0:
+              e.mode = qe;
+              break;
+            case 1:
+              if (rr(e), e.mode = ie, n === re) {
+                a >>>= 2, c -= 2;
+                break e;
+              }
+              break;
+            case 2:
+              e.mode = tt;
+              break;
+            case 3:
+              t.msg = "invalid block type", e.mode = A;
+          }
+          a >>>= 2, c -= 2;
+          break;
+        case qe:
+          for (a >>>= c & 7, c -= c & 7; c < 32; ) {
+            if (f === 0)
+              break e;
+            f--, a += i[r++] << c, c += 8;
+          }
+          if ((a & 65535) !== (a >>> 16 ^ 65535)) {
+            t.msg = "invalid stored block lengths", e.mode = A;
+            break;
+          }
+          if (e.length = a & 65535, a = 0, c = 0, e.mode = ye, n === re)
+            break e;
+        /* falls through */
+        case ye:
+          e.mode = et;
+        /* falls through */
+        case et:
+          if (l = e.length, l) {
+            if (l > f && (l = f), l > u && (l = u), l === 0)
+              break e;
+            o.set(i.subarray(r, r + l), s), f -= l, r += l, u -= l, s += l, e.length -= l;
+            break;
+          }
+          e.mode = F;
+          break;
+        case tt:
+          for (; c < 14; ) {
+            if (f === 0)
+              break e;
+            f--, a += i[r++] << c, c += 8;
+          }
+          if (e.nlen = (a & 31) + 257, a >>>= 5, c -= 5, e.ndist = (a & 31) + 1, a >>>= 5, c -= 5, e.ncode = (a & 15) + 4, a >>>= 4, c -= 4, e.nlen > 286 || e.ndist > 30) {
+            t.msg = "too many length or distance symbols", e.mode = A;
+            break;
+          }
+          e.have = 0, e.mode = nt;
+        /* falls through */
+        case nt:
+          for (; e.have < e.ncode; ) {
+            for (; c < 3; ) {
+              if (f === 0)
+                break e;
+              f--, a += i[r++] << c, c += 8;
+            }
+            e.lens[T[e.have++]] = a & 7, a >>>= 3, c -= 3;
+          }
+          for (; e.have < 19; )
+            e.lens[T[e.have++]] = 0;
+          if (e.lencode = e.lendyn, e.lenbits = 7, p = { bits: e.lenbits }, S = J(jn, e.lens, 0, 19, e.lencode, 0, e.work, p), e.lenbits = p.bits, S) {
+            t.msg = "invalid code lengths set", e.mode = A;
+            break;
+          }
+          e.have = 0, e.mode = rt;
+        /* falls through */
+        case rt:
+          for (; e.have < e.nlen + e.ndist; ) {
+            for (; _ = e.lencode[a & (1 << e.lenbits) - 1], k = _ >>> 24, x = _ >>> 16 & 255, I = _ & 65535, !(k <= c); ) {
+              if (f === 0)
+                break e;
+              f--, a += i[r++] << c, c += 8;
+            }
+            if (I < 16)
+              a >>>= k, c -= k, e.lens[e.have++] = I;
+            else {
+              if (I === 16) {
+                for (y = k + 2; c < y; ) {
+                  if (f === 0)
+                    break e;
+                  f--, a += i[r++] << c, c += 8;
+                }
+                if (a >>>= k, c -= k, e.have === 0) {
+                  t.msg = "invalid bit length repeat", e.mode = A;
+                  break;
+                }
+                m = e.lens[e.have - 1], l = 3 + (a & 3), a >>>= 2, c -= 2;
+              } else if (I === 17) {
+                for (y = k + 3; c < y; ) {
+                  if (f === 0)
+                    break e;
+                  f--, a += i[r++] << c, c += 8;
+                }
+                a >>>= k, c -= k, m = 0, l = 3 + (a & 7), a >>>= 3, c -= 3;
+              } else {
+                for (y = k + 7; c < y; ) {
+                  if (f === 0)
+                    break e;
+                  f--, a += i[r++] << c, c += 8;
+                }
+                a >>>= k, c -= k, m = 0, l = 11 + (a & 127), a >>>= 7, c -= 7;
+              }
+              if (e.have + l > e.nlen + e.ndist) {
+                t.msg = "invalid bit length repeat", e.mode = A;
+                break;
+              }
+              for (; l--; )
+                e.lens[e.have++] = m;
+            }
+          }
+          if (e.mode === A)
+            break;
+          if (e.lens[256] === 0) {
+            t.msg = "invalid code -- missing end-of-block", e.mode = A;
+            break;
+          }
+          if (e.lenbits = 9, p = { bits: e.lenbits }, S = J(Ot, e.lens, 0, e.nlen, e.lencode, 0, e.work, p), e.lenbits = p.bits, S) {
+            t.msg = "invalid literal/lengths set", e.mode = A;
+            break;
+          }
+          if (e.distbits = 6, e.distcode = e.distdyn, p = { bits: e.distbits }, S = J(Bt, e.lens, e.nlen, e.ndist, e.distcode, 0, e.work, p), e.distbits = p.bits, S) {
+            t.msg = "invalid distances set", e.mode = A;
+            break;
+          }
+          if (e.mode = ie, n === re)
+            break e;
+        /* falls through */
+        case ie:
+          e.mode = oe;
+        /* falls through */
+        case oe:
+          if (f >= 6 && u >= 258) {
+            t.next_out = s, t.avail_out = u, t.next_in = r, t.avail_in = f, e.hold = a, e.bits = c, zn(t, d), s = t.next_out, o = t.output, u = t.avail_out, r = t.next_in, i = t.input, f = t.avail_in, a = e.hold, c = e.bits, e.mode === F && (e.back = -1);
+            break;
+          }
+          for (e.back = 0; _ = e.lencode[a & (1 << e.lenbits) - 1], k = _ >>> 24, x = _ >>> 16 & 255, I = _ & 65535, !(k <= c); ) {
+            if (f === 0)
+              break e;
+            f--, a += i[r++] << c, c += 8;
+          }
+          if (x && !(x & 240)) {
+            for (g = k, E = x, O = I; _ = e.lencode[O + ((a & (1 << g + E) - 1) >> g)], k = _ >>> 24, x = _ >>> 16 & 255, I = _ & 65535, !(g + k <= c); ) {
+              if (f === 0)
+                break e;
+              f--, a += i[r++] << c, c += 8;
+            }
+            a >>>= g, c -= g, e.back += g;
+          }
+          if (a >>>= k, c -= k, e.back += k, e.length = I, x === 0) {
+            e.mode = ct;
+            break;
+          }
+          if (x & 32) {
+            e.back = -1, e.mode = F;
+            break;
+          }
+          if (x & 64) {
+            t.msg = "invalid literal/length code", e.mode = A;
+            break;
+          }
+          e.extra = x & 15, e.mode = it;
+        /* falls through */
+        case it:
+          if (e.extra) {
+            for (y = e.extra; c < y; ) {
+              if (f === 0)
+                break e;
+              f--, a += i[r++] << c, c += 8;
+            }
+            e.length += a & (1 << e.extra) - 1, a >>>= e.extra, c -= e.extra, e.back += e.extra;
+          }
+          e.was = e.length, e.mode = ot;
+        /* falls through */
+        case ot:
+          for (; _ = e.distcode[a & (1 << e.distbits) - 1], k = _ >>> 24, x = _ >>> 16 & 255, I = _ & 65535, !(k <= c); ) {
+            if (f === 0)
+              break e;
+            f--, a += i[r++] << c, c += 8;
+          }
+          if (!(x & 240)) {
+            for (g = k, E = x, O = I; _ = e.distcode[O + ((a & (1 << g + E) - 1) >> g)], k = _ >>> 24, x = _ >>> 16 & 255, I = _ & 65535, !(g + k <= c); ) {
+              if (f === 0)
+                break e;
+              f--, a += i[r++] << c, c += 8;
+            }
+            a >>>= g, c -= g, e.back += g;
+          }
+          if (a >>>= k, c -= k, e.back += k, x & 64) {
+            t.msg = "invalid distance code", e.mode = A;
+            break;
+          }
+          e.offset = I, e.extra = x & 15, e.mode = at;
+        /* falls through */
+        case at:
+          if (e.extra) {
+            for (y = e.extra; c < y; ) {
+              if (f === 0)
+                break e;
+              f--, a += i[r++] << c, c += 8;
+            }
+            e.offset += a & (1 << e.extra) - 1, a >>>= e.extra, c -= e.extra, e.back += e.extra;
+          }
+          if (e.offset > e.dmax) {
+            t.msg = "invalid distance too far back", e.mode = A;
+            break;
+          }
+          e.mode = st;
+        /* falls through */
+        case st:
+          if (u === 0)
+            break e;
+          if (l = d - u, e.offset > l) {
+            if (l = e.offset - l, l > e.whave && e.sane) {
+              t.msg = "invalid distance too far back", e.mode = A;
+              break;
+            }
+            l > e.wnext ? (l -= e.wnext, h = e.wsize - l) : h = e.wnext - l, l > e.length && (l = e.length), w = e.window;
+          } else
+            w = o, h = s - e.offset, l = e.length;
+          l > u && (l = u), u -= l, e.length -= l;
+          do
+            o[s++] = w[h++];
+          while (--l);
+          e.length === 0 && (e.mode = oe);
+          break;
+        case ct:
+          if (u === 0)
+            break e;
+          o[s++] = e.length, u--, e.mode = oe;
+          break;
+        case pe:
+          if (e.wrap) {
+            for (; c < 32; ) {
+              if (f === 0)
+                break e;
+              f--, a |= i[r++] << c, c += 8;
+            }
+            if (d -= u, t.total_out += d, e.total += d, e.wrap & 4 && d && (t.adler = e.check = /*UPDATE_CHECK(state.check, put - _out, _out);*/
+            e.flags ? P(e.check, o, d, s - d) : Be(e.check, o, d, s - d)), d = u, e.wrap & 4 && (e.flags ? a : ut(a)) !== e.check) {
+              t.msg = "incorrect data check", e.mode = A;
+              break;
+            }
+            a = 0, c = 0;
+          }
+          e.mode = ft;
+        /* falls through */
+        case ft:
+          if (e.wrap && e.flags) {
+            for (; c < 32; ) {
+              if (f === 0)
+                break e;
+              f--, a += i[r++] << c, c += 8;
+            }
+            if (e.wrap & 4 && a !== (e.total & 4294967295)) {
+              t.msg = "incorrect length check", e.mode = A;
+              break;
+            }
+            a = 0, c = 0;
+          }
+          e.mode = lt;
+        /* falls through */
+        case lt:
+          S = Kn;
+          break e;
+        case A:
+          S = At;
+          break e;
+        case Ut:
+          return Tt;
+        case Rt:
+        /* falls through */
+        default:
+          return C;
+      }
+  return t.next_out = s, t.avail_out = u, t.next_in = r, t.avail_in = f, e.hold = a, e.bits = c, (e.wsize || d !== t.avail_out && e.mode < A && (e.mode < pe || n !== $e)) && Pt(t, t.output, t.next_out, d - t.avail_out), v -= t.avail_in, d -= t.avail_out, t.total_in += v, t.total_out += d, e.total += d, e.wrap & 4 && d && (t.adler = e.check = /*UPDATE_CHECK(state.check, strm.next_out - _out, _out);*/
+  e.flags ? P(e.check, o, d, t.next_out - d) : Be(e.check, o, d, t.next_out - d)), t.data_type = e.bits + (e.last ? 64 : 0) + (e.mode === F ? 128 : 0) + (e.mode === ie || e.mode === ye ? 256 : 0), (v === 0 && d === 0 || n === $e) && S === H && (S = Xn), S;
+}, or = (t) => {
+  if (V(t))
+    return C;
+  let n = t.state;
+  return n.window && (n.window = null), t.state = null, H;
+}, ar = (t, n) => {
+  if (V(t))
+    return C;
+  const e = t.state;
+  return e.wrap & 2 ? (e.head = n, n.done = !1, H) : C;
+}, sr = (t, n) => {
+  const e = n.length;
+  let i, o, r;
+  return V(t) || (i = t.state, i.wrap !== 0 && i.mode !== ce) ? C : i.mode === ce && (o = 1, o = Be(o, n, e, 0), o !== i.check) ? At : (r = Pt(t, n, e, e), r ? (i.mode = Ut, Tt) : (i.havedict = 1, H));
+};
+var cr = Nt, fr = Ct, lr = Dt, ur = nr, hr = Lt, dr = ir, br = or, gr = ar, wr = sr, mr = "pako inflate (from Nodeca project)", M = {
+  inflateReset: cr,
+  inflateReset2: fr,
+  inflateResetKeep: lr,
+  inflateInit: ur,
+  inflateInit2: hr,
+  inflate: dr,
+  inflateEnd: br,
+  inflateGetHeader: gr,
+  inflateSetDictionary: wr,
+  inflateInfo: mr
+};
+function yr() {
+  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 pr = yr;
+const Ft = Object.prototype.toString, {
+  Z_NO_FLUSH: vr,
+  Z_FINISH: _r,
+  Z_OK: q,
+  Z_STREAM_END: ke,
+  Z_NEED_DICT: xe,
+  Z_STREAM_ERROR: kr,
+  Z_DATA_ERROR: dt,
+  Z_MEM_ERROR: xr
+} = Et;
+function ue(t) {
+  this.options = St.assign({
+    chunkSize: 1024 * 64,
+    windowBits: 15,
+    to: ""
+  }, t || {});
+  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 && !(t && t.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 Fn(), this.strm.avail_out = 0;
+  let e = M.inflateInit2(
+    this.strm,
+    n.windowBits
+  );
+  if (e !== q)
+    throw new Error(Ae[e]);
+  if (this.header = new pr(), M.inflateGetHeader(this.strm, this.header), n.dictionary && (typeof n.dictionary == "string" ? n.dictionary = Te.string2buf(n.dictionary) : Ft.call(n.dictionary) === "[object ArrayBuffer]" && (n.dictionary = new Uint8Array(n.dictionary)), n.raw && (e = M.inflateSetDictionary(this.strm, n.dictionary), e !== q)))
+    throw new Error(Ae[e]);
+}
+ue.prototype.push = function(t, n) {
+  const e = this.strm, i = this.options.chunkSize, o = this.options.dictionary;
+  let r, s, f;
+  if (this.ended) return !1;
+  for (n === ~~n ? s = n : s = n === !0 ? _r : vr, Ft.call(t) === "[object ArrayBuffer]" ? e.input = new Uint8Array(t) : e.input = t, e.next_in = 0, e.avail_in = e.input.length; ; ) {
+    for (e.avail_out === 0 && (e.output = new Uint8Array(i), e.next_out = 0, e.avail_out = i), r = M.inflate(e, s), r === xe && o && (r = M.inflateSetDictionary(e, o), r === q ? r = M.inflate(e, s) : r === dt && (r = xe)); e.avail_in > 0 && r === ke && e.state.wrap > 0 && t[e.next_in] !== 0; )
+      M.inflateReset(e), r = M.inflate(e, s);
+    switch (r) {
+      case kr:
+      case dt:
+      case xe:
+      case xr:
+        return this.onEnd(r), this.ended = !0, !1;
+    }
+    if (f = e.avail_out, e.next_out && (e.avail_out === 0 || r === ke))
+      if (this.options.to === "string") {
+        let u = Te.utf8border(e.output, e.next_out), a = e.next_out - u, c = Te.buf2string(e.output, u);
+        e.next_out = a, e.avail_out = i - a, a && e.output.set(e.output.subarray(u, u + a), 0), this.onData(c);
+      } else
+        this.onData(e.output.length === e.next_out ? e.output : e.output.subarray(0, e.next_out));
+    if (!(r === q && f === 0)) {
+      if (r === ke)
+        return r = M.inflateEnd(this.strm), this.onEnd(r), this.ended = !0, !0;
+      if (e.avail_in === 0) break;
+    }
+  }
+  return !0;
+};
+ue.prototype.onData = function(t) {
+  this.chunks.push(t);
+};
+ue.prototype.onEnd = function(t) {
+  t === q && (this.options.to === "string" ? this.result = this.chunks.join("") : this.result = St.flattenChunks(this.chunks)), this.chunks = [], this.err = t, this.msg = this.strm.msg;
+};
+function Er(t, n) {
+  const e = new ue(n);
+  if (e.push(t), e.err) throw e.msg || Ae[e.err];
+  return e.result;
+}
+function Sr(t, n) {
+  return n = n || {}, n.raw = !0, Er(t, n);
+}
+var Ir = Sr, Or = {
+  inflateRaw: Ir
+};
+const { inflateRaw: Br } = Or;
+var Ar = Br;
+function Tr(t) {
+  return Ar(t.subarray(2));
+}
+class Ur extends Error {
+  constructor(n) {
+    super(n), this.code = "ERR_ABORTED";
+  }
+}
+function Rr(t) {
+  t.sort((o, r) => o.offset - r.offset);
+  const n = [];
+  let e, i;
+  for (const o of t)
+    e && i && o.offset - i <= 2e3 ? (e.length = e.length + o.length - i + o.offset, e.blocks.push(o)) : n.push(e = {
+      blocks: [o],
+      length: o.length,
+      offset: o.offset
+    }), i = e.offset + e.length;
+  return n;
+}
+function ae(t) {
+  if (t && t.aborted)
+    if (typeof DOMException > "u") {
+      const n = new Ur("aborted");
+      throw n.code = "ERR_ABORTED", n;
+    } else
+      throw new DOMException("aborted", "AbortError");
+}
+const Ee = typeof TextDecoder < "u" ? new TextDecoder("utf8") : void 0;
+function Se(t, n, e, i) {
+  return t < i && n >= e;
+}
+class Mt {
+  constructor(n, e, i, o, r, s) {
+    if (this.bbi = n, this.refsByName = e, this.cirTreeOffset = i, this.isBigEndian = o, this.isCompressed = r, this.blockType = s, this.featureCache = new pt({
+      cache: new vt({ maxSize: 1e3 }),
+      fill: async (f, u) => {
+        const a = f.length, c = f.offset, { buffer: v } = await this.bbi.read(z.Buffer.alloc(a), 0, a, c, {
+          signal: u
+        });
+        return v;
+      }
+    }), !(i >= 0))
+      throw new Error("invalid cirTreeOffset!");
+  }
+  async readWigData(n, e, i, o, r) {
+    try {
+      const { refsByName: s, bbi: f, cirTreeOffset: u, isBigEndian: a } = this, c = s[n];
+      c === void 0 && o.complete();
+      const v = { chrId: c, start: e, end: i };
+      this.cirTreePromise || (this.cirTreePromise = f.read(z.Buffer.alloc(48), 0, 48, u, r));
+      const { buffer: d } = await this.cirTreePromise, l = a ? d.readUInt32BE(4) : d.readUInt32LE(4);
+      let h = [], w = 0;
+      const _ = !0, k = (E, O, m) => {
+        try {
+          const b = E.subarray(O), p = new DataView(b.buffer, b.byteOffset, b.length);
+          let y = 0;
+          const T = p.getUint8(y);
+          y += 2;
+          const D = p.getUint16(y, _);
+          if (y += 2, T === 1) {
+            const U = [];
+            for (let B = 0; B < D; B++) {
+              const N = p.getUint32(y, _);
+              y += 4;
+              const Z = p.getUint32(y, _);
+              y += 4;
+              const he = p.getUint32(y, _);
+              y += 4;
+              const de = p.getUint32(y, _);
+              y += 4;
+              const be = Number(p.getBigUint64(y, _));
+              y += 8;
+              const ge = Number(p.getBigUint64(y, _));
+              y += 8, U.push({
+                startChrom: N,
+                startBase: Z,
+                endBase: de,
+                endChrom: he,
+                blockOffset: be,
+                blockSize: ge,
+                offset: y
+              });
+            }
+            h = h.concat(U.filter((B) => x(B)).map((B) => ({
+              offset: B.blockOffset,
+              length: B.blockSize
+            })));
+          } else if (T === 0) {
+            const U = [];
+            for (let N = 0; N < D; N++) {
+              const Z = p.getUint32(y, _);
+              y += 4;
+              const he = p.getUint32(y, _);
+              y += 4;
+              const de = p.getUint32(y, _);
+              y += 4;
+              const be = p.getUint32(y, _);
+              y += 4;
+              const ge = Number(p.getBigUint64(y, _));
+              y += 8, U.push({
+                startChrom: Z,
+                startBase: he,
+                endChrom: de,
+                endBase: be,
+                blockOffset: ge,
+                offset: y
+              });
+            }
+            const B = U.filter((N) => x(N)).map((N) => N.blockOffset);
+            B.length > 0 && g(B, m + 1);
+          }
+        } catch (S) {
+          o.error(S);
+        }
+      }, x = (E) => {
+        const { startChrom: O, startBase: m, endChrom: S, endBase: b } = E;
+        return (O < c || O === c && m <= i) && (S > c || S === c && b >= e);
+      }, I = async (E, O, m) => {
+        try {
+          const S = O.max - O.min, b = O.min, p = await this.featureCache.get(`${S}_${b}`, { length: S, offset: b }, r == null ? void 0 : r.signal);
+          for (const y of E)
+            O.contains(y) && (k(p, y - b, m), w -= 1, w === 0 && this.readFeatures(o, h, {
+              ...r,
+              request: v
+            }).catch((T) => {
+              o.error(T);
+            }));
+        } catch (S) {
+          o.error(S);
+        }
+      }, g = (E, O) => {
+        try {
+          w += E.length;
+          const m = 4 + l * 32;
+          let S = new j([
+            {
+              min: E[0],
+              max: E[0] + m
+            }
+          ]);
+          for (let b = 1; b < E.length; b += 1) {
+            const p = new j([
+              {
+                min: E[b],
+                max: E[b] + m
+              }
+            ]);
+            S = S.union(p);
+          }
+          S.getRanges().map((b) => I(E, b, O));
+        } catch (m) {
+          o.error(m);
+        }
+      };
+      g([Number(u) + 48], 1);
+      return;
+    } catch (s) {
+      o.error(s);
+    }
+  }
+  parseSummaryBlock(n, e, i) {
+    const o = [];
+    let r = e;
+    const s = new DataView(n.buffer, n.byteOffset, n.length);
+    for (; r < n.byteLength; ) {
+      const f = s.getUint32(r, !0);
+      r += 4;
+      const u = s.getUint32(r, !0);
+      r += 4;
+      const a = s.getUint32(r, !0);
+      r += 4;
+      const c = s.getUint32(r, !0);
+      r += 4;
+      const v = s.getFloat32(r, !0);
+      r += 4;
+      const d = s.getFloat32(r, !0);
+      r += 4;
+      const l = s.getFloat32(r, !0);
+      r += 4, r += 4, (!i || f === i.chrId && Se(u, a, i.start, i.end)) && o.push({
+        start: u,
+        end: a,
+        maxScore: d,
+        minScore: v,
+        summary: !0,
+        score: l / (c || 1)
+      });
+    }
+    return o;
+  }
+  parseBigBedBlock(n, e, i, o) {
+    var r;
+    const s = [];
+    let f = e;
+    const u = !0, a = n, c = new DataView(a.buffer, a.byteOffset, a.length);
+    for (; f < n.byteLength; ) {
+      const v = f, d = c.getUint32(f, u);
+      f += 4;
+      const l = c.getInt32(f, u);
+      f += 4;
+      const h = c.getInt32(f, u);
+      f += 4;
+      let w = f;
+      for (; w < n.length && n[w] !== 0; w++)
+        ;
+      const _ = n.subarray(f, w), k = (r = Ee == null ? void 0 : Ee.decode(_)) !== null && r !== void 0 ? r : _.toString();
+      f = w + 1, s.push({
+        chromId: d,
+        start: l,
+        end: h,
+        rest: k,
+        uniqueId: `bb-${i + v}`
+      });
+    }
+    return o ? s.filter((v) => Se(v.start, v.end, o.start, o.end)) : s;
+  }
+  parseBigWigBlock(n, e, i) {
+    const o = n.subarray(e), r = new DataView(o.buffer, o.byteOffset, o.length);
+    let s = 0;
+    s += 4;
+    const f = r.getInt32(s, !0);
+    s += 8;
+    const u = r.getUint32(s, !0);
+    s += 4;
+    const a = r.getUint32(s, !0);
+    s += 4;
+    const c = r.getUint8(s);
+    s += 2;
+    const v = r.getUint16(s, !0);
+    s += 2;
+    const d = new Array(v);
+    switch (c) {
+      case 1: {
+        for (let l = 0; l < v; l++) {
+          const h = r.getInt32(s, !0);
+          s += 4;
+          const w = r.getInt32(s, !0);
+          s += 4;
+          const _ = r.getFloat32(s, !0);
+          s += 4, d[l] = {
+            start: h,
+            end: w,
+            score: _
+          };
+        }
+        break;
+      }
+      case 2: {
+        for (let l = 0; l < v; l++) {
+          const h = r.getInt32(s, !0);
+          s += 4;
+          const w = r.getFloat32(s, !0);
+          s += 4, d[l] = {
+            score: w,
+            start: h,
+            end: h + a
+          };
+        }
+        break;
+      }
+      case 3: {
+        for (let l = 0; l < v; l++) {
+          const h = r.getFloat32(s, !0);
+          s += 4;
+          const w = f + l * u;
+          d[l] = {
+            score: h,
+            start: w,
+            end: w + a
+          };
+        }
+        break;
+      }
+    }
+    return i ? d.filter((l) => Se(l.start, l.end, i.start, i.end)) : d;
+  }
+  async readFeatures(n, e, i = {}) {
+    try {
+      const { blockType: o, isCompressed: r } = this, { signal: s, request: f } = i, u = Rr(e);
+      ae(s), await Promise.all(u.map(async (a) => {
+        ae(s);
+        const { length: c, offset: v } = a, d = await this.featureCache.get(`${c}_${v}`, a, s);
+        for (const l of a.blocks) {
+          ae(s);
+          let h = Number(l.offset) - Number(a.offset), w = d;
+          switch (r && (w = Tr(d.subarray(h)), h = 0), ae(s), o) {
+            case "summary": {
+              n.next(this.parseSummaryBlock(w, h, f));
+              break;
+            }
+            case "bigwig": {
+              n.next(this.parseBigWigBlock(w, h, f));
+              break;
+            }
+            case "bigbed": {
+              n.next(this.parseBigBedBlock(w, h, Number(l.offset) * 256, f));
+              break;
+            }
+            default:
+              console.warn(`Don't know what to do with ${o}`);
+          }
+        }
+      })), n.complete();
+    } catch (o) {
+      n.error(o);
+    }
+  }
+}
+var Ue = function(t, n) {
+  return Ue = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(e, i) {
+    e.__proto__ = i;
+  } || function(e, i) {
+    for (var o in i) Object.prototype.hasOwnProperty.call(i, o) && (e[o] = i[o]);
+  }, Ue(t, n);
+};
+function Ne(t, n) {
+  if (typeof n != "function" && n !== null)
+    throw new TypeError("Class extends value " + String(n) + " is not a constructor or null");
+  Ue(t, n);
+  function e() {
+    this.constructor = t;
+  }
+  t.prototype = n === null ? Object.create(n) : (e.prototype = n.prototype, new e());
+}
+function Dr(t, n, e, i) {
+  function o(r) {
+    return r instanceof e ? r : new e(function(s) {
+      s(r);
+    });
+  }
+  return new (e || (e = Promise))(function(r, s) {
+    function f(c) {
+      try {
+        a(i.next(c));
+      } catch (v) {
+        s(v);
+      }
+    }
+    function u(c) {
+      try {
+        a(i.throw(c));
+      } catch (v) {
+        s(v);
+      }
+    }
+    function a(c) {
+      c.done ? r(c.value) : o(c.value).then(f, u);
+    }
+    a((i = i.apply(t, n || [])).next());
+  });
+}
+function zt(t, n) {
+  var e = { label: 0, sent: function() {
+    if (r[0] & 1) throw r[1];
+    return r[1];
+  }, trys: [], ops: [] }, i, o, r, s = Object.create((typeof Iterator == "function" ? Iterator : Object).prototype);
+  return s.next = f(0), s.throw = f(1), s.return = f(2), typeof Symbol == "function" && (s[Symbol.iterator] = function() {
+    return this;
+  }), s;
+  function f(a) {
+    return function(c) {
+      return u([a, c]);
+    };
+  }
+  function u(a) {
+    if (i) throw new TypeError("Generator is already executing.");
+    for (; s && (s = 0, a[0] && (e = 0)), e; ) try {
+      if (i = 1, o && (r = a[0] & 2 ? o.return : a[0] ? o.throw || ((r = o.return) && r.call(o), 0) : o.next) && !(r = r.call(o, a[1])).done) return r;
+      switch (o = 0, r && (a = [a[0] & 2, r.value]), a[0]) {
+        case 0:
+        case 1:
+          r = a;
+          break;
+        case 4:
+          return e.label++, { value: a[1], done: !1 };
+        case 5:
+          e.label++, o = a[1], a = [0];
+          continue;
+        case 7:
+          a = e.ops.pop(), e.trys.pop();
+          continue;
+        default:
+          if (r = e.trys, !(r = r.length > 0 && r[r.length - 1]) && (a[0] === 6 || a[0] === 2)) {
+            e = 0;
+            continue;
+          }
+          if (a[0] === 3 && (!r || a[1] > r[0] && a[1] < r[3])) {
+            e.label = a[1];
+            break;
+          }
+          if (a[0] === 6 && e.label < r[1]) {
+            e.label = r[1], r = a;
+            break;
+          }
+          if (r && e.label < r[2]) {
+            e.label = r[2], e.ops.push(a);
+            break;
+          }
+          r[2] && e.ops.pop(), e.trys.pop();
+          continue;
+      }
+      a = n.call(t, e);
+    } catch (c) {
+      a = [6, c], o = 0;
+    } finally {
+      i = r = 0;
+    }
+    if (a[0] & 5) throw a[1];
+    return { value: a[0] ? a[1] : void 0, done: !0 };
+  }
+}
+function ee(t) {
+  var n = typeof Symbol == "function" && Symbol.iterator, e = n && t[n], i = 0;
+  if (e) return e.call(t);
+  if (t && typeof t.length == "number") return {
+    next: function() {
+      return t && i >= t.length && (t = void 0), { value: t && t[i++], done: !t };
+    }
+  };
+  throw new TypeError(n ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function Re(t, n) {
+  var e = typeof Symbol == "function" && t[Symbol.iterator];
+  if (!e) return t;
+  var i = e.call(t), o, r = [], s;
+  try {
+    for (; (n === void 0 || n-- > 0) && !(o = i.next()).done; ) r.push(o.value);
+  } catch (f) {
+    s = { error: f };
+  } finally {
+    try {
+      o && !o.done && (e = i.return) && e.call(i);
+    } finally {
+      if (s) throw s.error;
+    }
+  }
+  return r;
+}
+function De(t, n, e) {
+  if (e || arguments.length === 2) for (var i = 0, o = n.length, r; i < o; i++)
+    (r || !(i in n)) && (r || (r = Array.prototype.slice.call(n, 0, i)), r[i] = n[i]);
+  return t.concat(r || Array.prototype.slice.call(n));
+}
+function Y(t) {
+  return this instanceof Y ? (this.v = t, this) : new Y(t);
+}
+function Nr(t, n, e) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var i = e.apply(t, n || []), o, r = [];
+  return o = Object.create((typeof AsyncIterator == "function" ? AsyncIterator : Object).prototype), f("next"), f("throw"), f("return", s), o[Symbol.asyncIterator] = function() {
+    return this;
+  }, o;
+  function s(l) {
+    return function(h) {
+      return Promise.resolve(h).then(l, v);
+    };
+  }
+  function f(l, h) {
+    i[l] && (o[l] = function(w) {
+      return new Promise(function(_, k) {
+        r.push([l, w, _, k]) > 1 || u(l, w);
+      });
+    }, h && (o[l] = h(o[l])));
+  }
+  function u(l, h) {
+    try {
+      a(i[l](h));
+    } catch (w) {
+      d(r[0][3], w);
+    }
+  }
+  function a(l) {
+    l.value instanceof Y ? Promise.resolve(l.value.v).then(c, v) : d(r[0][2], l);
+  }
+  function c(l) {
+    u("next", l);
+  }
+  function v(l) {
+    u("throw", l);
+  }
+  function d(l, h) {
+    l(h), r.shift(), r.length && u(r[0][0], r[0][1]);
+  }
+}
+function Cr(t) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var n = t[Symbol.asyncIterator], e;
+  return n ? n.call(t) : (t = typeof ee == "function" ? ee(t) : t[Symbol.iterator](), e = {}, i("next"), i("throw"), i("return"), e[Symbol.asyncIterator] = function() {
+    return this;
+  }, e);
+  function i(r) {
+    e[r] = t[r] && function(s) {
+      return new Promise(function(f, u) {
+        s = t[r](s), o(f, u, s.done, s.value);
+      });
+    };
+  }
+  function o(r, s, f, u) {
+    Promise.resolve(u).then(function(a) {
+      r({ value: a, done: f });
+    }, s);
+  }
+}
+function R(t) {
+  return typeof t == "function";
+}
+function Zt(t) {
+  var n = function(i) {
+    Error.call(i), i.stack = new Error().stack;
+  }, e = t(n);
+  return e.prototype = Object.create(Error.prototype), e.prototype.constructor = e, e;
+}
+var Ie = Zt(function(t) {
+  return function(e) {
+    t(this), this.message = e ? e.length + ` errors occurred during unsubscription:
+` + e.map(function(i, o) {
+      return o + 1 + ") " + i.toString();
+    }).join(`
+  `) : "", this.name = "UnsubscriptionError", this.errors = e;
+  };
+});
+function bt(t, n) {
+  if (t) {
+    var e = t.indexOf(n);
+    0 <= e && t.splice(e, 1);
+  }
+}
+var Ce = function() {
+  function t(n) {
+    this.initialTeardown = n, this.closed = !1, this._parentage = null, this._finalizers = null;
+  }
+  return t.prototype.unsubscribe = function() {
+    var n, e, i, o, r;
+    if (!this.closed) {
+      this.closed = !0;
+      var s = this._parentage;
+      if (s)
+        if (this._parentage = null, Array.isArray(s))
+          try {
+            for (var f = ee(s), u = f.next(); !u.done; u = f.next()) {
+              var a = u.value;
+              a.remove(this);
+            }
+          } catch (w) {
+            n = { error: w };
+          } finally {
+            try {
+              u && !u.done && (e = f.return) && e.call(f);
+            } finally {
+              if (n) throw n.error;
+            }
+          }
+        else
+          s.remove(this);
+      var c = this.initialTeardown;
+      if (R(c))
+        try {
+          c();
+        } catch (w) {
+          r = w instanceof Ie ? w.errors : [w];
+        }
+      var v = this._finalizers;
+      if (v) {
+        this._finalizers = null;
+        try {
+          for (var d = ee(v), l = d.next(); !l.done; l = d.next()) {
+            var h = l.value;
+            try {
+              gt(h);
+            } catch (w) {
+              r = r ?? [], w instanceof Ie ? r = De(De([], Re(r)), Re(w.errors)) : r.push(w);
+            }
+          }
+        } catch (w) {
+          i = { error: w };
+        } finally {
+          try {
+            l && !l.done && (o = d.return) && o.call(d);
+          } finally {
+            if (i) throw i.error;
+          }
+        }
+      }
+      if (r)
+        throw new Ie(r);
+    }
+  }, t.prototype.add = function(n) {
+    var e;
+    if (n && n !== this)
+      if (this.closed)
+        gt(n);
+      else {
+        if (n instanceof t) {
+          if (n.closed || n._hasParent(this))
+            return;
+          n._addParent(this);
+        }
+        (this._finalizers = (e = this._finalizers) !== null && e !== void 0 ? e : []).push(n);
+      }
+  }, t.prototype._hasParent = function(n) {
+    var e = this._parentage;
+    return e === n || Array.isArray(e) && e.includes(n);
+  }, t.prototype._addParent = function(n) {
+    var e = this._parentage;
+    this._parentage = Array.isArray(e) ? (e.push(n), e) : e ? [e, n] : n;
+  }, t.prototype._removeParent = function(n) {
+    var e = this._parentage;
+    e === n ? this._parentage = null : Array.isArray(e) && bt(e, n);
+  }, t.prototype.remove = function(n) {
+    var e = this._finalizers;
+    e && bt(e, n), n instanceof t && n._removeParent(this);
+  }, t.EMPTY = function() {
+    var n = new t();
+    return n.closed = !0, n;
+  }(), t;
+}();
+Ce.EMPTY;
+function $t(t) {
+  return t instanceof Ce || t && "closed" in t && R(t.remove) && R(t.add) && R(t.unsubscribe);
+}
+function gt(t) {
+  R(t) ? t() : t.unsubscribe();
+}
+var Lr = {
+  Promise: void 0
+}, Pr = {
+  setTimeout: function(t, n) {
+    for (var e = [], i = 2; i < arguments.length; i++)
+      e[i - 2] = arguments[i];
+    return setTimeout.apply(void 0, De([t, n], Re(e)));
+  },
+  clearTimeout: function(t) {
+    return clearTimeout(t);
+  },
+  delegate: void 0
+};
+function Ht(t) {
+  Pr.setTimeout(function() {
+    throw t;
+  });
+}
+function wt() {
+}
+function Fr(t) {
+  t();
+}
+var Le = function(t) {
+  Ne(n, t);
+  function n(e) {
+    var i = t.call(this) || this;
+    return i.isStopped = !1, e ? (i.destination = e, $t(e) && e.add(i)) : i.destination = Zr, i;
+  }
+  return n.create = function(e, i, o) {
+    return new fe(e, i, o);
+  }, n.prototype.next = function(e) {
+    this.isStopped || this._next(e);
+  }, n.prototype.error = function(e) {
+    this.isStopped || (this.isStopped = !0, this._error(e));
+  }, n.prototype.complete = function() {
+    this.isStopped || (this.isStopped = !0, this._complete());
+  }, n.prototype.unsubscribe = function() {
+    this.closed || (this.isStopped = !0, t.prototype.unsubscribe.call(this), this.destination = null);
+  }, n.prototype._next = function(e) {
+    this.destination.next(e);
+  }, n.prototype._error = function(e) {
+    try {
+      this.destination.error(e);
+    } finally {
+      this.unsubscribe();
+    }
+  }, n.prototype._complete = function() {
+    try {
+      this.destination.complete();
+    } finally {
+      this.unsubscribe();
+    }
+  }, n;
+}(Ce), Mr = function() {
+  function t(n) {
+    this.partialObserver = n;
+  }
+  return t.prototype.next = function(n) {
+    var e = this.partialObserver;
+    if (e.next)
+      try {
+        e.next(n);
+      } catch (i) {
+        se(i);
+      }
+  }, t.prototype.error = function(n) {
+    var e = this.partialObserver;
+    if (e.error)
+      try {
+        e.error(n);
+      } catch (i) {
+        se(i);
+      }
+    else
+      se(n);
+  }, t.prototype.complete = function() {
+    var n = this.partialObserver;
+    if (n.complete)
+      try {
+        n.complete();
+      } catch (e) {
+        se(e);
+      }
+  }, t;
+}(), fe = function(t) {
+  Ne(n, t);
+  function n(e, i, o) {
+    var r = t.call(this) || this, s;
+    return R(e) || !e ? s = {
+      next: e ?? void 0,
+      error: i ?? void 0,
+      complete: o ?? void 0
+    } : s = e, r.destination = new Mr(s), r;
+  }
+  return n;
+}(Le);
+function se(t) {
+  Ht(t);
+}
+function zr(t) {
+  throw t;
+}
+var Zr = {
+  closed: !0,
+  next: wt,
+  error: zr,
+  complete: wt
+}, Pe = function() {
+  return typeof Symbol == "function" && Symbol.observable || "@@observable";
+}();
+function Vt(t) {
+  return t;
+}
+function $r(t) {
+  return t.length === 0 ? Vt : t.length === 1 ? t[0] : function(e) {
+    return t.reduce(function(i, o) {
+      return o(i);
+    }, e);
+  };
+}
+var L = function() {
+  function t(n) {
+    n && (this._subscribe = n);
+  }
+  return t.prototype.lift = function(n) {
+    var e = new t();
+    return e.source = this, e.operator = n, e;
+  }, t.prototype.subscribe = function(n, e, i) {
+    var o = this, r = Vr(n) ? n : new fe(n, e, i);
+    return Fr(function() {
+      var s = o, f = s.operator, u = s.source;
+      r.add(f ? f.call(r, u) : u ? o._subscribe(r) : o._trySubscribe(r));
+    }), r;
+  }, t.prototype._trySubscribe = function(n) {
+    try {
+      return this._subscribe(n);
+    } catch (e) {
+      n.error(e);
+    }
+  }, t.prototype.forEach = function(n, e) {
+    var i = this;
+    return e = mt(e), new e(function(o, r) {
+      var s = new fe({
+        next: function(f) {
+          try {
+            n(f);
+          } catch (u) {
+            r(u), s.unsubscribe();
+          }
+        },
+        error: r,
+        complete: o
+      });
+      i.subscribe(s);
+    });
+  }, t.prototype._subscribe = function(n) {
+    var e;
+    return (e = this.source) === null || e === void 0 ? void 0 : e.subscribe(n);
+  }, t.prototype[Pe] = function() {
+    return this;
+  }, t.prototype.pipe = function() {
+    for (var n = [], e = 0; e < arguments.length; e++)
+      n[e] = arguments[e];
+    return $r(n)(this);
+  }, t.prototype.toPromise = function(n) {
+    var e = this;
+    return n = mt(n), new n(function(i, o) {
+      var r;
+      e.subscribe(function(s) {
+        return r = s;
+      }, function(s) {
+        return o(s);
+      }, function() {
+        return i(r);
+      });
+    });
+  }, t.create = function(n) {
+    return new t(n);
+  }, t;
+}();
+function mt(t) {
+  var n;
+  return (n = t ?? Lr.Promise) !== null && n !== void 0 ? n : Promise;
+}
+function Hr(t) {
+  return t && R(t.next) && R(t.error) && R(t.complete);
+}
+function Vr(t) {
+  return t && t instanceof Le || Hr(t) && $t(t);
+}
+function Gr(t) {
+  return R(t == null ? void 0 : t.lift);
+}
+function W(t) {
+  return function(n) {
+    if (Gr(n))
+      return n.lift(function(e) {
+        try {
+          return t(e, this);
+        } catch (i) {
+          this.error(i);
+        }
+      });
+    throw new TypeError("Unable to lift unknown Observable type");
+  };
+}
+function te(t, n, e, i, o) {
+  return new jr(t, n, e, i, o);
+}
+var jr = function(t) {
+  Ne(n, t);
+  function n(e, i, o, r, s, f) {
+    var u = t.call(this, e) || this;
+    return u.onFinalize = s, u.shouldUnsubscribe = f, u._next = i ? function(a) {
+      try {
+        i(a);
+      } catch (c) {
+        e.error(c);
+      }
+    } : t.prototype._next, u._error = r ? function(a) {
+      try {
+        r(a);
+      } catch (c) {
+        e.error(c);
+      } finally {
+        this.unsubscribe();
+      }
+    } : t.prototype._error, u._complete = o ? function() {
+      try {
+        o();
+      } catch (a) {
+        e.error(a);
+      } finally {
+        this.unsubscribe();
+      }
+    } : t.prototype._complete, u;
+  }
+  return n.prototype.unsubscribe = function() {
+    var e;
+    if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+      var i = this.closed;
+      t.prototype.unsubscribe.call(this), !i && ((e = this.onFinalize) === null || e === void 0 || e.call(this));
+    }
+  }, n;
+}(Le), Yr = new L(function(t) {
+  return t.complete();
+});
+function Kr(t) {
+  return t && R(t.schedule);
+}
+function Gt(t) {
+  return t[t.length - 1];
+}
+function Wr(t) {
+  return Kr(Gt(t)) ? t.pop() : void 0;
+}
+function Xr(t, n) {
+  return typeof Gt(t) == "number" ? t.pop() : n;
+}
+var jt = function(t) {
+  return t && typeof t.length == "number" && typeof t != "function";
+};
+function Yt(t) {
+  return R(t == null ? void 0 : t.then);
+}
+function Kt(t) {
+  return R(t[Pe]);
+}
+function Wt(t) {
+  return Symbol.asyncIterator && R(t == null ? void 0 : t[Symbol.asyncIterator]);
+}
+function Xt(t) {
+  return new TypeError("You provided " + (t !== null && typeof t == "object" ? "an invalid object" : "'" + t + "'") + " where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.");
+}
+function Jr() {
+  return typeof Symbol != "function" || !Symbol.iterator ? "@@iterator" : Symbol.iterator;
+}
+var Jt = Jr();
+function Qt(t) {
+  return R(t == null ? void 0 : t[Jt]);
+}
+function qt(t) {
+  return Nr(this, arguments, function() {
+    var e, i, o, r;
+    return zt(this, function(s) {
+      switch (s.label) {
+        case 0:
+          e = t.getReader(), s.label = 1;
+        case 1:
+          s.trys.push([1, , 9, 10]), s.label = 2;
+        case 2:
+          return [4, Y(e.read())];
+        case 3:
+          return i = s.sent(), o = i.value, r = i.done, r ? [4, Y(void 0)] : [3, 5];
+        case 4:
+          return [2, s.sent()];
+        case 5:
+          return [4, Y(o)];
+        case 6:
+          return [4, s.sent()];
+        case 7:
+          return s.sent(), [3, 2];
+        case 8:
+          return [3, 10];
+        case 9:
+          return e.releaseLock(), [7];
+        case 10:
+          return [2];
+      }
+    });
+  });
+}
+function en(t) {
+  return R(t == null ? void 0 : t.getReader);
+}
+function X(t) {
+  if (t instanceof L)
+    return t;
+  if (t != null) {
+    if (Kt(t))
+      return Qr(t);
+    if (jt(t))
+      return qr(t);
+    if (Yt(t))
+      return ei(t);
+    if (Wt(t))
+      return tn(t);
+    if (Qt(t))
+      return ti(t);
+    if (en(t))
+      return ni(t);
+  }
+  throw Xt(t);
+}
+function Qr(t) {
+  return new L(function(n) {
+    var e = t[Pe]();
+    if (R(e.subscribe))
+      return e.subscribe(n);
+    throw new TypeError("Provided object does not correctly implement Symbol.observable");
+  });
+}
+function qr(t) {
+  return new L(function(n) {
+    for (var e = 0; e < t.length && !n.closed; e++)
+      n.next(t[e]);
+    n.complete();
+  });
+}
+function ei(t) {
+  return new L(function(n) {
+    t.then(function(e) {
+      n.closed || (n.next(e), n.complete());
+    }, function(e) {
+      return n.error(e);
+    }).then(null, Ht);
+  });
+}
+function ti(t) {
+  return new L(function(n) {
+    var e, i;
+    try {
+      for (var o = ee(t), r = o.next(); !r.done; r = o.next()) {
+        var s = r.value;
+        if (n.next(s), n.closed)
+          return;
+      }
+    } catch (f) {
+      e = { error: f };
+    } finally {
+      try {
+        r && !r.done && (i = o.return) && i.call(o);
+      } finally {
+        if (e) throw e.error;
+      }
+    }
+    n.complete();
+  });
+}
+function tn(t) {
+  return new L(function(n) {
+    ri(t, n).catch(function(e) {
+      return n.error(e);
+    });
+  });
+}
+function ni(t) {
+  return tn(qt(t));
+}
+function ri(t, n) {
+  var e, i, o, r;
+  return Dr(this, void 0, void 0, function() {
+    var s, f;
+    return zt(this, function(u) {
+      switch (u.label) {
+        case 0:
+          u.trys.push([0, 5, 6, 11]), e = Cr(t), u.label = 1;
+        case 1:
+          return [4, e.next()];
+        case 2:
+          if (i = u.sent(), !!i.done) return [3, 4];
+          if (s = i.value, n.next(s), n.closed)
+            return [2];
+          u.label = 3;
+        case 3:
+          return [3, 1];
+        case 4:
+          return [3, 11];
+        case 5:
+          return f = u.sent(), o = { error: f }, [3, 11];
+        case 6:
+          return u.trys.push([6, , 9, 10]), i && !i.done && (r = e.return) ? [4, r.call(e)] : [3, 8];
+        case 7:
+          u.sent(), u.label = 8;
+        case 8:
+          return [3, 10];
+        case 9:
+          if (o) throw o.error;
+          return [7];
+        case 10:
+          return [7];
+        case 11:
+          return n.complete(), [2];
+      }
+    });
+  });
+}
+function $(t, n, e, i, o) {
+  i === void 0 && (i = 0), o === void 0 && (o = !1);
+  var r = n.schedule(function() {
+    e(), o ? t.add(this.schedule(null, i)) : this.unsubscribe();
+  }, i);
+  if (t.add(r), !o)
+    return r;
+}
+function nn(t, n) {
+  return n === void 0 && (n = 0), W(function(e, i) {
+    e.subscribe(te(i, function(o) {
+      return $(i, t, function() {
+        return i.next(o);
+      }, n);
+    }, function() {
+      return $(i, t, function() {
+        return i.complete();
+      }, n);
+    }, function(o) {
+      return $(i, t, function() {
+        return i.error(o);
+      }, n);
+    }));
+  });
+}
+function rn(t, n) {
+  return n === void 0 && (n = 0), W(function(e, i) {
+    i.add(t.schedule(function() {
+      return e.subscribe(i);
+    }, n));
+  });
+}
+function ii(t, n) {
+  return X(t).pipe(rn(n), nn(n));
+}
+function oi(t, n) {
+  return X(t).pipe(rn(n), nn(n));
+}
+function ai(t, n) {
+  return new L(function(e) {
+    var i = 0;
+    return n.schedule(function() {
+      i === t.length ? e.complete() : (e.next(t[i++]), e.closed || this.schedule());
+    });
+  });
+}
+function si(t, n) {
+  return new L(function(e) {
+    var i;
+    return $(e, n, function() {
+      i = t[Jt](), $(e, n, function() {
+        var o, r, s;
+        try {
+          o = i.next(), r = o.value, s = o.done;
+        } catch (f) {
+          e.error(f);
+          return;
+        }
+        s ? e.complete() : e.next(r);
+      }, 0, !0);
+    }), function() {
+      return R(i == null ? void 0 : i.return) && i.return();
+    };
+  });
+}
+function on(t, n) {
+  if (!t)
+    throw new Error("Iterable cannot be null");
+  return new L(function(e) {
+    $(e, n, function() {
+      var i = t[Symbol.asyncIterator]();
+      $(e, n, function() {
+        i.next().then(function(o) {
+          o.done ? e.complete() : e.next(o.value);
+        });
+      }, 0, !0);
+    });
+  });
+}
+function ci(t, n) {
+  return on(qt(t), n);
+}
+function fi(t, n) {
+  if (t != null) {
+    if (Kt(t))
+      return ii(t, n);
+    if (jt(t))
+      return ai(t, n);
+    if (Yt(t))
+      return oi(t, n);
+    if (Wt(t))
+      return on(t, n);
+    if (Qt(t))
+      return si(t, n);
+    if (en(t))
+      return ci(t, n);
+  }
+  throw Xt(t);
+}
+function li(t, n) {
+  return n ? fi(t, n) : X(t);
+}
+var ui = Zt(function(t) {
+  return function() {
+    t(this), this.name = "EmptyError", this.message = "no elements in sequence";
+  };
+});
+function an(t, n) {
+  return new Promise(function(e, i) {
+    var o = new fe({
+      next: function(r) {
+        e(r), o.unsubscribe();
+      },
+      error: i,
+      complete: function() {
+        i(new ui());
+      }
+    });
+    t.subscribe(o);
+  });
+}
+function sn(t, n) {
+  return W(function(e, i) {
+    var o = 0;
+    e.subscribe(te(i, function(r) {
+      i.next(t.call(n, r, o++));
+    }));
+  });
+}
+function hi(t, n, e, i, o, r, s, f) {
+  var u = [], a = 0, c = 0, v = !1, d = function() {
+    v && !u.length && !a && n.complete();
+  }, l = function(w) {
+    return a < i ? h(w) : u.push(w);
+  }, h = function(w) {
+    a++;
+    var _ = !1;
+    X(e(w, c++)).subscribe(te(n, function(k) {
+      n.next(k);
+    }, function() {
+      _ = !0;
+    }, void 0, function() {
+      if (_)
+        try {
+          a--;
+          for (var k = function() {
+            var x = u.shift();
+            s || h(x);
+          }; u.length && a < i; )
+            k();
+          d();
+        } catch (x) {
+          n.error(x);
+        }
+    }));
+  };
+  return t.subscribe(te(n, l, function() {
+    v = !0, d();
+  })), function() {
+  };
+}
+function cn(t, n, e) {
+  return e === void 0 && (e = 1 / 0), R(n) ? cn(function(i, o) {
+    return sn(function(r, s) {
+      return n(i, r, o, s);
+    })(X(t(i, o)));
+  }, e) : (typeof n == "number" && (e = n), W(function(i, o) {
+    return hi(i, o, t, e);
+  }));
+}
+function di(t) {
+  return t === void 0 && (t = 1 / 0), cn(Vt, t);
+}
+function bi() {
+  for (var t = [], n = 0; n < arguments.length; n++)
+    t[n] = arguments[n];
+  var e = Wr(t), i = Xr(t, 1 / 0), o = t;
+  return o.length ? o.length === 1 ? X(o[0]) : di(i)(li(o, e)) : Yr;
+}
+function gi(t, n, e, i, o) {
+  return function(r, s) {
+    var f = e, u = n, a = 0;
+    r.subscribe(te(s, function(c) {
+      var v = a++;
+      u = f ? t(u, c, v) : (f = !0, c);
+    }, function() {
+      f && s.next(u), s.complete();
+    }));
+  };
+}
+function fn(t, n) {
+  return W(gi(t, n, arguments.length >= 2, !1, !0));
+}
+var wi = function(t, n) {
+  return t.push(n), t;
+};
+function mi() {
+  return W(function(t, n) {
+    fn(wi, [])(t).subscribe(n);
+  });
+}
+const yt = -2003829722, Oe = -2021002517;
+class ln {
+  getHeader(n) {
+    return this.headerP || (this.headerP = this._getHeader(n).catch((e) => {
+      throw this.headerP = void 0, e;
+    })), 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: e, renameRefSeqs: i = (s) => s, path: o, url: r } = n;
+    if (this.renameRefSeqs = i, e)
+      this.bbi = e;
+    else if (r)
+      this.bbi = new hn(r);
+    else if (o)
+      this.bbi = new un(o);
+    else
+      throw new Error("no file given");
+  }
+  async _getHeader(n) {
+    const e = await this._getMainHeader(n), i = await this._readChromTree(e, n);
+    return { ...e, ...i };
+  }
+  async _getMainHeader(n, e = 2e3) {
+    const { buffer: o } = await this.bbi.read(z.Buffer.alloc(e), 0, e, 0, n), r = this._isBigEndian(o), s = o, f = new DataView(s.buffer, s.byteOffset, s.length);
+    let u = 0;
+    const a = f.getInt32(u, !0);
+    u += 4;
+    const c = f.getUint16(u, !0);
+    u += 2;
+    const v = f.getUint16(u, !0);
+    u += 2;
+    const d = Number(f.getBigUint64(u, !0));
+    u += 8;
+    const l = Number(f.getBigUint64(u, !0));
+    u += 8;
+    const h = Number(f.getBigUint64(u, !0));
+    u += 8;
+    const w = f.getUint16(u, !0);
+    u += 2;
+    const _ = f.getUint16(u, !0);
+    u += 2;
+    const k = Number(f.getBigUint64(u, !0));
+    u += 8;
+    const x = Number(f.getBigUint64(u, !0));
+    u += 8;
+    const I = f.getUint32(u, !0);
+    u += 4;
+    const g = Number(f.getBigUint64(u, !0));
+    u += 8;
+    const E = [];
+    for (let S = 0; S < v; S++) {
+      const b = f.getUint32(u, !0);
+      u += 4;
+      const p = f.getUint32(u, !0);
+      u += 4;
+      const y = Number(f.getBigUint64(u, !0));
+      u += 8;
+      const T = Number(f.getBigUint64(u, !0));
+      u += 8, E.push({ reductionLevel: b, reserved: p, dataOffset: y, indexOffset: T });
+    }
+    const O = a === Oe ? "bigbed" : "bigwig";
+    if (k > e || x > e - 8 * 5)
+      return this._getMainHeader(n, e * 2);
+    let m;
+    if (x) {
+      const S = o.subarray(Number(x));
+      let b = 0;
+      const p = new DataView(S.buffer, S.byteOffset, S.length), y = Number(p.getBigUint64(b, !0));
+      b += 8;
+      const T = p.getFloat64(b, !0);
+      b += 8;
+      const D = p.getFloat64(b, !0);
+      b += 8;
+      const U = p.getFloat64(b, !0);
+      b += 8;
+      const B = p.getFloat64(b, !0);
+      b += 8, m = {
+        scoreMin: T,
+        scoreMax: D,
+        scoreSum: U,
+        scoreSumSquares: B,
+        basesCovered: y
+      };
+    } else
+      throw new Error("no stats");
+    return {
+      zoomLevels: E,
+      magic: a,
+      extHeaderOffset: g,
+      numZoomLevels: v,
+      fieldCount: w,
+      totalSummary: m,
+      definedFieldCount: _,
+      uncompressBufSize: I,
+      asOffset: k,
+      chromTreeOffset: d,
+      totalSummaryOffset: x,
+      unzoomedDataOffset: l,
+      unzoomedIndexOffset: h,
+      fileType: O,
+      version: c,
+      isBigEndian: r,
+      autoSql: k ? o.subarray(k, o.indexOf(0, k)).toString() : ""
+    };
+  }
+  _isBigEndian(n) {
+    let e = n.readInt32LE(0);
+    if (e === yt || e === Oe)
+      return !1;
+    if (e = n.readInt32BE(0), e === yt || e === Oe)
+      return !0;
+    throw new Error("not a BigWig/BigBed file");
+  }
+  // todo: add progress if long running
+  async _readChromTree(n, e) {
+    const o = !n.isBigEndian, r = [], s = {};
+    let f = n.unzoomedDataOffset;
+    const u = n.chromTreeOffset;
+    for (; f % 4 !== 0; )
+      f += 1;
+    const a = f - u, { buffer: c } = await this.bbi.read(z.Buffer.alloc(a), 0, a, Number(u), e), v = c, d = new DataView(v.buffer, v.byteOffset, v.length);
+    let l = 0;
+    l += 4, l += 4;
+    const h = d.getUint32(l, o);
+    l += 4, l += 4, l += 8;
+    const w = 32, _ = async (k) => {
+      let x = k;
+      if (x >= c.length)
+        throw new Error("reading beyond end of buffer");
+      const I = d.getUint8(x);
+      x += 2;
+      const g = d.getUint16(x, o);
+      if (x += 2, I)
+        for (let E = 0; E < g; E++) {
+          const O = c.subarray(x, x + h).toString().replaceAll("\0", "");
+          x += h;
+          const m = d.getUint32(x, o);
+          x += 4;
+          const S = d.getUint32(x, o);
+          x += 4;
+          const b = { name: O, id: m, length: S };
+          s[this.renameRefSeqs(O)] = m, r[m] = b;
+        }
+      else {
+        const E = [];
+        for (let O = 0; O < g; O++) {
+          x += h;
+          const m = Number(d.getBigUint64(x, o));
+          x += 8, E.push(_(Number(m) - Number(u)));
+        }
+        await Promise.all(E);
+      }
+    };
+    return await _(w), {
+      refsByName: s,
+      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: e, refsByName: i, uncompressBufSize: o, isBigEndian: r, fileType: s } = await this.getHeader(n);
+    return new Mt(this.bbi, i, e, r, o > 0, s);
+  }
+  /**
+   * 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, e, i, o) {
+    await this.getHeader(o);
+    const r = this.renameRefSeqs(n);
+    let s;
+    const { basesPerSpan: f, scale: u } = o || {};
+    return f ? s = await this.getView(1 / f, o) : u ? s = await this.getView(u, o) : s = await this.getView(1, o), new L((a) => {
+      s.readWigData(r, e, i, a, o).catch((c) => {
+        a.error(c);
+      });
+    });
+  }
+  async getFeatures(n, e, i, o) {
+    const r = await this.getFeatureStream(n, e, i, o);
+    return (await an(r.pipe(mi()))).flat();
+  }
+}
+class xi extends ln {
+  /**
+   * 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, e) {
+    const { zoomLevels: i, refsByName: o, isBigEndian: r, uncompressBufSize: s } = await this.getHeader(e), f = 1 / n, u = i.length - 1;
+    for (let a = u; a >= 0; a -= 1) {
+      const c = i[a];
+      if (c && c.reductionLevel <= 2 * f)
+        return new Mt(this.bbi, o, c.indexOffset, r, s > 0, "summary");
+    }
+    return this.getUnzoomedView(e);
+  }
+}
+function yi(t) {
+  return t.filter((n) => !!n);
+}
+class Ei extends ln {
+  constructor() {
+    super(...arguments), this.readIndicesCache = new pt({
+      cache: new vt({ maxSize: 1 }),
+      fill: (n, e) => this._readIndices({ ...n, signal: e })
+    });
+  }
+  readIndices(n = {}) {
+    const { signal: e, ...i } = n;
+    return this.readIndicesCache.get(JSON.stringify(i), n, e);
+  }
+  /*
+   * retrieve unzoomed view for any scale
+   */
+  async getView(n, e) {
+    return this.getUnzoomedView(e);
+  }
+  /*
+   * 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: e, isBigEndian: i } = await this.getHeader(n), { buffer: o } = await this.bbi.read(z.Buffer.alloc(64), 0, 64, Number(e)), r = !i, s = o, f = new DataView(s.buffer, s.byteOffset, s.length);
+    let u = 0;
+    u += 2;
+    const a = f.getUint16(u, r);
+    u += 2;
+    const c = Number(f.getBigUint64(u, r));
+    if (u += 8, a === 0)
+      return [];
+    const v = 20, d = v * a, { buffer: l } = await this.bbi.read(z.Buffer.alloc(d), 0, d, Number(c)), h = [];
+    for (let w = 0; w < a; w += 1) {
+      const _ = l.subarray(w * v), k = new DataView(_.buffer, _.byteOffset, _.length);
+      let x = 0;
+      const I = k.getInt16(x, r);
+      x += 2;
+      const g = k.getInt16(x, r);
+      x += 2;
+      const E = Number(k.getBigUint64(x, r));
+      x += 12;
+      const O = k.getInt16(x, r);
+      h.push({ type: I, fieldcount: g, offset: Number(E), field: O });
+    }
+    return h;
+  }
+  /*
+   * 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, e = {}) {
+    const { isBigEndian: i } = await this.getHeader(e), o = await this.readIndices(e);
+    if (o.length === 0)
+      return [];
+    const r = o.map(async (s) => {
+      const { offset: f, field: u } = s, { buffer: a } = await this.bbi.read(z.Buffer.alloc(32), 0, 32, f, e), c = !i, v = a, d = new DataView(v.buffer, v.byteOffset, v.length);
+      let l = 0;
+      l += 4;
+      const h = d.getInt32(l, c);
+      l += 4;
+      const w = d.getInt32(l, c);
+      l += 4;
+      const _ = d.getInt32(l, c);
+      l += 4, l += 8;
+      const k = async (I) => {
+        const g = Number(I), E = 4 + h * (w + _), { buffer: O } = await this.bbi.read(z.Buffer.alloc(E), 0, E, g, e), m = O, S = new DataView(m.buffer, m.byteOffset, m.length);
+        let b = 0;
+        const p = S.getInt8(b);
+        b += 2;
+        const y = S.getInt16(b, c);
+        b += 2;
+        const T = [];
+        if (p === 0) {
+          const D = [];
+          for (let B = 0; B < y; B++) {
+            const N = m.subarray(b, b + w).toString().replaceAll("\0", "");
+            b += w;
+            const Z = Number(S.getBigUint64(b, c));
+            b += 8, D.push({ key: N, offset: Z });
+          }
+          let U = 0;
+          for (const { key: B, offset: N } of D) {
+            if (n.localeCompare(B) < 0 && U)
+              return k(U);
+            U = N;
+          }
+          return k(U);
+        } else if (p === 1) {
+          for (let D = 0; D < y; D++) {
+            const U = m.subarray(b, b + w).toString().replaceAll("\0", "");
+            b += w;
+            const B = Number(S.getBigUint64(b, c));
+            b += 8;
+            const N = S.getUint32(b, c);
+            b += 4;
+            const Z = S.getUint32(b, c);
+            b += 4, T.push({ key: U, offset: B, length: N, reserved: Z });
+          }
+          for (const D of T)
+            if (D.key === n)
+              return { ...D, field: u };
+          return;
+        }
+      };
+      return k(f + 32);
+    });
+    return yi(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, e = {}) {
+    const i = await this.searchExtraIndexBlocks(n, e);
+    if (i.length === 0)
+      return [];
+    const o = await this.getUnzoomedView(e), r = i.map((f) => new L((u) => {
+      o.readFeatures(u, [f], e).catch((a) => {
+        u.error(a);
+      });
+    }).pipe(fn((u, a) => u.concat(a)), sn((u) => {
+      for (const a of u)
+        a.field = f.field;
+      return u;
+    })));
+    return (await an(bi(...r))).filter((f) => {
+      var u;
+      return ((u = f.rest) === null || u === void 0 ? void 0 : u.split("	")[(f.field || 0) - 3]) === n;
+    });
+  }
+}
+export {
+  Ei as BigBed,
+  xi as BigWig
+};