@genome-spy/core 0.37.3 → 0.38.0

package/dist/bundle/index-lmJu1tfP.js

@@ -0,0 +1,1372 @@
+import { L as Y, u as L, a as X } from "./long-Veu0zKh9.js";
+import { b as E } from "./index-1QVesMzU.js";
+import { g as W } from "./_commonjsHelpers-QtkX90xp.js";
+import { L as R } from "./__vite-browser-external-ENoMJThg.js";
+import { R as k } from "./remoteFile-Ur-gRKsH.js";
+import { _ as J, L as K } from "./index-LD6yPc3X.js";
+class U {
+  constructor(e, t) {
+    this.blockPosition = e, this.dataPosition = t;
+  }
+  toString() {
+    return `${this.blockPosition}:${this.dataPosition}`;
+  }
+  compareTo(e) {
+    return this.blockPosition - e.blockPosition || this.dataPosition - e.dataPosition;
+  }
+  static min(...e) {
+    let t, n = 0;
+    for (; !t; n += 1)
+      t = e[n];
+    for (; n < e.length; n += 1)
+      t.compareTo(e[n]) > 0 && (t = e[n]);
+    return t;
+  }
+}
+function y(o, e = 0, t = !1) {
+  if (t)
+    throw new Error("big-endian virtual file offsets not implemented");
+  return new U(o[e + 7] * 1099511627776 + o[e + 6] * 4294967296 + o[e + 5] * 16777216 + o[e + 4] * 65536 + o[e + 3] * 256 + o[e + 2], o[e + 1] << 8 | o[e]);
+}
+class z {
+  constructor(e, t, n, r) {
+    this.minv = e, this.maxv = t, this.bin = n, this._fetchedSize = r;
+  }
+  toUniqueString() {
+    return `${this.minv}..${this.maxv} (bin ${this.bin}, fetchedSize ${this.fetchedSize()})`;
+  }
+  toString() {
+    return this.toUniqueString();
+  }
+  compareTo(e) {
+    return this.minv.compareTo(e.minv) || this.maxv.compareTo(e.maxv) || this.bin - e.bin;
+  }
+  fetchedSize() {
+    return this._fetchedSize !== void 0 ? this._fetchedSize : this.maxv.blockPosition + 65536 - this.minv.blockPosition;
+  }
+}
+function Z(o) {
+  return new Promise((e) => setTimeout(e, o));
+}
+function ee(o) {
+  if (o.greaterThan(Number.MAX_SAFE_INTEGER) || o.lessThan(Number.MIN_SAFE_INTEGER))
+    throw new Error("integer overflow");
+  return o.toNumber();
+}
+function te(o) {
+  if (o && o.aborted)
+    if (typeof DOMException > "u") {
+      const e = new Error("aborted");
+      throw e.code = "ERR_ABORTED", e;
+    } else
+      throw new DOMException("aborted", "AbortError");
+}
+function ne(o, e) {
+  return e.minv.blockPosition - o.maxv.blockPosition < 65e3 && e.maxv.blockPosition - o.minv.blockPosition < 5e6;
+}
+function re(o = {}) {
+  return "aborted" in o ? { signal: o } : o;
+}
+function O(o, e) {
+  const t = [];
+  let n;
+  if (o.length === 0)
+    return o;
+  o.sort((r, a) => {
+    const i = r.minv.blockPosition - a.minv.blockPosition;
+    return i === 0 ? r.minv.dataPosition - a.minv.dataPosition : i;
+  });
+  for (const r of o)
+    (!e || r.maxv.compareTo(e) > 0) && (n === void 0 ? (t.push(r), n = r) : ne(n, r) ? r.maxv.compareTo(n.maxv) > 0 && (n.maxv = r.maxv) : (t.push(r), n = r));
+  return t;
+}
+function H(o, e) {
+  return { lineCount: ee(Y.fromBytesLE(Array.prototype.slice.call(o, e, e + 8), !0)) };
+}
+function P(o, e) {
+  return o ? o.compareTo(e) > 0 ? e : o : e;
+}
+function ae(o, e = (t) => t) {
+  let t = 0, n = 0;
+  const r = [], a = {};
+  for (let i = 0; i < o.length; i += 1)
+    if (!o[i]) {
+      if (n < i) {
+        let c = o.toString("utf8", n, i);
+        c = e(c), r[t] = c, a[c] = t;
+      }
+      n = i + 1, t += 1;
+    }
+  return { refNameToId: a, refIdToName: r };
+}
+class G {
+  /**
+   * @param {filehandle} filehandle
+   * @param {function} [renameRefSeqs]
+   */
+  constructor({ filehandle: e, renameRefSeq: t = (n) => n }) {
+    this.filehandle = e, this.renameRefSeq = t;
+  }
+}
+const se = 21578050;
+function ie(o, e) {
+  return o - o % e;
+}
+function oe(o, e) {
+  return o - o % e + e;
+}
+function de(o, e) {
+  return e -= 1, [
+    [0, 0],
+    [1 + (o >> 26), 1 + (e >> 26)],
+    [9 + (o >> 23), 9 + (e >> 23)],
+    [73 + (o >> 20), 73 + (e >> 20)],
+    [585 + (o >> 17), 585 + (e >> 17)],
+    [4681 + (o >> 14), 4681 + (e >> 14)]
+  ];
+}
+class A extends G {
+  async lineCount(e, t) {
+    var n, r;
+    return ((r = (n = (await this.parse(t)).indices[e]) === null || n === void 0 ? void 0 : n.stats) === null || r === void 0 ? void 0 : r.lineCount) || 0;
+  }
+  // fetch and parse the index
+  async _parse(e) {
+    const t = await this.filehandle.readFile(e);
+    if (t.readUInt32LE(0) !== se)
+      throw new Error("Not a BAI file");
+    const n = t.readInt32LE(4), a = ((1 << (5 + 1) * 3) - 1) / 7;
+    let i = 8, c;
+    const d = new Array(n);
+    for (let s = 0; s < n; s++) {
+      const l = t.readInt32LE(i);
+      let u;
+      i += 4;
+      const h = {};
+      for (let b = 0; b < l; b += 1) {
+        const x = t.readUInt32LE(i);
+        if (i += 4, x === a + 1)
+          i += 4, u = H(t, i + 16), i += 32;
+        else {
+          if (x > a + 1)
+            throw new Error("bai index contains too many bins, please use CSI");
+          {
+            const g = t.readInt32LE(i);
+            i += 4;
+            const p = new Array(g);
+            for (let w = 0; w < g; w++) {
+              const v = y(t, i);
+              i += 8;
+              const S = y(t, i);
+              i += 8, c = P(c, v), p[w] = new z(v, S, x);
+            }
+            h[x] = p;
+          }
+        }
+      }
+      const f = t.readInt32LE(i);
+      i += 4;
+      const m = new Array(f);
+      for (let b = 0; b < f; b++) {
+        const x = y(t, i);
+        i += 8, c = P(c, x), m[b] = x;
+      }
+      d[s] = { binIndex: h, linearIndex: m, stats: u };
+    }
+    return {
+      bai: !0,
+      firstDataLine: c,
+      maxBlockSize: 65536,
+      indices: d,
+      refCount: n
+    };
+  }
+  async indexCov(e, t, n, r = {}) {
+    const i = t !== void 0, d = (await this.parse(r)).indices[e];
+    if (!d)
+      return [];
+    const { linearIndex: s = [], stats: l } = d;
+    if (s.length === 0)
+      return [];
+    const u = n === void 0 ? (s.length - 1) * 16384 : oe(n, 16384), h = t === void 0 ? 0 : ie(t, 16384), f = i ? new Array((u - h) / 16384) : new Array(s.length - 1), m = s[s.length - 1].blockPosition;
+    if (u > (s.length - 1) * 16384)
+      throw new Error("query outside of range of linear index");
+    let b = s[h / 16384].blockPosition;
+    for (let x = h / 16384, g = 0; x < u / 16384; x++, g++)
+      f[g] = {
+        score: s[x + 1].blockPosition - b,
+        start: x * 16384,
+        end: x * 16384 + 16384
+      }, b = s[x + 1].blockPosition;
+    return f.map((x) => ({
+      ...x,
+      score: x.score * ((l == null ? void 0 : l.lineCount) || 0) / m
+    }));
+  }
+  async blocksForRange(e, t, n, r = {}) {
+    t < 0 && (t = 0);
+    const a = await this.parse(r);
+    if (!a)
+      return [];
+    const i = a.indices[e];
+    if (!i)
+      return [];
+    const c = de(t, n), d = [];
+    for (const [f, m] of c)
+      for (let b = f; b <= m; b++)
+        if (i.binIndex[b]) {
+          const x = i.binIndex[b];
+          for (const g of x)
+            d.push(g);
+        }
+    const s = i.linearIndex.length;
+    let l;
+    const u = Math.min(t >> 14, s - 1), h = Math.min(n >> 14, s - 1);
+    for (let f = u; f <= h; ++f) {
+      const m = i.linearIndex[f];
+      m && (!l || m.compareTo(l) < 0) && (l = m);
+    }
+    return O(d, l);
+  }
+  async parse(e = {}) {
+    return this.setupP || (this.setupP = this._parse(e).catch((t) => {
+      throw this.setupP = void 0, t;
+    })), this.setupP;
+  }
+  async hasRefSeq(e, t = {}) {
+    var n;
+    return !!(!((n = (await this.parse(t)).indices[e]) === null || n === void 0) && n.binIndex);
+  }
+}
+var I = E.Buffer, M = [
+  0,
+  1996959894,
+  3993919788,
+  2567524794,
+  124634137,
+  1886057615,
+  3915621685,
+  2657392035,
+  249268274,
+  2044508324,
+  3772115230,
+  2547177864,
+  162941995,
+  2125561021,
+  3887607047,
+  2428444049,
+  498536548,
+  1789927666,
+  4089016648,
+  2227061214,
+  450548861,
+  1843258603,
+  4107580753,
+  2211677639,
+  325883990,
+  1684777152,
+  4251122042,
+  2321926636,
+  335633487,
+  1661365465,
+  4195302755,
+  2366115317,
+  997073096,
+  1281953886,
+  3579855332,
+  2724688242,
+  1006888145,
+  1258607687,
+  3524101629,
+  2768942443,
+  901097722,
+  1119000684,
+  3686517206,
+  2898065728,
+  853044451,
+  1172266101,
+  3705015759,
+  2882616665,
+  651767980,
+  1373503546,
+  3369554304,
+  3218104598,
+  565507253,
+  1454621731,
+  3485111705,
+  3099436303,
+  671266974,
+  1594198024,
+  3322730930,
+  2970347812,
+  795835527,
+  1483230225,
+  3244367275,
+  3060149565,
+  1994146192,
+  31158534,
+  2563907772,
+  4023717930,
+  1907459465,
+  112637215,
+  2680153253,
+  3904427059,
+  2013776290,
+  251722036,
+  2517215374,
+  3775830040,
+  2137656763,
+  141376813,
+  2439277719,
+  3865271297,
+  1802195444,
+  476864866,
+  2238001368,
+  4066508878,
+  1812370925,
+  453092731,
+  2181625025,
+  4111451223,
+  1706088902,
+  314042704,
+  2344532202,
+  4240017532,
+  1658658271,
+  366619977,
+  2362670323,
+  4224994405,
+  1303535960,
+  984961486,
+  2747007092,
+  3569037538,
+  1256170817,
+  1037604311,
+  2765210733,
+  3554079995,
+  1131014506,
+  879679996,
+  2909243462,
+  3663771856,
+  1141124467,
+  855842277,
+  2852801631,
+  3708648649,
+  1342533948,
+  654459306,
+  3188396048,
+  3373015174,
+  1466479909,
+  544179635,
+  3110523913,
+  3462522015,
+  1591671054,
+  702138776,
+  2966460450,
+  3352799412,
+  1504918807,
+  783551873,
+  3082640443,
+  3233442989,
+  3988292384,
+  2596254646,
+  62317068,
+  1957810842,
+  3939845945,
+  2647816111,
+  81470997,
+  1943803523,
+  3814918930,
+  2489596804,
+  225274430,
+  2053790376,
+  3826175755,
+  2466906013,
+  167816743,
+  2097651377,
+  4027552580,
+  2265490386,
+  503444072,
+  1762050814,
+  4150417245,
+  2154129355,
+  426522225,
+  1852507879,
+  4275313526,
+  2312317920,
+  282753626,
+  1742555852,
+  4189708143,
+  2394877945,
+  397917763,
+  1622183637,
+  3604390888,
+  2714866558,
+  953729732,
+  1340076626,
+  3518719985,
+  2797360999,
+  1068828381,
+  1219638859,
+  3624741850,
+  2936675148,
+  906185462,
+  1090812512,
+  3747672003,
+  2825379669,
+  829329135,
+  1181335161,
+  3412177804,
+  3160834842,
+  628085408,
+  1382605366,
+  3423369109,
+  3138078467,
+  570562233,
+  1426400815,
+  3317316542,
+  2998733608,
+  733239954,
+  1555261956,
+  3268935591,
+  3050360625,
+  752459403,
+  1541320221,
+  2607071920,
+  3965973030,
+  1969922972,
+  40735498,
+  2617837225,
+  3943577151,
+  1913087877,
+  83908371,
+  2512341634,
+  3803740692,
+  2075208622,
+  213261112,
+  2463272603,
+  3855990285,
+  2094854071,
+  198958881,
+  2262029012,
+  4057260610,
+  1759359992,
+  534414190,
+  2176718541,
+  4139329115,
+  1873836001,
+  414664567,
+  2282248934,
+  4279200368,
+  1711684554,
+  285281116,
+  2405801727,
+  4167216745,
+  1634467795,
+  376229701,
+  2685067896,
+  3608007406,
+  1308918612,
+  956543938,
+  2808555105,
+  3495958263,
+  1231636301,
+  1047427035,
+  2932959818,
+  3654703836,
+  1088359270,
+  936918e3,
+  2847714899,
+  3736837829,
+  1202900863,
+  817233897,
+  3183342108,
+  3401237130,
+  1404277552,
+  615818150,
+  3134207493,
+  3453421203,
+  1423857449,
+  601450431,
+  3009837614,
+  3294710456,
+  1567103746,
+  711928724,
+  3020668471,
+  3272380065,
+  1510334235,
+  755167117
+];
+typeof Int32Array < "u" && (M = new Int32Array(M));
+function j(o) {
+  if (I.isBuffer(o))
+    return o;
+  var e = typeof I.alloc == "function" && typeof I.from == "function";
+  if (typeof o == "number")
+    return e ? I.alloc(o) : new I(o);
+  if (typeof o == "string")
+    return e ? I.from(o) : new I(o);
+  throw new Error("input must be buffer, number, or string, received " + typeof o);
+}
+function ce(o) {
+  var e = j(4);
+  return e.writeInt32BE(o, 0), e;
+}
+function B(o, e) {
+  o = j(o), I.isBuffer(e) && (e = e.readUInt32BE(0));
+  for (var t = ~~e ^ -1, n = 0; n < o.length; n++)
+    t = M[(t ^ o[n]) & 255] ^ t >>> 8;
+  return t ^ -1;
+}
+function F() {
+  return ce(B.apply(null, arguments));
+}
+F.signed = function() {
+  return B.apply(null, arguments);
+};
+F.unsigned = function() {
+  return B.apply(null, arguments) >>> 0;
+};
+var fe = F;
+const he = /* @__PURE__ */ W(fe), le = 21582659, ue = 38359875;
+function xe(o, e) {
+  return o * 2 ** e;
+}
+function q(o, e) {
+  return Math.floor(o / 2 ** e);
+}
+class T extends G {
+  constructor() {
+    super(...arguments), this.maxBinNumber = 0, this.depth = 0, this.minShift = 0;
+  }
+  async lineCount(e, t) {
+    var n, r;
+    return ((r = (n = (await this.parse(t)).indices[e]) === null || n === void 0 ? void 0 : n.stats) === null || r === void 0 ? void 0 : r.lineCount) || 0;
+  }
+  async indexCov() {
+    return [];
+  }
+  parseAuxData(e, t) {
+    const n = e.readInt32LE(t), r = n & 65536 ? "zero-based-half-open" : "1-based-closed", a = { 0: "generic", 1: "SAM", 2: "VCF" }[n & 15];
+    if (!a)
+      throw new Error(`invalid Tabix preset format flags ${n}`);
+    const i = {
+      ref: e.readInt32LE(t + 4),
+      start: e.readInt32LE(t + 8),
+      end: e.readInt32LE(t + 12)
+    }, c = e.readInt32LE(t + 16), d = c ? String.fromCharCode(c) : "", s = e.readInt32LE(t + 20), l = e.readInt32LE(t + 24);
+    return {
+      columnNumbers: i,
+      coordinateType: r,
+      metaValue: c,
+      metaChar: d,
+      skipLines: s,
+      format: a,
+      formatFlags: n,
+      ...ae(e.subarray(t + 28, t + 28 + l), this.renameRefSeq)
+    };
+  }
+  // fetch and parse the index
+  async _parse(e) {
+    const t = await this.filehandle.readFile(e), n = await L(t);
+    let r;
+    if (n.readUInt32LE(0) === le)
+      r = 1;
+    else if (n.readUInt32LE(0) === ue)
+      r = 2;
+    else
+      throw new Error("Not a CSI file");
+    this.minShift = n.readInt32LE(4), this.depth = n.readInt32LE(8), this.maxBinNumber = ((1 << (this.depth + 1) * 3) - 1) / 7;
+    const a = n.readInt32LE(12), i = a >= 30 ? this.parseAuxData(n, 16) : void 0, c = n.readInt32LE(16 + a);
+    let d = 16 + a + 4, s;
+    const l = new Array(c);
+    for (let u = 0; u < c; u++) {
+      const h = n.readInt32LE(d);
+      d += 4;
+      const f = {};
+      let m;
+      for (let b = 0; b < h; b++) {
+        const x = n.readUInt32LE(d);
+        if (d += 4, x > this.maxBinNumber)
+          m = H(n, d + 28), d += 28 + 16;
+        else {
+          s = P(s, y(n, d)), d += 8;
+          const g = n.readInt32LE(d);
+          d += 4;
+          const p = new Array(g);
+          for (let w = 0; w < g; w += 1) {
+            const v = y(n, d);
+            d += 8;
+            const S = y(n, d);
+            d += 8, s = P(s, v), p[w] = new z(v, S, x);
+          }
+          f[x] = p;
+        }
+      }
+      l[u] = { binIndex: f, stats: m };
+    }
+    return {
+      csiVersion: r,
+      firstDataLine: s,
+      indices: l,
+      refCount: c,
+      csi: !0,
+      maxBlockSize: 65536,
+      ...i
+    };
+  }
+  async blocksForRange(e, t, n, r = {}) {
+    t < 0 && (t = 0);
+    const a = await this.parse(r), i = a == null ? void 0 : a.indices[e];
+    if (!i)
+      return [];
+    const c = this.reg2bins(t, n);
+    if (c.length === 0)
+      return [];
+    const d = [];
+    for (const [s, l] of c)
+      for (let u = s; u <= l; u++)
+        if (i.binIndex[u]) {
+          const h = i.binIndex[u];
+          for (const f of h)
+            d.push(f);
+        }
+    return O(d, new U(0, 0));
+  }
+  /**
+   * calculate the list of bins that may overlap with region [beg,end)
+   * (zero-based half-open)
+   */
+  reg2bins(e, t) {
+    e -= 1, e < 1 && (e = 1), t > 2 ** 50 && (t = 2 ** 34), t -= 1;
+    let n = 0, r = 0, a = this.minShift + this.depth * 3;
+    const i = [];
+    for (; n <= this.depth; a -= 3, r += xe(1, n * 3), n += 1) {
+      const c = r + q(e, a), d = r + q(t, a);
+      if (d - c + i.length > this.maxBinNumber)
+        throw new Error(`query ${e}-${t} is too large for current binning scheme (shift ${this.minShift}, depth ${this.depth}), try a smaller query or a coarser index binning scheme`);
+      i.push([c, d]);
+    }
+    return i;
+  }
+  async parse(e = {}) {
+    return this.setupP || (this.setupP = this._parse(e).catch((t) => {
+      throw this.setupP = void 0, t;
+    })), this.setupP;
+  }
+  async hasRefSeq(e, t = {}) {
+    var n;
+    return !!(!((n = (await this.parse(t)).indices[e]) === null || n === void 0) && n.binIndex);
+  }
+}
+const _ = {
+  //  the read is paired in sequencing, no matter whether it is mapped in a pair
+  BAM_FPAIRED: 1,
+  //  the read is mapped in a proper pair
+  BAM_FPROPER_PAIR: 2,
+  //  the read itself is unmapped; conflictive with BAM_FPROPER_PAIR
+  BAM_FUNMAP: 4,
+  //  the mate is unmapped
+  BAM_FMUNMAP: 8,
+  //  the read is mapped to the reverse strand
+  BAM_FREVERSE: 16,
+  //  the mate is mapped to the reverse strand
+  BAM_FMREVERSE: 32,
+  //  this is read1
+  BAM_FREAD1: 64,
+  //  this is read2
+  BAM_FREAD2: 128,
+  //  not primary alignment
+  BAM_FSECONDARY: 256,
+  //  QC failure
+  BAM_FQCFAIL: 512,
+  //  optical or PCR duplicate
+  BAM_FDUP: 1024,
+  //  supplementary alignment
+  BAM_FSUPPLEMENTARY: 2048
+}, N = "=ACMGRSVTWYHKDBN".split(""), C = "MIDNSHP=X???????".split("");
+class be {
+  constructor(e) {
+    this.data = {}, this._tagList = [], this._allTagsParsed = !1;
+    const { bytes: t, fileOffset: n } = e, { byteArray: r, start: a } = t;
+    this.data = {}, this.bytes = t, this._id = n, this._refID = r.readInt32LE(a + 4), this.data.start = r.readInt32LE(a + 8), this.flags = (r.readInt32LE(a + 16) & 4294901760) >> 16;
+  }
+  get(e) {
+    return this[e] ? this.data[e] ? this.data[e] : (this.data[e] = this[e](), this.data[e]) : this._get(e.toLowerCase());
+  }
+  end() {
+    return this.get("start") + this.get("length_on_ref");
+  }
+  seq_id() {
+    return this._refID;
+  }
+  // same as get(), except requires lower-case arguments.  used
+  // internally to save lots of calls to field.toLowerCase()
+  _get(e) {
+    return e in this.data ? this.data[e] : (this.data[e] = this._parseTag(e), this.data[e]);
+  }
+  _tags() {
+    this._parseAllTags();
+    let e = ["seq"];
+    this.isSegmentUnmapped() || e.push("start", "end", "strand", "score", "qual", "MQ", "CIGAR", "length_on_ref", "template_length"), this.isPaired() && e.push("next_segment_position", "pair_orientation"), e = e.concat(this._tagList || []);
+    for (const n of Object.keys(this.data))
+      n[0] !== "_" && n !== "next_seq_id" && e.push(n);
+    const t = {};
+    return e.filter((n) => {
+      if (n in this.data && this.data[n] === void 0 || n === "CG" || n === "cg")
+        return !1;
+      const r = n.toLowerCase(), a = t[r];
+      return t[r] = !0, !a;
+    });
+  }
+  parent() {
+  }
+  children() {
+    return this.get("subfeatures");
+  }
+  id() {
+    return this._id;
+  }
+  // special parsers
+  /**
+   * Mapping quality score.
+   */
+  mq() {
+    const e = (this.get("_bin_mq_nl") & 65280) >> 8;
+    return e === 255 ? void 0 : e;
+  }
+  score() {
+    return this.get("mq");
+  }
+  qual() {
+    var e;
+    return (e = this.qualRaw()) === null || e === void 0 ? void 0 : e.join(" ");
+  }
+  qualRaw() {
+    if (this.isSegmentUnmapped())
+      return;
+    const { start: e, byteArray: t } = this.bytes, n = e + 36 + this.get("_l_read_name") + this.get("_n_cigar_op") * 4 + this.get("_seq_bytes"), r = this.get("seq_length");
+    return t.subarray(n, n + r);
+  }
+  strand() {
+    return this.isReverseComplemented() ? -1 : 1;
+  }
+  multi_segment_next_segment_strand() {
+    if (!this.isMateUnmapped())
+      return this.isMateReverseComplemented() ? -1 : 1;
+  }
+  name() {
+    return this.get("_read_name");
+  }
+  _read_name() {
+    const e = this.get("_l_read_name"), { byteArray: t, start: n } = this.bytes;
+    return t.toString("ascii", n + 36, n + 36 + e - 1);
+  }
+  /**
+   * Get the value of a tag, parsing the tags as far as necessary.
+   * Only called if we have not already parsed that field.
+   */
+  _parseTag(e) {
+    if (this._allTagsParsed)
+      return;
+    const { byteArray: t, start: n } = this.bytes;
+    let r = this._tagOffset || n + 36 + this.get("_l_read_name") + this.get("_n_cigar_op") * 4 + this.get("_seq_bytes") + this.get("seq_length");
+    const a = this.bytes.end;
+    let i;
+    for (; r < a && i !== e; ) {
+      const c = String.fromCharCode(t[r], t[r + 1]);
+      i = c.toLowerCase();
+      const d = String.fromCharCode(t[r + 2]);
+      r += 3;
+      let s;
+      switch (d) {
+        case "A": {
+          s = String.fromCharCode(t[r]), r += 1;
+          break;
+        }
+        case "i": {
+          s = t.readInt32LE(r), r += 4;
+          break;
+        }
+        case "I": {
+          s = t.readUInt32LE(r), r += 4;
+          break;
+        }
+        case "c": {
+          s = t.readInt8(r), r += 1;
+          break;
+        }
+        case "C": {
+          s = t.readUInt8(r), r += 1;
+          break;
+        }
+        case "s": {
+          s = t.readInt16LE(r), r += 2;
+          break;
+        }
+        case "S": {
+          s = t.readUInt16LE(r), r += 2;
+          break;
+        }
+        case "f": {
+          s = t.readFloatLE(r), r += 4;
+          break;
+        }
+        case "Z":
+        case "H": {
+          for (s = ""; r <= a; ) {
+            const l = t[r++];
+            if (l === 0)
+              break;
+            s += String.fromCharCode(l);
+          }
+          break;
+        }
+        case "B": {
+          s = "";
+          const l = t[r++], u = String.fromCharCode(l), h = t.readInt32LE(r);
+          if (r += 4, u === "i")
+            if (c === "CG")
+              for (let f = 0; f < h; f++) {
+                const m = t.readInt32LE(r), b = m >> 4, x = C[m & 15];
+                s += b + x, r += 4;
+              }
+            else
+              for (let f = 0; f < h; f++)
+                s += t.readInt32LE(r), f + 1 < h && (s += ","), r += 4;
+          if (u === "I")
+            if (c === "CG")
+              for (let f = 0; f < h; f++) {
+                const m = t.readUInt32LE(r), b = m >> 4, x = C[m & 15];
+                s += b + x, r += 4;
+              }
+            else
+              for (let f = 0; f < h; f++)
+                s += t.readUInt32LE(r), f + 1 < h && (s += ","), r += 4;
+          if (u === "s")
+            for (let f = 0; f < h; f++)
+              s += t.readInt16LE(r), f + 1 < h && (s += ","), r += 2;
+          if (u === "S")
+            for (let f = 0; f < h; f++)
+              s += t.readUInt16LE(r), f + 1 < h && (s += ","), r += 2;
+          if (u === "c")
+            for (let f = 0; f < h; f++)
+              s += t.readInt8(r), f + 1 < h && (s += ","), r += 1;
+          if (u === "C")
+            for (let f = 0; f < h; f++)
+              s += t.readUInt8(r), f + 1 < h && (s += ","), r += 1;
+          if (u === "f")
+            for (let f = 0; f < h; f++)
+              s += t.readFloatLE(r), f + 1 < h && (s += ","), r += 4;
+          break;
+        }
+        default:
+          console.warn(`Unknown BAM tag type '${d}', tags may be incomplete`), s = void 0, r = a;
+      }
+      if (this._tagOffset = r, this._tagList.push(c), i === e)
+        return s;
+      this.data[i] = s;
+    }
+    this._allTagsParsed = !0;
+  }
+  _parseAllTags() {
+    this._parseTag("");
+  }
+  _parseCigar(e) {
+    return (
+      //@ts-ignore
+      e.match(/\d+\D/g).map((t) => [t.match(/\D/)[0].toUpperCase(), Number.parseInt(t, 10)])
+    );
+  }
+  /**
+   * @returns {boolean} true if the read is paired, regardless of whether both segments are mapped
+   */
+  isPaired() {
+    return !!(this.flags & _.BAM_FPAIRED);
+  }
+  /** @returns {boolean} true if the read is paired, and both segments are mapped */
+  isProperlyPaired() {
+    return !!(this.flags & _.BAM_FPROPER_PAIR);
+  }
+  /** @returns {boolean} true if the read itself is unmapped; conflictive with isProperlyPaired */
+  isSegmentUnmapped() {
+    return !!(this.flags & _.BAM_FUNMAP);
+  }
+  /** @returns {boolean} true if the read itself is unmapped; conflictive with isProperlyPaired */
+  isMateUnmapped() {
+    return !!(this.flags & _.BAM_FMUNMAP);
+  }
+  /** @returns {boolean} true if the read is mapped to the reverse strand */
+  isReverseComplemented() {
+    return !!(this.flags & _.BAM_FREVERSE);
+  }
+  /** @returns {boolean} true if the mate is mapped to the reverse strand */
+  isMateReverseComplemented() {
+    return !!(this.flags & _.BAM_FMREVERSE);
+  }
+  /** @returns {boolean} true if this is read number 1 in a pair */
+  isRead1() {
+    return !!(this.flags & _.BAM_FREAD1);
+  }
+  /** @returns {boolean} true if this is read number 2 in a pair */
+  isRead2() {
+    return !!(this.flags & _.BAM_FREAD2);
+  }
+  /** @returns {boolean} true if this is a secondary alignment */
+  isSecondary() {
+    return !!(this.flags & _.BAM_FSECONDARY);
+  }
+  /** @returns {boolean} true if this read has failed QC checks */
+  isFailedQc() {
+    return !!(this.flags & _.BAM_FQCFAIL);
+  }
+  /** @returns {boolean} true if the read is an optical or PCR duplicate */
+  isDuplicate() {
+    return !!(this.flags & _.BAM_FDUP);
+  }
+  /** @returns {boolean} true if this is a supplementary alignment */
+  isSupplementary() {
+    return !!(this.flags & _.BAM_FSUPPLEMENTARY);
+  }
+  cigar() {
+    if (this.isSegmentUnmapped())
+      return;
+    const { byteArray: e, start: t } = this.bytes, n = this.get("_n_cigar_op");
+    let r = t + 36 + this.get("_l_read_name");
+    const a = this.get("seq_length");
+    let i = "", c = 0, d = e.readInt32LE(r), s = d >> 4, l = C[d & 15];
+    if (l === "S" && s === a)
+      return r += 4, d = e.readInt32LE(r), s = d >> 4, l = C[d & 15], l !== "N" && console.warn("CG tag with no N tag"), this.data.length_on_ref = s, this.get("CG");
+    for (let u = 0; u < n; ++u)
+      d = e.readInt32LE(r), s = d >> 4, l = C[d & 15], i += s + l, l !== "H" && l !== "S" && l !== "I" && (c += s), r += 4;
+    return this.data.length_on_ref = c, i;
+  }
+  _flags() {
+  }
+  length_on_ref() {
+    return this.data.length_on_ref ? this.data.length_on_ref : (this.get("cigar"), this.data.length_on_ref);
+  }
+  _n_cigar_op() {
+    return this.get("_flag_nc") & 65535;
+  }
+  _l_read_name() {
+    return this.get("_bin_mq_nl") & 255;
+  }
+  /**
+   * number of bytes in the sequence field
+   */
+  _seq_bytes() {
+    return this.get("seq_length") + 1 >> 1;
+  }
+  getReadBases() {
+    return this.seq();
+  }
+  seq() {
+    const { byteArray: e, start: t } = this.bytes, n = t + 36 + this.get("_l_read_name") + this.get("_n_cigar_op") * 4, r = this.get("_seq_bytes"), a = this.get("seq_length");
+    let i = "", c = 0;
+    for (let d = 0; d < r; ++d) {
+      const s = e[n + d];
+      i += N[(s & 240) >> 4], c++, c < a && (i += N[s & 15], c++);
+    }
+    return i;
+  }
+  // adapted from igv.js
+  getPairOrientation() {
+    if (!this.isSegmentUnmapped() && !this.isMateUnmapped() && this._refID === this._next_refid()) {
+      const e = this.isReverseComplemented() ? "R" : "F", t = this.isMateReverseComplemented() ? "R" : "F";
+      let n = " ", r = " ";
+      this.isRead1() ? (n = "1", r = "2") : this.isRead2() && (n = "2", r = "1");
+      const a = [];
+      return this.template_length() > 0 ? (a[0] = e, a[1] = n, a[2] = t, a[3] = r) : (a[2] = e, a[3] = n, a[0] = t, a[1] = r), a.join("");
+    }
+    return "";
+  }
+  _bin_mq_nl() {
+    return this.bytes.byteArray.readInt32LE(this.bytes.start + 12);
+  }
+  _flag_nc() {
+    return this.bytes.byteArray.readInt32LE(this.bytes.start + 16);
+  }
+  seq_length() {
+    return this.bytes.byteArray.readInt32LE(this.bytes.start + 20);
+  }
+  _next_refid() {
+    return this.bytes.byteArray.readInt32LE(this.bytes.start + 24);
+  }
+  _next_pos() {
+    return this.bytes.byteArray.readInt32LE(this.bytes.start + 28);
+  }
+  template_length() {
+    return this.bytes.byteArray.readInt32LE(this.bytes.start + 32);
+  }
+  toJSON() {
+    const e = {};
+    for (const t of Object.keys(this))
+      t.charAt(0) === "_" || t === "bytes" || (e[t] = this[t]);
+    return e;
+  }
+}
+function V(o) {
+  const e = o.split(/\r?\n/), t = [];
+  for (const n of e) {
+    const [r, ...a] = n.split(/\t/);
+    r && t.push({
+      tag: r.slice(1),
+      data: a.map((i) => {
+        const [c, d] = i.split(":", 2);
+        return { tag: c, value: d };
+      })
+    });
+  }
+  return t;
+}
+const Q = 21840194, D = 65536;
+async function me(o) {
+  let e = [];
+  for await (const t of o)
+    e = e.concat(t);
+  return e;
+}
+class ge {
+  read() {
+    throw new Error("never called");
+  }
+  stat() {
+    throw new Error("never called");
+  }
+  readFile() {
+    throw new Error("never called");
+  }
+  close() {
+    throw new Error("never called");
+  }
+}
+class _e {
+  constructor({ bamFilehandle: e, bamPath: t, bamUrl: n, baiPath: r, baiFilehandle: a, baiUrl: i, csiPath: c, csiFilehandle: d, csiUrl: s, htsget: l, yieldThreadTime: u = 100, renameRefSeqs: h = (f) => f }) {
+    if (this.htsget = !1, this.featureCache = new J({
+      cache: new K({
+        maxSize: 50
+      }),
+      fill: async (f, m) => {
+        const { chunk: b, opts: x } = f, { data: g, cpositions: p, dpositions: w } = await this._readChunk({
+          chunk: b,
+          opts: { ...x, signal: m }
+        });
+        return this.readBamFeatures(g, p, w, b);
+      }
+    }), this.renameRefSeq = h, e)
+      this.bam = e;
+    else if (t)
+      this.bam = new R(t);
+    else if (n)
+      this.bam = new k(n);
+    else if (l)
+      this.htsget = !0, this.bam = new ge();
+    else
+      throw new Error("unable to initialize bam");
+    if (d)
+      this.index = new T({ filehandle: d });
+    else if (c)
+      this.index = new T({ filehandle: new R(c) });
+    else if (s)
+      this.index = new T({ filehandle: new k(s) });
+    else if (a)
+      this.index = new A({ filehandle: a });
+    else if (r)
+      this.index = new A({ filehandle: new R(r) });
+    else if (i)
+      this.index = new A({ filehandle: new k(i) });
+    else if (t)
+      this.index = new A({ filehandle: new R(`${t}.bai`) });
+    else if (n)
+      this.index = new A({ filehandle: new k(`${n}.bai`) });
+    else if (l)
+      this.htsget = !0;
+    else
+      throw new Error("unable to infer index format");
+    this.yieldThreadTime = u;
+  }
+  async getHeaderPre(e) {
+    const t = re(e);
+    if (!this.index)
+      return;
+    const n = await this.index.parse(t), r = n.firstDataLine ? n.firstDataLine.blockPosition + 65535 : void 0;
+    let a;
+    if (r) {
+      const l = r + D, u = await this.bam.read(E.Buffer.alloc(l), 0, l, 0, t);
+      if (!u.bytesRead)
+        throw new Error("Error reading header");
+      a = u.buffer.subarray(0, Math.min(u.bytesRead, r));
+    } else
+      a = await this.bam.readFile(t);
+    const i = await L(a);
+    if (i.readInt32LE(0) !== Q)
+      throw new Error("Not a BAM file");
+    const c = i.readInt32LE(4);
+    this.header = i.toString("utf8", 8, 8 + c);
+    const { chrToIndex: d, indexToChr: s } = await this._readRefSeqs(c + 8, 65535, t);
+    return this.chrToIndex = d, this.indexToChr = s, V(this.header);
+  }
+  getHeader(e) {
+    return this.headerP || (this.headerP = this.getHeaderPre(e).catch((t) => {
+      throw this.headerP = void 0, t;
+    })), this.headerP;
+  }
+  async getHeaderText(e = {}) {
+    return await this.getHeader(e), this.header;
+  }
+  // the full length of the refseq block is not given in advance so this grabs
+  // a chunk and doubles it if all refseqs haven't been processed
+  async _readRefSeqs(e, t, n) {
+    if (e > t)
+      return this._readRefSeqs(e, t * 2, n);
+    const r = t + D, { bytesRead: a, buffer: i } = await this.bam.read(E.Buffer.alloc(r), 0, t, 0, n);
+    if (!a)
+      throw new Error("Error reading refseqs from header");
+    const c = await L(i.subarray(0, Math.min(a, t))), d = c.readInt32LE(e);
+    let s = e + 4;
+    const l = {}, u = [];
+    for (let h = 0; h < d; h += 1) {
+      const f = c.readInt32LE(s), m = this.renameRefSeq(c.toString("utf8", s + 4, s + 4 + f - 1)), b = c.readInt32LE(s + f + 4);
+      if (l[m] = h, u.push({ refName: m, length: b }), s = s + 8 + f, s > c.length)
+        return console.warn(`BAM header is very big.  Re-fetching ${t} bytes.`), this._readRefSeqs(e, t * 2, n);
+    }
+    return { chrToIndex: l, indexToChr: u };
+  }
+  async getRecordsForRange(e, t, n, r) {
+    return me(this.streamRecordsForRange(e, t, n, r));
+  }
+  async *streamRecordsForRange(e, t, n, r) {
+    var a;
+    await this.getHeader(r);
+    const i = (a = this.chrToIndex) === null || a === void 0 ? void 0 : a[e];
+    if (i === void 0 || !this.index)
+      yield [];
+    else {
+      const c = await this.index.blocksForRange(i, t - 1, n, r);
+      yield* this._fetchChunkFeatures(c, i, t, n, r);
+    }
+  }
+  async *_fetchChunkFeatures(e, t, n, r, a = {}) {
+    const { viewAsPairs: i } = a, c = [];
+    let d = !1;
+    for (const s of e) {
+      const l = await this.featureCache.get(s.toString(), { chunk: s, opts: a }, a.signal), u = [];
+      for (const h of l)
+        if (h.seq_id() === t)
+          if (h.get("start") >= r) {
+            d = !0;
+            break;
+          } else
+            h.get("end") >= n && u.push(h);
+      if (c.push(u), yield u, d)
+        break;
+    }
+    te(a.signal), i && (yield this.fetchPairs(t, c, a));
+  }
+  async fetchPairs(e, t, n) {
+    const { pairAcrossChr: r, maxInsertSize: a = 2e5 } = n, i = {}, c = {};
+    t.map((h) => {
+      const f = {};
+      for (const m of h) {
+        const b = m.name(), x = m.id();
+        f[b] || (f[b] = 0), f[b]++, c[x] = 1;
+      }
+      for (const [m, b] of Object.entries(f))
+        b === 1 && (i[m] = !0);
+    });
+    const d = [];
+    t.map((h) => {
+      for (const f of h) {
+        const m = f.name(), b = f.get("start"), x = f._next_pos(), g = f._next_refid();
+        this.index && i[m] && (r || g === e && Math.abs(b - x) < a) && d.push(this.index.blocksForRange(g, x, x + 1, n));
+      }
+    });
+    const s = /* @__PURE__ */ new Map(), l = await Promise.all(d);
+    for (const h of l.flat())
+      s.has(h.toString()) || s.set(h.toString(), h);
+    return (await Promise.all([...s.values()].map(async (h) => {
+      const { data: f, cpositions: m, dpositions: b, chunk: x } = await this._readChunk({
+        chunk: h,
+        opts: n
+      }), g = [];
+      for (const p of await this.readBamFeatures(f, m, b, x))
+        i[p.get("name")] && !c[p.id()] && g.push(p);
+      return g;
+    }))).flat();
+  }
+  async _readRegion(e, t, n = {}) {
+    const { bytesRead: r, buffer: a } = await this.bam.read(E.Buffer.alloc(t), 0, t, e, n);
+    return a.subarray(0, Math.min(r, t));
+  }
+  async _readChunk({ chunk: e, opts: t }) {
+    const n = await this._readRegion(e.minv.blockPosition, e.fetchedSize(), t), { buffer: r, cpositions: a, dpositions: i } = await X(n, e);
+    return { data: r, cpositions: a, dpositions: i, chunk: e };
+  }
+  async readBamFeatures(e, t, n, r) {
+    let a = 0;
+    const i = [];
+    let c = 0, d = +Date.now();
+    for (; a + 4 < e.length; ) {
+      const s = e.readInt32LE(a), l = a + 4 + s - 1;
+      if (n) {
+        for (; a + r.minv.dataPosition >= n[c++]; )
+          ;
+        c--;
+      }
+      if (l < e.length) {
+        const u = new be({
+          bytes: {
+            byteArray: e,
+            start: a,
+            end: l
+          },
+          // the below results in an automatically calculated file-offset based
+          // ID if the info for that is available, otherwise crc32 of the
+          // features
+          //
+          // cpositions[pos] refers to actual file offset of a bgzip block
+          // boundaries
+          //
+          // we multiply by (1 <<8) in order to make sure each block has a
+          // "unique" address space so that data in that block could never
+          // overlap
+          //
+          // then the blockStart-dpositions is an uncompressed file offset from
+          // that bgzip block boundary, and since the cpositions are multiplied
+          // by (1 << 8) these uncompressed offsets get a unique space
+          //
+          // this has an extra chunk.minv.dataPosition added on because it
+          // blockStart starts at 0 instead of chunk.minv.dataPosition
+          //
+          // the +1 is just to avoid any possible uniqueId 0 but this does not
+          // realistically happen
+          fileOffset: t.length > 0 ? t[c] * 256 + (a - n[c]) + r.minv.dataPosition + 1 : (
+            // must be slice, not subarray for buffer polyfill on web
+            he.signed(e.slice(a, l))
+          )
+        });
+        i.push(u), this.yieldThreadTime && +Date.now() - d > this.yieldThreadTime && (await Z(1), d = +Date.now());
+      }
+      a = l + 1;
+    }
+    return i;
+  }
+  async hasRefSeq(e) {
+    var t, n;
+    const r = (t = this.chrToIndex) === null || t === void 0 ? void 0 : t[e];
+    return r === void 0 ? !1 : (n = this.index) === null || n === void 0 ? void 0 : n.hasRefSeq(r);
+  }
+  async lineCount(e) {
+    var t;
+    const n = (t = this.chrToIndex) === null || t === void 0 ? void 0 : t[e];
+    return n === void 0 || !this.index ? 0 : this.index.lineCount(n);
+  }
+  async indexCov(e, t, n) {
+    var r;
+    if (!this.index)
+      return [];
+    await this.index.parse();
+    const a = (r = this.chrToIndex) === null || r === void 0 ? void 0 : r[e];
+    return a === void 0 ? [] : this.index.indexCov(a, t, n);
+  }
+  async blocksForRange(e, t, n, r) {
+    var a;
+    if (!this.index)
+      return [];
+    await this.index.parse();
+    const i = (a = this.chrToIndex) === null || a === void 0 ? void 0 : a[e];
+    return i === void 0 ? [] : this.index.blocksForRange(i, t, n, r);
+  }
+}
+async function $(o, e) {
+  const t = await Promise.all(o.map(async (n) => {
+    const { url: r, headers: a } = n;
+    if (r.startsWith("data:"))
+      return E.Buffer.from(r.split(",")[1], "base64");
+    {
+      const { referer: i, ...c } = a, d = await fetch(r, {
+        ...e,
+        headers: { ...e == null ? void 0 : e.headers, ...c }
+      });
+      if (!d.ok)
+        throw new Error(`HTTP ${d.status} fetching ${r}: ${await d.text()}`);
+      return E.Buffer.from(await d.arrayBuffer());
+    }
+  }));
+  return E.Buffer.concat(await Promise.all(t.map((n) => L(n))));
+}
+class Ae extends _e {
+  constructor(e) {
+    super({ htsget: !0 }), this.baseUrl = e.baseUrl, this.trackId = e.trackId;
+  }
+  async *streamRecordsForRange(e, t, n, r) {
+    var a;
+    const c = `${`${this.baseUrl}/${this.trackId}`}?referenceName=${e}&start=${t}&end=${n}&format=BAM`, d = (a = this.chrToIndex) === null || a === void 0 ? void 0 : a[e];
+    if (d === void 0)
+      yield [];
+    else {
+      const s = await fetch(c, { ...r });
+      if (!s.ok)
+        throw new Error(`HTTP ${s.status} fetching ${c}: ${await s.text()}`);
+      const l = await s.json(), u = await $(l.htsget.urls.slice(1), r);
+      yield* this._fetchChunkFeatures([
+        // fake stuff to pretend to be a Chunk
+        {
+          buffer: u,
+          _fetchedSize: void 0,
+          bin: 0,
+          compareTo() {
+            return 0;
+          },
+          toUniqueString() {
+            return `${e}_${t}_${n}`;
+          },
+          fetchedSize() {
+            return 0;
+          },
+          minv: {
+            dataPosition: 0,
+            blockPosition: 0,
+            compareTo: () => 0
+          },
+          maxv: {
+            dataPosition: Number.MAX_SAFE_INTEGER,
+            blockPosition: 0,
+            compareTo: () => 0
+          },
+          toString() {
+            return `${e}_${t}_${n}`;
+          }
+        }
+      ], d, t, n, r);
+    }
+  }
+  async _readChunk({ chunk: e }) {
+    if (!e.buffer)
+      throw new Error("expected chunk.buffer in htsget");
+    return { data: e.buffer, cpositions: [], dpositions: [], chunk: e };
+  }
+  async getHeader(e = {}) {
+    const t = `${this.baseUrl}/${this.trackId}?referenceName=na&class=header`, n = await fetch(t, e);
+    if (!n.ok)
+      throw new Error(`HTTP ${n.status} fetching ${t}: ${await n.text()}`);
+    const r = await n.json(), a = await $(r.htsget.urls, e);
+    if (a.readInt32LE(0) !== Q)
+      throw new Error("Not a BAM file");
+    const i = a.readInt32LE(4), c = a.toString("utf8", 8, 8 + i), d = V(c), s = [], l = {}, u = d.filter((h) => h.tag === "SQ");
+    for (const [h, f] of u.entries()) {
+      let m = "", b = 0;
+      for (const x of f.data)
+        x.tag === "SN" ? m = x.value : x.tag === "LN" && (b = +x.value);
+      l[m] = h, s[h] = { refName: m, length: b };
+    }
+    return this.chrToIndex = l, this.indexToChr = s, d;
+  }
+}
+export {
+  A as BAI,
+  _e as BamFile,
+  be as BamRecord,
+  T as CSI,
+  Ae as HtsgetFile
+};