@genome-spy/app 0.51.0 → 0.53.0

package/dist/{index-BtRKzKhM.js → index-_tI-fMQF.js}

@@ -1,10 +1,9 @@
-import { L as Y, u as L, a as X } from "./long-CYrAUkxh.js";
-import { b as E } from "./index-C8lYPtq_.js";
-import { g as W } from "./_commonjsHelpers-BIiJCwQW.js";
-import { L as R } from "./__vite-browser-external-C--ziKoh.js";
-import { R as k } from "./remoteFile-1_eCK3VV.js";
-import { _ as J, L as K } from "./index-mihmTLo-.js";
-class U {
+import { L as V, u as k, a as Q } from "./long-D4tVjLLz.js";
+import { b as I } from "./index-B5cesONJ.js";
+import { L as A } from "./__vite-browser-external-C--ziKoh.js";
+import { R } from "./remoteFile-BkTxwFub.js";
+import { _ as Y, L as W } from "./index-uO0O4Uv-.js";
+class D {
   constructor(e, t) {
     this.blockPosition = e, this.dataPosition = t;
   }
@@ -23,17 +22,17 @@ class U {
     return t;
   }
 }
-function y(o, e = 0, t = !1) {
+function x(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]);
+  return new D(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 {
+class $ {
   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()})`;
+    return `${this.minv.toString()}..${this.maxv.toString()} (bin ${this.bin}, fetchedSize ${this.fetchedSize()})`;
   }
   toString() {
     return this.toUniqueString();
@@ -45,15 +44,15 @@ class z {
     return this._fetchedSize !== void 0 ? this._fetchedSize : this.maxv.blockPosition + 65536 - this.minv.blockPosition;
   }
 }
-function Z(o) {
+function X(o) {
   return new Promise((e) => setTimeout(e, o));
 }
-function ee(o) {
+function J(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) {
+function K(o) {
   if (o && o.aborted)
     if (typeof DOMException > "u") {
       const e = new Error("aborted");
@@ -61,45 +60,45 @@ function te(o) {
     } else
       throw new DOMException("aborted", "AbortError");
 }
-function ne(o, e) {
+function Z(o, e) {
   return e.minv.blockPosition - o.maxv.blockPosition < 65e3 && e.maxv.blockPosition - o.minv.blockPosition < 5e6;
 }
-function re(o = {}) {
+function ee(o = {}) {
   return "aborted" in o ? { signal: o } : o;
 }
-function O(o, e) {
+function U(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;
+  o.sort((r, s) => {
+    const a = r.minv.blockPosition - s.minv.blockPosition;
+    return a === 0 ? r.minv.dataPosition - s.minv.dataPosition : a;
   });
   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));
+    (!e || r.maxv.compareTo(e) > 0) && (n === void 0 ? (t.push(r), n = r) : Z(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 z(o, e) {
+  return { lineCount: J(V.fromBytesLE(Array.prototype.slice.call(o, e, e + 8), !0)) };
 }
-function P(o, e) {
+function L(o, e) {
   return o ? o.compareTo(e) > 0 ? e : o : e;
 }
-function ae(o, e = (t) => t) {
+function te(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;
+  const r = [], s = {};
+  for (let a = 0; a < o.length; a += 1)
+    if (!o[a]) {
+      if (n < a) {
+        let h = o.toString("utf8", n, a);
+        h = e(h), r[t] = h, s[h] = t;
       }
-      n = i + 1, t += 1;
+      n = a + 1, t += 1;
     }
-  return { refNameToId: a, refIdToName: r };
+  return { refNameToId: s, refIdToName: r };
 }
-class G {
+class O {
   /**
    * @param {filehandle} filehandle
    * @param {function} [renameRefSeqs]
@@ -108,14 +107,14 @@ class G {
     this.filehandle = e, this.renameRefSeq = t;
   }
 }
-const se = 21578050;
-function ie(o, e) {
+const ne = 21578050;
+function re(o, e) {
   return o - o % e;
 }
-function oe(o, e) {
+function se(o, e) {
   return o - o % e + e;
 }
-function de(o, e) {
+function ie(o, e) {
   return e -= 1, [
     [0, 0],
     [1 + (o >> 26), 1 + (e >> 26)],
@@ -125,7 +124,7 @@ function de(o, e) {
     [4681 + (o >> 14), 4681 + (e >> 14)]
   ];
 }
-class A extends G {
+class v extends O {
   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;
@@ -133,100 +132,100 @@ class A extends G {
   // fetch and parse the index
   async _parse(e) {
     const t = await this.filehandle.readFile(e);
-    if (t.readUInt32LE(0) !== se)
+    if (t.readUInt32LE(0) !== ne)
       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);
+    const n = t.readInt32LE(4), s = ((1 << (5 + 1) * 3) - 1) / 7;
+    let a = 8, h;
+    const c = new Array(n);
+    for (let i = 0; i < n; i++) {
+      const l = t.readInt32LE(a);
       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;
+      a += 4;
+      const f = {};
+      for (let g = 0; g < l; g += 1) {
+        const m = t.readUInt32LE(a);
+        if (a += 4, m === s + 1)
+          a += 4, u = z(t, a + 16), a += 32;
         else {
-          if (x > a + 1)
+          if (m > s + 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);
+            const p = t.readInt32LE(a);
+            a += 4;
+            const w = new Array(p);
+            for (let E = 0; E < p; E++) {
+              const y = x(t, a);
+              a += 8;
+              const S = x(t, a);
+              a += 8, h = L(h, y), w[E] = new $(y, S, m);
             }
-            h[x] = p;
+            f[m] = w;
           }
         }
       }
-      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;
+      const d = t.readInt32LE(a);
+      a += 4;
+      const _ = new Array(d);
+      for (let g = 0; g < d; g++) {
+        const m = x(t, a);
+        a += 8, h = L(h, m), _[g] = m;
       }
-      d[s] = { binIndex: h, linearIndex: m, stats: u };
+      c[i] = { binIndex: f, linearIndex: _, stats: u };
     }
     return {
       bai: !0,
-      firstDataLine: c,
+      firstDataLine: h,
       maxBlockSize: 65536,
-      indices: d,
+      indices: c,
       refCount: n
     };
   }
   async indexCov(e, t, n, r = {}) {
-    const i = t !== void 0, d = (await this.parse(r)).indices[e];
-    if (!d)
+    const a = t !== void 0, c = (await this.parse(r)).indices[e];
+    if (!c)
       return [];
-    const { linearIndex: s = [], stats: l } = d;
-    if (s.length === 0)
+    const { linearIndex: i = [], stats: l } = c;
+    if (i.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)
+    const u = n === void 0 ? (i.length - 1) * 16384 : se(n, 16384), f = t === void 0 ? 0 : re(t, 16384), d = a ? new Array((u - f) / 16384) : new Array(i.length - 1), _ = i[i.length - 1].blockPosition;
+    if (u > (i.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
+    let g = i[f / 16384].blockPosition;
+    for (let m = f / 16384, p = 0; m < u / 16384; m++, p++)
+      d[p] = {
+        score: i[m + 1].blockPosition - g,
+        start: m * 16384,
+        end: m * 16384 + 16384
+      }, g = i[m + 1].blockPosition;
+    return d.map((m) => ({
+      ...m,
+      score: m.score * ((l == null ? void 0 : l.lineCount) || 0) / _
     }));
   }
   async blocksForRange(e, t, n, r = {}) {
     t < 0 && (t = 0);
-    const a = await this.parse(r);
-    if (!a)
+    const s = await this.parse(r);
+    if (!s)
       return [];
-    const i = a.indices[e];
-    if (!i)
+    const a = s.indices[e];
+    if (!a)
       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 h = ie(t, n), c = [];
+    for (const [d, _] of h)
+      for (let g = d; g <= _; g++)
+        if (a.binIndex[g]) {
+          const m = a.binIndex[g];
+          for (const p of m)
+            c.push(p);
         }
-    const s = i.linearIndex.length;
+    const i = a.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);
+    const u = Math.min(t >> 14, i - 1), f = Math.min(n >> 14, i - 1);
+    for (let d = u; d <= f; ++d) {
+      const _ = a.linearIndex[d];
+      _ && (!l || _.compareTo(l) < 0) && (l = _);
     }
-    return O(d, l);
+    return U(c, l);
   }
   async parse(e = {}) {
     return this.setupP || (this.setupP = this._parse(e).catch((t) => {
@@ -238,7 +237,10 @@ class A extends G {
     return !!(!((n = (await this.parse(t)).indices[e]) === null || n === void 0) && n.binIndex);
   }
 }
-var I = E.Buffer, M = [
+function ae(o) {
+  return o && o.__esModule && Object.prototype.hasOwnProperty.call(o, "default") ? o.default : o;
+}
+const oe = new Int32Array([
   0,
   1996959894,
   3993919788,
@@ -495,46 +497,45 @@ var I = E.Buffer, M = [
   3272380065,
   1510334235,
   755167117
-];
-typeof Int32Array < "u" && (M = new Int32Array(M));
-function j(o) {
-  if (I.isBuffer(o))
+]);
+function H(o) {
+  if (Buffer.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);
+    return Buffer.alloc(o);
   if (typeof o == "string")
-    return e ? I.from(o) : new I(o);
+    return Buffer.from(o);
   throw new Error("input must be buffer, number, or string, received " + typeof o);
 }
 function ce(o) {
-  var e = j(4);
+  const e = H(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;
+function T(o, e) {
+  o = H(o), Buffer.isBuffer(e) && (e = e.readUInt32BE(0));
+  let t = ~~e ^ -1;
+  for (var n = 0; n < o.length; n++)
+    t = oe[(t ^ o[n]) & 255] ^ t >>> 8;
   return t ^ -1;
 }
-function F() {
-  return ce(B.apply(null, arguments));
+function M() {
+  return ce(T.apply(null, arguments));
 }
-F.signed = function() {
-  return B.apply(null, arguments);
+M.signed = function() {
+  return T.apply(null, arguments);
 };
-F.unsigned = function() {
-  return B.apply(null, arguments) >>> 0;
+M.unsigned = function() {
+  return T.apply(null, arguments) >>> 0;
 };
-var fe = F;
-const he = /* @__PURE__ */ W(fe), le = 21582659, ue = 38359875;
-function xe(o, e) {
+var he = M;
+const de = /* @__PURE__ */ ae(he), fe = 21582659, le = 38359875;
+function ue(o, e) {
   return o * 2 ** e;
 }
-function q(o, e) {
+function B(o, e) {
   return Math.floor(o / 2 ** e);
 }
-class T extends G {
+class P extends O {
   constructor() {
     super(...arguments), this.maxBinNumber = 0, this.depth = 0, this.minShift = 0;
   }
@@ -546,91 +547,91 @@ class T extends G {
     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)
+    const n = e.readInt32LE(t), r = n & 65536 ? "zero-based-half-open" : "1-based-closed", s = { 0: "generic", 1: "SAM", 2: "VCF" }[n & 15];
+    if (!s)
       throw new Error(`invalid Tabix preset format flags ${n}`);
-    const i = {
+    const a = {
       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);
+    }, h = e.readInt32LE(t + 16), c = h ? String.fromCharCode(h) : "", i = e.readInt32LE(t + 20), l = e.readInt32LE(t + 24);
     return {
-      columnNumbers: i,
+      columnNumbers: a,
       coordinateType: r,
-      metaValue: c,
-      metaChar: d,
-      skipLines: s,
-      format: a,
+      metaValue: h,
+      metaChar: c,
+      skipLines: i,
+      format: s,
       formatFlags: n,
-      ...ae(e.subarray(t + 28, t + 28 + l), this.renameRefSeq)
+      ...te(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);
+    const t = await this.filehandle.readFile(e), n = await k(t);
     let r;
-    if (n.readUInt32LE(0) === le)
+    if (n.readUInt32LE(0) === fe)
       r = 1;
-    else if (n.readUInt32LE(0) === ue)
+    else if (n.readUInt32LE(0) === le)
       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;
+    const s = n.readInt32LE(12), a = s >= 30 ? this.parseAuxData(n, 16) : void 0, h = n.readInt32LE(16 + s);
+    let c = 16 + s + 4, i;
+    const l = new Array(h);
+    for (let u = 0; u < h; u++) {
+      const f = n.readInt32LE(c);
+      c += 4;
+      const d = {};
+      let _;
+      for (let g = 0; g < f; g++) {
+        const m = n.readUInt32LE(c);
+        if (c += 4, m > this.maxBinNumber)
+          _ = z(n, c + 28), c += 44;
         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);
+          i = L(i, x(n, c)), c += 8;
+          const p = n.readInt32LE(c);
+          c += 4;
+          const w = new Array(p);
+          for (let E = 0; E < p; E += 1) {
+            const y = x(n, c);
+            c += 8;
+            const S = x(n, c);
+            c += 8, i = L(i, y), w[E] = new $(y, S, m);
           }
-          f[x] = p;
+          d[m] = w;
         }
       }
-      l[u] = { binIndex: f, stats: m };
+      l[u] = { binIndex: d, stats: _ };
     }
     return {
       csiVersion: r,
-      firstDataLine: s,
+      firstDataLine: i,
       indices: l,
-      refCount: c,
+      refCount: h,
       csi: !0,
       maxBlockSize: 65536,
-      ...i
+      ...a
     };
   }
   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)
+    const s = await this.parse(r), a = s == null ? void 0 : s.indices[e];
+    if (!a)
       return [];
-    const c = this.reg2bins(t, n);
-    if (c.length === 0)
+    const h = this.reg2bins(t, n);
+    if (h.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);
+    const c = [];
+    for (const [i, l] of h)
+      for (let u = i; u <= l; u++)
+        if (a.binIndex[u]) {
+          const f = a.binIndex[u];
+          for (const d of f)
+            c.push(d);
         }
-    return O(d, new U(0, 0));
+    return U(c, new D(0, 0));
   }
   /**
    * calculate the list of bins that may overlap with region [beg,end)
@@ -638,15 +639,15 @@ class T extends G {
    */
   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)
+    let n = 0, r = 0, s = this.minShift + this.depth * 3;
+    const a = [];
+    for (; n <= this.depth; s -= 3, r += ue(1, n * 3), n += 1) {
+      const h = r + B(e, s), c = r + B(t, s);
+      if (c - h + a.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]);
+      a.push([h, c]);
     }
-    return i;
+    return a;
   }
   async parse(e = {}) {
     return this.setupP || (this.setupP = this._parse(e).catch((t) => {
@@ -658,7 +659,7 @@ class T extends G {
     return !!(!((n = (await this.parse(t)).indices[e]) === null || n === void 0) && n.binIndex);
   }
 }
-const _ = {
+const b = {
   //  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
@@ -683,12 +684,12 @@ const _ = {
   BAM_FDUP: 1024,
   //  supplementary alignment
   BAM_FSUPPLEMENTARY: 2048
-}, N = "=ACMGRSVTWYHKDBN".split(""), C = "MIDNSHP=X???????".split("");
-class be {
+}, F = "=ACMGRSVTWYHKDBN".split(""), C = "MIDNSHP=X???????".split("");
+class me {
   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;
+    const { bytes: t, fileOffset: n } = e, { byteArray: r, start: s } = t;
+    this.data = {}, this.bytes = t, this._id = n, this._refID = r.readInt32LE(s + 4), this.data.start = r.readInt32LE(s + 8), this.flags = (r.readInt32LE(s + 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());
@@ -709,13 +710,13 @@ class be {
     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);
+      !n.startsWith("_") && 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;
+      const r = n.toLowerCase(), s = t[r];
+      return t[r] = !0, !s;
     });
   }
   parent() {
@@ -770,101 +771,101 @@ class be {
       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]);
+    const s = this.bytes.end;
+    let a;
+    for (; r < s && a !== e; ) {
+      const h = String.fromCharCode(t[r], t[r + 1]);
+      a = h.toLowerCase();
+      const c = String.fromCharCode(t[r + 2]);
       r += 3;
-      let s;
-      switch (d) {
+      let i;
+      switch (c) {
         case "A": {
-          s = String.fromCharCode(t[r]), r += 1;
+          i = String.fromCharCode(t[r]), r += 1;
           break;
         }
         case "i": {
-          s = t.readInt32LE(r), r += 4;
+          i = t.readInt32LE(r), r += 4;
           break;
         }
         case "I": {
-          s = t.readUInt32LE(r), r += 4;
+          i = t.readUInt32LE(r), r += 4;
           break;
         }
         case "c": {
-          s = t.readInt8(r), r += 1;
+          i = t.readInt8(r), r += 1;
           break;
         }
         case "C": {
-          s = t.readUInt8(r), r += 1;
+          i = t.readUInt8(r), r += 1;
           break;
         }
         case "s": {
-          s = t.readInt16LE(r), r += 2;
+          i = t.readInt16LE(r), r += 2;
           break;
         }
         case "S": {
-          s = t.readUInt16LE(r), r += 2;
+          i = t.readUInt16LE(r), r += 2;
           break;
         }
         case "f": {
-          s = t.readFloatLE(r), r += 4;
+          i = t.readFloatLE(r), r += 4;
           break;
         }
         case "Z":
         case "H": {
-          for (s = ""; r <= a; ) {
+          for (i = ""; r <= s; ) {
             const l = t[r++];
             if (l === 0)
               break;
-            s += String.fromCharCode(l);
+            i += String.fromCharCode(l);
           }
           break;
         }
         case "B": {
-          s = "";
-          const l = t[r++], u = String.fromCharCode(l), h = t.readInt32LE(r);
+          i = "";
+          const l = t[r++], u = String.fromCharCode(l), f = 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;
+            if (h === "CG")
+              for (let d = 0; d < f; d++) {
+                const _ = t.readInt32LE(r), g = _ >> 4, m = C[_ & 15];
+                i += g + m, r += 4;
               }
             else
-              for (let f = 0; f < h; f++)
-                s += t.readInt32LE(r), f + 1 < h && (s += ","), r += 4;
+              for (let d = 0; d < f; d++)
+                i += t.readInt32LE(r), d + 1 < f && (i += ","), 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;
+            if (h === "CG")
+              for (let d = 0; d < f; d++) {
+                const _ = t.readUInt32LE(r), g = _ >> 4, m = C[_ & 15];
+                i += g + m, r += 4;
               }
             else
-              for (let f = 0; f < h; f++)
-                s += t.readUInt32LE(r), f + 1 < h && (s += ","), r += 4;
+              for (let d = 0; d < f; d++)
+                i += t.readUInt32LE(r), d + 1 < f && (i += ","), r += 4;
           if (u === "s")
-            for (let f = 0; f < h; f++)
-              s += t.readInt16LE(r), f + 1 < h && (s += ","), r += 2;
+            for (let d = 0; d < f; d++)
+              i += t.readInt16LE(r), d + 1 < f && (i += ","), r += 2;
           if (u === "S")
-            for (let f = 0; f < h; f++)
-              s += t.readUInt16LE(r), f + 1 < h && (s += ","), r += 2;
+            for (let d = 0; d < f; d++)
+              i += t.readUInt16LE(r), d + 1 < f && (i += ","), r += 2;
           if (u === "c")
-            for (let f = 0; f < h; f++)
-              s += t.readInt8(r), f + 1 < h && (s += ","), r += 1;
+            for (let d = 0; d < f; d++)
+              i += t.readInt8(r), d + 1 < f && (i += ","), r += 1;
           if (u === "C")
-            for (let f = 0; f < h; f++)
-              s += t.readUInt8(r), f + 1 < h && (s += ","), r += 1;
+            for (let d = 0; d < f; d++)
+              i += t.readUInt8(r), d + 1 < f && (i += ","), r += 1;
           if (u === "f")
-            for (let f = 0; f < h; f++)
-              s += t.readFloatLE(r), f + 1 < h && (s += ","), r += 4;
+            for (let d = 0; d < f; d++)
+              i += t.readFloatLE(r), d + 1 < f && (i += ","), r += 4;
           break;
         }
         default:
-          console.warn(`Unknown BAM tag type '${d}', tags may be incomplete`), s = void 0, r = a;
+          console.warn(`Unknown BAM tag type '${c}', tags may be incomplete`), i = void 0, r = s;
       }
-      if (this._tagOffset = r, this._tagList.push(c), i === e)
-        return s;
-      this.data[i] = s;
+      if (this._tagOffset = r, this._tagList.push(h), a === e)
+        return i;
+      this.data[a] = i;
     }
     this._allTagsParsed = !0;
   }
@@ -881,66 +882,64 @@ class be {
    * @returns {boolean} true if the read is paired, regardless of whether both segments are mapped
    */
   isPaired() {
-    return !!(this.flags & _.BAM_FPAIRED);
+    return !!(this.flags & b.BAM_FPAIRED);
   }
   /** @returns {boolean} true if the read is paired, and both segments are mapped */
   isProperlyPaired() {
-    return !!(this.flags & _.BAM_FPROPER_PAIR);
+    return !!(this.flags & b.BAM_FPROPER_PAIR);
   }
   /** @returns {boolean} true if the read itself is unmapped; conflictive with isProperlyPaired */
   isSegmentUnmapped() {
-    return !!(this.flags & _.BAM_FUNMAP);
+    return !!(this.flags & b.BAM_FUNMAP);
   }
   /** @returns {boolean} true if the read itself is unmapped; conflictive with isProperlyPaired */
   isMateUnmapped() {
-    return !!(this.flags & _.BAM_FMUNMAP);
+    return !!(this.flags & b.BAM_FMUNMAP);
   }
   /** @returns {boolean} true if the read is mapped to the reverse strand */
   isReverseComplemented() {
-    return !!(this.flags & _.BAM_FREVERSE);
+    return !!(this.flags & b.BAM_FREVERSE);
   }
   /** @returns {boolean} true if the mate is mapped to the reverse strand */
   isMateReverseComplemented() {
-    return !!(this.flags & _.BAM_FMREVERSE);
+    return !!(this.flags & b.BAM_FMREVERSE);
   }
   /** @returns {boolean} true if this is read number 1 in a pair */
   isRead1() {
-    return !!(this.flags & _.BAM_FREAD1);
+    return !!(this.flags & b.BAM_FREAD1);
   }
   /** @returns {boolean} true if this is read number 2 in a pair */
   isRead2() {
-    return !!(this.flags & _.BAM_FREAD2);
+    return !!(this.flags & b.BAM_FREAD2);
   }
   /** @returns {boolean} true if this is a secondary alignment */
   isSecondary() {
-    return !!(this.flags & _.BAM_FSECONDARY);
+    return !!(this.flags & b.BAM_FSECONDARY);
   }
   /** @returns {boolean} true if this read has failed QC checks */
   isFailedQc() {
-    return !!(this.flags & _.BAM_FQCFAIL);
+    return !!(this.flags & b.BAM_FQCFAIL);
   }
   /** @returns {boolean} true if the read is an optical or PCR duplicate */
   isDuplicate() {
-    return !!(this.flags & _.BAM_FDUP);
+    return !!(this.flags & b.BAM_FDUP);
   }
   /** @returns {boolean} true if this is a supplementary alignment */
   isSupplementary() {
-    return !!(this.flags & _.BAM_FSUPPLEMENTARY);
+    return !!(this.flags & b.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");
+    const s = this.get("seq_length");
+    let a = "", h = 0, c = e.readInt32LE(r), i = c >> 4, l = C[c & 15];
+    if (l === "S" && i === s)
+      return r += 4, c = e.readInt32LE(r), i = c >> 4, l = C[c & 15], l !== "N" && console.warn("CG tag with no N tag"), this.data.length_on_ref = i, 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() {
+      c = e.readInt32LE(r), i = c >> 4, l = C[c & 15], a += i + l, l !== "H" && l !== "S" && l !== "I" && (h += i), r += 4;
+    return this.data.length_on_ref = h, a;
   }
   length_on_ref() {
     return this.data.length_on_ref ? this.data.length_on_ref : (this.get("cigar"), this.data.length_on_ref);
@@ -961,13 +960,13 @@ class be {
     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++);
+    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"), s = this.get("seq_length");
+    let a = "", h = 0;
+    for (let c = 0; c < r; ++c) {
+      const i = e[n + c];
+      a += F[(i & 240) >> 4], h++, h < s && (a += F[i & 15], h++);
     }
-    return i;
+    return a;
   }
   // adapted from igv.js
   getPairOrientation() {
@@ -975,8 +974,8 @@ class be {
       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("");
+      const s = [];
+      return this.template_length() > 0 ? (s[0] = e, s[1] = n, s[2] = t, s[3] = r) : (s[2] = e, s[3] = n, s[0] = t, s[1] = r), s.join("");
     }
     return "";
   }
@@ -1001,32 +1000,32 @@ class be {
   toJSON() {
     const e = {};
     for (const t of Object.keys(this))
-      t.charAt(0) === "_" || t === "bytes" || (e[t] = this[t]);
+      t.startsWith("_") || t === "bytes" || (e[t] = this[t]);
     return e;
   }
 }
-function V(o) {
+function G(o) {
   const e = o.split(/\r?\n/), t = [];
   for (const n of e) {
-    const [r, ...a] = n.split(/\t/);
+    const [r, ...s] = 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 };
+      data: s.map((a) => {
+        const h = a.indexOf(":"), c = a.slice(0, h), i = a.slice(h + 1);
+        return { tag: c, value: i };
       })
     });
   }
   return t;
 }
-const Q = 21840194, D = 65536;
-async function me(o) {
+const j = 21840194, q = 65536;
+async function ge(o) {
   let e = [];
   for await (const t of o)
     e = e.concat(t);
   return e;
 }
-class ge {
+class _e {
   read() {
     throw new Error("never called");
   }
@@ -1040,45 +1039,45 @@ class ge {
     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({
+class pe {
+  constructor({ bamFilehandle: e, bamPath: t, bamUrl: n, baiPath: r, baiFilehandle: s, baiUrl: a, csiPath: h, csiFilehandle: c, csiUrl: i, htsget: l, yieldThreadTime: u = 100, renameRefSeqs: f = (d) => d }) {
+    if (this.htsget = !1, this.featureCache = new Y({
+      cache: new W({
         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 }
+      fill: async (d, _) => {
+        const { chunk: g, opts: m } = d, { data: p, cpositions: w, dpositions: E } = await this._readChunk({
+          chunk: g,
+          opts: { ...m, signal: _ }
         });
-        return this.readBamFeatures(g, p, w, b);
+        return this.readBamFeatures(p, w, E, g);
       }
-    }), this.renameRefSeq = h, e)
+    }), this.renameRefSeq = f, e)
       this.bam = e;
     else if (t)
-      this.bam = new R(t);
+      this.bam = new A(t);
     else if (n)
-      this.bam = new k(n);
+      this.bam = new R(n);
     else if (l)
-      this.htsget = !0, this.bam = new ge();
+      this.htsget = !0, this.bam = new _e();
     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) });
+    if (c)
+      this.index = new P({ filehandle: c });
+    else if (h)
+      this.index = new P({ filehandle: new A(h) });
+    else if (i)
+      this.index = new P({ filehandle: new R(i) });
     else if (s)
-      this.index = new T({ filehandle: new k(s) });
-    else if (a)
-      this.index = new A({ filehandle: a });
+      this.index = new v({ filehandle: s });
     else if (r)
-      this.index = new A({ filehandle: new R(r) });
-    else if (i)
-      this.index = new A({ filehandle: new k(i) });
+      this.index = new v({ filehandle: new A(r) });
+    else if (a)
+      this.index = new v({ filehandle: new R(a) });
     else if (t)
-      this.index = new A({ filehandle: new R(`${t}.bai`) });
+      this.index = new v({ filehandle: new A(`${t}.bai`) });
     else if (n)
-      this.index = new A({ filehandle: new k(`${n}.bai`) });
+      this.index = new v({ filehandle: new R(`${n}.bai`) });
     else if (l)
       this.htsget = !0;
     else
@@ -1086,25 +1085,25 @@ class _e {
     this.yieldThreadTime = u;
   }
   async getHeaderPre(e) {
-    const t = re(e);
+    const t = ee(e);
     if (!this.index)
       return;
     const n = await this.index.parse(t), r = n.firstDataLine ? n.firstDataLine.blockPosition + 65535 : void 0;
-    let a;
+    let s;
     if (r) {
-      const l = r + D, u = await this.bam.read(E.Buffer.alloc(l), 0, l, 0, t);
+      const l = r + q, u = await this.bam.read(I.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));
+      s = 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)
+      s = await this.bam.readFile(t);
+    const a = await k(s);
+    if (a.readInt32LE(0) !== j)
       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);
+    const h = a.readInt32LE(4);
+    this.header = a.toString("utf8", 8, 8 + h);
+    const { chrToIndex: c, indexToChr: i } = await this._readRefSeqs(h + 8, 65535, t);
+    return this.chrToIndex = c, this.indexToChr = i, G(this.header);
   }
   getHeader(e) {
     return this.headerP || (this.headerP = this.getHeaderPre(e).catch((t) => {
@@ -1119,105 +1118,105 @@ class _e {
   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)
+    const r = t + q, { bytesRead: s, buffer: a } = await this.bam.read(I.Buffer.alloc(r), 0, t, 0, n);
+    if (!s)
       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 h = await k(a.subarray(0, Math.min(s, t))), c = h.readInt32LE(e);
+    let i = 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)
+    for (let f = 0; f < c; f += 1) {
+      const d = h.readInt32LE(i), _ = this.renameRefSeq(h.toString("utf8", i + 4, i + 4 + d - 1)), g = h.readInt32LE(i + d + 4);
+      if (l[_] = f, u.push({ refName: _, length: g }), i = i + 8 + d, i > h.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));
+    return ge(this.streamRecordsForRange(e, t, n, r));
   }
   async *streamRecordsForRange(e, t, n, r) {
-    var a;
+    var s;
     await this.getHeader(r);
-    const i = (a = this.chrToIndex) === null || a === void 0 ? void 0 : a[e];
-    if (i === void 0 || !this.index)
+    const a = (s = this.chrToIndex) === null || s === void 0 ? void 0 : s[e];
+    if (a === 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);
+      const h = await this.index.blocksForRange(a, t - 1, n, r);
+      yield* this._fetchChunkFeatures(h, a, 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;
+  async *_fetchChunkFeatures(e, t, n, r, s = {}) {
+    const { viewAsPairs: a } = s, h = [];
+    let c = !1;
+    for (const i of e) {
+      const l = await this.featureCache.get(i.toString(), { chunk: i, opts: s }, s.signal), u = [];
+      for (const f of l)
+        if (f.seq_id() === t)
+          if (f.get("start") >= r) {
+            c = !0;
             break;
           } else
-            h.get("end") >= n && u.push(h);
-      if (c.push(u), yield u, d)
+            f.get("end") >= n && u.push(f);
+      if (h.push(u), yield u, c)
         break;
     }
-    te(a.signal), i && (yield this.fetchPairs(t, c, a));
+    K(s.signal), a && (yield this.fetchPairs(t, h, s));
   }
   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;
+    const { pairAcrossChr: r, maxInsertSize: s = 2e5 } = n, a = {}, h = {};
+    t.map((f) => {
+      const d = {};
+      for (const _ of f) {
+        const g = _.name(), m = _.id();
+        d[g] || (d[g] = 0), d[g]++, h[m] = 1;
       }
-      for (const [m, b] of Object.entries(f))
-        b === 1 && (i[m] = !0);
+      for (const [_, g] of Object.entries(d))
+        g === 1 && (a[_] = !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 c = [];
+    t.map((f) => {
+      for (const d of f) {
+        const _ = d.name(), g = d.get("start"), m = d._next_pos(), p = d._next_refid();
+        this.index && a[_] && (r || p === e && Math.abs(g - m) < s) && c.push(this.index.blocksForRange(p, m, m + 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,
+    const i = /* @__PURE__ */ new Map(), l = await Promise.all(c);
+    for (const f of l.flat())
+      i.has(f.toString()) || i.set(f.toString(), f);
+    return (await Promise.all([...i.values()].map(async (f) => {
+      const { data: d, cpositions: _, dpositions: g, chunk: m } = await this._readChunk({
+        chunk: f,
         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;
+      }), p = [];
+      for (const w of await this.readBamFeatures(d, _, g, m))
+        a[w.get("name")] && !h[w.id()] && p.push(w);
+      return p;
     }))).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));
+    const { bytesRead: r, buffer: s } = await this.bam.read(I.Buffer.alloc(t), 0, t, e, n);
+    return s.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 };
+    const n = await this._readRegion(e.minv.blockPosition, e.fetchedSize(), t), { buffer: r, cpositions: s, dpositions: a } = await Q(n, e);
+    return { data: r, cpositions: s, dpositions: a, 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;
+    let s = 0;
+    const a = [];
+    let h = 0, c = +Date.now();
+    for (; s + 4 < e.length; ) {
+      const i = e.readInt32LE(s), l = s + 4 + i - 1;
       if (n) {
-        for (; a + r.minv.dataPosition >= n[c++]; )
+        for (; s + r.minv.dataPosition >= n[h++]; )
           ;
-        c--;
+        h--;
       }
       if (l < e.length) {
-        const u = new be({
+        const u = new me({
           bytes: {
             byteArray: e,
-            start: a,
+            start: s,
             end: l
           },
           // the below results in an automatically calculated file-offset based
@@ -1240,16 +1239,16 @@ class _e {
           //
           // 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 : (
+          fileOffset: t.length > 0 ? t[h] * 256 + (s - n[h]) + r.minv.dataPosition + 1 : (
             // must be slice, not subarray for buffer polyfill on web
-            he.signed(e.slice(a, l))
+            de.signed(e.slice(s, l))
           )
         });
-        i.push(u), this.yieldThreadTime && +Date.now() - d > this.yieldThreadTime && (await Z(1), d = +Date.now());
+        a.push(u), this.yieldThreadTime && +Date.now() - c > this.yieldThreadTime && (await X(1), c = +Date.now());
       }
-      a = l + 1;
+      s = l + 1;
     }
-    return i;
+    return a;
   }
   async hasRefSeq(e) {
     var t, n;
@@ -1266,49 +1265,49 @@ class _e {
     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);
+    const s = (r = this.chrToIndex) === null || r === void 0 ? void 0 : r[e];
+    return s === void 0 ? [] : this.index.indexCov(s, t, n);
   }
   async blocksForRange(e, t, n, r) {
-    var a;
+    var s;
     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);
+    const a = (s = this.chrToIndex) === null || s === void 0 ? void 0 : s[e];
+    return a === void 0 ? [] : this.index.blocksForRange(a, t, n, r);
   }
 }
-async function $(o, e) {
+async function N(o, e) {
   const t = await Promise.all(o.map(async (n) => {
-    const { url: r, headers: a } = n;
+    const { url: r, headers: s } = n;
     if (r.startsWith("data:"))
-      return E.Buffer.from(r.split(",")[1], "base64");
+      return I.Buffer.from(r.split(",")[1], "base64");
     {
-      const { referer: i, ...c } = a, d = await fetch(r, {
+      const { referer: a, ...h } = s, c = await fetch(r, {
         ...e,
-        headers: { ...e == null ? void 0 : e.headers, ...c }
+        headers: { ...e == null ? void 0 : e.headers, ...h }
       });
-      if (!d.ok)
-        throw new Error(`HTTP ${d.status} fetching ${r}: ${await d.text()}`);
-      return E.Buffer.from(await d.arrayBuffer());
+      if (!c.ok)
+        throw new Error(`HTTP ${c.status} fetching ${r}: ${await c.text()}`);
+      return I.Buffer.from(await c.arrayBuffer());
     }
   }));
-  return E.Buffer.concat(await Promise.all(t.map((n) => L(n))));
+  return I.Buffer.concat(await Promise.all(t.map((n) => k(n))));
 }
-class Ae extends _e {
+class ye extends pe {
   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)
+    var s;
+    const h = `${`${this.baseUrl}/${this.trackId}`}?referenceName=${e}&start=${t}&end=${n}&format=BAM`, c = (s = this.chrToIndex) === null || s === void 0 ? void 0 : s[e];
+    if (c === 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);
+      const i = await fetch(h, { ...r });
+      if (!i.ok)
+        throw new Error(`HTTP ${i.status} fetching ${h}: ${await i.text()}`);
+      const l = await i.json(), u = await N(l.htsget.urls.slice(1), r);
       yield* this._fetchChunkFeatures([
         // fake stuff to pretend to be a Chunk
         {
@@ -1338,7 +1337,7 @@ class Ae extends _e {
             return `${e}_${t}_${n}`;
           }
         }
-      ], d, t, n, r);
+      ], c, t, n, r);
     }
   }
   async _readChunk({ chunk: e }) {
@@ -1350,23 +1349,23 @@ class Ae extends _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)
+    const r = await n.json(), s = await N(r.htsget.urls, e);
+    if (s.readInt32LE(0) !== j)
       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 };
+    const a = s.readInt32LE(4), h = s.toString("utf8", 8, 8 + a), c = G(h), i = [], l = {}, u = c.filter((f) => f.tag === "SQ");
+    for (const [f, d] of u.entries()) {
+      let _ = "", g = 0;
+      for (const m of d.data)
+        m.tag === "SN" ? _ = m.value : m.tag === "LN" && (g = +m.value);
+      l[_] = f, i[f] = { refName: _, length: g };
     }
-    return this.chrToIndex = l, this.indexToChr = s, d;
+    return this.chrToIndex = l, this.indexToChr = i, c;
   }
 }
 export {
-  A as BAI,
-  _e as BamFile,
-  be as BamRecord,
-  T as CSI,
-  Ae as HtsgetFile
+  v as BAI,
+  pe as BamFile,
+  me as BamRecord,
+  P as CSI,
+  ye as HtsgetFile
 };