@genome-spy/app 0.57.0 → 0.58.0

package/dist/{index-C159nEYc.js → index-CCJIjehY.js}

@@ -1,7 +1,7 @@
-import { g as l } from "./_commonjsHelpers-DjF3Plf2.js";
-class d {
-}
+import { g as u } from "./_commonjsHelpers-DjF3Plf2.js";
 class f {
+}
+class b {
   constructor() {
     this.signals = /* @__PURE__ */ new Set(), this.abortController = new AbortController();
   }
@@ -11,7 +11,7 @@ class f {
    *  longer be abortable.
    */
   //@ts-ignore
-  addSignal(t = new d()) {
+  addSignal(t = new f()) {
     if (this.signal.aborted)
       throw new Error("cannot add a signal, already aborted!");
     this.signals.add(t), t.aborted ? this.handleAborted(t) : typeof t.addEventListener == "function" && t.addEventListener("abort", () => {
@@ -28,7 +28,7 @@ class f {
     this.abortController.abort();
   }
 }
-class u {
+class g {
   constructor() {
     this.callbacks = /* @__PURE__ */ new Set();
   }
@@ -42,7 +42,7 @@ class u {
       e(t);
   }
 }
-class n {
+class l {
   constructor({ fill: t, cache: e }) {
     if (typeof t != "function")
       throw new TypeError("must pass a fill function");
@@ -65,13 +65,13 @@ class n {
   evict(t, e) {
     this.cache.get(t) === e && this.cache.delete(t);
   }
-  fill(t, e, r, a) {
-    const s = new f(), c = new u();
-    c.addCallback(a);
-    const i = {
+  fill(t, e, r, i) {
+    const s = new b(), c = new g();
+    c.addCallback(i);
+    const a = {
       aborter: s,
-      promise: this.fillCallback(e, s.signal, (o) => {
-        c.callback(o);
+      promise: this.fillCallback(e, s.signal, (h) => {
+        c.callback(h);
       }),
       settled: !1,
       statusReporter: c,
@@ -79,23 +79,23 @@ class n {
         return this.aborter.signal.aborted;
       }
     };
-    i.aborter.addSignal(r), i.aborter.signal.addEventListener("abort", () => {
-      i.settled || this.evict(t, i);
-    }), i.promise.then(() => {
-      i.settled = !0;
+    a.aborter.addSignal(r), a.aborter.signal.addEventListener("abort", () => {
+      a.settled || this.evict(t, a);
+    }), a.promise.then(() => {
+      a.settled = !0;
     }, () => {
-      i.settled = !0, this.evict(t, i);
-    }).catch((o) => {
-      throw console.error(o), o;
-    }), this.cache.set(t, i);
+      a.settled = !0, this.evict(t, a);
+    }).catch((h) => {
+      throw console.error(h), h;
+    }), this.cache.set(t, a);
   }
   static checkSinglePromise(t, e) {
     function r() {
       if (e != null && e.aborted)
         throw Object.assign(new Error("aborted"), { code: "ERR_ABORTED" });
     }
-    return t.then((a) => (r(), a), (a) => {
-      throw r(), a;
+    return t.then((i) => (r(), i), (i) => {
+      throw r(), i;
     });
   }
   has(t) {
@@ -113,11 +113,11 @@ class n {
    * @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(t, e, r, a) {
+  get(t, e, r, i) {
     if (!r && e instanceof AbortSignal)
       throw new TypeError("second get argument appears to be an AbortSignal, perhaps you meant to pass `null` for the fill data?");
     const s = this.cache.get(t);
-    return s ? s.aborted && !s.settled ? (this.evict(t, s), this.get(t, e, r, a)) : s.settled ? s.promise : (s.aborter.addSignal(r), s.statusReporter.addCallback(a), n.checkSinglePromise(s.promise, r)) : (this.fill(t, e, r, a), n.checkSinglePromise(
+    return s ? s.aborted && !s.settled ? (this.evict(t, s), this.get(t, e, r, i)) : s.settled ? s.promise : (s.aborter.addSignal(r), s.statusReporter.addCallback(i), l.checkSinglePromise(s.promise, r)) : (this.fill(t, e, r, i), l.checkSinglePromise(
       //see https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#non-null-assertion-operator-postfix-
       this.cache.get(t).promise,
       r
@@ -145,68 +145,74 @@ class n {
     return e;
   }
 }
-class b {
-  constructor(t = {}) {
-    if (!(t.maxSize && t.maxSize > 0))
-      throw new TypeError("`maxSize` must be a number greater than 0");
-    this.maxSize = t.maxSize, this.cache = /* @__PURE__ */ new Map(), this.oldCache = /* @__PURE__ */ new Map(), this._size = 0;
-  }
-  _set(t, e) {
-    this.cache.set(t, e), this._size++, this._size >= this.maxSize && (this._size = 0, this.oldCache = this.cache, this.cache = /* @__PURE__ */ new Map());
-  }
-  get(t) {
-    if (this.cache.has(t))
-      return this.cache.get(t);
-    if (this.oldCache.has(t)) {
-      const e = this.oldCache.get(t);
-      return this.oldCache.delete(t), this._set(t, e), e;
+var n, d;
+function p() {
+  if (d) return n;
+  d = 1;
+  class o {
+    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(t, e) {
-    return this.cache.has(t) ? this.cache.set(t, e) : this._set(t, e), this;
-  }
-  has(t) {
-    return this.cache.has(t) || this.oldCache.has(t);
-  }
-  peek(t) {
-    if (this.cache.has(t))
-      return this.cache.get(t);
-    if (this.oldCache.has(t))
-      return this.oldCache.get(t);
-  }
-  delete(t) {
-    const e = this.cache.delete(t);
-    return e && this._size--, this.oldCache.delete(t) || e;
-  }
-  clear() {
-    this.cache.clear(), this.oldCache.clear(), this._size = 0;
-  }
-  *keys() {
-    for (const [t] of this)
-      yield t;
-  }
-  *values() {
-    for (const [, t] of this)
-      yield t;
-  }
-  *[Symbol.iterator]() {
-    for (const t of this.cache)
-      yield t;
-    for (const t of this.oldCache) {
-      const [e] = t;
-      this.cache.has(e) || (yield t);
+    _set(e, r) {
+      this.cache.set(e, r), 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 r = this.oldCache.get(e);
+        return this.oldCache.delete(e), this._set(e, r), r;
+      }
+    }
+    set(e, r) {
+      return this.cache.has(e) ? this.cache.set(e, r) : this._set(e, r), 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 r = this.cache.delete(e);
+      return r && this._size--, this.oldCache.delete(e) || r;
+    }
+    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 [r] = e;
+        this.cache.has(r) || (yield e);
+      }
+    }
+    get size() {
+      let e = 0;
+      for (const r of this.oldCache.keys())
+        this.cache.has(r) || e++;
+      return this._size + e;
     }
   }
-  get size() {
-    let t = 0;
-    for (const e of this.oldCache.keys())
-      this.cache.has(e) || t++;
-    return this._size + t;
-  }
+  return n = o, n;
 }
-var g = b;
-const p = /* @__PURE__ */ l(g);
+var m = p();
+const C = /* @__PURE__ */ u(m);
 export {
-  n as A,
-  p as L
+  l as A,
+  C as L
 };