@genome-spy/core 0.65.0 → 0.67.0

package/dist/bundle/index-Cq3QFUxX.js

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