@genome-spy/core 0.65.0 → 0.67.0

package/dist/bundle/index-D28m8tSW.js

@@ -0,0 +1,1607 @@
+import { Q as V, u as D, a as Y } from "./unzip-NywezaRR.js";
+import { LocalFile as v, RemoteFile as B } from "./browser-BRemItdO.js";
+let G = class {
+  constructor(e, n, t, s) {
+    this.minv = e, this.maxv = n, this.bin = t, this._fetchedSize = s;
+  }
+  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;
+  }
+};
+const q = 65536, J = q * q;
+function X(h, e = 0) {
+  const n = h[e] | h[e + 1] << 8 | h[e + 2] << 16 | h[e + 3] << 24;
+  return ((h[e + 4] | h[e + 5] << 8 | h[e + 6] << 16 | h[e + 7] << 24) >>> 0) * J + (n >>> 0);
+}
+function Z(h = {}) {
+  return "aborted" in h ? { signal: h } : h;
+}
+function N(h, e) {
+  const n = h.length;
+  if (n === 0)
+    return h;
+  let t;
+  if (e) {
+    const a = e.blockPosition, x = e.dataPosition;
+    t = [];
+    for (let u = 0; u < n; u++) {
+      const c = h[u], d = c.maxv;
+      (d.blockPosition - a || d.dataPosition - x) > 0 && t.push(c);
+    }
+    if (t.length === 0)
+      return t;
+  } else
+    t = h;
+  t.sort((a, x) => {
+    const u = a.minv.blockPosition - x.minv.blockPosition;
+    return u !== 0 ? u : a.minv.dataPosition - x.minv.dataPosition;
+  });
+  const s = [];
+  let r = t[0];
+  s.push(r);
+  let o = r.minv.blockPosition, i = r.maxv.blockPosition;
+  for (let a = 1; a < t.length; a++) {
+    const x = t[a], u = x.minv.blockPosition, c = x.maxv.blockPosition;
+    if (u - i < 65e3 && c - o < 5e6) {
+      const d = x.maxv, f = r.maxv;
+      (c - i || d.dataPosition - f.dataPosition) > 0 && (r.maxv = d, i = c);
+    } else
+      s.push(x), r = x, o = u, i = c;
+  }
+  return s;
+}
+function H(h, e) {
+  return {
+    lineCount: X(h, e)
+  };
+}
+function M(h, e) {
+  return h ? h.compareTo(e) > 0 ? e : h : e;
+}
+function ee(h, e = (n) => n) {
+  let n = 0, t = 0;
+  const s = [], r = {};
+  for (let o = 0; o < h.length; o += 1)
+    if (!h[o]) {
+      if (t < o) {
+        let i = "";
+        for (let a = t; a < o; a++)
+          i += String.fromCharCode(h[a]);
+        i = e(i), s[n] = i, r[i] = n;
+      }
+      t = o + 1, n += 1;
+    }
+  return { refNameToId: r, refIdToName: s };
+}
+function te(h) {
+  let e = 0;
+  for (const s of h)
+    e += s.length;
+  const n = new Uint8Array(e);
+  let t = 0;
+  for (const s of h)
+    n.set(s, t), t += s.length;
+  return n;
+}
+function ne(h, e, n) {
+  return !!((h & e) !== e || h & n);
+}
+function re(h, e) {
+  return e === "*" ? h === void 0 : `${h}` != `${e}`;
+}
+function se(h) {
+  if (!h)
+    return "";
+  const { flagInclude: e = 0, flagExclude: n = 0, tagFilter: t } = h, s = t ? `:${t.tag}=${t.value ?? "*"}` : "";
+  return `:f${e}x${n}${s}`;
+}
+let j = class {
+  constructor({ filehandle: e, renameRefSeq: n = (t) => t }) {
+    this.filehandle = e, this.renameRefSeq = n;
+  }
+  async estimatedBytesForRegions(e, n) {
+    const t = await Promise.all(e.map((o) => this.blocksForRange(o.refId, o.start, o.end, n))), s = N(t.flat());
+    let r = 0;
+    for (const o of s)
+      r += o.fetchedSize();
+    return r;
+  }
+}, Q = class {
+  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 S(h, e = 0, n = !1) {
+  if (n)
+    throw new Error("big-endian virtual file offsets not implemented");
+  return new Q(h[e + 7] * 1099511627776 + h[e + 6] * 4294967296 + h[e + 5] * 16777216 + h[e + 4] * 65536 + h[e + 3] * 256 + h[e + 2], h[e + 1] << 8 | h[e]);
+}
+const ie = 21578050;
+function ae(h, e) {
+  return h - h % e;
+}
+function oe(h, e) {
+  return h - h % e + e;
+}
+function ce(h, e) {
+  return e -= 1, [
+    [0, 0],
+    [1 + (h >> 26), 1 + (e >> 26)],
+    [9 + (h >> 23), 9 + (e >> 23)],
+    [73 + (h >> 20), 73 + (e >> 20)],
+    [585 + (h >> 17), 585 + (e >> 17)],
+    [4681 + (h >> 14), 4681 + (e >> 14)]
+  ];
+}
+class F extends j {
+  async lineCount(e, n) {
+    var s, r;
+    return ((r = (s = (await this.parse(n)).indices(e)) == null ? void 0 : s.stats) == null ? void 0 : r.lineCount) || 0;
+  }
+  async _parse(e) {
+    const n = await this.filehandle.readFile(), t = new DataView(n.buffer);
+    if (t.getUint32(0, !0) !== ie)
+      throw new Error("Not a BAI file");
+    const s = t.getInt32(4, !0), o = ((1 << (5 + 1) * 3) - 1) / 7;
+    let i = 8, a;
+    const x = [];
+    for (let d = 0; d < s; d++) {
+      x.push(i);
+      const f = t.getInt32(i, !0);
+      i += 4;
+      for (let l = 0; l < f; l += 1) {
+        const g = t.getUint32(i, !0);
+        if (i += 4, g === o + 1)
+          i += 4, i += 32;
+        else {
+          if (g > o + 1)
+            throw new Error("bai index contains too many bins, please use CSI");
+          {
+            const _ = t.getInt32(i, !0);
+            i += 4;
+            for (let m = 0; m < _; m++)
+              i += 8, i += 8;
+          }
+        }
+      }
+      const b = t.getInt32(i, !0);
+      i += 4;
+      const w = new Array(b);
+      for (let l = 0; l < b; l++) {
+        const g = S(n, i);
+        i += 8, a = M(a, g), w[l] = g;
+      }
+    }
+    const u = new V({
+      maxSize: 5
+    });
+    function c(d) {
+      let f = x[d];
+      if (f === void 0)
+        return;
+      const b = t.getInt32(f, !0);
+      let w;
+      f += 4;
+      const l = {};
+      for (let m = 0; m < b; m += 1) {
+        const p = t.getUint32(f, !0);
+        if (f += 4, p === o + 1)
+          f += 4, w = H(n, f + 16), f += 32;
+        else {
+          if (p > o + 1)
+            throw new Error("bai index contains too many bins, please use CSI");
+          {
+            const y = t.getInt32(f, !0);
+            f += 4;
+            const C = new Array(y);
+            for (let I = 0; I < y; I++) {
+              const k = S(n, f);
+              f += 8;
+              const R = S(n, f);
+              f += 8, a = M(a, k), C[I] = new G(k, R, p);
+            }
+            l[p] = C;
+          }
+        }
+      }
+      const g = t.getInt32(f, !0);
+      f += 4;
+      const _ = new Array(g);
+      for (let m = 0; m < g; m++) {
+        const p = S(n, f);
+        f += 8, a = M(a, p), _[m] = p;
+      }
+      return {
+        binIndex: l,
+        linearIndex: _,
+        stats: w
+      };
+    }
+    return {
+      bai: !0,
+      firstDataLine: a,
+      maxBlockSize: 65536,
+      indices: (d) => {
+        if (!u.has(d)) {
+          const f = c(d);
+          return f && u.set(d, f), f;
+        }
+        return u.get(d);
+      },
+      refCount: s
+    };
+  }
+  async indexCov(e, n, t, s) {
+    const o = n !== void 0, a = (await this.parse(s)).indices(e);
+    if (!a)
+      return [];
+    const { linearIndex: x, stats: u } = a;
+    if (x.length === 0)
+      return [];
+    const c = t === void 0 ? (x.length - 1) * 16384 : oe(t, 16384), d = n === void 0 ? 0 : ae(n, 16384), f = o ? new Array((c - d) / 16384) : new Array(x.length - 1), b = x[x.length - 1].blockPosition;
+    if (c > (x.length - 1) * 16384)
+      throw new Error("query outside of range of linear index");
+    let w = x[d / 16384].blockPosition;
+    for (let l = d / 16384, g = 0; l < c / 16384; l++, g++)
+      f[g] = {
+        score: x[l + 1].blockPosition - w,
+        start: l * 16384,
+        end: l * 16384 + 16384
+      }, w = x[l + 1].blockPosition;
+    return f.map((l) => ({
+      ...l,
+      score: l.score * ((u == null ? void 0 : u.lineCount) || 0) / b
+    }));
+  }
+  async blocksForRange(e, n, t, s = {}) {
+    n < 0 && (n = 0);
+    const r = await this.parse(s);
+    if (!r)
+      return [];
+    const o = r.indices(e);
+    if (!o)
+      return [];
+    const i = ce(n, t), a = [], { binIndex: x } = o;
+    for (const [b, w] of i)
+      for (let l = b; l <= w; l++) {
+        const g = x[l];
+        if (g)
+          for (let _ = 0, m = g.length; _ < m; _++)
+            a.push(g[_]);
+      }
+    const { linearIndex: u } = o, c = u.length, d = Math.min(n >> 14, c - 1), f = u[d];
+    return N(a, f);
+  }
+  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 s;
+    return !!((s = (await this.parse(n)).indices(e)) != null && s.binIndex);
+  }
+}
+let U = [
+  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" && (U = new Int32Array(U));
+const de = (h, e) => {
+  let n = -1;
+  for (let t = 0; t < h.length; t++)
+    n = U[(n ^ h[t]) & 255] ^ n >>> 8;
+  return n ^ -1;
+}, fe = 21582659, he = 38359875;
+function ue(h, e) {
+  return h * 2 ** e;
+}
+function L(h, e) {
+  return Math.floor(h / 2 ** e);
+}
+let $ = class extends j {
+  constructor() {
+    super(...arguments), this.maxBinNumber = 0, this.depth = 0, this.minShift = 0;
+  }
+  async lineCount(e, n) {
+    var s, r;
+    return ((r = (s = (await this.parse(n)).indices(e)) == null ? void 0 : s.stats) == null ? void 0 : r.lineCount) || 0;
+  }
+  async indexCov() {
+    return [];
+  }
+  parseAuxData(e, n) {
+    const t = new DataView(e.buffer), s = t.getUint32(n, !0), r = s & 65536 ? "zero-based-half-open" : "1-based-closed", o = { 0: "generic", 1: "SAM", 2: "VCF" }[s & 15];
+    if (!o)
+      throw new Error(`invalid Tabix preset format flags ${s}`);
+    const i = {
+      ref: t.getInt32(n + 4, !0),
+      start: t.getInt32(n + 8, !0),
+      end: t.getInt32(n + 12, !0)
+    }, a = t.getInt32(n + 16, !0), x = a ? String.fromCharCode(a) : "", u = t.getInt32(n + 20, !0), c = t.getInt32(n + 24, !0);
+    return {
+      columnNumbers: i,
+      coordinateType: r,
+      metaValue: a,
+      metaChar: x,
+      skipLines: u,
+      format: o,
+      formatFlags: s,
+      ...ee(e.subarray(n + 28, n + 28 + c), this.renameRefSeq)
+    };
+  }
+  // fetch and parse the index
+  async _parse(e) {
+    const n = await this.filehandle.readFile(e), t = await D(n), s = new DataView(t.buffer);
+    let r;
+    const o = s.getUint32(0, !0);
+    if (o === fe)
+      r = 1;
+    else if (o === he)
+      r = 2;
+    else
+      throw new Error(`Not a CSI file ${o}`);
+    this.minShift = s.getInt32(4, !0), this.depth = s.getInt32(8, !0), this.maxBinNumber = ((1 << (this.depth + 1) * 3) - 1) / 7;
+    const i = this.maxBinNumber, a = s.getInt32(12, !0), x = a >= 30 ? this.parseAuxData(t, 16) : void 0, u = s.getInt32(16 + a, !0);
+    let c = 16 + a + 4, d;
+    const f = [];
+    for (let l = 0; l < u; l++) {
+      f.push(c);
+      const g = s.getInt32(c, !0);
+      c += 4;
+      for (let _ = 0; _ < g; _++) {
+        const m = s.getUint32(c, !0);
+        if (c += 4, m > this.maxBinNumber)
+          c += 44;
+        else {
+          c += 8;
+          const p = s.getInt32(c, !0);
+          c += 4;
+          for (let y = 0; y < p; y += 1) {
+            const C = S(t, c);
+            c += 8, c += 8, d = M(d, C);
+          }
+        }
+      }
+    }
+    const b = new V({
+      maxSize: 5
+    });
+    function w(l) {
+      let g = f[l];
+      if (g === void 0)
+        return;
+      const _ = s.getInt32(g, !0);
+      g += 4;
+      const m = {};
+      let p;
+      for (let y = 0; y < _; y++) {
+        const C = s.getUint32(g, !0);
+        if (g += 4, C > i)
+          p = H(t, g + 28), g += 44;
+        else {
+          d = M(d, S(t, g)), g += 8;
+          const I = s.getInt32(g, !0);
+          g += 4;
+          const k = new Array(I);
+          for (let R = 0; R < I; R += 1) {
+            const T = S(t, g);
+            g += 8;
+            const P = S(t, g);
+            g += 8, k[R] = new G(T, P, C);
+          }
+          m[C] = k;
+        }
+      }
+      return {
+        binIndex: m,
+        stats: p
+      };
+    }
+    return {
+      csiVersion: r,
+      firstDataLine: d,
+      indices: (l) => {
+        if (!b.has(l)) {
+          const g = w(l);
+          return g && b.set(l, g), g;
+        }
+        return b.get(l);
+      },
+      refCount: u,
+      csi: !0,
+      maxBlockSize: 65536,
+      ...x
+    };
+  }
+  async blocksForRange(e, n, t, s = {}) {
+    n < 0 && (n = 0);
+    const o = (await this.parse(s)).indices(e);
+    if (!o)
+      return [];
+    const i = this.reg2bins(n, t);
+    if (i.length === 0)
+      return [];
+    const a = [], { binIndex: x } = o;
+    for (const [u, c] of i)
+      for (let d = u; d <= c; d++) {
+        const f = x[d];
+        if (f)
+          for (let b = 0, w = f.length; b < w; b++)
+            a.push(f[b]);
+      }
+    return N(a, new Q(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, s = 0, r = this.minShift + this.depth * 3;
+    const o = [];
+    for (; t <= this.depth; r -= 3, s += ue(1, t * 3), t += 1) {
+      const i = s + L(e, r), a = s + L(n, r);
+      if (a - i + o.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`);
+      o.push([i, a]);
+    }
+    return o;
+  }
+  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 s;
+    return !!((s = (await this.parse(n)).indices(e)) != null && s.binIndex);
+  }
+};
+class le {
+  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 xe = 3, be = 4, 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
+}, E = "=ACMGRSVTWYHKDBN".split(""), ge = [
+  77,
+  73,
+  68,
+  78,
+  83,
+  72,
+  80,
+  61,
+  88,
+  63,
+  63,
+  63,
+  63,
+  63,
+  63,
+  63
+], O = 461;
+class we {
+  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._cachedFlags === void 0 && (this._cachedFlags = (this._dataView.getInt32(this.bytes.start + 16, !0) & 4294901760) >> 16), this._cachedFlags;
+  }
+  get ref_id() {
+    return this._cachedRefId === void 0 && (this._cachedRefId = this._dataView.getInt32(this.bytes.start + 4, !0)), this._cachedRefId;
+  }
+  get start() {
+    return this._cachedStart === void 0 && (this._cachedStart = this._dataView.getInt32(this.bytes.start + 8, !0)), this._cachedStart;
+  }
+  get end() {
+    return this._cachedEnd === void 0 && (this._cachedEnd = this.start + this.length_on_ref), this._cachedEnd;
+  }
+  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 null;
+    {
+      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 tagsStart() {
+    return this._cachedTagsStart === void 0 && (this._cachedTagsStart = this.b0 + this.read_name_length + this.num_cigar_bytes + this.num_seq_bytes + this.seq_length), this._cachedTagsStart;
+  }
+  // batch fromCharCode: fastest for typical name lengths (see benchmarks/string-building.bench.ts)
+  get name() {
+    const e = this.read_name_length - 1, n = this.b0, t = this.byteArray, s = new Array(e);
+    for (let r = 0; r < e; r++)
+      s[r] = t[n + r];
+    return String.fromCharCode(...s);
+  }
+  get NUMERIC_MD() {
+    if (this._cachedNUMERIC_MD === void 0) {
+      const e = this.getTagRaw("MD");
+      this._cachedNUMERIC_MD = e instanceof Uint8Array ? e : null;
+    }
+    return this._cachedNUMERIC_MD === null ? void 0 : this._cachedNUMERIC_MD;
+  }
+  get tags() {
+    return this._cachedTags === void 0 && (this._cachedTags = this._computeTags()), this._cachedTags;
+  }
+  getTag(e) {
+    return this._cachedTags !== void 0 ? this._cachedTags[e] : this._findTag(e, !1);
+  }
+  getTagRaw(e) {
+    return this._findTag(e, !0);
+  }
+  _findTag(e, n) {
+    const t = e.charCodeAt(0), s = e.charCodeAt(1);
+    let r = this.tagsStart;
+    const o = this.bytes.end, i = this.byteArray;
+    for (; r < o; ) {
+      const a = i[r], x = i[r + 1], u = i[r + 2];
+      r += 3;
+      const c = a === t && x === s;
+      switch (u) {
+        case 65:
+          if (c)
+            return String.fromCharCode(i[r]);
+          r += 1;
+          break;
+        case 105:
+          if (c)
+            return this._dataView.getInt32(r, !0);
+          r += 4;
+          break;
+        case 73:
+          if (c)
+            return this._dataView.getUint32(r, !0);
+          r += 4;
+          break;
+        case 99:
+          if (c)
+            return this._dataView.getInt8(r);
+          r += 1;
+          break;
+        case 67:
+          if (c)
+            return this._dataView.getUint8(r);
+          r += 1;
+          break;
+        case 115:
+          if (c)
+            return this._dataView.getInt16(r, !0);
+          r += 2;
+          break;
+        case 83:
+          if (c)
+            return this._dataView.getUint16(r, !0);
+          r += 2;
+          break;
+        case 102:
+          if (c)
+            return this._dataView.getFloat32(r, !0);
+          r += 4;
+          break;
+        case 90:
+        // 'Z'
+        case 72: {
+          if (c) {
+            const d = r;
+            for (; r < o && i[r] !== 0; )
+              r++;
+            if (n)
+              return i.subarray(d, r);
+            const f = [];
+            for (let b = d; b < r; b++)
+              f.push(String.fromCharCode(i[b]));
+            return f.join("");
+          }
+          for (; r <= o && i[r++] !== 0; )
+            ;
+          break;
+        }
+        case 66: {
+          const d = i[r++], f = this._dataView.getInt32(r, !0);
+          r += 4;
+          const b = i.byteOffset + r;
+          if (c)
+            if (d === 105) {
+              if (b % 4 === 0)
+                return new Int32Array(i.buffer, b, f);
+              const w = new Array(f);
+              for (let l = 0; l < f; l++)
+                w[l] = this._dataView.getInt32(r + l * 4, !0);
+              return w;
+            } else if (d === 73) {
+              if (b % 4 === 0)
+                return new Uint32Array(i.buffer, b, f);
+              const w = new Array(f);
+              for (let l = 0; l < f; l++)
+                w[l] = this._dataView.getUint32(r + l * 4, !0);
+              return w;
+            } else if (d === 115) {
+              if (b % 2 === 0)
+                return new Int16Array(i.buffer, b, f);
+              const w = new Array(f);
+              for (let l = 0; l < f; l++)
+                w[l] = this._dataView.getInt16(r + l * 2, !0);
+              return w;
+            } else if (d === 83) {
+              if (b % 2 === 0)
+                return new Uint16Array(i.buffer, b, f);
+              const w = new Array(f);
+              for (let l = 0; l < f; l++)
+                w[l] = this._dataView.getUint16(r + l * 2, !0);
+              return w;
+            } else {
+              if (d === 99)
+                return new Int8Array(i.buffer, b, f);
+              if (d === 67)
+                return new Uint8Array(i.buffer, b, f);
+              if (d === 102) {
+                if (b % 4 === 0)
+                  return new Float32Array(i.buffer, b, f);
+                const w = new Array(f);
+                for (let l = 0; l < f; l++)
+                  w[l] = this._dataView.getFloat32(r + l * 4, !0);
+                return w;
+              }
+            }
+          d === 105 || d === 73 || d === 102 ? r += f << 2 : d === 115 || d === 83 ? r += f << 1 : (d === 99 || d === 67) && (r += f);
+          break;
+        }
+      }
+    }
+  }
+  _computeTags() {
+    let e = this.tagsStart;
+    const n = this.bytes.end, t = this.byteArray, s = {};
+    for (; e < n; ) {
+      const r = String.fromCharCode(t[e], t[e + 1]), o = t[e + 2];
+      switch (e += 3, o) {
+        case 65:
+          s[r] = String.fromCharCode(t[e]), e += 1;
+          break;
+        case 105:
+          s[r] = this._dataView.getInt32(e, !0), e += 4;
+          break;
+        case 73:
+          s[r] = this._dataView.getUint32(e, !0), e += 4;
+          break;
+        case 99:
+          s[r] = this._dataView.getInt8(e), e += 1;
+          break;
+        case 67:
+          s[r] = this._dataView.getUint8(e), e += 1;
+          break;
+        case 115:
+          s[r] = this._dataView.getInt16(e, !0), e += 2;
+          break;
+        case 83:
+          s[r] = this._dataView.getUint16(e, !0), e += 2;
+          break;
+        case 102:
+          s[r] = this._dataView.getFloat32(e, !0), e += 4;
+          break;
+        case 90:
+        // 'Z'
+        case 72: {
+          const i = [];
+          for (; e <= n; ) {
+            const a = t[e++];
+            if (a !== 0)
+              i.push(String.fromCharCode(a));
+            else
+              break;
+          }
+          s[r] = i.join("");
+          break;
+        }
+        case 66: {
+          const i = t[e++], a = this._dataView.getInt32(e, !0);
+          e += 4;
+          const x = t.byteOffset + e;
+          if (i === 105) {
+            if (x % 4 === 0)
+              s[r] = new Int32Array(t.buffer, x, a);
+            else {
+              const u = new Array(a);
+              for (let c = 0; c < a; c++)
+                u[c] = this._dataView.getInt32(e + c * 4, !0);
+              s[r] = u;
+            }
+            e += a << 2;
+          } else if (i === 73) {
+            if (x % 4 === 0)
+              s[r] = new Uint32Array(t.buffer, x, a);
+            else {
+              const u = new Array(a);
+              for (let c = 0; c < a; c++)
+                u[c] = this._dataView.getUint32(e + c * 4, !0);
+              s[r] = u;
+            }
+            e += a << 2;
+          } else if (i === 115) {
+            if (x % 2 === 0)
+              s[r] = new Int16Array(t.buffer, x, a);
+            else {
+              const u = new Array(a);
+              for (let c = 0; c < a; c++)
+                u[c] = this._dataView.getInt16(e + c * 2, !0);
+              s[r] = u;
+            }
+            e += a << 1;
+          } else if (i === 83) {
+            if (x % 2 === 0)
+              s[r] = new Uint16Array(t.buffer, x, a);
+            else {
+              const u = new Array(a);
+              for (let c = 0; c < a; c++)
+                u[c] = this._dataView.getUint16(e + c * 2, !0);
+              s[r] = u;
+            }
+            e += a << 1;
+          } else if (i === 99)
+            s[r] = new Int8Array(t.buffer, x, a), e += a;
+          else if (i === 67)
+            s[r] = new Uint8Array(t.buffer, x, a), e += a;
+          else if (i === 102) {
+            if (x % 4 === 0)
+              s[r] = new Float32Array(t.buffer, x, a);
+            else {
+              const u = new Array(a);
+              for (let c = 0; c < a; c++)
+                u[c] = this._dataView.getFloat32(e + c * 4, !0);
+              s[r] = u;
+            }
+            e += a << 2;
+          }
+          break;
+        }
+        default:
+          console.error("Unknown BAM tag type", o);
+          break;
+      }
+    }
+    return s;
+  }
+  isPaired() {
+    return !!(this.flags & A.BAM_FPAIRED);
+  }
+  isProperlyPaired() {
+    return !!(this.flags & A.BAM_FPROPER_PAIR);
+  }
+  isSegmentUnmapped() {
+    return !!(this.flags & A.BAM_FUNMAP);
+  }
+  isMateUnmapped() {
+    return !!(this.flags & A.BAM_FMUNMAP);
+  }
+  isReverseComplemented() {
+    return !!(this.flags & A.BAM_FREVERSE);
+  }
+  isMateReverseComplemented() {
+    return !!(this.flags & A.BAM_FMREVERSE);
+  }
+  isRead1() {
+    return !!(this.flags & A.BAM_FREAD1);
+  }
+  isRead2() {
+    return !!(this.flags & A.BAM_FREAD2);
+  }
+  isSecondary() {
+    return !!(this.flags & A.BAM_FSECONDARY);
+  }
+  isFailedQc() {
+    return !!(this.flags & A.BAM_FQCFAIL);
+  }
+  isDuplicate() {
+    return !!(this.flags & A.BAM_FDUP);
+  }
+  isSupplementary() {
+    return !!(this.flags & A.BAM_FSUPPLEMENTARY);
+  }
+  get cigarAndLength() {
+    return this._cachedCigarAndLength === void 0 && (this._cachedCigarAndLength = this._computeCigarAndLength()), this._cachedCigarAndLength;
+  }
+  // Benchmark results for CIGAR parsing strategies (see benchmarks/cigar-lifecycle.bench.ts):
+  //
+  // Aligned data:
+  //   - Plain array is 1.6-1.8x faster than Uint32Array for small CIGARs (≤50 ops)
+  //   - Uint32Array view is 1.3-2.2x faster for large CIGARs (≥200 ops)
+  //   - Crossover point is around 50-100 ops
+  //
+  // Unaligned data (requires slice+copy for Uint32Array):
+  //   - Plain array is 3.7-6.1x faster for typical sizes (50-200 ops)
+  //   - Plain array is 9-10x faster for small CIGARs (1-7 ops)
+  //   - Uint32Array slice+copy only wins at extreme sizes (10000 ops: 1.4x faster)
+  //
+  // Using |0 to force 32-bit integers in plain array path:
+  //   - 1.67x faster for medium CIGARs (50 ops)
+  //   - Neutral for small CIGARs (1-7 ops)
+  //
+  // Strategy: use plain array with |0 for small aligned (≤50 ops) and all unaligned,
+  // Uint32Array view only for large aligned CIGARs.
+  _computeCigarAndLength() {
+    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), s = t >> 4;
+    if ((t & 15) === be && s === this.seq_length) {
+      n += 4;
+      const u = this._dataView.getInt32(n, !0), c = u >> 4;
+      return (u & 15) !== xe && console.warn("CG tag with no N tag"), {
+        NUMERIC_CIGAR: this.tags.CG,
+        length_on_ref: c
+      };
+    }
+    const o = this.byteArray.byteOffset + n;
+    if (o % 4 === 0 && e > 50) {
+      const u = new Uint32Array(this.byteArray.buffer, o, e);
+      let c = 0;
+      for (let d = 0; d < e; ++d) {
+        const f = u[d];
+        c += (f >> 4) * (O >> (f & 15) & 1);
+      }
+      return {
+        NUMERIC_CIGAR: u,
+        length_on_ref: c
+      };
+    }
+    const a = new Array(e);
+    let x = 0;
+    for (let u = 0; u < e; ++u) {
+      const c = this._dataView.getInt32(n + u * 4, !0) | 0;
+      a[u] = c, x += (c >> 4) * (O >> (c & 15) & 1);
+    }
+    return {
+      NUMERIC_CIGAR: a,
+      length_on_ref: x
+    };
+  }
+  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, s = e.length; t < s; t++) {
+      const r = e[t], o = r >> 4, i = ge[r & 15];
+      n += o + String.fromCharCode(i);
+    }
+    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;
+    return this.byteArray.subarray(e, e + this.num_seq_bytes);
+  }
+  get seq() {
+    const e = this.NUMERIC_SEQ, n = this.seq_length, t = new Array(n);
+    let s = 0;
+    const r = n >> 1;
+    for (let o = 0; o < r; ++o) {
+      const i = e[o];
+      t[s++] = E[(i & 240) >> 4], t[s++] = E[i & 15];
+    }
+    if (s < n) {
+      const o = e[r];
+      t[s] = E[(o & 240) >> 4];
+    }
+    return t.join("");
+  }
+  // adapted from igv.js
+  // uses template literal instead of array+join (6.4x faster, see benchmarks/string-building.bench.ts)
+  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 = " ", s = " ";
+      return this.isRead1() ? (t = "1", s = "2") : this.isRead2() && (t = "2", s = "1"), this.template_length > 0 ? `${e}${t}${n}${s}` : `${n}${s}${e}${t}`;
+    }
+  }
+  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 ? E[(t & 240) >> 4] : E[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 K(h) {
+  const e = h.split(/\r?\n/), n = [];
+  for (const t of e) {
+    const [s, ...r] = t.split(/\t/);
+    s && n.push({
+      tag: s.slice(1),
+      data: r.map((o) => {
+        const i = o.indexOf(":"), a = o.slice(0, i), x = o.slice(i + 1);
+        return { tag: a, value: x };
+      })
+    });
+  }
+  return n;
+}
+const W = 21840194, _e = 65536;
+class me {
+  constructor({ bamFilehandle: e, bamPath: n, bamUrl: t, baiPath: s, baiFilehandle: r, baiUrl: o, csiPath: i, csiFilehandle: a, csiUrl: x, htsget: u, renameRefSeqs: c = (f) => f, recordClass: d }) {
+    if (this.htsget = !1, this.chunkFeatureCache = new V({
+      maxSize: 100
+    }), this.renameRefSeq = c, this.RecordClass = d ?? we, e)
+      this.bam = e;
+    else if (n)
+      this.bam = new v(n);
+    else if (t)
+      this.bam = new B(t);
+    else if (u)
+      this.htsget = !0, this.bam = new le();
+    else
+      throw new Error("unable to initialize bam");
+    if (a)
+      this.index = new $({ filehandle: a });
+    else if (i)
+      this.index = new $({ filehandle: new v(i) });
+    else if (x)
+      this.index = new $({ filehandle: new B(x) });
+    else if (r)
+      this.index = new F({ filehandle: r });
+    else if (s)
+      this.index = new F({ filehandle: new v(s) });
+    else if (o)
+      this.index = new F({ filehandle: new B(o) });
+    else if (n)
+      this.index = new F({ filehandle: new v(`${n}.bai`) });
+    else if (t)
+      this.index = new F({ filehandle: new B(`${t}.bai`) });
+    else if (u)
+      this.htsget = !0;
+    else
+      throw new Error("unable to infer index format");
+  }
+  async getHeaderPre(e) {
+    const n = Z(e);
+    if (!this.index)
+      return;
+    const t = await this.index.parse(n), s = 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 + _e, 0)
+    ), r = await D(s), o = new DataView(r.buffer);
+    if (o.getInt32(0, !0) !== W)
+      throw new Error("Not a BAM file");
+    const i = o.getInt32(4, !0), a = new TextDecoder("utf8");
+    this.header = a.decode(r.subarray(8, 8 + i));
+    const { chrToIndex: x, indexToChr: u } = this._parseRefSeqs(r, i + 8);
+    return this.chrToIndex = x, this.indexToChr = u, K(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), s = t.getInt32(n, !0);
+    let r = n + 4;
+    const o = {}, i = [], a = new TextDecoder("utf8");
+    for (let x = 0; x < s; x += 1) {
+      if (r + 8 > e.length)
+        throw new Error(`Insufficient data for reference sequences: need more than ${e.length} bytes`);
+      const u = t.getInt32(r, !0), c = this.renameRefSeq(a.decode(e.subarray(r + 4, r + 4 + u - 1))), d = t.getInt32(r + u + 4, !0);
+      o[c] = x, i.push({
+        refName: c,
+        length: d
+      }), r = r + 8 + u;
+    }
+    return { chrToIndex: o, indexToChr: i };
+  }
+  async getRecordsForRange(e, n, t, s) {
+    var i;
+    await this.getHeader(s);
+    const r = (i = this.chrToIndex) == null ? void 0 : i[e];
+    if (r === void 0 || !this.index)
+      return [];
+    const o = await this.index.blocksForRange(r, n - 1, t, s);
+    return this._fetchChunkFeaturesDirect(o, r, n, t, s);
+  }
+  chunkCacheKey(e, n) {
+    const { minv: t, maxv: s } = e;
+    return `${t.blockPosition}:${t.dataPosition}-${s.blockPosition}:${s.dataPosition}${se(n)}`;
+  }
+  blocksOverlap(e, n, t, s) {
+    return e <= s && n >= t;
+  }
+  // Evict any cached chunks that overlap with the given block range
+  evictOverlappingChunks(e, n) {
+    for (const [t, s] of this.chunkFeatureCache)
+      this.blocksOverlap(e, n, s.minBlock, s.maxBlock) && this.chunkFeatureCache.delete(t);
+  }
+  async _fetchChunkFeaturesDirect(e, n, t, s, r = {}) {
+    const { viewAsPairs: o, filterBy: i } = r, { flagInclude: a = 0, flagExclude: x = 0, tagFilter: u } = i || {}, c = [];
+    for (let d = 0, f = e.length; d < f; d++) {
+      const b = e[d], w = this.chunkCacheKey(b, i), l = b.minv.blockPosition, g = b.maxv.blockPosition;
+      let _;
+      const m = this.chunkFeatureCache.get(w);
+      if (m)
+        _ = m.features;
+      else {
+        this.evictOverlappingChunks(l, g);
+        const { data: y, cpositions: C, dpositions: I } = await this._readChunk({
+          chunk: b,
+          opts: r
+        }), k = await this.readBamFeatures(y, C, I, b);
+        if (i) {
+          _ = [];
+          for (let R = 0, T = k.length; R < T; R++) {
+            const P = k[R];
+            ne(P.flags, a, x) || u && re(P.tags[u.tag], u.value) || _.push(P);
+          }
+        } else
+          _ = k;
+        this.chunkFeatureCache.set(w, {
+          minBlock: l,
+          maxBlock: g,
+          features: _
+        });
+      }
+      let p = !1;
+      for (let y = 0, C = _.length; y < C; y++) {
+        const I = _[y];
+        if (I.ref_id === n)
+          if (I.start >= s) {
+            p = !0;
+            break;
+          } else I.end >= t && c.push(I);
+      }
+      if (p)
+        break;
+    }
+    if (o) {
+      const d = await this.fetchPairs(n, c, r);
+      for (let f = 0, b = d.length; f < b; f++)
+        c.push(d[f]);
+    }
+    return c;
+  }
+  async fetchPairs(e, n, t) {
+    const { pairAcrossChr: s, maxInsertSize: r = 2e5 } = t, o = {}, i = {};
+    for (let d = 0, f = n.length; d < f; d++) {
+      const b = n[d], w = b.name;
+      o[w] = (o[w] || 0) + 1, i[b.fileOffset] = 1;
+    }
+    const a = [];
+    for (let d = 0, f = n.length; d < f; d++) {
+      const b = n[d], w = b.name;
+      this.index && o[w] === 1 && (s || b.next_refid === e && Math.abs(b.start - b.next_pos) < r) && a.push(this.index.blocksForRange(b.next_refid, b.next_pos, b.next_pos + 1, t));
+    }
+    const x = /* @__PURE__ */ new Map(), u = await Promise.all(a);
+    for (let d = 0, f = u.length; d < f; d++) {
+      const b = u[d];
+      for (let w = 0, l = b.length; w < l; w++) {
+        const g = b[w], _ = g.toString();
+        x.has(_) || x.set(_, g);
+      }
+    }
+    return (await Promise.all([...x.values()].map(async (d) => {
+      const { data: f, cpositions: b, dpositions: w, chunk: l } = await this._readChunk({
+        chunk: d,
+        opts: t
+      }), g = [], _ = await this.readBamFeatures(f, b, w, l);
+      for (let m = 0, p = _.length; m < p; m++) {
+        const y = _[m];
+        o[y.name] === 1 && !i[y.fileOffset] && g.push(y);
+      }
+      return g;
+    }))).flat();
+  }
+  async _readChunk({ chunk: e, opts: n }) {
+    const t = await this.bam.read(e.fetchedSize(), e.minv.blockPosition, n), { buffer: s, cpositions: r, dpositions: o } = await Y(t, e);
+    return { data: s, cpositions: r, dpositions: o, chunk: e };
+  }
+  async readBamFeatures(e, n, t, s) {
+    let r = 0;
+    const o = [];
+    let i = 0;
+    const a = new DataView(e.buffer), x = t.length > 0, u = n.length > 0;
+    for (; r + 4 < e.length; ) {
+      const c = a.getInt32(r, !0), d = r + 4 + c - 1;
+      if (x) {
+        for (; r + s.minv.dataPosition >= t[i++]; )
+          ;
+        i--;
+      }
+      if (d < e.length) {
+        const f = new this.RecordClass({
+          bytes: {
+            byteArray: e,
+            start: r,
+            end: d
+          },
+          fileOffset: u ? n[i] * 256 + (r - t[i]) + s.minv.dataPosition + 1 : de(e.subarray(r, d)) >>> 0
+        });
+        o.push(f);
+      }
+      r = d + 1;
+    }
+    return o;
+  }
+  async hasRefSeq(e) {
+    var t, s;
+    const n = (t = this.chrToIndex) == null ? void 0 : t[e];
+    return n === void 0 ? !1 : (s = this.index) == null ? void 0 : s.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 r;
+    if (!this.index)
+      return [];
+    await this.index.parse();
+    const s = (r = this.chrToIndex) == null ? void 0 : r[e];
+    return s === void 0 ? [] : this.index.indexCov(s, n, t);
+  }
+  async blocksForRange(e, n, t, s) {
+    var o;
+    if (!this.index)
+      return [];
+    await this.index.parse();
+    const r = (o = this.chrToIndex) == null ? void 0 : o[e];
+    return r === void 0 ? [] : this.index.blocksForRange(r, n, t, s);
+  }
+  clearFeatureCache() {
+    this.chunkFeatureCache.clear();
+  }
+  async estimatedBytesForRegions(e, n) {
+    if (!this.index)
+      return 0;
+    if (await this.getHeader(n), !this.chrToIndex)
+      throw new Error("Header not yet parsed");
+    return this.index.estimatedBytesForRegions(e.map((t) => {
+      const s = this.chrToIndex[t.refName];
+      if (s === void 0)
+        throw new Error(`Unknown reference name: ${t.refName}`);
+      return {
+        refId: s,
+        start: t.start,
+        end: t.end
+      };
+    }), n);
+  }
+}
+async function z(h, e) {
+  const n = await Promise.all(h.map(async (t) => {
+    const { url: s, headers: r } = t;
+    if (s.startsWith("data:")) {
+      const o = await fetch(s);
+      if (!o.ok)
+        throw new Error("failed to decode base64");
+      const i = await o.arrayBuffer();
+      return new Uint8Array(i);
+    } else {
+      const { referer: o, ...i } = r, a = await fetch(s, {
+        ...e,
+        headers: { ...e == null ? void 0 : e.headers, ...i }
+      });
+      if (!a.ok)
+        throw new Error(`HTTP ${a.status} fetching ${s}: ${await a.text()}`);
+      return new Uint8Array(await a.arrayBuffer());
+    }
+  }));
+  return te(await Promise.all(n.map((t) => D(t))));
+}
+class Re extends me {
+  constructor(e) {
+    super({ htsget: !0, recordClass: e.recordClass }), this.baseUrl = e.baseUrl, this.trackId = e.trackId;
+  }
+  async getRecordsForRange(e, n, t, s) {
+    var f;
+    const o = `${`${this.baseUrl}/${this.trackId}`}?referenceName=${e}&start=${n}&end=${t}&format=BAM`, i = (f = this.chrToIndex) == null ? void 0 : f[e];
+    if (i === void 0)
+      return [];
+    const a = await fetch(o, { ...s });
+    if (!a.ok)
+      throw new Error(`HTTP ${a.status} fetching ${o}: ${await a.text()}`);
+    const x = await a.json(), u = await z(x.htsget.urls.slice(1), s), c = await this.readBamFeatures(u, [], [], {
+      minv: { dataPosition: 0, blockPosition: 0 },
+      maxv: { dataPosition: 0, blockPosition: 0 }
+    }), d = [];
+    for (let b = 0, w = c.length; b < w; b++) {
+      const l = c[b];
+      if (l.ref_id === i) {
+        if (l.start >= t)
+          break;
+        l.end >= n && d.push(l);
+      }
+    }
+    return d;
+  }
+  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 s = await t.json(), r = await z(s.htsget.urls, e), o = new DataView(r.buffer);
+    if (o.getInt32(0, !0) !== W)
+      throw new Error("Not a BAM file");
+    const i = o.getInt32(4, !0), x = new TextDecoder("utf8").decode(r.subarray(8, 8 + i)), u = K(x), c = [], d = {}, f = u.filter((b) => b.tag === "SQ");
+    for (const [b, w] of f.entries()) {
+      let l = "", g = 0;
+      for (const _ of w.data)
+        _.tag === "SN" ? l = _.value : _.tag === "LN" && (g = +_.value);
+      d[l] = b, c[b] = { refName: l, length: g };
+    }
+    return this.chrToIndex = d, this.indexToChr = c, u;
+  }
+}
+export {
+  F as BAI,
+  me as BamFile,
+  we as BamRecord,
+  $ as CSI,
+  Re as HtsgetFile
+};