@genome-spy/core 0.63.0 → 0.65.0

package/dist/bundle/index-BQpbYrv4.js

@@ -0,0 +1,1712 @@
+var Ct = Object.defineProperty;
+var Nt = (t, e, n) => e in t ? Ct(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n;
+var T = (t, e, n) => Nt(t, typeof e != "symbol" ? e + "" : e, n);
+import { RemoteFile as zt, LocalFile as Lt } from "./browser-txUcLy2H.js";
+import { A as ut } from "./AbortablePromiseCache-CcuMrnn7.js";
+import { L as ft } from "./index-BhtHKLUo.js";
+import { i as Mt } from "./inflate-DRgHi_KK.js";
+const lt = BigInt(32);
+function Ht(t, e, n) {
+  const r = +!!n, o = +!n;
+  return BigInt(t.getInt32(e, n) * o + t.getInt32(e + 4, n) * r) << lt | BigInt(t.getUint32(e, n) * r + t.getUint32(e + 4, n) * o);
+}
+function $t(t, e, n) {
+  const r = t.getUint32(e, n), o = t.getUint32(e + 4, n), i = +!!n, s = +!n;
+  return BigInt(r * s + o * i) << lt | BigInt(r * i + o * s);
+}
+"getBigInt64" in DataView || (DataView.prototype.getBigInt64 = function(t, e) {
+  return Ht(this, t, e);
+});
+"getBigUint64" in DataView || (DataView.prototype.getBigUint64 = function(t, e) {
+  return $t(this, t, e);
+});
+var K = function(t, e) {
+  return K = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(n, r) {
+    n.__proto__ = r;
+  } || function(n, r) {
+    for (var o in r) Object.prototype.hasOwnProperty.call(r, o) && (n[o] = r[o]);
+  }, K(t, e);
+};
+function tt(t, e) {
+  if (typeof e != "function" && e !== null)
+    throw new TypeError("Class extends value " + String(e) + " is not a constructor or null");
+  K(t, e);
+  function n() {
+    this.constructor = t;
+  }
+  t.prototype = e === null ? Object.create(e) : (n.prototype = e.prototype, new n());
+}
+function jt(t, e, n, r) {
+  function o(i) {
+    return i instanceof n ? i : new n(function(s) {
+      s(i);
+    });
+  }
+  return new (n || (n = Promise))(function(i, s) {
+    function u(d) {
+      try {
+        c(r.next(d));
+      } catch (y) {
+        s(y);
+      }
+    }
+    function a(d) {
+      try {
+        c(r.throw(d));
+      } catch (y) {
+        s(y);
+      }
+    }
+    function c(d) {
+      d.done ? i(d.value) : o(d.value).then(u, a);
+    }
+    c((r = r.apply(t, e || [])).next());
+  });
+}
+function ht(t, e) {
+  var n = { label: 0, sent: function() {
+    if (i[0] & 1) throw i[1];
+    return i[1];
+  }, trys: [], ops: [] }, r, o, i, s = Object.create((typeof Iterator == "function" ? Iterator : Object).prototype);
+  return s.next = u(0), s.throw = u(1), s.return = u(2), typeof Symbol == "function" && (s[Symbol.iterator] = function() {
+    return this;
+  }), s;
+  function u(c) {
+    return function(d) {
+      return a([c, d]);
+    };
+  }
+  function a(c) {
+    if (r) throw new TypeError("Generator is already executing.");
+    for (; s && (s = 0, c[0] && (n = 0)), n; ) try {
+      if (r = 1, o && (i = c[0] & 2 ? o.return : c[0] ? o.throw || ((i = o.return) && i.call(o), 0) : o.next) && !(i = i.call(o, c[1])).done) return i;
+      switch (o = 0, i && (c = [c[0] & 2, i.value]), c[0]) {
+        case 0:
+        case 1:
+          i = c;
+          break;
+        case 4:
+          return n.label++, { value: c[1], done: !1 };
+        case 5:
+          n.label++, o = c[1], c = [0];
+          continue;
+        case 7:
+          c = n.ops.pop(), n.trys.pop();
+          continue;
+        default:
+          if (i = n.trys, !(i = i.length > 0 && i[i.length - 1]) && (c[0] === 6 || c[0] === 2)) {
+            n = 0;
+            continue;
+          }
+          if (c[0] === 3 && (!i || c[1] > i[0] && c[1] < i[3])) {
+            n.label = c[1];
+            break;
+          }
+          if (c[0] === 6 && n.label < i[1]) {
+            n.label = i[1], i = c;
+            break;
+          }
+          if (i && n.label < i[2]) {
+            n.label = i[2], n.ops.push(c);
+            break;
+          }
+          i[2] && n.ops.pop(), n.trys.pop();
+          continue;
+      }
+      c = e.call(t, n);
+    } catch (d) {
+      c = [6, d], o = 0;
+    } finally {
+      r = i = 0;
+    }
+    if (c[0] & 5) throw c[1];
+    return { value: c[0] ? c[1] : void 0, done: !0 };
+  }
+}
+function M(t) {
+  var e = typeof Symbol == "function" && Symbol.iterator, n = e && t[e], r = 0;
+  if (n) return n.call(t);
+  if (t && typeof t.length == "number") return {
+    next: function() {
+      return t && r >= t.length && (t = void 0), { value: t && t[r++], done: !t };
+    }
+  };
+  throw new TypeError(e ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function Q(t, e) {
+  var n = typeof Symbol == "function" && t[Symbol.iterator];
+  if (!n) return t;
+  var r = n.call(t), o, i = [], s;
+  try {
+    for (; (e === void 0 || e-- > 0) && !(o = r.next()).done; ) i.push(o.value);
+  } catch (u) {
+    s = { error: u };
+  } finally {
+    try {
+      o && !o.done && (n = r.return) && n.call(r);
+    } finally {
+      if (s) throw s.error;
+    }
+  }
+  return i;
+}
+function X(t, e, n) {
+  if (n || arguments.length === 2) for (var r = 0, o = e.length, i; r < o; r++)
+    (i || !(r in e)) && (i || (i = Array.prototype.slice.call(e, 0, r)), i[r] = e[r]);
+  return t.concat(i || Array.prototype.slice.call(e));
+}
+function C(t) {
+  return this instanceof C ? (this.v = t, this) : new C(t);
+}
+function Gt(t, e, n) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var r = n.apply(t, e || []), o, i = [];
+  return o = Object.create((typeof AsyncIterator == "function" ? AsyncIterator : Object).prototype), u("next"), u("throw"), u("return", s), o[Symbol.asyncIterator] = function() {
+    return this;
+  }, o;
+  function s(f) {
+    return function(m) {
+      return Promise.resolve(m).then(f, y);
+    };
+  }
+  function u(f, m) {
+    r[f] && (o[f] = function(l) {
+      return new Promise(function(v, b) {
+        i.push([f, l, v, b]) > 1 || a(f, l);
+      });
+    }, m && (o[f] = m(o[f])));
+  }
+  function a(f, m) {
+    try {
+      c(r[f](m));
+    } catch (l) {
+      g(i[0][3], l);
+    }
+  }
+  function c(f) {
+    f.value instanceof C ? Promise.resolve(f.value.v).then(d, y) : g(i[0][2], f);
+  }
+  function d(f) {
+    a("next", f);
+  }
+  function y(f) {
+    a("throw", f);
+  }
+  function g(f, m) {
+    f(m), i.shift(), i.length && a(i[0][0], i[0][1]);
+  }
+}
+function Wt(t) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var e = t[Symbol.asyncIterator], n;
+  return e ? e.call(t) : (t = typeof M == "function" ? M(t) : t[Symbol.iterator](), n = {}, r("next"), r("throw"), r("return"), n[Symbol.asyncIterator] = function() {
+    return this;
+  }, n);
+  function r(i) {
+    n[i] = t[i] && function(s) {
+      return new Promise(function(u, a) {
+        s = t[i](s), o(u, a, s.done, s.value);
+      });
+    };
+  }
+  function o(i, s, u, a) {
+    Promise.resolve(a).then(function(c) {
+      i({ value: c, done: u });
+    }, s);
+  }
+}
+function k(t) {
+  return typeof t == "function";
+}
+function dt(t) {
+  var e = function(r) {
+    Error.call(r), r.stack = new Error().stack;
+  }, n = t(e);
+  return n.prototype = Object.create(Error.prototype), n.prototype.constructor = n, n;
+}
+var q = dt(function(t) {
+  return function(n) {
+    t(this), this.message = n ? n.length + ` errors occurred during unsubscription:
+` + n.map(function(r, o) {
+      return o + 1 + ") " + r.toString();
+    }).join(`
+  `) : "", this.name = "UnsubscriptionError", this.errors = n;
+  };
+});
+function ot(t, e) {
+  if (t) {
+    var n = t.indexOf(e);
+    0 <= n && t.splice(n, 1);
+  }
+}
+var et = function() {
+  function t(e) {
+    this.initialTeardown = e, this.closed = !1, this._parentage = null, this._finalizers = null;
+  }
+  return t.prototype.unsubscribe = function() {
+    var e, n, r, o, i;
+    if (!this.closed) {
+      this.closed = !0;
+      var s = this._parentage;
+      if (s)
+        if (this._parentage = null, Array.isArray(s))
+          try {
+            for (var u = M(s), a = u.next(); !a.done; a = u.next()) {
+              var c = a.value;
+              c.remove(this);
+            }
+          } catch (l) {
+            e = { error: l };
+          } finally {
+            try {
+              a && !a.done && (n = u.return) && n.call(u);
+            } finally {
+              if (e) throw e.error;
+            }
+          }
+        else
+          s.remove(this);
+      var d = this.initialTeardown;
+      if (k(d))
+        try {
+          d();
+        } catch (l) {
+          i = l instanceof q ? l.errors : [l];
+        }
+      var y = this._finalizers;
+      if (y) {
+        this._finalizers = null;
+        try {
+          for (var g = M(y), f = g.next(); !f.done; f = g.next()) {
+            var m = f.value;
+            try {
+              it(m);
+            } catch (l) {
+              i = i ?? [], l instanceof q ? i = X(X([], Q(i)), Q(l.errors)) : i.push(l);
+            }
+          }
+        } catch (l) {
+          r = { error: l };
+        } finally {
+          try {
+            f && !f.done && (o = g.return) && o.call(g);
+          } finally {
+            if (r) throw r.error;
+          }
+        }
+      }
+      if (i)
+        throw new q(i);
+    }
+  }, t.prototype.add = function(e) {
+    var n;
+    if (e && e !== this)
+      if (this.closed)
+        it(e);
+      else {
+        if (e instanceof t) {
+          if (e.closed || e._hasParent(this))
+            return;
+          e._addParent(this);
+        }
+        (this._finalizers = (n = this._finalizers) !== null && n !== void 0 ? n : []).push(e);
+      }
+  }, t.prototype._hasParent = function(e) {
+    var n = this._parentage;
+    return n === e || Array.isArray(n) && n.includes(e);
+  }, t.prototype._addParent = function(e) {
+    var n = this._parentage;
+    this._parentage = Array.isArray(n) ? (n.push(e), n) : n ? [n, e] : e;
+  }, t.prototype._removeParent = function(e) {
+    var n = this._parentage;
+    n === e ? this._parentage = null : Array.isArray(n) && ot(n, e);
+  }, t.prototype.remove = function(e) {
+    var n = this._finalizers;
+    n && ot(n, e), e instanceof t && e._removeParent(this);
+  }, t.EMPTY = function() {
+    var e = new t();
+    return e.closed = !0, e;
+  }(), t;
+}();
+et.EMPTY;
+function mt(t) {
+  return t instanceof et || t && "closed" in t && k(t.remove) && k(t.add) && k(t.unsubscribe);
+}
+function it(t) {
+  k(t) ? t() : t.unsubscribe();
+}
+var Yt = {
+  Promise: void 0
+}, qt = {
+  setTimeout: function(t, e) {
+    for (var n = [], r = 2; r < arguments.length; r++)
+      n[r - 2] = arguments[r];
+    return setTimeout.apply(void 0, X([t, e], Q(n)));
+  },
+  clearTimeout: function(t) {
+    return clearTimeout(t);
+  },
+  delegate: void 0
+};
+function gt(t) {
+  qt.setTimeout(function() {
+    throw t;
+  });
+}
+function st() {
+}
+function Jt(t) {
+  t();
+}
+var nt = function(t) {
+  tt(e, t);
+  function e(n) {
+    var r = t.call(this) || this;
+    return r.isStopped = !1, n ? (r.destination = n, mt(n) && n.add(r)) : r.destination = Qt, r;
+  }
+  return e.create = function(n, r, o) {
+    return new G(n, r, o);
+  }, e.prototype.next = function(n) {
+    this.isStopped || this._next(n);
+  }, e.prototype.error = function(n) {
+    this.isStopped || (this.isStopped = !0, this._error(n));
+  }, e.prototype.complete = function() {
+    this.isStopped || (this.isStopped = !0, this._complete());
+  }, e.prototype.unsubscribe = function() {
+    this.closed || (this.isStopped = !0, t.prototype.unsubscribe.call(this), this.destination = null);
+  }, e.prototype._next = function(n) {
+    this.destination.next(n);
+  }, e.prototype._error = function(n) {
+    try {
+      this.destination.error(n);
+    } finally {
+      this.unsubscribe();
+    }
+  }, e.prototype._complete = function() {
+    try {
+      this.destination.complete();
+    } finally {
+      this.unsubscribe();
+    }
+  }, e;
+}(et), Zt = function() {
+  function t(e) {
+    this.partialObserver = e;
+  }
+  return t.prototype.next = function(e) {
+    var n = this.partialObserver;
+    if (n.next)
+      try {
+        n.next(e);
+      } catch (r) {
+        $(r);
+      }
+  }, t.prototype.error = function(e) {
+    var n = this.partialObserver;
+    if (n.error)
+      try {
+        n.error(e);
+      } catch (r) {
+        $(r);
+      }
+    else
+      $(e);
+  }, t.prototype.complete = function() {
+    var e = this.partialObserver;
+    if (e.complete)
+      try {
+        e.complete();
+      } catch (n) {
+        $(n);
+      }
+  }, t;
+}(), G = function(t) {
+  tt(e, t);
+  function e(n, r, o) {
+    var i = t.call(this) || this, s;
+    return k(n) || !n ? s = {
+      next: n ?? void 0,
+      error: r ?? void 0,
+      complete: o ?? void 0
+    } : s = n, i.destination = new Zt(s), i;
+  }
+  return e;
+}(nt);
+function $(t) {
+  gt(t);
+}
+function Kt(t) {
+  throw t;
+}
+var Qt = {
+  closed: !0,
+  next: st,
+  error: Kt,
+  complete: st
+}, rt = function() {
+  return typeof Symbol == "function" && Symbol.observable || "@@observable";
+}();
+function yt(t) {
+  return t;
+}
+function Xt(t) {
+  return t.length === 0 ? yt : t.length === 1 ? t[0] : function(n) {
+    return t.reduce(function(r, o) {
+      return o(r);
+    }, n);
+  };
+}
+var A = function() {
+  function t(e) {
+    e && (this._subscribe = e);
+  }
+  return t.prototype.lift = function(e) {
+    var n = new t();
+    return n.source = this, n.operator = e, n;
+  }, t.prototype.subscribe = function(e, n, r) {
+    var o = this, i = ee(e) ? e : new G(e, n, r);
+    return Jt(function() {
+      var s = o, u = s.operator, a = s.source;
+      i.add(u ? u.call(i, a) : a ? o._subscribe(i) : o._trySubscribe(i));
+    }), i;
+  }, t.prototype._trySubscribe = function(e) {
+    try {
+      return this._subscribe(e);
+    } catch (n) {
+      e.error(n);
+    }
+  }, t.prototype.forEach = function(e, n) {
+    var r = this;
+    return n = ct(n), new n(function(o, i) {
+      var s = new G({
+        next: function(u) {
+          try {
+            e(u);
+          } catch (a) {
+            i(a), s.unsubscribe();
+          }
+        },
+        error: i,
+        complete: o
+      });
+      r.subscribe(s);
+    });
+  }, t.prototype._subscribe = function(e) {
+    var n;
+    return (n = this.source) === null || n === void 0 ? void 0 : n.subscribe(e);
+  }, t.prototype[rt] = function() {
+    return this;
+  }, t.prototype.pipe = function() {
+    for (var e = [], n = 0; n < arguments.length; n++)
+      e[n] = arguments[n];
+    return Xt(e)(this);
+  }, t.prototype.toPromise = function(e) {
+    var n = this;
+    return e = ct(e), new e(function(r, o) {
+      var i;
+      n.subscribe(function(s) {
+        return i = s;
+      }, function(s) {
+        return o(s);
+      }, function() {
+        return r(i);
+      });
+    });
+  }, t.create = function(e) {
+    return new t(e);
+  }, t;
+}();
+function ct(t) {
+  var e;
+  return (e = t ?? Yt.Promise) !== null && e !== void 0 ? e : Promise;
+}
+function te(t) {
+  return t && k(t.next) && k(t.error) && k(t.complete);
+}
+function ee(t) {
+  return t && t instanceof nt || te(t) && mt(t);
+}
+function ne(t) {
+  return k(t == null ? void 0 : t.lift);
+}
+function z(t) {
+  return function(e) {
+    if (ne(e))
+      return e.lift(function(n) {
+        try {
+          return t(n, this);
+        } catch (r) {
+          this.error(r);
+        }
+      });
+    throw new TypeError("Unable to lift unknown Observable type");
+  };
+}
+function H(t, e, n, r, o) {
+  return new re(t, e, n, r, o);
+}
+var re = function(t) {
+  tt(e, t);
+  function e(n, r, o, i, s, u) {
+    var a = t.call(this, n) || this;
+    return a.onFinalize = s, a.shouldUnsubscribe = u, a._next = r ? function(c) {
+      try {
+        r(c);
+      } catch (d) {
+        n.error(d);
+      }
+    } : t.prototype._next, a._error = i ? function(c) {
+      try {
+        i(c);
+      } catch (d) {
+        n.error(d);
+      } finally {
+        this.unsubscribe();
+      }
+    } : t.prototype._error, a._complete = o ? function() {
+      try {
+        o();
+      } catch (c) {
+        n.error(c);
+      } finally {
+        this.unsubscribe();
+      }
+    } : t.prototype._complete, a;
+  }
+  return e.prototype.unsubscribe = function() {
+    var n;
+    if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+      var r = this.closed;
+      t.prototype.unsubscribe.call(this), !r && ((n = this.onFinalize) === null || n === void 0 || n.call(this));
+    }
+  }, e;
+}(nt), oe = new A(function(t) {
+  return t.complete();
+});
+function ie(t) {
+  return t && k(t.schedule);
+}
+function bt(t) {
+  return t[t.length - 1];
+}
+function se(t) {
+  return ie(bt(t)) ? t.pop() : void 0;
+}
+function ce(t, e) {
+  return typeof bt(t) == "number" ? t.pop() : e;
+}
+var pt = function(t) {
+  return t && typeof t.length == "number" && typeof t != "function";
+};
+function wt(t) {
+  return k(t == null ? void 0 : t.then);
+}
+function vt(t) {
+  return k(t[rt]);
+}
+function xt(t) {
+  return Symbol.asyncIterator && k(t == null ? void 0 : t[Symbol.asyncIterator]);
+}
+function St(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 ae() {
+  return typeof Symbol != "function" || !Symbol.iterator ? "@@iterator" : Symbol.iterator;
+}
+var It = ae();
+function Bt(t) {
+  return k(t == null ? void 0 : t[It]);
+}
+function Ut(t) {
+  return Gt(this, arguments, function() {
+    var n, r, o, i;
+    return ht(this, function(s) {
+      switch (s.label) {
+        case 0:
+          n = t.getReader(), s.label = 1;
+        case 1:
+          s.trys.push([1, , 9, 10]), s.label = 2;
+        case 2:
+          return [4, C(n.read())];
+        case 3:
+          return r = s.sent(), o = r.value, i = r.done, i ? [4, C(void 0)] : [3, 5];
+        case 4:
+          return [2, s.sent()];
+        case 5:
+          return [4, C(o)];
+        case 6:
+          return [4, s.sent()];
+        case 7:
+          return s.sent(), [3, 2];
+        case 8:
+          return [3, 10];
+        case 9:
+          return n.releaseLock(), [7];
+        case 10:
+          return [2];
+      }
+    });
+  });
+}
+function kt(t) {
+  return k(t == null ? void 0 : t.getReader);
+}
+function L(t) {
+  if (t instanceof A)
+    return t;
+  if (t != null) {
+    if (vt(t))
+      return ue(t);
+    if (pt(t))
+      return fe(t);
+    if (wt(t))
+      return le(t);
+    if (xt(t))
+      return Ot(t);
+    if (Bt(t))
+      return he(t);
+    if (kt(t))
+      return de(t);
+  }
+  throw St(t);
+}
+function ue(t) {
+  return new A(function(e) {
+    var n = t[rt]();
+    if (k(n.subscribe))
+      return n.subscribe(e);
+    throw new TypeError("Provided object does not correctly implement Symbol.observable");
+  });
+}
+function fe(t) {
+  return new A(function(e) {
+    for (var n = 0; n < t.length && !e.closed; n++)
+      e.next(t[n]);
+    e.complete();
+  });
+}
+function le(t) {
+  return new A(function(e) {
+    t.then(function(n) {
+      e.closed || (e.next(n), e.complete());
+    }, function(n) {
+      return e.error(n);
+    }).then(null, gt);
+  });
+}
+function he(t) {
+  return new A(function(e) {
+    var n, r;
+    try {
+      for (var o = M(t), i = o.next(); !i.done; i = o.next()) {
+        var s = i.value;
+        if (e.next(s), e.closed)
+          return;
+      }
+    } catch (u) {
+      n = { error: u };
+    } finally {
+      try {
+        i && !i.done && (r = o.return) && r.call(o);
+      } finally {
+        if (n) throw n.error;
+      }
+    }
+    e.complete();
+  });
+}
+function Ot(t) {
+  return new A(function(e) {
+    me(t, e).catch(function(n) {
+      return e.error(n);
+    });
+  });
+}
+function de(t) {
+  return Ot(Ut(t));
+}
+function me(t, e) {
+  var n, r, o, i;
+  return jt(this, void 0, void 0, function() {
+    var s, u;
+    return ht(this, function(a) {
+      switch (a.label) {
+        case 0:
+          a.trys.push([0, 5, 6, 11]), n = Wt(t), a.label = 1;
+        case 1:
+          return [4, n.next()];
+        case 2:
+          if (r = a.sent(), !!r.done) return [3, 4];
+          if (s = r.value, e.next(s), e.closed)
+            return [2];
+          a.label = 3;
+        case 3:
+          return [3, 1];
+        case 4:
+          return [3, 11];
+        case 5:
+          return u = a.sent(), o = { error: u }, [3, 11];
+        case 6:
+          return a.trys.push([6, , 9, 10]), r && !r.done && (i = n.return) ? [4, i.call(n)] : [3, 8];
+        case 7:
+          a.sent(), a.label = 8;
+        case 8:
+          return [3, 10];
+        case 9:
+          if (o) throw o.error;
+          return [7];
+        case 10:
+          return [7];
+        case 11:
+          return e.complete(), [2];
+      }
+    });
+  });
+}
+function D(t, e, n, r, o) {
+  r === void 0 && (r = 0), o === void 0 && (o = !1);
+  var i = e.schedule(function() {
+    n(), o ? t.add(this.schedule(null, r)) : this.unsubscribe();
+  }, r);
+  if (t.add(i), !o)
+    return i;
+}
+function Tt(t, e) {
+  return e === void 0 && (e = 0), z(function(n, r) {
+    n.subscribe(H(r, function(o) {
+      return D(r, t, function() {
+        return r.next(o);
+      }, e);
+    }, function() {
+      return D(r, t, function() {
+        return r.complete();
+      }, e);
+    }, function(o) {
+      return D(r, t, function() {
+        return r.error(o);
+      }, e);
+    }));
+  });
+}
+function Et(t, e) {
+  return e === void 0 && (e = 0), z(function(n, r) {
+    r.add(t.schedule(function() {
+      return n.subscribe(r);
+    }, e));
+  });
+}
+function ge(t, e) {
+  return L(t).pipe(Et(e), Tt(e));
+}
+function ye(t, e) {
+  return L(t).pipe(Et(e), Tt(e));
+}
+function be(t, e) {
+  return new A(function(n) {
+    var r = 0;
+    return e.schedule(function() {
+      r === t.length ? n.complete() : (n.next(t[r++]), n.closed || this.schedule());
+    });
+  });
+}
+function pe(t, e) {
+  return new A(function(n) {
+    var r;
+    return D(n, e, function() {
+      r = t[It](), D(n, e, function() {
+        var o, i, s;
+        try {
+          o = r.next(), i = o.value, s = o.done;
+        } catch (u) {
+          n.error(u);
+          return;
+        }
+        s ? n.complete() : n.next(i);
+      }, 0, !0);
+    }), function() {
+      return k(r == null ? void 0 : r.return) && r.return();
+    };
+  });
+}
+function Pt(t, e) {
+  if (!t)
+    throw new Error("Iterable cannot be null");
+  return new A(function(n) {
+    D(n, e, function() {
+      var r = t[Symbol.asyncIterator]();
+      D(n, e, function() {
+        r.next().then(function(o) {
+          o.done ? n.complete() : n.next(o.value);
+        });
+      }, 0, !0);
+    });
+  });
+}
+function we(t, e) {
+  return Pt(Ut(t), e);
+}
+function ve(t, e) {
+  if (t != null) {
+    if (vt(t))
+      return ge(t, e);
+    if (pt(t))
+      return be(t, e);
+    if (wt(t))
+      return ye(t, e);
+    if (xt(t))
+      return Pt(t, e);
+    if (Bt(t))
+      return pe(t, e);
+    if (kt(t))
+      return we(t, e);
+  }
+  throw St(t);
+}
+function xe(t, e) {
+  return e ? ve(t, e) : L(t);
+}
+var Se = dt(function(t) {
+  return function() {
+    t(this), this.name = "EmptyError", this.message = "no elements in sequence";
+  };
+});
+function Vt(t, e) {
+  return new Promise(function(n, r) {
+    var o = new G({
+      next: function(i) {
+        n(i), o.unsubscribe();
+      },
+      error: r,
+      complete: function() {
+        r(new Se());
+      }
+    });
+    t.subscribe(o);
+  });
+}
+function At(t, e) {
+  return z(function(n, r) {
+    var o = 0;
+    n.subscribe(H(r, function(i) {
+      r.next(t.call(e, i, o++));
+    }));
+  });
+}
+function Ie(t, e, n, r, o, i, s, u) {
+  var a = [], c = 0, d = 0, y = !1, g = function() {
+    y && !a.length && !c && e.complete();
+  }, f = function(l) {
+    return c < r ? m(l) : a.push(l);
+  }, m = function(l) {
+    c++;
+    var v = !1;
+    L(n(l, d++)).subscribe(H(e, function(b) {
+      e.next(b);
+    }, function() {
+      v = !0;
+    }, void 0, function() {
+      if (v)
+        try {
+          c--;
+          for (var b = function() {
+            var x = a.shift();
+            s || m(x);
+          }; a.length && c < r; )
+            b();
+          g();
+        } catch (x) {
+          e.error(x);
+        }
+    }));
+  };
+  return t.subscribe(H(e, f, function() {
+    y = !0, g();
+  })), function() {
+  };
+}
+function _t(t, e, n) {
+  return n === void 0 && (n = 1 / 0), k(e) ? _t(function(r, o) {
+    return At(function(i, s) {
+      return e(r, i, o, s);
+    })(L(t(r, o)));
+  }, n) : (typeof e == "number" && (n = e), z(function(r, o) {
+    return Ie(r, o, t, n);
+  }));
+}
+function Be(t) {
+  return t === void 0 && (t = 1 / 0), _t(yt, t);
+}
+function Ue() {
+  for (var t = [], e = 0; e < arguments.length; e++)
+    t[e] = arguments[e];
+  var n = se(t), r = ce(t, 1 / 0), o = t;
+  return o.length ? o.length === 1 ? L(o[0]) : Be(r)(xe(o, n)) : oe;
+}
+function ke(t, e, n, r, o) {
+  return function(i, s) {
+    var u = n, a = e, c = 0;
+    i.subscribe(H(s, function(d) {
+      var y = c++;
+      a = u ? t(a, d, y) : (u = !0, d);
+    }, function() {
+      u && s.next(a), s.complete();
+    }));
+  };
+}
+function Ft(t, e) {
+  return z(ke(t, e, arguments.length >= 2, !1, !0));
+}
+var Oe = function(t, e) {
+  return t.push(e), t;
+};
+function Te() {
+  return z(function(t, e) {
+    Ft(Oe, [])(t).subscribe(e);
+  });
+}
+class N {
+  constructor(e) {
+    T(this, "ranges");
+    this.ranges = e;
+  }
+  get min() {
+    return this.ranges[0].min;
+  }
+  get max() {
+    return this.ranges.at(-1).max;
+  }
+  contains(e) {
+    for (const n of this.ranges)
+      if (n.min <= e && n.max >= e)
+        return !0;
+    return !1;
+  }
+  isContiguous() {
+    return this.ranges.length > 1;
+  }
+  getRanges() {
+    return this.ranges.map((e) => new N([{ min: e.min, max: e.max }]));
+  }
+  toString() {
+    return this.ranges.map((e) => `[${e.min}-${e.max}]`).join(",");
+  }
+  union(e) {
+    const n = [...this.getRanges(), ...e.getRanges()].sort((i, s) => i.min < s.min ? -1 : i.min > s.min ? 1 : i.max < s.max ? -1 : s.max > i.max ? 1 : 0), r = [];
+    let o = n[0];
+    for (const i of n)
+      i.min > o.max + 1 ? (r.push(o), o = i) : i.max > o.max && (o = new N([{ min: o.min, max: i.max }]));
+    return r.push(o), r.length === 1 ? r[0] : new N(r);
+  }
+}
+function Ee(t) {
+  return Mt(t.subarray(2), void 0);
+}
+class Pe extends Error {
+  constructor(n) {
+    super(n);
+    T(this, "code");
+    this.code = "ERR_ABORTED";
+  }
+}
+function Ve(t) {
+  t.sort((o, i) => o.offset - i.offset);
+  const e = [];
+  let n, r;
+  for (const o of t)
+    n && r && o.offset - r <= 2e3 ? (n.length = n.length + o.length - r + o.offset, n.blocks.push(o)) : e.push(n = {
+      blocks: [o],
+      length: o.length,
+      offset: o.offset
+    }), r = n.offset + n.length;
+  return e;
+}
+function j(t) {
+  if (t && t.aborted)
+    if (typeof DOMException > "u") {
+      const e = new Pe("aborted");
+      throw e.code = "ERR_ABORTED", e;
+    } else
+      throw new DOMException("aborted", "AbortError");
+}
+const J = typeof TextDecoder < "u" ? new TextDecoder("utf8") : void 0;
+function Z(t, e, n, r) {
+  return t < r && e >= n;
+}
+class Dt {
+  constructor(e, n, r, o, i) {
+    T(this, "bbi");
+    T(this, "refsByName");
+    T(this, "cirTreeOffset");
+    T(this, "isCompressed");
+    T(this, "blockType");
+    T(this, "cirTreePromise");
+    T(this, "featureCache", new ut({
+      cache: new ft({ maxSize: 1e3 }),
+      fill: async ({ length: e, offset: n }, r) => this.bbi.read(e, n, { signal: r })
+    }));
+    if (this.bbi = e, this.refsByName = n, this.cirTreeOffset = r, this.isCompressed = o, this.blockType = i, !(r >= 0))
+      throw new Error("invalid cirTreeOffset!");
+  }
+  async readWigData(e, n, r, o, i) {
+    try {
+      const s = this.refsByName[e];
+      s === void 0 && o.complete();
+      const u = { chrId: s, start: n, end: r };
+      this.cirTreePromise || (this.cirTreePromise = this.bbi.read(48, this.cirTreeOffset, i));
+      const a = await this.cirTreePromise, d = new DataView(a.buffer).getUint32(4, !0);
+      let y = [], g = 0;
+      const f = (b, x, B) => {
+        try {
+          const p = b.subarray(x), w = new DataView(p.buffer, p.byteOffset, p.length);
+          let h = 0;
+          const U = w.getUint8(h);
+          h += 2;
+          const E = w.getUint16(h, !0);
+          if (h += 2, U === 1) {
+            const P = [];
+            for (let I = 0; I < E; I++) {
+              const O = w.getUint32(h, !0);
+              h += 4;
+              const V = w.getUint32(h, !0);
+              h += 4;
+              const _ = w.getUint32(h, !0);
+              h += 4;
+              const F = w.getUint32(h, !0);
+              h += 4;
+              const W = Number(w.getBigUint64(h, !0));
+              h += 8;
+              const Y = Number(w.getBigUint64(h, !0));
+              h += 8, P.push({
+                startChrom: O,
+                startBase: V,
+                endBase: F,
+                endChrom: _,
+                blockOffset: W,
+                blockSize: Y,
+                offset: h
+              });
+            }
+            y = y.concat(P.filter((I) => m(I)).map((I) => ({
+              offset: I.blockOffset,
+              length: I.blockSize
+            })));
+          } else if (U === 0) {
+            const P = [];
+            for (let O = 0; O < E; O++) {
+              const V = w.getUint32(h, !0);
+              h += 4;
+              const _ = w.getUint32(h, !0);
+              h += 4;
+              const F = w.getUint32(h, !0);
+              h += 4;
+              const W = w.getUint32(h, !0);
+              h += 4;
+              const Y = Number(w.getBigUint64(h, !0));
+              h += 8, P.push({
+                startChrom: V,
+                startBase: _,
+                endChrom: F,
+                endBase: W,
+                blockOffset: Y,
+                offset: h
+              });
+            }
+            const I = P.filter((O) => m(O)).map((O) => O.blockOffset);
+            I.length > 0 && v(I, B + 1);
+          }
+        } catch (S) {
+          o.error(S);
+        }
+      }, m = (b) => {
+        const { startChrom: x, startBase: B, endChrom: S, endBase: p } = b;
+        return (x < s || x === s && B <= r) && (S > s || S === s && p >= n);
+      }, l = async (b, x, B) => {
+        try {
+          const S = x.max - x.min, p = x.min, w = await this.featureCache.get(`${S}_${p}`, { length: S, offset: p }, i == null ? void 0 : i.signal);
+          for (const h of b)
+            x.contains(h) && (f(w, h - p, B), g -= 1, g === 0 && this.readFeatures(o, y, {
+              ...i,
+              request: u
+            }).catch((U) => {
+              o.error(U);
+            }));
+        } catch (S) {
+          o.error(S);
+        }
+      }, v = (b, x) => {
+        try {
+          g += b.length;
+          const B = 4 + d * 32;
+          let S = new N([
+            {
+              min: b[0],
+              max: b[0] + B
+            }
+          ]);
+          for (let p = 1; p < b.length; p += 1) {
+            const w = new N([
+              {
+                min: b[p],
+                max: b[p] + B
+              }
+            ]);
+            S = S.union(w);
+          }
+          S.getRanges().map((p) => l(b, p, x));
+        } catch (B) {
+          o.error(B);
+        }
+      };
+      v([this.cirTreeOffset + 48], 1);
+      return;
+    } catch (s) {
+      o.error(s);
+    }
+  }
+  parseSummaryBlock(e, n, r) {
+    const o = [];
+    let i = n;
+    const s = new DataView(e.buffer, e.byteOffset, e.length);
+    for (; i < e.byteLength; ) {
+      const u = s.getUint32(i, !0);
+      i += 4;
+      const a = s.getUint32(i, !0);
+      i += 4;
+      const c = s.getUint32(i, !0);
+      i += 4;
+      const d = s.getUint32(i, !0);
+      i += 4;
+      const y = s.getFloat32(i, !0);
+      i += 4;
+      const g = s.getFloat32(i, !0);
+      i += 4;
+      const f = s.getFloat32(i, !0);
+      i += 4, i += 4, (!r || u === r.chrId && Z(a, c, r.start, r.end)) && o.push({
+        start: a,
+        end: c,
+        maxScore: g,
+        minScore: y,
+        summary: !0,
+        score: f / (d || 1)
+      });
+    }
+    return o;
+  }
+  parseBigBedBlock(e, n, r, o) {
+    const i = [];
+    let s = n;
+    const u = e, a = new DataView(u.buffer, u.byteOffset, u.length);
+    for (; s < e.byteLength; ) {
+      const c = s, d = a.getUint32(s, !0);
+      s += 4;
+      const y = a.getInt32(s, !0);
+      s += 4;
+      const g = a.getInt32(s, !0);
+      s += 4;
+      let f = s;
+      for (; f < e.length && e[f] !== 0; f++)
+        ;
+      const m = e.subarray(s, f), l = (J == null ? void 0 : J.decode(m)) ?? m.toString();
+      s = f + 1, i.push({
+        chromId: d,
+        start: y,
+        end: g,
+        rest: l,
+        uniqueId: `bb-${r + c}`
+      });
+    }
+    return o ? i.filter((c) => Z(c.start, c.end, o.start, o.end)) : i;
+  }
+  parseBigWigBlock(e, n, r) {
+    const o = e.subarray(n), i = new DataView(o.buffer, o.byteOffset, o.length);
+    let s = 0;
+    s += 4;
+    const u = i.getInt32(s, !0);
+    s += 8;
+    const a = i.getUint32(s, !0);
+    s += 4;
+    const c = i.getUint32(s, !0);
+    s += 4;
+    const d = i.getUint8(s);
+    s += 2;
+    const y = i.getUint16(s, !0);
+    s += 2;
+    const g = new Array(y);
+    switch (d) {
+      case 1: {
+        for (let f = 0; f < y; f++) {
+          const m = i.getInt32(s, !0);
+          s += 4;
+          const l = i.getInt32(s, !0);
+          s += 4;
+          const v = i.getFloat32(s, !0);
+          s += 4, g[f] = {
+            start: m,
+            end: l,
+            score: v
+          };
+        }
+        break;
+      }
+      case 2: {
+        for (let f = 0; f < y; f++) {
+          const m = i.getInt32(s, !0);
+          s += 4;
+          const l = i.getFloat32(s, !0);
+          s += 4, g[f] = {
+            score: l,
+            start: m,
+            end: m + c
+          };
+        }
+        break;
+      }
+      case 3: {
+        for (let f = 0; f < y; f++) {
+          const m = i.getFloat32(s, !0);
+          s += 4;
+          const l = u + f * a;
+          g[f] = {
+            score: m,
+            start: l,
+            end: l + c
+          };
+        }
+        break;
+      }
+    }
+    return r ? g.filter((f) => Z(f.start, f.end, r.start, r.end)) : g;
+  }
+  async readFeatures(e, n, r = {}) {
+    try {
+      const { blockType: o, isCompressed: i } = this, { signal: s, request: u } = r, a = Ve(n);
+      j(s), await Promise.all(a.map(async (c) => {
+        j(s);
+        const { length: d, offset: y } = c, g = await this.featureCache.get(`${d}_${y}`, c, s);
+        for (const f of c.blocks) {
+          j(s);
+          let m = g.subarray(f.offset - c.offset);
+          switch (i && (m = Ee(m)), j(s), o) {
+            case "summary": {
+              e.next(this.parseSummaryBlock(m, 0, u));
+              break;
+            }
+            case "bigwig": {
+              e.next(this.parseBigWigBlock(m, 0, u));
+              break;
+            }
+            case "bigbed": {
+              e.next(this.parseBigBedBlock(m, 0, f.offset * 256, u));
+              break;
+            }
+            default:
+              console.warn(`Don't know what to do with ${o}`);
+          }
+        }
+      })), e.complete();
+    } catch (o) {
+      e.error(o);
+    }
+  }
+}
+const Ae = -2003829722, at = -2021002517;
+function R(t) {
+  return new DataView(t.buffer, t.byteOffset, t.length);
+}
+class Rt {
+  /*
+   * @param filehandle - a filehandle from generic-filehandle2
+   *
+   * @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(e) {
+    T(this, "bbi");
+    T(this, "headerP");
+    T(this, "renameRefSeqs");
+    const { filehandle: n, renameRefSeqs: r = (s) => s, path: o, url: i } = e;
+    if (this.renameRefSeqs = r, n)
+      this.bbi = n;
+    else if (i)
+      this.bbi = new zt(i);
+    else if (o)
+      this.bbi = new Lt(o);
+    else
+      throw new Error("no file given");
+  }
+  getHeader(e) {
+    return this.headerP || (this.headerP = this._getHeader(e).catch((n) => {
+      throw this.headerP = void 0, n;
+    })), this.headerP;
+  }
+  async _getHeader(e) {
+    const n = await this._getMainHeader(e), r = await this._readChromTree(n, e);
+    return {
+      ...n,
+      ...r
+    };
+  }
+  async _getMainHeader(e, n = 2e3) {
+    const r = await this.bbi.read(n, 0, e), o = R(r), i = o.getInt32(0, !0);
+    if (i !== Ae && i !== at)
+      throw new Error("not a BigWig/BigBed file");
+    let s = 0;
+    const u = o.getInt32(s, !0);
+    s += 4;
+    const a = o.getUint16(s, !0);
+    s += 2;
+    const c = o.getUint16(s, !0);
+    s += 2;
+    const d = Number(o.getBigUint64(s, !0));
+    s += 8;
+    const y = Number(o.getBigUint64(s, !0));
+    s += 8;
+    const g = Number(o.getBigUint64(s, !0));
+    s += 8;
+    const f = o.getUint16(s, !0);
+    s += 2;
+    const m = o.getUint16(s, !0);
+    s += 2;
+    const l = Number(o.getBigUint64(s, !0));
+    s += 8;
+    const v = Number(o.getBigUint64(s, !0));
+    s += 8;
+    const b = o.getUint32(s, !0);
+    s += 4;
+    const x = Number(o.getBigUint64(s, !0));
+    s += 8;
+    const B = [];
+    for (let h = 0; h < c; h++) {
+      const U = o.getUint32(s, !0);
+      s += 4;
+      const E = o.getUint32(s, !0);
+      s += 4;
+      const P = Number(o.getBigUint64(s, !0));
+      s += 8;
+      const I = Number(o.getBigUint64(s, !0));
+      s += 8, B.push({
+        reductionLevel: U,
+        reserved: E,
+        dataOffset: P,
+        indexOffset: I
+      });
+    }
+    const S = u === at ? "bigbed" : "bigwig";
+    if (l > n || v > n - 8 * 5)
+      return this._getMainHeader(e, n * 2);
+    let p;
+    if (v) {
+      const h = r.subarray(v);
+      let U = 0;
+      const E = R(h), P = Number(E.getBigUint64(U, !0));
+      U += 8;
+      const I = E.getFloat64(U, !0);
+      U += 8;
+      const O = E.getFloat64(U, !0);
+      U += 8;
+      const V = E.getFloat64(U, !0);
+      U += 8;
+      const _ = E.getFloat64(U, !0);
+      U += 8, p = {
+        scoreMin: I,
+        scoreMax: O,
+        scoreSum: V,
+        scoreSumSquares: _,
+        basesCovered: P
+      };
+    } else
+      throw new Error("no stats");
+    const w = new TextDecoder("utf8");
+    return {
+      zoomLevels: B,
+      magic: u,
+      extHeaderOffset: x,
+      numZoomLevels: c,
+      fieldCount: f,
+      totalSummary: p,
+      definedFieldCount: m,
+      uncompressBufSize: b,
+      asOffset: l,
+      chromTreeOffset: d,
+      totalSummaryOffset: v,
+      unzoomedDataOffset: y,
+      unzoomedIndexOffset: g,
+      fileType: S,
+      version: a,
+      autoSql: l ? w.decode(r.subarray(l, r.indexOf(0, l))) : ""
+    };
+  }
+  async _readChromTree(e, n) {
+    const r = [], o = {}, i = e.chromTreeOffset, s = R(await this.bbi.read(32, i, n));
+    let u = 0;
+    u += 4, u += 4;
+    const a = s.getUint32(u, !0);
+    u += 4;
+    const c = s.getUint32(u, !0);
+    u += 4, u += 8;
+    const d = new TextDecoder("utf8"), y = async (g) => {
+      const f = await this.bbi.read(4, g), m = R(f);
+      let l = 0;
+      const v = m.getUint8(l);
+      l += 1, l += 1;
+      const b = m.getUint16(l, !0);
+      if (l += 2, v) {
+        const x = await this.bbi.read(b * (a + c), g + l), B = R(x);
+        l = 0;
+        for (let S = 0; S < b; S++) {
+          const p = d.decode(x.subarray(l, l + a)).replaceAll("\0", "");
+          l += a;
+          const w = B.getUint32(l, !0);
+          l += 4;
+          const h = B.getUint32(l, !0);
+          l += 4, o[this.renameRefSeqs(p)] = w, r[w] = {
+            name: p,
+            id: w,
+            length: h
+          };
+        }
+      } else {
+        const x = [], B = R(await this.bbi.read(b * (a + 8), g + l));
+        l = 0;
+        for (let S = 0; S < b; S++) {
+          l += a;
+          const p = Number(B.getBigUint64(l, !0));
+          l += 8, x.push(y(p));
+        }
+        await Promise.all(x);
+      }
+    };
+    return await y(i + 32), {
+      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(e) {
+    const { unzoomedIndexOffset: n, refsByName: r, uncompressBufSize: o, fileType: i } = await this.getHeader(e);
+    return new Dt(this.bbi, r, n, o > 0, i);
+  }
+  /**
+   * 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(e, n, r, o) {
+    await this.getHeader(o);
+    const i = this.renameRefSeqs(e);
+    let s;
+    const { basesPerSpan: u, scale: a } = o || {};
+    return u ? s = await this.getView(1 / u, o) : a ? s = await this.getView(a, o) : s = await this.getView(1, o), new A((c) => {
+      s.readWigData(i, n, r, c, o).catch((d) => {
+        c.error(d);
+      });
+    });
+  }
+  async getFeatures(e, n, r, o) {
+    const i = await this.getFeatureStream(e, n, r, o);
+    return (await Vt(i.pipe(Te()))).flat();
+  }
+}
+class ze extends Rt {
+  /**
+   * 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(e, n) {
+    const { zoomLevels: r, refsByName: o, uncompressBufSize: i } = await this.getHeader(n), s = 1 / e, u = r.length - 1;
+    for (let a = u; a >= 0; a -= 1) {
+      const c = r[a];
+      if (c && c.reductionLevel <= 2 * s)
+        return new Dt(this.bbi, o, c.indexOffset, i > 0, "summary");
+    }
+    return this.getUnzoomedView(n);
+  }
+}
+function _e(t) {
+  return t.filter((e) => !!e);
+}
+class Le extends Rt {
+  constructor() {
+    super(...arguments);
+    T(this, "readIndicesCache", new ut({
+      cache: new ft({ maxSize: 1 }),
+      fill: (n, r) => this._readIndices({ ...n, signal: r })
+    }));
+  }
+  readIndices(n = {}) {
+    const { signal: r, ...o } = n;
+    return this.readIndicesCache.get(JSON.stringify(o), n, r);
+  }
+  /*
+   * retrieve unzoomed view for any scale
+   */
+  async getView(n, r) {
+    return this.getUnzoomedView(r);
+  }
+  /*
+   * 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: r } = await this.getHeader(n), o = await this.bbi.read(64, r), i = new DataView(o.buffer, o.byteOffset, o.length);
+    let s = 0;
+    s += 2;
+    const u = i.getUint16(s, !0);
+    s += 2;
+    const a = Number(i.getBigUint64(s, !0));
+    if (s += 8, u === 0)
+      return [];
+    const c = 20, d = c * u, y = await this.bbi.read(d, a), g = [];
+    for (let f = 0; f < u; f += 1) {
+      const m = y.subarray(f * c), l = new DataView(m.buffer, m.byteOffset, m.length);
+      let v = 0;
+      const b = l.getInt16(v, !0);
+      v += 2;
+      const x = l.getInt16(v, !0);
+      v += 2;
+      const B = Number(l.getBigUint64(v, !0));
+      v += 12;
+      const S = l.getInt16(v, !0);
+      g.push({
+        type: b,
+        fieldcount: x,
+        offset: B,
+        field: S
+      });
+    }
+    return g;
+  }
+  /*
+   * 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, r = {}) {
+    const o = await this.readIndices(r);
+    if (o.length === 0)
+      return [];
+    const i = new TextDecoder("utf8"), s = o.map(async (u) => {
+      const { offset: a, field: c } = u, d = await this.bbi.read(32, a, r), y = new DataView(d.buffer, d.byteOffset, d.length);
+      let g = 0;
+      g += 4;
+      const f = y.getInt32(g, !0);
+      g += 4;
+      const m = y.getInt32(g, !0);
+      g += 4;
+      const l = y.getInt32(g, !0);
+      g += 4, g += 8;
+      const v = async (b) => {
+        const x = b, B = 4 + f * (m + l), p = await this.bbi.read(B, x, r), w = new DataView(p.buffer, p.byteOffset, p.length);
+        let h = 0;
+        const U = w.getInt8(h);
+        h += 2;
+        const E = w.getInt16(h, !0);
+        h += 2;
+        const P = [];
+        if (U === 0) {
+          const I = [];
+          for (let V = 0; V < E; V++) {
+            const _ = i.decode(p.subarray(h, h + m)).replaceAll("\0", "");
+            h += m;
+            const F = Number(w.getBigUint64(h, !0));
+            h += 8, I.push({
+              key: _,
+              offset: F
+            });
+          }
+          let O = 0;
+          for (const { key: V, offset: _ } of I) {
+            if (n.localeCompare(V) < 0 && O)
+              return v(O);
+            O = _;
+          }
+          return v(O);
+        } else if (U === 1) {
+          for (let I = 0; I < E; I++) {
+            const O = i.decode(p.subarray(h, h + m)).replaceAll("\0", "");
+            h += m;
+            const V = Number(w.getBigUint64(h, !0));
+            h += 8;
+            const _ = w.getUint32(h, !0);
+            h += 4;
+            const F = w.getUint32(h, !0);
+            h += 4, P.push({
+              key: O,
+              offset: V,
+              length: _,
+              reserved: F
+            });
+          }
+          for (const I of P)
+            if (I.key === n)
+              return {
+                ...I,
+                field: c
+              };
+          return;
+        }
+      };
+      return v(a + 32);
+    });
+    return _e(await Promise.all(s));
+  }
+  /*
+   * 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 - options object with optional AboutSignal
+   *
+   * @return array of Feature
+   */
+  async searchExtraIndex(n, r = {}) {
+    const o = await this.searchExtraIndexBlocks(n, r);
+    if (o.length === 0)
+      return [];
+    const i = await this.getUnzoomedView(r), s = o.map((a) => new A((c) => {
+      i.readFeatures(c, [a], r).catch((d) => {
+        c.error(d);
+      });
+    }).pipe(Ft((c, d) => c.concat(d)), At((c) => {
+      for (const d of c)
+        d.field = a.field;
+      return c;
+    })));
+    return (await Vt(Ue(...s))).filter((a) => {
+      var c;
+      return ((c = a.rest) == null ? void 0 : c.split("	")[(a.field || 0) - 3]) === n;
+    });
+  }
+}
+export {
+  Le as BigBed,
+  ze as BigWig
+};