@genome-spy/core 0.63.0 → 0.65.0

package/dist/bundle/index-BhtHKLUo.js

@@ -0,0 +1,73 @@
+function c(s) {
+  return s && s.__esModule && Object.prototype.hasOwnProperty.call(s, "default") ? s.default : s;
+}
+var h, i;
+function a() {
+  if (i) return h;
+  i = 1;
+  class s {
+    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;
+    }
+  }
+  return h = s, h;
+}
+var r = a();
+const l = /* @__PURE__ */ c(r);
+export {
+  l as L
+};

package/dist/bundle/index-C0llXMqm.js

@@ -0,0 +1,280 @@
+var v = Object.defineProperty;
+var R = (n, e, t) => e in n ? v(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
+var a = (n, e, t) => R(n, typeof e != "symbol" ? e + "" : e, t);
+const k = /%([0-9A-Fa-f]{2})/g, y = /^\s*##\s*(\S+)\s*(.*)/, g = /\r?\n$/, _ = /\s+/, b = /\D/g;
+function m(n) {
+  return n.includes("%") ? n.replaceAll(k, (e, t) => String.fromCharCode(parseInt(t, 16))) : n;
+}
+function F(n) {
+  if (!n.length || n === ".")
+    return {};
+  const e = {};
+  let t = n;
+  t.endsWith(`
+`) && (t = t.slice(0, t.endsWith(`\r
+`) ? -2 : -1));
+  for (const r of t.split(";")) {
+    const s = r.indexOf("=");
+    if (s === -1)
+      continue;
+    const c = r.slice(s + 1);
+    if (!c.length)
+      continue;
+    const o = r.slice(0, s).trim();
+    let i = e[o];
+    i || (i = [], e[o] = i);
+    for (const l of c.split(","))
+      i.push(m(l.trim()));
+  }
+  return e;
+}
+function I(n) {
+  return C(n.split("	"));
+}
+function f(n) {
+  return n === "." || n === "" || n === void 0 ? null : n;
+}
+function C(n) {
+  const e = f(n[0]), t = f(n[1]), r = f(n[2]), s = f(n[3]), c = f(n[4]), o = f(n[5]), i = f(n[6]), l = f(n[7]), u = f(n[8]);
+  return {
+    seq_id: e ? m(e) : null,
+    source: t ? m(t) : null,
+    type: r ? m(r) : null,
+    start: s === null ? null : parseInt(s, 10),
+    end: c === null ? null : parseInt(c, 10),
+    score: o === null ? null : parseFloat(o),
+    strand: i,
+    phase: l,
+    attributes: u === null ? null : F(u)
+  };
+}
+function L(n) {
+  var c, o;
+  const e = y.exec(n);
+  if (!e)
+    return null;
+  const [, t] = e;
+  let [, , r] = e;
+  const s = { directive: t };
+  if (r.length && (r = r.replace(g, ""), s.value = r), t === "sequence-region") {
+    const i = r.split(_, 3);
+    return {
+      ...s,
+      seq_id: i[0],
+      start: (c = i[1]) == null ? void 0 : c.replaceAll(b, ""),
+      end: (o = i[2]) == null ? void 0 : o.replaceAll(b, "")
+    };
+  } else if (t === "genome-build") {
+    const [i, l] = r.split(_, 2);
+    return {
+      ...s,
+      source: i,
+      buildName: l
+    };
+  }
+  return s;
+}
+const D = /^\s*[^#\s>]/, A = /^\s*(#+)(.*)/, x = /^\s*$/, S = /^\s*>/, w = /\r?\n?$/g;
+class p {
+  constructor(e) {
+    a(this, "featureCallback");
+    a(this, "endCallback");
+    a(this, "commentCallback");
+    a(this, "errorCallback");
+    a(this, "disableDerivesFromReferences");
+    a(this, "directiveCallback");
+    a(this, "bufferSize");
+    a(this, "eof", !1);
+    a(this, "lineNumber", 0);
+    // features that we have to keep on hand for now because they
+    // might be referenced by something else
+    a(this, "_underConstructionTopLevel", []);
+    // index of the above by ID
+    a(this, "_underConstructionById", {});
+    a(this, "_completedReferences", {});
+    // features that reference something we have not seen yet
+    // structured as:
+    // {  'some_id' : {
+    //     'Parent' : [ orphans that have a Parent attr referencing it ],
+    //     'Derives_from' : [ orphans that have a Derives_from attr referencing it ],
+    //    }
+    // }
+    a(this, "_underConstructionOrphans", {});
+    const t = () => {
+    };
+    this.featureCallback = e.featureCallback || t, this.endCallback = e.endCallback || t, this.commentCallback = e.commentCallback || t, this.errorCallback = e.errorCallback || t, this.directiveCallback = e.directiveCallback || t, this.disableDerivesFromReferences = e.disableDerivesFromReferences || !1, this.bufferSize = e.bufferSize === void 0 ? 1 / 0 : e.bufferSize;
+  }
+  addLine(e) {
+    if (this.eof)
+      return;
+    if (this.lineNumber += 1, D.test(e)) {
+      this._bufferLine(e);
+      return;
+    }
+    const t = A.exec(e);
+    if (t) {
+      const [, r] = t;
+      let [, , s] = t;
+      if (r.length === 3)
+        this._emitAllUnderConstructionFeatures();
+      else if (r.length === 2) {
+        const c = L(e);
+        c && (c.directive === "FASTA" ? (this._emitAllUnderConstructionFeatures(), this.eof = !0) : this._emitItem(c));
+      } else
+        this._emitItem({ comment: s.trimStart() });
+    } else if (!x.test(e)) if (S.test(e))
+      this._emitAllUnderConstructionFeatures(), this.eof = !0;
+    else {
+      const r = e.replaceAll(w, "");
+      throw new Error(`GFF3 parse error.  Cannot parse '${r}'.`);
+    }
+  }
+  addParsedFeatureLine(e) {
+    this.eof || (this.lineNumber += 1, this._bufferParsedLine(e));
+  }
+  finish() {
+    this._emitAllUnderConstructionFeatures(), this.endCallback();
+  }
+  _emitItem(e) {
+    Array.isArray(e) ? this.featureCallback(e) : "directive" in e ? this.directiveCallback(e) : "comment" in e && this.commentCallback(e);
+  }
+  _enforceBufferSizeLimit(e = 0) {
+    const t = (r) => {
+      var s, c;
+      r && Array.isArray(r) && ((c = (s = r[0].attributes) == null ? void 0 : s.ID) != null && c[0]) && (r[0].attributes.ID.forEach((i) => {
+        delete this._underConstructionById[i], delete this._completedReferences[i];
+      }), r.forEach((i) => {
+        i.child_features && i.child_features.forEach((l) => {
+          t(l);
+        }), i.derived_features && i.derived_features.forEach((l) => {
+          t(l);
+        });
+      }));
+    };
+    for (; this._underConstructionTopLevel.length + e > this.bufferSize; ) {
+      const r = this._underConstructionTopLevel.shift();
+      r && (this._emitItem(r), t(r));
+    }
+  }
+  /**
+   * return all under-construction features, called when we know
+   * there will be no additional data to attach to them
+   */
+  _emitAllUnderConstructionFeatures() {
+    this._underConstructionTopLevel.forEach(this._emitItem.bind(this)), this._underConstructionTopLevel = [], this._underConstructionById = {}, this._completedReferences = {};
+    const e = Object.keys(this._underConstructionOrphans);
+    if (e.length)
+      throw new Error(`some features reference other features that do not exist in the file (or in the same '###' scope). ${e.join(",")}`);
+  }
+  _bufferLine(e) {
+    this._bufferParsedLine(I(e));
+  }
+  _bufferParsedLine(e) {
+    var i, l, u;
+    const t = e;
+    t.child_features = [], t.derived_features = [];
+    const r = ((i = t.attributes) == null ? void 0 : i.ID) || [], s = ((l = t.attributes) == null ? void 0 : l.Parent) || [], c = this.disableDerivesFromReferences ? [] : ((u = t.attributes) == null ? void 0 : u.Derives_from) || [];
+    if (!r.length && !s.length && !c.length) {
+      this._emitItem([t]);
+      return;
+    }
+    let o;
+    r.forEach((d) => {
+      const h = this._underConstructionById[d];
+      h ? (h[h.length - 1].type !== t.type && this._parseError(`multi-line feature "${d}" has inconsistent types: "${t.type}", "${h[h.length - 1].type}"`), h.push(t), o = h) : (o = [t], this._enforceBufferSizeLimit(1), !s.length && !c.length && this._underConstructionTopLevel.push(o), this._underConstructionById[d] = o, this._resolveReferencesTo(o, d));
+    }), this._resolveReferencesFrom(
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      o || [t],
+      { Parent: s, Derives_from: c },
+      r
+    );
+  }
+  _resolveReferencesTo(e, t) {
+    const r = this._underConstructionOrphans[t];
+    if (r) {
+      for (const s of e)
+        s.child_features.push(...r.Parent), s.derived_features.push(...r.Derives_from);
+      delete this._underConstructionOrphans[t];
+    }
+  }
+  _parseError(e) {
+    this.eof = !0, this.errorCallback(`${this.lineNumber}: ${e}`);
+  }
+  _resolveReferencesFrom(e, t, r) {
+    for (const s of t.Parent) {
+      const c = this._underConstructionById[s];
+      if (c) {
+        let o = !1;
+        for (const i of r) {
+          const l = `Parent,${s}`, u = this._completedReferences[i] || (this._completedReferences[i] = {});
+          u[l] && (o = !0), u[l] = !0;
+        }
+        if (!o)
+          for (const i of c)
+            i.child_features.push(e);
+      } else {
+        let o = this._underConstructionOrphans[s];
+        o || (o = { Parent: [], Derives_from: [] }, this._underConstructionOrphans[s] = o), o.Parent.push(e);
+      }
+    }
+    for (const s of t.Derives_from) {
+      const c = this._underConstructionById[s];
+      if (c) {
+        let o = !1;
+        for (const i of r) {
+          const l = `Derives_from,${s}`, u = this._completedReferences[i] || (this._completedReferences[i] = {});
+          u[l] && (o = !0), u[l] = !0;
+        }
+        if (!o)
+          for (const i of c)
+            i.derived_features.push(e);
+      } else {
+        let o = this._underConstructionOrphans[s];
+        o || (o = { Parent: [], Derives_from: [] }, this._underConstructionOrphans[s] = o), o.Derives_from.push(e);
+      }
+    }
+  }
+}
+function P(n) {
+  const e = [], t = new p({
+    featureCallback: (r) => e.push(r),
+    disableDerivesFromReferences: !0,
+    errorCallback: (r) => {
+      throw new Error(r);
+    }
+  });
+  for (const r of n.split(/\r?\n/))
+    t.addLine(r);
+  return t.finish(), e;
+}
+function $(n) {
+  const e = [], t = new p({
+    featureCallback: (r) => e.push(r),
+    disableDerivesFromReferences: !0,
+    errorCallback: (r) => {
+      throw new Error(r);
+    }
+  });
+  for (const r of n)
+    t.addLine(r);
+  return t.finish(), e;
+}
+function O(n) {
+  const e = [], t = new p({
+    featureCallback: (r) => e.push(r),
+    disableDerivesFromReferences: !0,
+    errorCallback: (r) => {
+      throw new Error(r);
+    }
+  });
+  for (const r of n) {
+    const s = C(r.fields);
+    r.lineHash !== void 0 && (s.attributes || (s.attributes = {}), s.attributes._lineHash = [String(r.lineHash)]), t.addParsedFeatureLine(s);
+  }
+  return t.finish(), e;
+}
+export {
+  $ as parseArraySync,
+  O as parseRecordsSync,
+  P as parseStringSync
+};