@genome-spy/core 0.37.3 → 0.38.0

package/dist/bundle/index-LD6yPc3X.js

@@ -0,0 +1,515 @@
+import { c as v, g as D } from "./_commonjsHelpers-QtkX90xp.js";
+var j = {}, m = {}, h = {}, g = {};
+Object.defineProperty(g, "__esModule", { value: !0 });
+function A(r, e) {
+  if (!(r instanceof e))
+    throw new TypeError("Cannot call a class as a function");
+}
+function P(r, e) {
+  for (var t = 0; t < e.length; t++) {
+    var o = e[t];
+    o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(r, o.key, o);
+  }
+}
+function E(r, e, t) {
+  return e && P(r.prototype, e), t && P(r, t), Object.defineProperty(r, "prototype", {
+    writable: !1
+  }), r;
+}
+function B(r, e) {
+  if (typeof e != "function" && e !== null)
+    throw new TypeError("Super expression must either be null or a function");
+  r.prototype = Object.create(e && e.prototype, {
+    constructor: {
+      value: r,
+      writable: !0,
+      configurable: !0
+    }
+  }), Object.defineProperty(r, "prototype", {
+    writable: !1
+  }), e && w(r, e);
+}
+function d(r) {
+  return d = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(t) {
+    return t.__proto__ || Object.getPrototypeOf(t);
+  }, d(r);
+}
+function w(r, e) {
+  return w = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(o, n) {
+    return o.__proto__ = n, o;
+  }, w(r, e);
+}
+function $() {
+  if (typeof Reflect > "u" || !Reflect.construct || Reflect.construct.sham)
+    return !1;
+  if (typeof Proxy == "function")
+    return !0;
+  try {
+    return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    })), !0;
+  } catch {
+    return !1;
+  }
+}
+function p(r) {
+  if (r === void 0)
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return r;
+}
+function Y(r, e) {
+  if (e && (typeof e == "object" || typeof e == "function"))
+    return e;
+  if (e !== void 0)
+    throw new TypeError("Derived constructors may only return object or undefined");
+  return p(r);
+}
+function G(r) {
+  var e = $();
+  return function() {
+    var o = d(r), n;
+    if (e) {
+      var a = d(this).constructor;
+      n = Reflect.construct(o, arguments, a);
+    } else
+      n = o.apply(this, arguments);
+    return Y(this, n);
+  };
+}
+function U(r, e) {
+  for (; !Object.prototype.hasOwnProperty.call(r, e) && (r = d(r), r !== null); )
+    ;
+  return r;
+}
+function y() {
+  return typeof Reflect < "u" && Reflect.get ? y = Reflect.get.bind() : y = function(e, t, o) {
+    var n = U(e, t);
+    if (n) {
+      var a = Object.getOwnPropertyDescriptor(n, t);
+      return a.get ? a.get.call(arguments.length < 3 ? e : o) : a.value;
+    }
+  }, y.apply(this, arguments);
+}
+var T = /* @__PURE__ */ function() {
+  function r() {
+    A(this, r), Object.defineProperty(this, "listeners", {
+      value: {},
+      writable: !0,
+      configurable: !0
+    });
+  }
+  return E(r, [{
+    key: "addEventListener",
+    value: function(t, o, n) {
+      t in this.listeners || (this.listeners[t] = []), this.listeners[t].push({
+        callback: o,
+        options: n
+      });
+    }
+  }, {
+    key: "removeEventListener",
+    value: function(t, o) {
+      if (t in this.listeners) {
+        for (var n = this.listeners[t], a = 0, c = n.length; a < c; a++)
+          if (n[a].callback === o) {
+            n.splice(a, 1);
+            return;
+          }
+      }
+    }
+  }, {
+    key: "dispatchEvent",
+    value: function(t) {
+      if (t.type in this.listeners) {
+        for (var o = this.listeners[t.type], n = o.slice(), a = 0, c = n.length; a < c; a++) {
+          var i = n[a];
+          try {
+            i.callback.call(this, t);
+          } catch (l) {
+            Promise.resolve().then(function() {
+              throw l;
+            });
+          }
+          i.options && i.options.once && this.removeEventListener(t.type, i.callback);
+        }
+        return !t.defaultPrevented;
+      }
+    }
+  }]), r;
+}(), R = /* @__PURE__ */ function(r) {
+  B(t, r);
+  var e = G(t);
+  function t() {
+    var o;
+    return A(this, t), o = e.call(this), o.listeners || T.call(p(o)), Object.defineProperty(p(o), "aborted", {
+      value: !1,
+      writable: !0,
+      configurable: !0
+    }), Object.defineProperty(p(o), "onabort", {
+      value: null,
+      writable: !0,
+      configurable: !0
+    }), Object.defineProperty(p(o), "reason", {
+      value: void 0,
+      writable: !0,
+      configurable: !0
+    }), o;
+  }
+  return E(t, [{
+    key: "toString",
+    value: function() {
+      return "[object AbortSignal]";
+    }
+  }, {
+    key: "dispatchEvent",
+    value: function(n) {
+      n.type === "abort" && (this.aborted = !0, typeof this.onabort == "function" && this.onabort.call(this, n)), y(d(t.prototype), "dispatchEvent", this).call(this, n);
+    }
+  }]), t;
+}(T), k = /* @__PURE__ */ function() {
+  function r() {
+    A(this, r), Object.defineProperty(this, "signal", {
+      value: new R(),
+      writable: !0,
+      configurable: !0
+    });
+  }
+  return E(r, [{
+    key: "abort",
+    value: function(t) {
+      var o;
+      try {
+        o = new Event("abort");
+      } catch {
+        typeof document < "u" ? document.createEvent ? (o = document.createEvent("Event"), o.initEvent("abort", !1, !1)) : (o = document.createEventObject(), o.type = "abort") : o = {
+          type: "abort",
+          bubbles: !1,
+          cancelable: !1
+        };
+      }
+      var n = t;
+      if (n === void 0)
+        if (typeof document > "u")
+          n = new Error("This operation was aborted"), n.name = "AbortError";
+        else
+          try {
+            n = new DOMException("signal is aborted without reason");
+          } catch {
+            n = new Error("This operation was aborted"), n.name = "AbortError";
+          }
+      this.signal.reason = n, this.signal.dispatchEvent(o);
+    }
+  }, {
+    key: "toString",
+    value: function() {
+      return "[object AbortController]";
+    }
+  }]), r;
+}();
+typeof Symbol < "u" && Symbol.toStringTag && (k.prototype[Symbol.toStringTag] = "AbortController", R.prototype[Symbol.toStringTag] = "AbortSignal");
+function Q(r) {
+  return r.__FORCE_INSTALL_ABORTCONTROLLER_POLYFILL ? (console.log("__FORCE_INSTALL_ABORTCONTROLLER_POLYFILL=true is set, will force install polyfill"), !0) : typeof r.Request == "function" && !r.Request.prototype.hasOwnProperty("signal") || !r.AbortController;
+}
+function H(r) {
+  typeof r == "function" && (r = {
+    fetch: r
+  });
+  var e = r, t = e.fetch, o = e.Request, n = o === void 0 ? t.Request : o, a = e.AbortController, c = e.__FORCE_INSTALL_ABORTCONTROLLER_POLYFILL, i = c === void 0 ? !1 : c;
+  if (!Q({
+    fetch: t,
+    Request: n,
+    AbortController: a,
+    __FORCE_INSTALL_ABORTCONTROLLER_POLYFILL: i
+  }))
+    return {
+      fetch: t,
+      Request: l
+    };
+  var l = n;
+  (l && !l.prototype.hasOwnProperty("signal") || i) && (l = function(b, s) {
+    var f;
+    s && s.signal && (f = s.signal, delete s.signal);
+    var u = new n(b, s);
+    return f && Object.defineProperty(u, "signal", {
+      writable: !1,
+      enumerable: !1,
+      configurable: !0,
+      value: f
+    }), u;
+  }, l.prototype = n.prototype);
+  var L = t, N = function(b, s) {
+    var f = l && l.prototype.isPrototypeOf(b) ? b.signal : s ? s.signal : void 0;
+    if (f) {
+      var u;
+      try {
+        u = new DOMException("Aborted", "AbortError");
+      } catch {
+        u = new Error("Aborted"), u.name = "AbortError";
+      }
+      if (f.aborted)
+        return Promise.reject(u);
+      var q = new Promise(function(I, x) {
+        f.addEventListener("abort", function() {
+          return x(u);
+        }, {
+          once: !0
+        });
+      });
+      return s && s.signal && delete s.signal, Promise.race([q, L(b, s)]);
+    }
+    return L(b, s);
+  };
+  return {
+    fetch: N,
+    Request: l
+  };
+}
+g.AbortController = k;
+g.AbortSignal = R;
+g.abortableFetch = H;
+Object.defineProperty(h, "__esModule", { value: !0 });
+h.AbortSignal = h.AbortController = void 0;
+const F = g;
+var _ = function() {
+  if (typeof self < "u")
+    return self;
+  if (typeof window < "u")
+    return window;
+  if (typeof globalThis < "u")
+    return globalThis;
+  throw new Error("unable to locate global object");
+};
+let J = typeof _().AbortController > "u" ? F.AbortController : _().AbortController;
+h.AbortController = J;
+let K = typeof _().AbortController > "u" ? F.AbortSignal : _().AbortSignal;
+h.AbortSignal = K;
+var S = {};
+Object.defineProperty(S, "__esModule", { value: !0 });
+const V = h;
+class W {
+}
+class X {
+  constructor() {
+    this.signals = /* @__PURE__ */ new Set(), this.abortController = new V.AbortController();
+  }
+  /**
+   * @param {AbortSignal} [signal] optional AbortSignal to add. if falsy,
+   *  will be treated as a null-signal, and this abortcontroller will no
+   *  longer be abortable.
+   */
+  //@ts-ignore
+  addSignal(e = new W()) {
+    if (this.signal.aborted)
+      throw new Error("cannot add a signal, already aborted!");
+    this.signals.add(e), e.aborted ? this.handleAborted(e) : typeof e.addEventListener == "function" && e.addEventListener("abort", () => {
+      this.handleAborted(e);
+    });
+  }
+  handleAborted(e) {
+    this.signals.delete(e), this.signals.size === 0 && this.abortController.abort();
+  }
+  get signal() {
+    return this.abortController.signal;
+  }
+  abort() {
+    this.abortController.abort();
+  }
+}
+S.default = X;
+var C = {};
+Object.defineProperty(C, "__esModule", { value: !0 });
+class Z {
+  constructor() {
+    this.callbacks = /* @__PURE__ */ new Set();
+  }
+  addCallback(e = () => {
+  }) {
+    this.callbacks.add(e), e(this.currentMessage);
+  }
+  callback(e) {
+    this.currentMessage = e, this.callbacks.forEach((t) => {
+      t(e);
+    });
+  }
+}
+C.default = Z;
+var z = v && v.__importDefault || function(r) {
+  return r && r.__esModule ? r : { default: r };
+};
+Object.defineProperty(m, "__esModule", { value: !0 });
+const ee = h, te = z(S), re = z(C);
+class O {
+  constructor({ fill: e, cache: t }) {
+    if (typeof e != "function")
+      throw new TypeError("must pass a fill function");
+    if (typeof t != "object")
+      throw new TypeError("must pass a cache object");
+    if (typeof t.get != "function" || typeof t.set != "function" || typeof t.delete != "function")
+      throw new TypeError("cache must implement get(key), set(key, val), and and delete(key)");
+    this.cache = t, this.fillCallback = e;
+  }
+  static isAbortException(e) {
+    return (
+      // DOMException
+      e.name === "AbortError" || // standard-ish non-DOM abort exception
+      //@ts-ignore
+      e.code === "ERR_ABORTED" || // stringified DOMException
+      e.message === "AbortError: aborted" || // stringified standard-ish exception
+      e.message === "Error: aborted"
+    );
+  }
+  evict(e, t) {
+    this.cache.get(e) === t && this.cache.delete(e);
+  }
+  fill(e, t, o, n) {
+    const a = new te.default(), c = new re.default();
+    c.addCallback(n);
+    const i = {
+      aborter: a,
+      promise: this.fillCallback(t, a.signal, (l) => {
+        c.callback(l);
+      }),
+      settled: !1,
+      statusReporter: c,
+      get aborted() {
+        return this.aborter.signal.aborted;
+      }
+    };
+    i.aborter.addSignal(o), i.aborter.signal.addEventListener("abort", () => {
+      i.settled || this.evict(e, i);
+    }), i.promise.then(() => {
+      i.settled = !0;
+    }, () => {
+      i.settled = !0, this.evict(e, i);
+    }).catch((l) => {
+      throw console.error(l), l;
+    }), this.cache.set(e, i);
+  }
+  static checkSinglePromise(e, t) {
+    function o() {
+      if (t && t.aborted)
+        throw Object.assign(new Error("aborted"), { code: "ERR_ABORTED" });
+    }
+    return e.then((n) => (o(), n), (n) => {
+      throw o(), n;
+    });
+  }
+  has(e) {
+    return this.cache.has(e);
+  }
+  /**
+   * Callback for getting status of the pending async
+   *
+   * @callback statusCallback
+   * @param {any} status, current status string or message object
+   */
+  /**
+   * @param {any} key cache key to use for this request
+   * @param {any} data data passed as the first argument to the fill callback
+   * @param {AbortSignal} [signal] optional AbortSignal object that aborts the request
+   * @param {statusCallback} a callback to get the current status of a pending async operation
+   */
+  get(e, t, o, n) {
+    if (!o && t instanceof ee.AbortSignal)
+      throw new TypeError("second get argument appears to be an AbortSignal, perhaps you meant to pass `null` for the fill data?");
+    const a = this.cache.get(e);
+    return a ? a.aborted && !a.settled ? (this.evict(e, a), this.get(e, t, o, n)) : a.settled ? a.promise : (a.aborter.addSignal(o), a.statusReporter.addCallback(n), O.checkSinglePromise(a.promise, o)) : (this.fill(e, t, o, n), O.checkSinglePromise(
+      //see https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#non-null-assertion-operator-postfix-
+      //eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      this.cache.get(e).promise,
+      o
+    ));
+  }
+  /**
+   * delete the given entry from the cache. if it exists and its fill request has
+   * not yet settled, the fill will be signaled to abort.
+   *
+   * @param {any} key
+   */
+  delete(e) {
+    const t = this.cache.get(e);
+    t && (t.settled || t.aborter.abort(), this.cache.delete(e));
+  }
+  /**
+   * Clear all requests from the cache. Aborts any that have not settled.
+   * @returns {number} count of entries deleted
+   */
+  clear() {
+    const e = this.cache.keys();
+    let t = 0;
+    for (let o = e.next(); !o.done; o = e.next())
+      this.delete(o.value), t += 1;
+    return t;
+  }
+}
+m.default = O;
+var oe = v && v.__importDefault || function(r) {
+  return r && r.__esModule ? r : { default: r };
+};
+Object.defineProperty(j, "__esModule", { value: !0 });
+const ne = oe(m);
+var se = j.default = ne.default;
+class ae {
+  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, t) {
+    this.cache.set(e, t), 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 t = this.oldCache.get(e);
+      return this.oldCache.delete(e), this._set(e, t), t;
+    }
+  }
+  set(e, t) {
+    return this.cache.has(e) ? this.cache.set(e, t) : this._set(e, t), 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 t = this.cache.delete(e);
+    return t && this._size--, this.oldCache.delete(e) || t;
+  }
+  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 [t] = e;
+      this.cache.has(t) || (yield e);
+    }
+  }
+  get size() {
+    let e = 0;
+    for (const t of this.oldCache.keys())
+      this.cache.has(t) || e++;
+    return this._size + e;
+  }
+}
+var ie = ae;
+const ce = /* @__PURE__ */ D(ie);
+export {
+  ce as L,
+  se as _
+};