@genome-spy/core 0.64.0 → 0.66.1

package/dist/bundle/{index-CCJIjehY.js → AbortablePromiseCache-CcuMrnn7.js}

@@ -1,7 +1,6 @@
-import { g as u } from "./_commonjsHelpers-DjF3Plf2.js";
-class f {
+class h {
 }
-class b {
+class d {
   constructor() {
     this.signals = /* @__PURE__ */ new Set(), this.abortController = new AbortController();
   }
@@ -11,7 +10,7 @@ class b {
    *  longer be abortable.
    */
   //@ts-ignore
-  addSignal(t = new f()) {
+  addSignal(t = new h()) {
     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,13 +27,13 @@ class b {
     this.abortController.abort();
   }
 }
-class g {
+class b {
   constructor() {
     this.callbacks = /* @__PURE__ */ new Set();
   }
   addCallback(t = () => {
   }) {
-    this.callbacks.add(t), t(this.currentMessage);
+    this.callbacks.add(t), this.currentMessage && t(this.currentMessage);
   }
   callback(t) {
     this.currentMessage = t;
@@ -42,7 +41,7 @@ class g {
       e(t);
   }
 }
-class l {
+class c {
   constructor({ fill: t, cache: e }) {
     if (typeof t != "function")
       throw new TypeError("must pass a fill function");
@@ -65,16 +64,16 @@ class l {
   evict(t, e) {
     this.cache.get(t) === e && this.cache.delete(t);
   }
-  fill(t, e, r, i) {
-    const s = new b(), c = new g();
-    c.addCallback(i);
+  fill(t, e, r, s) {
+    const o = new d(), i = new b();
+    i.addCallback(s);
     const a = {
-      aborter: s,
-      promise: this.fillCallback(e, s.signal, (h) => {
-        c.callback(h);
+      aborter: o,
+      promise: this.fillCallback(e, o.signal, (n) => {
+        i.callback(n);
       }),
       settled: !1,
-      statusReporter: c,
+      statusReporter: i,
       get aborted() {
         return this.aborter.signal.aborted;
       }
@@ -85,8 +84,8 @@ class l {
       a.settled = !0;
     }, () => {
       a.settled = !0, this.evict(t, a);
-    }).catch((h) => {
-      throw console.error(h), h;
+    }).catch((n) => {
+      throw console.error(n), n;
     }), this.cache.set(t, a);
   }
   static checkSinglePromise(t, e) {
@@ -94,8 +93,8 @@ class l {
       if (e != null && e.aborted)
         throw Object.assign(new Error("aborted"), { code: "ERR_ABORTED" });
     }
-    return t.then((i) => (r(), i), (i) => {
-      throw r(), i;
+    return t.then((s) => (r(), s), (s) => {
+      throw r(), s;
     });
   }
   has(t) {
@@ -113,12 +112,12 @@ class l {
    * @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, i) {
+  get(t, e, r, s) {
     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, 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-
+    const o = this.cache.get(t);
+    return o ? o.aborted && !o.settled ? (this.evict(t, o), this.get(t, e, r, s)) : o.settled ? o.promise : (o.aborter.addSignal(r), o.statusReporter.addCallback(s), c.checkSinglePromise(o.promise, r)) : (this.fill(t, e, r, s), c.checkSinglePromise(
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
       this.cache.get(t).promise,
       r
     ));
@@ -145,74 +144,6 @@ class l {
     return 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(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;
-    }
-  }
-  return n = o, n;
-}
-var m = p();
-const C = /* @__PURE__ */ u(m);
 export {
-  l as A,
-  C as L
+  c as A
 };

package/dist/bundle/browser-BRemItdO.js

@@ -0,0 +1,138 @@
+class f {
+  constructor(e) {
+    this.blob = e;
+  }
+  async read(e, r = 0) {
+    if (!e)
+      return new Uint8Array(0);
+    const s = r, n = s + e, a = this.blob.slice(s, n);
+    return a.bytes ? a.bytes() : new Uint8Array(await a.arrayBuffer());
+  }
+  async readFile(e) {
+    const r = typeof e == "string" ? e : e == null ? void 0 : e.encoding;
+    if (r === "utf8")
+      return this.blob.text();
+    if (r)
+      throw new Error(`unsupported encoding: ${r}`);
+    return this.blob.bytes ? this.blob.bytes() : new Uint8Array(await this.blob.arrayBuffer());
+  }
+  async stat() {
+    return { size: this.blob.size };
+  }
+  async close() {
+  }
+}
+function d(i) {
+  return (typeof i == "object" && i !== null && "message" in i ? i.message : `${i}`).replace(/\.$/, "");
+}
+class u {
+  constructor(e, r = {}) {
+    this.baseOverrides = {}, this.url = e;
+    const s = r.fetch || globalThis.fetch.bind(globalThis);
+    r.overrides && (this.baseOverrides = r.overrides), this.fetchImplementation = s;
+  }
+  async fetch(e, r) {
+    const s = (a) => new Error(`${d(a)} fetching ${e}`, { cause: a });
+    let n;
+    try {
+      n = await this.fetchImplementation(e, r);
+    } catch (a) {
+      if (`${a}`.includes("Failed to fetch")) {
+        console.warn(`generic-filehandle: refetching ${e} to attempt to work around chrome CORS header caching bug`);
+        try {
+          n = await this.fetchImplementation(e, {
+            ...r,
+            cache: "reload"
+          });
+        } catch (c) {
+          throw s(c);
+        }
+      } else
+        throw s(a);
+    }
+    return n;
+  }
+  async read(e, r, s = {}) {
+    if (e === 0)
+      return new Uint8Array(0);
+    const { headers: n = {}, signal: a, overrides: c = {} } = s;
+    e < 1 / 0 ? n.range = `bytes=${r}-${r + e - 1}` : e === 1 / 0 && r !== 0 && (n.range = `bytes=${r}-`);
+    const t = await this.fetch(this.url, {
+      ...this.baseOverrides,
+      ...c,
+      headers: {
+        ...this.baseOverrides.headers,
+        ...c.headers,
+        ...n
+      },
+      method: "GET",
+      redirect: "follow",
+      mode: "cors",
+      signal: a
+    });
+    if (!t.ok)
+      throw new Error(`HTTP ${t.status} fetching ${this.url}`);
+    if (t.status === 200 && r === 0 || t.status === 206) {
+      const l = t.headers.get("content-range"), o = /\/(\d+)$/.exec(l || "");
+      o != null && o[1] && (this._stat = {
+        size: parseInt(o[1], 10)
+      });
+      const h = t.bytes ? await t.bytes() : new Uint8Array(await t.arrayBuffer());
+      return h.byteLength <= e ? h : h.subarray(0, e);
+    }
+    throw new Error(t.status === 200 ? `${this.url} fetch returned status 200, expected 206` : `HTTP ${t.status} fetching ${this.url}`);
+  }
+  async readFile(e = {}) {
+    let r, s;
+    if (typeof e == "string")
+      r = e, s = {};
+    else {
+      r = e.encoding;
+      const { encoding: l, ...o } = e;
+      s = o;
+    }
+    const { headers: n = {}, signal: a, overrides: c = {} } = s, t = await this.fetch(this.url, {
+      ...this.baseOverrides,
+      ...c,
+      headers: {
+        ...this.baseOverrides.headers,
+        ...c.headers,
+        ...n
+      },
+      method: "GET",
+      redirect: "follow",
+      mode: "cors",
+      signal: a
+    });
+    if (!t.ok)
+      throw new Error(`HTTP ${t.status} fetching ${this.url}`);
+    if (r === "utf8")
+      return t.text();
+    if (r)
+      throw new Error(`unsupported encoding: ${r}`);
+    return t.bytes ? t.bytes() : new Uint8Array(await t.arrayBuffer());
+  }
+  async stat() {
+    if (!this._stat && (await this.read(10, 0), !this._stat))
+      throw new Error(`unable to determine size of file at ${this.url}`);
+    return this._stat;
+  }
+  async close() {
+  }
+}
+class w {
+  readFile() {
+    throw new Error("unimplemented");
+  }
+  read() {
+    throw new Error("unimplemented");
+  }
+  close() {
+    throw new Error("unimplemented");
+  }
+}
+export {
+  f as BlobFile,
+  w as LocalFile,
+  u as RemoteFile
+};

package/dist/bundle/index-BatuyGAI.js

@@ -0,0 +1,271 @@
+var _ = Object.defineProperty;
+var I = (r, e, t) => e in r ? _(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
+var h = (r, e, t) => I(r, typeof e != "symbol" ? e + "" : e, t);
+import { LocalFile as d } from "./browser-BRemItdO.js";
+import { I as b, Z as F } from "./inflate-GtwLkvSP.js";
+const w = 65536, S = w * w;
+function g(r, e = 0) {
+  const t = r[e] | r[e + 1] << 8 | r[e + 2] << 16 | r[e + 3] << 24;
+  return ((r[e + 4] | r[e + 5] << 8 | r[e + 6] << 16 | r[e + 7] << 24) >>> 0) * S + (t >>> 0);
+}
+const u = 1;
+function m(r, e, t) {
+  const n = e[u], s = t ? t[u] : 1 / 0;
+  return n <= r && s > r ? 0 : n < r ? -1 : 1;
+}
+class B {
+  constructor({ filehandle: e }) {
+    h(this, "filehandle");
+    h(this, "index");
+    this.filehandle = e;
+  }
+  _getIndex() {
+    return this.index || (this.index = this._readIndex().catch((e) => {
+      throw this.index = void 0, e;
+    })), this.index;
+  }
+  async _readIndex() {
+    const e = await this.filehandle.read(8, 0), t = g(e);
+    if (!t)
+      return [[0, 0]];
+    const n = new Array(t + 1);
+    n[0] = [0, 0];
+    const s = 16 * t;
+    if (s > Number.MAX_SAFE_INTEGER)
+      throw new TypeError("integer overflow");
+    const i = await this.filehandle.read(s, 8);
+    for (let a = 0; a < t; a += 1) {
+      const o = g(i, a * 16), c = g(i, a * 16 + 8);
+      n[a + 1] = [o, c];
+    }
+    return n;
+  }
+  async getLastBlock() {
+    return (await this._getIndex()).at(-1);
+  }
+  async getRelevantBlocksForRead(e, t) {
+    const n = t + e;
+    if (e === 0)
+      return [];
+    const s = await this._getIndex(), i = [];
+    let a = 0, o = s.length - 1, c = Math.floor(s.length / 2), l = m(t, s[c], s[c + 1]);
+    for (; l !== 0; )
+      l > 0 ? o = c - 1 : l < 0 && (a = c + 1), c = Math.ceil((o - a) / 2) + a, l = m(t, s[c], s[c + 1]);
+    i.push(s[c]);
+    let f = c + 1;
+    for (; f < s.length && (i.push(s[f]), !(s[f][u] >= n)); f += 1)
+      ;
+    return i[i.length - 1][u] < n && i.push([]), i;
+  }
+}
+function E(r) {
+  let e = 0;
+  for (const t of r)
+    e += t.length;
+  return e;
+}
+function y(r, e) {
+  const t = new Uint8Array(e ?? E(r));
+  let n = 0;
+  for (const s of r)
+    t.set(s, n), n += s.length;
+  return t;
+}
+async function k(r) {
+  try {
+    let e, t = 0, n;
+    const s = [];
+    let i = 0;
+    do {
+      const a = r.subarray(t);
+      if (n = new b(void 0), { strm: e } = n, n.push(a, F), n.err)
+        throw new Error(n.msg);
+      t += e.next_in;
+      const o = n.result;
+      s.push(o), i += o.length;
+    } while (e.avail_in);
+    return y(s, i);
+  } catch (e) {
+    throw /incorrect header check/.exec(`${e}`) ? new Error("problem decompressing block: incorrect gzip header check") : e;
+  }
+}
+class p {
+  constructor({ filehandle: e, gziFilehandle: t }) {
+    h(this, "filehandle");
+    h(this, "gzi");
+    this.filehandle = e, this.gzi = new B({
+      filehandle: t
+    });
+  }
+  async _readAndUncompressBlock(e, t) {
+    let n = t;
+    n || (n = (await this.filehandle.stat()).size);
+    const s = n - e, i = await this.filehandle.read(s, e);
+    return k(i);
+  }
+  async read(e, t) {
+    const n = await this.gzi.getRelevantBlocksForRead(e, t), s = [];
+    for (let i = 0; i < n.length - 1; i += 1) {
+      const a = await this._readAndUncompressBlock(n[i][0], n[i + 1][0]), [, o] = n[i], c = o >= t ? 0 : t - o, l = Math.min(t + e, o + a.length) - o;
+      c >= 0 && c < a.length && s.push(a.subarray(c, l));
+    }
+    return y(s);
+  }
+}
+function x(r, e) {
+  return r.offset + r.lineBytes * Math.floor(e / r.lineLength) + e % r.lineLength;
+}
+async function z(r, e = {}) {
+  const t = new TextDecoder("utf8");
+  return Object.fromEntries(t.decode(await r.readFile(e)).split(/\r?\n/).map((n) => n.trim()).filter((n) => !!n).map((n) => n.split("	")).map((n) => {
+    var s;
+    if ((s = n[0]) != null && s.startsWith(">"))
+      throw new Error("found > in sequence name, might have supplied FASTA file for the FASTA index");
+    return [
+      n[0],
+      {
+        name: n[0],
+        length: +n[1],
+        start: 0,
+        end: +n[1],
+        offset: +n[2],
+        lineLength: +n[3],
+        lineBytes: +n[4]
+      }
+    ];
+  }));
+}
+class N {
+  constructor({ fasta: e, fai: t, path: n, faiPath: s }) {
+    if (e)
+      this.fasta = e;
+    else if (n)
+      this.fasta = new d(n);
+    else
+      throw new Error("Need to pass filehandle for fasta or path to localfile");
+    if (t)
+      this.fai = t;
+    else if (s)
+      this.fai = new d(s);
+    else if (n)
+      this.fai = new d(`${n}.fai`);
+    else
+      throw new Error("Need to pass filehandle for  or path to localfile");
+  }
+  async _getIndexes(e) {
+    return this.indexes || (this.indexes = z(this.fai, e).catch((t) => {
+      throw this.indexes = void 0, t;
+    })), this.indexes;
+  }
+  /**
+   * @returns array of string sequence names that are present in the index, in
+   * which the array index indicates the sequence ID, and the value is the
+   * sequence name
+   */
+  async getSequenceNames(e) {
+    return Object.keys(await this._getIndexes(e));
+  }
+  /**
+   * @returns array of string sequence names that are present in the index, in
+   * which the array index indicates the sequence ID, and the value is the
+   * sequence name
+   */
+  async getSequenceSizes(e) {
+    const t = {}, n = await this._getIndexes(e);
+    for (const s of Object.values(n))
+      t[s.name] = s.length;
+    return t;
+  }
+  /**
+   * @returns array of string sequence names that are present in the index, in
+   * which the array index indicates the sequence ID, and the value is the
+   * sequence name
+   */
+  async getSequenceSize(e, t) {
+    var s;
+    return (s = (await this._getIndexes(t))[e]) == null ? void 0 : s.length;
+  }
+  /**
+   * @param name
+   *
+   * @returns true if the file contains the given reference sequence name
+   */
+  async hasReferenceSequence(e, t) {
+    return !!(await this._getIndexes(t))[e];
+  }
+  /**
+   * @param seqName
+   * @param min
+   * @param max
+   */
+  async getResiduesByName(e, t, n, s) {
+    const i = (await this._getIndexes(s))[e];
+    return i ? this._fetchFromIndexEntry(i, t, n, s) : void 0;
+  }
+  //alias for getResiduesByName
+  async getSequence(e, t, n, s) {
+    return this.getResiduesByName(e, t, n, s);
+  }
+  async _fetchFromIndexEntry(e, t = 0, n, s) {
+    let i = n;
+    if (t < 0)
+      throw new TypeError("regionStart cannot be less than 0");
+    if ((i === void 0 || i > e.length) && (i = e.length), t >= i)
+      return "";
+    const a = x(e, t), o = x(e, i) - a, l = new TextDecoder("utf8").decode(await this.fasta.read(o, a, s)).replace(/\s+/g, "");
+    if (/[^\x20-\x7e]/.test(l.slice(0, 1e3)))
+      throw new Error("Non-ASCII characters detected in sequence. The file may be gzip compressed. Use BgzipIndexedFasta for bgzip files, or decompress the file.");
+    return l;
+  }
+}
+class O extends N {
+  constructor({ fasta: e, path: t, fai: n, faiPath: s, gzi: i, gziPath: a }) {
+    super({ fasta: e, path: t, fai: n, faiPath: s }), e && i ? this.fasta = new p({
+      filehandle: e,
+      gziFilehandle: i
+    }) : t && a && (this.fasta = new p({
+      filehandle: new d(t),
+      gziFilehandle: new d(a)
+    }));
+  }
+}
+function A(r) {
+  return r.split(">").filter((e) => /\S/.test(e)).map((e) => {
+    const [t, ...n] = e.split(`
+`), [s, ...i] = t.split(" "), a = n.join("").replace(/\s/g, "");
+    return {
+      id: s,
+      description: i.join(" "),
+      sequence: a
+    };
+  });
+}
+class R {
+  constructor({ fasta: e, path: t }) {
+    if (e)
+      this.fasta = e;
+    else if (t)
+      this.fasta = new d(t);
+    else
+      throw new Error("Need to pass fasta or path");
+    this.data = this.fasta.readFile().then((n) => {
+      const i = new TextDecoder("utf8").decode(n);
+      return A(i);
+    });
+  }
+  async fetch(e, t, n) {
+    const i = (await this.data).find((o) => o.id === e), a = n - t;
+    if (!i)
+      throw new Error(`no sequence with id ${e} exists`);
+    return i.sequence.slice(t, a);
+  }
+  async getSequenceNames() {
+    return (await this.data).map((t) => t.id);
+  }
+}
+export {
+  O as BgzipIndexedFasta,
+  R as FetchableSmallFasta,
+  N as IndexedFasta,
+  A as parseSmallFasta
+};