@genome-spy/core 0.64.0 → 0.65.0

package/dist/bundle/index-DhcU-Gk-.js

@@ -0,0 +1,1487 @@
+import { L as D } from "./index-BhtHKLUo.js";
+import { I as z, Z as G } from "./inflate-DRgHi_KK.js";
+import { LocalFile as B, RemoteFile as T } from "./browser-txUcLy2H.js";
+class N {
+  constructor(e, n, t, r) {
+    this.minv = e, this.maxv = n, this.bin = t, this._fetchedSize = r;
+  }
+  toUniqueString() {
+    return `${this.minv.toString()}..${this.maxv.toString()} (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;
+  }
+}
+class H {
+  constructor({ filehandle: e, renameRefSeq: n = (t) => t }) {
+    this.filehandle = e, this.renameRefSeq = n;
+  }
+}
+const $ = 65536, te = $ * $;
+function ne(c, e = 0) {
+  const n = c[e] | c[e + 1] << 8 | c[e + 2] << 16 | c[e + 3] << 24;
+  return ((c[e + 4] | c[e + 5] << 8 | c[e + 6] << 16 | c[e + 7] << 24) >>> 0) * te + (n >>> 0);
+}
+function re(c, e) {
+  return e.minv.blockPosition - c.maxv.blockPosition < 65e3 && e.maxv.blockPosition - c.minv.blockPosition < 5e6;
+}
+function se(c = {}) {
+  return "aborted" in c ? { signal: c } : c;
+}
+function j(c, e) {
+  const n = [];
+  let t;
+  if (c.length === 0)
+    return c;
+  c.sort((r, a) => {
+    const s = r.minv.blockPosition - a.minv.blockPosition;
+    return s === 0 ? r.minv.dataPosition - a.minv.dataPosition : s;
+  });
+  for (const r of c)
+    (!e || r.maxv.compareTo(e) > 0) && (t === void 0 ? (n.push(r), t = r) : re(t, r) ? r.maxv.compareTo(t.maxv) > 0 && (t.maxv = r.maxv) : (n.push(r), t = r));
+  return n;
+}
+function Q(c, e) {
+  return {
+    lineCount: ne(c, e)
+  };
+}
+function F(c, e) {
+  return c ? c.compareTo(e) > 0 ? e : c : e;
+}
+function ie(c, e = (n) => n) {
+  let n = 0, t = 0;
+  const r = [], a = {};
+  for (let s = 0; s < c.length; s += 1)
+    if (!c[s]) {
+      if (t < s) {
+        let o = "";
+        for (let i = t; i < s; i++)
+          o += String.fromCharCode(c[i]);
+        o = e(o), r[n] = o, a[o] = n;
+      }
+      t = s + 1, n += 1;
+    }
+  return { refNameToId: a, refIdToName: r };
+}
+function ae(c) {
+  let e = 0;
+  for (const r of c)
+    e += r.length;
+  const n = new Uint8Array(e);
+  let t = 0;
+  for (const r of c)
+    n.set(r, t), t += r.length;
+  return n;
+}
+async function oe(c) {
+  const e = [];
+  for await (const n of c)
+    for (const t of n)
+      e.push(t);
+  return e;
+}
+class W {
+  constructor(e, n) {
+    this.blockPosition = e, this.dataPosition = n;
+  }
+  toString() {
+    return `${this.blockPosition}:${this.dataPosition}`;
+  }
+  compareTo(e) {
+    return this.blockPosition - e.blockPosition || this.dataPosition - e.dataPosition;
+  }
+}
+function C(c, e = 0, n = !1) {
+  if (n)
+    throw new Error("big-endian virtual file offsets not implemented");
+  return new W(c[e + 7] * 1099511627776 + c[e + 6] * 4294967296 + c[e + 5] * 16777216 + c[e + 4] * 65536 + c[e + 3] * 256 + c[e + 2], c[e + 1] << 8 | c[e]);
+}
+const ce = 21578050;
+function fe(c, e) {
+  return c - c % e;
+}
+function de(c, e) {
+  return c - c % e + e;
+}
+function he(c, e) {
+  return e -= 1, [
+    [0, 0],
+    [1 + (c >> 26), 1 + (e >> 26)],
+    [9 + (c >> 23), 9 + (e >> 23)],
+    [73 + (c >> 20), 73 + (e >> 20)],
+    [585 + (c >> 17), 585 + (e >> 17)],
+    [4681 + (c >> 14), 4681 + (e >> 14)]
+  ];
+}
+class E extends H {
+  async lineCount(e, n) {
+    var r, a;
+    return ((a = (r = (await this.parse(n)).indices(e)) == null ? void 0 : r.stats) == null ? void 0 : a.lineCount) || 0;
+  }
+  async _parse(e) {
+    const n = await this.filehandle.readFile(), t = new DataView(n.buffer);
+    if (t.getUint32(0, !0) !== ce)
+      throw new Error("Not a BAI file");
+    const r = t.getInt32(4, !0), s = ((1 << (5 + 1) * 3) - 1) / 7;
+    let o = 8, i;
+    const f = [];
+    for (let b = 0; b < r; b++) {
+      f.push(o);
+      const h = t.getInt32(o, !0);
+      o += 4;
+      for (let u = 0; u < h; u += 1) {
+        const l = t.getUint32(o, !0);
+        if (o += 4, l === s + 1)
+          o += 4, o += 32;
+        else {
+          if (l > s + 1)
+            throw new Error("bai index contains too many bins, please use CSI");
+          {
+            const m = t.getInt32(o, !0);
+            o += 4;
+            for (let y = 0; y < m; y++)
+              o += 8, o += 8;
+          }
+        }
+      }
+      const g = t.getInt32(o, !0);
+      o += 4;
+      const w = new Array(g);
+      for (let u = 0; u < g; u++) {
+        const l = C(n, o);
+        o += 8, i = F(i, l), w[u] = l;
+      }
+    }
+    const d = new D({
+      maxSize: 5
+    });
+    function x(b) {
+      let h = f[b];
+      if (h === void 0)
+        return;
+      const g = t.getInt32(h, !0);
+      let w;
+      h += 4;
+      const u = {};
+      for (let y = 0; y < g; y += 1) {
+        const _ = t.getUint32(h, !0);
+        if (h += 4, _ === s + 1)
+          h += 4, w = Q(n, h + 16), h += 32;
+        else {
+          if (_ > s + 1)
+            throw new Error("bai index contains too many bins, please use CSI");
+          {
+            const p = t.getInt32(h, !0);
+            h += 4;
+            const I = new Array(p);
+            for (let P = 0; P < p; P++) {
+              const S = C(n, h);
+              h += 8;
+              const k = C(n, h);
+              h += 8, i = F(i, S), I[P] = new N(S, k, _);
+            }
+            u[_] = I;
+          }
+        }
+      }
+      const l = t.getInt32(h, !0);
+      h += 4;
+      const m = new Array(l);
+      for (let y = 0; y < l; y++) {
+        const _ = C(n, h);
+        h += 8, i = F(i, _), m[y] = _;
+      }
+      return {
+        binIndex: u,
+        linearIndex: m,
+        stats: w
+      };
+    }
+    return {
+      bai: !0,
+      firstDataLine: i,
+      maxBlockSize: 65536,
+      indices: (b) => {
+        if (!d.has(b)) {
+          const h = x(b);
+          return h && d.set(b, h), h;
+        }
+        return d.get(b);
+      },
+      refCount: r
+    };
+  }
+  async indexCov(e, n, t, r) {
+    const s = n !== void 0, i = (await this.parse(r)).indices(e);
+    if (!i)
+      return [];
+    const { linearIndex: f = [], stats: d } = i;
+    if (f.length === 0)
+      return [];
+    const x = t === void 0 ? (f.length - 1) * 16384 : de(t, 16384), b = n === void 0 ? 0 : fe(n, 16384), h = s ? new Array((x - b) / 16384) : new Array(f.length - 1), g = f[f.length - 1].blockPosition;
+    if (x > (f.length - 1) * 16384)
+      throw new Error("query outside of range of linear index");
+    let w = f[b / 16384].blockPosition;
+    for (let u = b / 16384, l = 0; u < x / 16384; u++, l++)
+      h[l] = {
+        score: f[u + 1].blockPosition - w,
+        start: u * 16384,
+        end: u * 16384 + 16384
+      }, w = f[u + 1].blockPosition;
+    return h.map((u) => ({
+      ...u,
+      score: u.score * ((d == null ? void 0 : d.lineCount) || 0) / g
+    }));
+  }
+  async blocksForRange(e, n, t, r = {}) {
+    n < 0 && (n = 0);
+    const a = await this.parse(r);
+    if (!a)
+      return [];
+    const s = a.indices(e);
+    if (!s)
+      return [];
+    const o = he(n, t), i = [];
+    for (const [h, g] of o)
+      for (let w = h; w <= g; w++)
+        if (s.binIndex[w]) {
+          const u = s.binIndex[w];
+          for (const l of u)
+            i.push(new N(l.minv, l.maxv, w));
+        }
+    const f = s.linearIndex.length;
+    let d;
+    const x = Math.min(n >> 14, f - 1), b = Math.min(t >> 14, f - 1);
+    for (let h = x; h <= b; ++h) {
+      const g = s.linearIndex[h];
+      g && (!d || g.compareTo(d) < 0) && (d = g);
+    }
+    return j(i, d);
+  }
+  async parse(e = {}) {
+    return this.setupP || (this.setupP = this._parse(e).catch((n) => {
+      throw this.setupP = void 0, n;
+    })), this.setupP;
+  }
+  async hasRefSeq(e, n = {}) {
+    var r;
+    return !!((r = (await this.parse(n)).indices(e)) != null && r.binIndex);
+  }
+}
+function ue(c) {
+  let e = 0;
+  for (const n of c)
+    e += n.length;
+  return e;
+}
+function Y(c, e) {
+  const n = new Uint8Array(e ?? ue(c));
+  let t = 0;
+  for (const r of c)
+    n.set(r, t), t += r.length;
+  return n;
+}
+async function V(c) {
+  try {
+    let e, n = 0, t;
+    const r = [];
+    let a = 0;
+    do {
+      const s = c.subarray(n);
+      if (t = new z(void 0), { strm: e } = t, t.push(s, G), t.err)
+        throw new Error(t.msg);
+      n += e.next_in;
+      const o = t.result;
+      r.push(o), a += o.length;
+    } while (e.avail_in);
+    return Y(r, a);
+  } catch (e) {
+    throw /incorrect header check/.exec(`${e}`) ? new Error("problem decompressing block: incorrect gzip header check") : e;
+  }
+}
+async function le(c, e, n) {
+  try {
+    let t;
+    const { minv: r, maxv: a } = e;
+    let s = r.blockPosition, o = r.dataPosition;
+    const i = [], f = [], d = [];
+    let x = 0, b = !1, h = 0;
+    do {
+      const g = c.subarray(s - r.blockPosition), w = s.toString();
+      let u, l;
+      const m = n == null ? void 0 : n.get(w);
+      if (m)
+        u = m.buffer, l = m.nextIn, b = !0;
+      else {
+        const p = new z(void 0);
+        if ({ strm: t } = p, p.push(g, G), p.err)
+          throw new Error(p.msg);
+        u = p.result, l = t.next_in, b = !1, n == null || n.set(w, { buffer: u, nextIn: l });
+      }
+      i.push(u);
+      let y = u.length;
+      f.push(s), d.push(o), i.length === 1 && r.dataPosition && (i[0] = i[0].subarray(r.dataPosition), y = i[0].length);
+      const _ = s;
+      if (s += l, o += y, _ >= a.blockPosition) {
+        i[x] = i[x].subarray(0, a.blockPosition === r.blockPosition ? a.dataPosition - r.dataPosition + 1 : a.dataPosition + 1), h += i[x].length, f.push(s), d.push(o);
+        break;
+      }
+      h += y, x++;
+    } while (b ? s < c.length + r.blockPosition : (
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+      t.avail_in
+    ));
+    return {
+      buffer: Y(i, h),
+      cpositions: f,
+      dpositions: d
+    };
+  } catch (t) {
+    throw /incorrect header check/.exec(`${t}`) ? new Error("problem decompressing block: incorrect gzip header check") : t;
+  }
+}
+let q = [
+  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" && (q = new Int32Array(q));
+const xe = (c, e) => {
+  let n = -1;
+  for (let t = 0; t < c.length; t++)
+    n = q[(n ^ c[t]) & 255] ^ n >>> 8;
+  return n ^ -1;
+}, be = 21582659, ge = 38359875;
+function we(c, e) {
+  return c * 2 ** e;
+}
+function O(c, e) {
+  return Math.floor(c / 2 ** e);
+}
+class U extends H {
+  constructor() {
+    super(...arguments), this.maxBinNumber = 0, this.depth = 0, this.minShift = 0;
+  }
+  async lineCount(e, n) {
+    var r, a;
+    return ((a = (r = (await this.parse(n)).indices(e)) == null ? void 0 : r.stats) == null ? void 0 : a.lineCount) || 0;
+  }
+  async indexCov() {
+    return [];
+  }
+  parseAuxData(e, n) {
+    const t = new DataView(e.buffer), r = t.getUint32(n, !0), a = r & 65536 ? "zero-based-half-open" : "1-based-closed", s = { 0: "generic", 1: "SAM", 2: "VCF" }[r & 15];
+    if (!s)
+      throw new Error(`invalid Tabix preset format flags ${r}`);
+    const o = {
+      ref: t.getInt32(n + 4, !0),
+      start: t.getInt32(n + 8, !0),
+      end: t.getInt32(n + 12, !0)
+    }, i = t.getInt32(n + 16, !0), f = i ? String.fromCharCode(i) : "", d = t.getInt32(n + 20, !0), x = t.getInt32(n + 24, !0);
+    return {
+      columnNumbers: o,
+      coordinateType: a,
+      metaValue: i,
+      metaChar: f,
+      skipLines: d,
+      format: s,
+      formatFlags: r,
+      ...ie(e.subarray(n + 28, n + 28 + x), this.renameRefSeq)
+    };
+  }
+  // fetch and parse the index
+  async _parse(e) {
+    const n = await this.filehandle.readFile(e), t = await V(n), r = new DataView(t.buffer);
+    let a;
+    const s = r.getUint32(0, !0);
+    if (s === be)
+      a = 1;
+    else if (s === ge)
+      a = 2;
+    else
+      throw new Error(`Not a CSI file ${s}`);
+    this.minShift = r.getInt32(4, !0), this.depth = r.getInt32(8, !0), this.maxBinNumber = ((1 << (this.depth + 1) * 3) - 1) / 7;
+    const o = this.maxBinNumber, i = r.getInt32(12, !0), f = i >= 30 ? this.parseAuxData(t, 16) : void 0, d = r.getInt32(16 + i, !0);
+    let x = 16 + i + 4, b;
+    const h = [];
+    for (let u = 0; u < d; u++) {
+      h.push(x);
+      const l = r.getInt32(x, !0);
+      x += 4;
+      for (let m = 0; m < l; m++) {
+        const y = r.getUint32(x, !0);
+        if (x += 4, y > this.maxBinNumber)
+          x += 44;
+        else {
+          x += 8;
+          const _ = r.getInt32(x, !0);
+          x += 4;
+          for (let p = 0; p < _; p += 1) {
+            const I = C(t, x);
+            x += 8, x += 8, b = F(b, I);
+          }
+        }
+      }
+    }
+    const g = new D({
+      maxSize: 5
+    });
+    function w(u) {
+      let l = h[u];
+      if (l === void 0)
+        return;
+      const m = r.getInt32(l, !0);
+      l += 4;
+      const y = {};
+      let _;
+      for (let p = 0; p < m; p++) {
+        const I = r.getUint32(l, !0);
+        if (l += 4, I > o)
+          _ = Q(t, l + 28), l += 44;
+        else {
+          b = F(b, C(t, l)), l += 8;
+          const P = r.getInt32(l, !0);
+          l += 4;
+          const S = new Array(P);
+          for (let k = 0; k < P; k += 1) {
+            const X = C(t, l);
+            l += 8;
+            const ee = C(t, l);
+            l += 8, S[k] = new N(X, ee, I);
+          }
+          y[I] = S;
+        }
+      }
+      return {
+        binIndex: y,
+        stats: _
+      };
+    }
+    return {
+      csiVersion: a,
+      firstDataLine: b,
+      indices: (u) => {
+        if (!g.has(u)) {
+          const l = w(u);
+          return l && g.set(u, l), l;
+        }
+        return g.get(u);
+      },
+      refCount: d,
+      csi: !0,
+      maxBlockSize: 65536,
+      ...f
+    };
+  }
+  async blocksForRange(e, n, t, r = {}) {
+    n < 0 && (n = 0);
+    const s = (await this.parse(r)).indices(e);
+    if (!s)
+      return [];
+    const o = this.reg2bins(n, t);
+    if (o.length === 0)
+      return [];
+    const i = [];
+    for (const [f, d] of o)
+      for (let x = f; x <= d; x++)
+        if (s.binIndex[x]) {
+          const b = s.binIndex[x];
+          for (const h of b)
+            i.push(h);
+        }
+    return j(i, new W(0, 0));
+  }
+  /**
+   * calculate the list of bins that may overlap with region [beg,end)
+   * (zero-based half-open)
+   */
+  reg2bins(e, n) {
+    e -= 1, e < 1 && (e = 1), n > 2 ** 50 && (n = 2 ** 34), n -= 1;
+    let t = 0, r = 0, a = this.minShift + this.depth * 3;
+    const s = [];
+    for (; t <= this.depth; a -= 3, r += we(1, t * 3), t += 1) {
+      const o = r + O(e, a), i = r + O(n, a);
+      if (i - o + s.length > this.maxBinNumber)
+        throw new Error(`query ${e}-${n} is too large for current binning scheme (shift ${this.minShift}, depth ${this.depth}), try a smaller query or a coarser index binning scheme`);
+      s.push([o, i]);
+    }
+    return s;
+  }
+  async parse(e = {}) {
+    return this.setupP || (this.setupP = this._parse(e).catch((n) => {
+      throw this.setupP = void 0, n;
+    })), this.setupP;
+  }
+  async hasRefSeq(e, n = {}) {
+    var r;
+    return !!((r = (await this.parse(n)).indices(e)) != null && r.binIndex);
+  }
+}
+class me {
+  read() {
+    throw new Error("never called");
+  }
+  stat() {
+    throw new Error("never called");
+  }
+  readFile() {
+    throw new Error("never called");
+  }
+  close() {
+    throw new Error("never called");
+  }
+}
+const A = {
+  //  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
+}, v = "=ACMGRSVTWYHKDBN".split(""), ye = [
+  77,
+  73,
+  68,
+  78,
+  83,
+  72,
+  80,
+  61,
+  88,
+  63,
+  63,
+  63,
+  63,
+  63,
+  63,
+  63
+], _e = 1, pe = 3, K = 4, Ae = 5, Ie = 1 << _e | 1 << K | 1 << Ae;
+class R {
+  constructor(e) {
+    this.bytes = e.bytes, this.fileOffset = e.fileOffset, this._dataView = new DataView(this.bytes.byteArray.buffer);
+  }
+  get byteArray() {
+    return this.bytes.byteArray;
+  }
+  get flags() {
+    return (this._dataView.getInt32(this.bytes.start + 16, !0) & 4294901760) >> 16;
+  }
+  get ref_id() {
+    return this._dataView.getInt32(this.bytes.start + 4, !0);
+  }
+  get start() {
+    return this._dataView.getInt32(this.bytes.start + 8, !0);
+  }
+  get end() {
+    return this.start + this.length_on_ref;
+  }
+  get id() {
+    return this.fileOffset;
+  }
+  get mq() {
+    const e = (this.bin_mq_nl & 65280) >> 8;
+    return e === 255 ? void 0 : e;
+  }
+  get score() {
+    return this.mq;
+  }
+  get qual() {
+    if (this.isSegmentUnmapped())
+      return;
+    const e = this.b0 + this.read_name_length + this.num_cigar_bytes + this.num_seq_bytes;
+    return this.byteArray.subarray(e, e + this.seq_length);
+  }
+  get strand() {
+    return this.isReverseComplemented() ? -1 : 1;
+  }
+  get b0() {
+    return this.bytes.start + 36;
+  }
+  get name() {
+    let e = "";
+    for (let n = 0; n < this.read_name_length - 1; n++)
+      e += String.fromCharCode(this.byteArray[this.b0 + n]);
+    return e;
+  }
+  get tags() {
+    let e = this.b0 + this.read_name_length + this.num_cigar_bytes + this.num_seq_bytes + this.seq_length;
+    const n = this.bytes.end, t = {};
+    for (; e < n; ) {
+      const r = String.fromCharCode(this.byteArray[e]) + String.fromCharCode(this.byteArray[e + 1]), a = String.fromCharCode(this.byteArray[e + 2]);
+      switch (e += 3, a) {
+        case "A":
+          t[r] = String.fromCharCode(this.byteArray[e]), e += 1;
+          break;
+        case "i":
+          t[r] = this._dataView.getInt32(e, !0), e += 4;
+          break;
+        case "I":
+          t[r] = this._dataView.getUint32(e, !0), e += 4;
+          break;
+        case "c":
+          t[r] = this._dataView.getInt8(e), e += 1;
+          break;
+        case "C":
+          t[r] = this._dataView.getUint8(e), e += 1;
+          break;
+        case "s":
+          t[r] = this._dataView.getInt16(e, !0), e += 2;
+          break;
+        case "S":
+          t[r] = this._dataView.getUint16(e, !0), e += 2;
+          break;
+        case "f":
+          t[r] = this._dataView.getFloat32(e, !0), e += 4;
+          break;
+        case "Z":
+        case "H": {
+          const s = [];
+          for (; e <= n; ) {
+            const o = this.byteArray[e++];
+            if (o !== 0)
+              s.push(String.fromCharCode(o));
+            else
+              break;
+          }
+          t[r] = s.join("");
+          break;
+        }
+        case "B": {
+          const s = this.byteArray[e++], o = String.fromCharCode(s), i = this._dataView.getInt32(e, !0);
+          e += 4;
+          const f = this.byteArray.byteOffset + e;
+          if (o === "i") {
+            if (f % 4 === 0)
+              t[r] = new Int32Array(this.byteArray.buffer, f, i);
+            else {
+              const d = this.byteArray.slice(e, e + (i << 2));
+              t[r] = new Int32Array(d.buffer, d.byteOffset, i);
+            }
+            e += i << 2;
+          } else if (o === "I") {
+            if (f % 4 === 0)
+              t[r] = new Uint32Array(this.byteArray.buffer, f, i);
+            else {
+              const d = this.byteArray.slice(e, e + (i << 2));
+              t[r] = new Uint32Array(d.buffer, d.byteOffset, i);
+            }
+            e += i << 2;
+          } else if (o === "s") {
+            if (f % 2 === 0)
+              t[r] = new Int16Array(this.byteArray.buffer, f, i);
+            else {
+              const d = this.byteArray.slice(e, e + (i << 1));
+              t[r] = new Int16Array(d.buffer, d.byteOffset, i);
+            }
+            e += i << 1;
+          } else if (o === "S") {
+            if (f % 2 === 0)
+              t[r] = new Uint16Array(this.byteArray.buffer, f, i);
+            else {
+              const d = this.byteArray.slice(e, e + (i << 1));
+              t[r] = new Uint16Array(d.buffer, d.byteOffset, i);
+            }
+            e += i << 1;
+          } else if (o === "c")
+            t[r] = new Int8Array(this.byteArray.buffer, f, i), e += i;
+          else if (o === "C")
+            t[r] = new Uint8Array(this.byteArray.buffer, f, i), e += i;
+          else if (o === "f") {
+            if (f % 4 === 0)
+              t[r] = new Float32Array(this.byteArray.buffer, f, i);
+            else {
+              const d = this.byteArray.slice(e, e + (i << 2));
+              t[r] = new Float32Array(d.buffer, d.byteOffset, i);
+            }
+            e += i << 2;
+          }
+          break;
+        }
+        default:
+          console.error("Unknown BAM tag type", a);
+          break;
+      }
+    }
+    return t;
+  }
+  /**
+   * @returns {boolean} true if the read is paired, regardless of whether both
+   * segments are mapped
+   */
+  isPaired() {
+    return !!(this.flags & A.BAM_FPAIRED);
+  }
+  /** @returns {boolean} true if the read is paired, and both segments are mapped */
+  isProperlyPaired() {
+    return !!(this.flags & A.BAM_FPROPER_PAIR);
+  }
+  /** @returns {boolean} true if the read itself is unmapped; conflictive with isProperlyPaired */
+  isSegmentUnmapped() {
+    return !!(this.flags & A.BAM_FUNMAP);
+  }
+  /** @returns {boolean} true if the read itself is unmapped; conflictive with isProperlyPaired */
+  isMateUnmapped() {
+    return !!(this.flags & A.BAM_FMUNMAP);
+  }
+  /** @returns {boolean} true if the read is mapped to the reverse strand */
+  isReverseComplemented() {
+    return !!(this.flags & A.BAM_FREVERSE);
+  }
+  /** @returns {boolean} true if the mate is mapped to the reverse strand */
+  isMateReverseComplemented() {
+    return !!(this.flags & A.BAM_FMREVERSE);
+  }
+  /** @returns {boolean} true if this is read number 1 in a pair */
+  isRead1() {
+    return !!(this.flags & A.BAM_FREAD1);
+  }
+  /** @returns {boolean} true if this is read number 2 in a pair */
+  isRead2() {
+    return !!(this.flags & A.BAM_FREAD2);
+  }
+  /** @returns {boolean} true if this is a secondary alignment */
+  isSecondary() {
+    return !!(this.flags & A.BAM_FSECONDARY);
+  }
+  /** @returns {boolean} true if this read has failed QC checks */
+  isFailedQc() {
+    return !!(this.flags & A.BAM_FQCFAIL);
+  }
+  /** @returns {boolean} true if the read is an optical or PCR duplicate */
+  isDuplicate() {
+    return !!(this.flags & A.BAM_FDUP);
+  }
+  /** @returns {boolean} true if this is a supplementary alignment */
+  isSupplementary() {
+    return !!(this.flags & A.BAM_FSUPPLEMENTARY);
+  }
+  get cigarAndLength() {
+    if (this.isSegmentUnmapped())
+      return {
+        length_on_ref: 0,
+        NUMERIC_CIGAR: new Uint32Array(0)
+      };
+    const e = this.num_cigar_ops;
+    let n = this.b0 + this.read_name_length;
+    const t = this._dataView.getInt32(n, !0), r = t >> 4;
+    if ((t & 15) === K && r === this.seq_length) {
+      n += 4;
+      const s = this._dataView.getInt32(n, !0), o = s >> 4;
+      return (s & 15) !== pe && console.warn("CG tag with no N tag"), {
+        NUMERIC_CIGAR: this.tags.CG,
+        length_on_ref: o
+      };
+    } else {
+      const s = this.byteArray.byteOffset + n, o = s % 4 === 0 ? new Uint32Array(this.byteArray.buffer, s, e) : new Uint32Array(this.byteArray.slice(n, n + (e << 2)).buffer, 0, e);
+      let i = 0;
+      for (let f = 0; f < e; ++f) {
+        const d = o[f];
+        1 << (d & 15) & Ie || (i += d >> 4);
+      }
+      return {
+        NUMERIC_CIGAR: o,
+        length_on_ref: i
+      };
+    }
+  }
+  get length_on_ref() {
+    return this.cigarAndLength.length_on_ref;
+  }
+  get NUMERIC_CIGAR() {
+    return this.cigarAndLength.NUMERIC_CIGAR;
+  }
+  get CIGAR() {
+    const e = this.NUMERIC_CIGAR;
+    let n = "";
+    for (let t = 0, r = e.length; t < r; t++) {
+      const a = e[t], s = a >> 4, o = ye[a & 15];
+      n += s + String.fromCharCode(o);
+    }
+    return n;
+  }
+  get num_cigar_ops() {
+    return this.flag_nc & 65535;
+  }
+  get num_cigar_bytes() {
+    return this.num_cigar_ops << 2;
+  }
+  get read_name_length() {
+    return this.bin_mq_nl & 255;
+  }
+  get num_seq_bytes() {
+    return this.seq_length + 1 >> 1;
+  }
+  get NUMERIC_SEQ() {
+    const e = this.b0 + this.read_name_length + this.num_cigar_bytes, n = this.byteArray.subarray(e, e + this.num_seq_bytes);
+    return new Uint8Array(n.buffer, n.byteOffset, this.num_seq_bytes);
+  }
+  get seq() {
+    const e = this.NUMERIC_SEQ, n = this.seq_length, t = new Array(n);
+    let r = 0;
+    const a = n >> 1;
+    for (let s = 0; s < a; ++s) {
+      const o = e[s];
+      t[r++] = v[(o & 240) >> 4], t[r++] = v[o & 15];
+    }
+    if (r < n) {
+      const s = e[a];
+      t[r] = v[(s & 240) >> 4];
+    }
+    return t.join("");
+  }
+  // adapted from igv.js
+  get pair_orientation() {
+    if (!this.isSegmentUnmapped() && !this.isMateUnmapped() && this.ref_id === this.next_refid) {
+      const e = this.isReverseComplemented() ? "R" : "F", n = this.isMateReverseComplemented() ? "R" : "F";
+      let t = " ", r = " ";
+      this.isRead1() ? (t = "1", r = "2") : this.isRead2() && (t = "2", r = "1");
+      const a = [];
+      return this.template_length > 0 ? (a[0] = e, a[1] = t, a[2] = n, a[3] = r) : (a[2] = e, a[3] = t, a[0] = n, a[1] = r), a.join("");
+    }
+  }
+  get bin_mq_nl() {
+    return this._dataView.getInt32(this.bytes.start + 12, !0);
+  }
+  get flag_nc() {
+    return this._dataView.getInt32(this.bytes.start + 16, !0);
+  }
+  get seq_length() {
+    return this._dataView.getInt32(this.bytes.start + 20, !0);
+  }
+  get next_refid() {
+    return this._dataView.getInt32(this.bytes.start + 24, !0);
+  }
+  get next_pos() {
+    return this._dataView.getInt32(this.bytes.start + 28, !0);
+  }
+  get template_length() {
+    return this._dataView.getInt32(this.bytes.start + 32, !0);
+  }
+  seqAt(e) {
+    if (e < this.seq_length) {
+      const n = e >> 1, t = this.byteArray[this.b0 + this.read_name_length + this.num_cigar_bytes + n];
+      return e % 2 === 0 ? v[(t & 240) >> 4] : v[t & 15];
+    } else
+      return;
+  }
+  toJSON() {
+    const e = {};
+    for (const n of Object.keys(this))
+      n.startsWith("_") || n === "bytes" || (e[n] = this[n]);
+    return e;
+  }
+}
+function M(c, e) {
+  const n = Object.getOwnPropertyDescriptor(c.prototype, e);
+  if (!n)
+    throw new Error("OH NO, NO PROPERTY DESCRIPTOR");
+  const t = n.get;
+  if (!t)
+    throw new Error("OH NO, NOT A GETTER");
+  Object.defineProperty(c.prototype, e, {
+    get() {
+      const r = t.call(this);
+      return Object.defineProperty(this, e, { value: r }), r;
+    }
+  });
+}
+M(R, "tags");
+M(R, "cigarAndLength");
+M(R, "seq");
+M(R, "qual");
+M(R, "end");
+function Z(c) {
+  const e = c.split(/\r?\n/), n = [];
+  for (const t of e) {
+    const [r, ...a] = t.split(/\t/);
+    r && n.push({
+      tag: r.slice(1),
+      data: a.map((s) => {
+        const o = s.indexOf(":"), i = s.slice(0, o), f = s.slice(o + 1);
+        return { tag: i, value: f };
+      })
+    });
+  }
+  return n;
+}
+const J = 21840194, Ce = 65536;
+class Pe {
+  constructor({ bamFilehandle: e, bamPath: n, bamUrl: t, baiPath: r, baiFilehandle: a, baiUrl: s, csiPath: o, csiFilehandle: i, csiUrl: f, htsget: d, renameRefSeqs: x = (b) => b }) {
+    if (this.htsget = !1, this.cache = new D({
+      maxSize: 1e3
+    }), this.renameRefSeq = x, e)
+      this.bam = e;
+    else if (n)
+      this.bam = new B(n);
+    else if (t)
+      this.bam = new T(t);
+    else if (d)
+      this.htsget = !0, this.bam = new me();
+    else
+      throw new Error("unable to initialize bam");
+    if (i)
+      this.index = new U({ filehandle: i });
+    else if (o)
+      this.index = new U({ filehandle: new B(o) });
+    else if (f)
+      this.index = new U({ filehandle: new T(f) });
+    else if (a)
+      this.index = new E({ filehandle: a });
+    else if (r)
+      this.index = new E({ filehandle: new B(r) });
+    else if (s)
+      this.index = new E({ filehandle: new T(s) });
+    else if (n)
+      this.index = new E({ filehandle: new B(`${n}.bai`) });
+    else if (t)
+      this.index = new E({ filehandle: new T(`${t}.bai`) });
+    else if (d)
+      this.htsget = !0;
+    else
+      throw new Error("unable to infer index format");
+  }
+  async getHeaderPre(e) {
+    const n = se(e);
+    if (!this.index)
+      return;
+    const t = await this.index.parse(n), r = t.firstDataLine === void 0 ? await this.bam.readFile() : (
+      // the logic indexData.firstDataLine is a virtualOffset telling us
+      // where the data is. It is in the middle of a virtualOffset
+      // (provided by the bgzip block offset at blockPosition + the
+      // virtualOffset dataPosition, so we add one extra blockLen to make
+      // sure we consume the full header)
+      await this.bam.read(t.firstDataLine.blockPosition + Ce, 0)
+    ), a = await V(r), s = new DataView(a.buffer);
+    if (s.getInt32(0, !0) !== J)
+      throw new Error("Not a BAM file");
+    const o = s.getInt32(4, !0), i = new TextDecoder("utf8");
+    this.header = i.decode(a.subarray(8, 8 + o));
+    const { chrToIndex: f, indexToChr: d } = this._parseRefSeqs(a, o + 8);
+    return this.chrToIndex = f, this.indexToChr = d, Z(this.header);
+  }
+  getHeader(e) {
+    return this.headerP || (this.headerP = this.getHeaderPre(e).catch((n) => {
+      throw this.headerP = void 0, n;
+    })), this.headerP;
+  }
+  async getHeaderText(e = {}) {
+    return await this.getHeader(e), this.header;
+  }
+  _parseRefSeqs(e, n) {
+    const t = new DataView(e.buffer), r = t.getInt32(n, !0);
+    let a = n + 4;
+    const s = {}, o = [], i = new TextDecoder("utf8");
+    for (let f = 0; f < r; f += 1) {
+      if (a + 8 > e.length)
+        throw new Error(`Insufficient data for reference sequences: need more than ${e.length} bytes`);
+      const d = t.getInt32(a, !0), x = this.renameRefSeq(i.decode(e.subarray(a + 4, a + 4 + d - 1))), b = t.getInt32(a + d + 4, !0);
+      s[x] = f, o.push({ refName: x, length: b }), a = a + 8 + d;
+    }
+    return { chrToIndex: s, indexToChr: o };
+  }
+  async getRecordsForRange(e, n, t, r) {
+    return oe(this.streamRecordsForRange(e, n, t, r));
+  }
+  async *streamRecordsForRange(e, n, t, r) {
+    var o;
+    await this.getHeader(r);
+    const a = (o = this.chrToIndex) == null ? void 0 : o[e];
+    if (a === void 0 || !this.index)
+      return;
+    const s = await this.index.blocksForRange(a, n - 1, t, r);
+    yield* this._fetchChunkFeatures(s, a, n, t, r);
+  }
+  async *_fetchChunkFeatures(e, n, t, r, a = {}) {
+    const { viewAsPairs: s } = a, o = [];
+    let i = !1;
+    for (const f of e) {
+      const { data: d, cpositions: x, dpositions: b } = await this._readChunk({
+        chunk: f,
+        opts: a
+      }), h = await this.readBamFeatures(d, x, b, f, n, t, r), g = [];
+      for (const w of h)
+        if (w.ref_id === n)
+          if (w.start >= r) {
+            i = !0;
+            break;
+          } else w.end >= t && g.push(w);
+      if (o.push(g), yield g, i)
+        break;
+    }
+    s && (yield this.fetchPairs(n, o, a));
+  }
+  async fetchPairs(e, n, t) {
+    const { pairAcrossChr: r, maxInsertSize: a = 2e5 } = t, s = {}, o = {};
+    for (const b of n) {
+      const h = {};
+      for (const g of b) {
+        const w = g.name, u = g.id;
+        h[w] || (h[w] = 0), h[w]++, o[u] = 1;
+      }
+      for (const [g, w] of Object.entries(h))
+        w === 1 && (s[g] = !0);
+    }
+    const i = [];
+    for (const b of n)
+      for (const h of b) {
+        const g = h.name, w = h.start, u = h.next_pos, l = h.next_refid;
+        this.index && s[g] && (r || l === e && Math.abs(w - u) < a) && i.push(this.index.blocksForRange(l, u, u + 1, t));
+      }
+    const f = /* @__PURE__ */ new Map(), d = await Promise.all(i);
+    for (const b of d.flat())
+      f.has(b.toString()) || f.set(b.toString(), b);
+    return (await Promise.all([...f.values()].map(async (b) => {
+      const { data: h, cpositions: g, dpositions: w, chunk: u } = await this._readChunk({
+        chunk: b,
+        opts: t
+      }), l = [];
+      for (const m of await this.readBamFeatures(h, g, w, u))
+        s[m.name] && !o[m.id] && l.push(m);
+      return l;
+    }))).flat();
+  }
+  async _readChunk({ chunk: e, opts: n }) {
+    const t = await this.bam.read(e.fetchedSize(), e.minv.blockPosition, n), { buffer: r, cpositions: a, dpositions: s } = await le(t, e, this.cache);
+    return { data: r, cpositions: a, dpositions: s, chunk: e };
+  }
+  async readBamFeatures(e, n, t, r, a, s, o) {
+    let i = 0;
+    const f = [];
+    let d = 0;
+    const x = new DataView(e.buffer), b = t.length > 0, h = n.length > 0, g = a !== void 0 && s !== void 0 && o !== void 0;
+    for (; i + 4 < e.length; ) {
+      const w = x.getInt32(i, !0), u = i + 4 + w - 1;
+      if (b) {
+        for (; i + r.minv.dataPosition >= t[d++]; )
+          ;
+        d--;
+      }
+      if (u < e.length) {
+        if (g && i + 12 < e.length && !this._shouldIncludeFeature(x, i, a, o)) {
+          i = u + 1;
+          continue;
+        }
+        const l = new R({
+          bytes: {
+            byteArray: e,
+            start: i,
+            end: u
+          },
+          fileOffset: h ? n[d] * 256 + (i - t[d]) + r.minv.dataPosition + 1 : xe(e.subarray(i, u)) >>> 0
+        });
+        f.push(l);
+      }
+      i = u + 1;
+    }
+    return f;
+  }
+  _shouldIncludeFeature(e, n, t, r) {
+    const a = e.getInt32(n + 4, !0), s = e.getInt32(n + 8, !0);
+    return a === t && s < r;
+  }
+  async hasRefSeq(e) {
+    var t, r;
+    const n = (t = this.chrToIndex) == null ? void 0 : t[e];
+    return n === void 0 ? !1 : (r = this.index) == null ? void 0 : r.hasRefSeq(n);
+  }
+  async lineCount(e) {
+    var t;
+    const n = (t = this.chrToIndex) == null ? void 0 : t[e];
+    return n === void 0 || !this.index ? 0 : this.index.lineCount(n);
+  }
+  async indexCov(e, n, t) {
+    var a;
+    if (!this.index)
+      return [];
+    await this.index.parse();
+    const r = (a = this.chrToIndex) == null ? void 0 : a[e];
+    return r === void 0 ? [] : this.index.indexCov(r, n, t);
+  }
+  async blocksForRange(e, n, t, r) {
+    var s;
+    if (!this.index)
+      return [];
+    await this.index.parse();
+    const a = (s = this.chrToIndex) == null ? void 0 : s[e];
+    return a === void 0 ? [] : this.index.blocksForRange(a, n, t, r);
+  }
+}
+async function L(c, e) {
+  const n = await Promise.all(c.map(async (t) => {
+    const { url: r, headers: a } = t;
+    if (r.startsWith("data:")) {
+      const s = await fetch(r);
+      if (!s.ok)
+        throw new Error("failed to decode base64");
+      const o = await s.arrayBuffer();
+      return new Uint8Array(o);
+    } else {
+      const { referer: s, ...o } = a, i = await fetch(r, {
+        ...e,
+        headers: { ...e == null ? void 0 : e.headers, ...o }
+      });
+      if (!i.ok)
+        throw new Error(`HTTP ${i.status} fetching ${r}: ${await i.text()}`);
+      return new Uint8Array(await i.arrayBuffer());
+    }
+  }));
+  return ae(await Promise.all(n.map((t) => V(t))));
+}
+class Ee extends Pe {
+  constructor(e) {
+    super({ htsget: !0 }), this.baseUrl = e.baseUrl, this.trackId = e.trackId;
+  }
+  async *streamRecordsForRange(e, n, t, r) {
+    var i;
+    const s = `${`${this.baseUrl}/${this.trackId}`}?referenceName=${e}&start=${n}&end=${t}&format=BAM`, o = (i = this.chrToIndex) == null ? void 0 : i[e];
+    if (o === void 0)
+      yield [];
+    else {
+      const f = await fetch(s, { ...r });
+      if (!f.ok)
+        throw new Error(`HTTP ${f.status} fetching ${s}: ${await f.text()}`);
+      const d = await f.json(), x = await L(d.htsget.urls.slice(1), r);
+      yield* this._fetchChunkFeatures([
+        // fake stuff to pretend to be a Chunk
+        {
+          buffer: x,
+          _fetchedSize: void 0,
+          bin: 0,
+          compareTo() {
+            return 0;
+          },
+          toUniqueString() {
+            return `${e}_${n}_${t}`;
+          },
+          fetchedSize() {
+            return 0;
+          },
+          minv: {
+            dataPosition: 0,
+            blockPosition: 0,
+            compareTo: () => 0
+          },
+          maxv: {
+            dataPosition: Number.MAX_SAFE_INTEGER,
+            blockPosition: 0,
+            compareTo: () => 0
+          },
+          toString() {
+            return `${e}_${n}_${t}`;
+          }
+        }
+      ], o, n, t, 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 n = `${this.baseUrl}/${this.trackId}?referenceName=na&class=header`, t = await fetch(n, e);
+    if (!t.ok)
+      throw new Error(`HTTP ${t.status} fetching ${n}: ${await t.text()}`);
+    const r = await t.json(), a = await L(r.htsget.urls, e), s = new DataView(a.buffer);
+    if (s.getInt32(0, !0) !== J)
+      throw new Error("Not a BAM file");
+    const o = s.getInt32(4, !0), f = new TextDecoder("utf8").decode(a.subarray(8, 8 + o)), d = Z(f), x = [], b = {}, h = d.filter((g) => g.tag === "SQ");
+    for (const [g, w] of h.entries()) {
+      let u = "", l = 0;
+      for (const m of w.data)
+        m.tag === "SN" ? u = m.value : m.tag === "LN" && (l = +m.value);
+      b[u] = g, x[g] = { refName: u, length: l };
+    }
+    return this.chrToIndex = b, this.indexToChr = x, d;
+  }
+}
+export {
+  E as BAI,
+  Pe as BamFile,
+  R as BamRecord,
+  U as CSI,
+  Ee as HtsgetFile
+};