igv 2.13.7 → 2.13.8

package/dist/igv.js

@@ -13966,7 +13966,7 @@
     const {
       Inflate,
       inflate: inflate$3,
-      inflateRaw,
+      inflateRaw: inflateRaw$2,
       ungzip: ungzip$2
     } = inflate_1$1;
     var Deflate_1 = Deflate;
@@ -13975,7 +13975,7 @@
     var gzip_1 = gzip;
     var Inflate_1 = Inflate;
     var inflate_1 = inflate$3;
-    var inflateRaw_1 = inflateRaw;
+    var inflateRaw_1 = inflateRaw$2;
     var ungzip_1 = ungzip$2;
     var constants_1 = constants$2;
     var pako = {
@@ -14008,7 +14008,7 @@
 
     pako.deflateRaw;
     pako.deflate;
-    pako.inflateRaw;
+    const inflateRaw = pako.inflateRaw;
     const inflate = pako.inflate;
     pako.gzip;
     const FEXTRA = 4; // gzip spec F.EXTRA flag
@@ -14080,7 +14080,7 @@
         return out;
       }
     }
-    function bgzBlockSize(data) {
+    function bgzBlockSize$1(data) {
       const ba = ArrayBuffer.isView(data) ? data : new Uint8Array(data);
       const bsize = (ba[17] << 8 | ba[16]) + 1;
       return bsize;
@@ -18865,7 +18865,7 @@
 
     const doAutoscale = function (features) {
       var min, max;
-      if (features.length > 0) {
+      if (features && features.length > 0) {
         min = Number.MAX_VALUE;
         max = -Number.MAX_VALUE;
         features.forEach(function (f) {
@@ -21939,7 +21939,7 @@
       }
     };
 
-    const _version = "2.13.7";
+    const _version = "2.13.8";
     function version$1() {
       return _version;
     }
@@ -26462,12 +26462,81 @@
       isGreaterThan(vp) {
         return this.block > vp.block || this.block === vp.block && this.offset > vp.offset;
       }
+      isEqualTo(vp) {
+        return this.block === vp.block && this.offset === vp.offset;
+      }
       print() {
         return "" + this.block + ":" + this.offset;
       }
     }
 
-    // Represents a BAM index.
+    function optimizeChunks(chunks, lowest) {
+      if (chunks.length === 0) return chunks;
+      chunks.sort(function (c0, c1) {
+        const dif = c0.minv.block - c1.minv.block;
+        if (dif !== 0) {
+          return dif;
+        } else {
+          return c0.minv.offset - c1.minv.offset;
+        }
+      });
+      if (chunks.length <= 1) {
+        return chunks;
+      }
+
+      // console.log("Before trimming " + chunks.length)
+      // for (let c of chunks) {
+      //     console.log(`${c.minv.block} ${c.minv.offset}  -  ${c.maxv.block} ${c.maxv.offset}`)
+      // }
+
+      if (lowest) {
+        chunks = chunks.filter(c => c.maxv.isGreaterThan(lowest));
+      }
+
+      // console.log("Before merging " + chunks.length)
+      // for (let c of chunks) {
+      //     console.log(`${c.minv.block} ${c.minv.offset}  -  ${c.maxv.block} ${c.maxv.offset}`)
+      // }
+
+      const mergedChunks = [];
+      let lastChunk;
+      for (let chunk of chunks) {
+        if (!lastChunk) {
+          mergedChunks.push(chunk);
+          lastChunk = chunk;
+        } else {
+          if (canMerge(lastChunk, chunk)) {
+            if (chunk.maxv.isGreaterThan(lastChunk.maxv)) {
+              lastChunk.maxv = chunk.maxv;
+            }
+          } else {
+            mergedChunks.push(chunk);
+            lastChunk = chunk;
+          }
+        }
+      }
+
+      // console.log("After merging " + mergedChunks.length)
+      // for (let c of mergedChunks) {
+      //     console.log(`${c.minv.block} ${c.minv.offset}  -  ${c.maxv.block} ${c.maxv.offset}`)
+      // }
+
+      return mergedChunks;
+    }
+
+    /**
+     * Merge 2 blocks if the file position gap between them is < 16 kb, and the total size is < ~5 mb
+     * @param chunk1
+     * @param chunk2
+     * @returns {boolean|boolean}
+     */
+    function canMerge(chunk1, chunk2) {
+      const gap = chunk2.minv.block - chunk1.maxv.block;
+      const sizeEstimate = chunk1.maxv.block - chunk1.minv.block;
+      return gap < 65000 && sizeEstimate < 5000000;
+    }
+
+    // Represents a CSI Bam or Tabix index
     const CSI1_MAGIC$1 = 21582659; // CSI\1
     const CSI2_MAGIC$1 = 38359875; // CSI\2
 
@@ -26579,7 +26648,7 @@
        * @param max  genomic end position
        * @param return an array of {minv: {filePointer, offset}, {maxv: {filePointer, offset}}
        */
-      blocksForRange(refId, min, max) {
+      chunksForRange(refId, min, max) {
         const ba = this.indices[refId];
         if (!ba) {
           return [];
@@ -26605,7 +26674,7 @@
             }
           }
           const lowestOffset = ba.loffset[overlappingBins[0]];
-          return optimizeChunks$1(chunks, lowestOffset);
+          return optimizeChunks(chunks, lowestOffset);
         }
       }
 
@@ -26637,48 +26706,10 @@
         return ((1 << (this.depth + 1) * 3) - 1) / 7;
       }
     }
-    function optimizeChunks$1(chunks, lowest) {
-      const mergedChunks = [];
-      let lastChunk = null;
-      if (chunks.length === 0) return chunks;
-      chunks.sort(function (c0, c1) {
-        const dif = c0.minv.block - c1.minv.block;
-        if (dif !== 0) {
-          return dif;
-        } else {
-          return c0.minv.offset - c1.minv.offset;
-        }
-      });
-      chunks.forEach(function (chunk) {
-        if (!lowest || chunk.maxv.isGreaterThan(lowest)) {
-          if (lastChunk === null) {
-            mergedChunks.push(chunk);
-            lastChunk = chunk;
-          } else {
-            if (canMerge$1(lastChunk, chunk)) {
-              if (chunk.maxv.isGreaterThan(lastChunk.maxv)) {
-                lastChunk.maxv = chunk.maxv;
-              }
-            } else {
-              mergedChunks.push(chunk);
-              lastChunk = chunk;
-            }
-          }
-        }
-      });
-      return mergedChunks;
-    }
-    function canMerge$1(chunk1, chunk2) {
-      return chunk2.minv.block - chunk1.maxv.block < 65000 && chunk2.maxv.block - chunk1.minv.block < 5000000;
-      // lastChunk.minv.block === lastChunk.maxv.block &&
-      // lastChunk.maxv.block === chunk.minv.block &&
-      // chunk.minv.block === chunk.maxv.block
-    }
 
-    // Represents a BAM index.
+    // Represents a BAM or Tabix index.
     const BAI_MAGIC$1 = 21578050;
     const TABIX_MAGIC$1 = 21578324;
-    const MB = 1000000;
     async function parseBamIndex(arrayBuffer, genome) {
       const index = new BamIndex();
       await index.parse(arrayBuffer, false, genome);
@@ -26780,22 +26811,27 @@
       }
 
       /**
-       * Fetch blocks for a particular genomic range.  This method is public so it can be unit-tested.
+       * Fetch chunks for a particular genomic range.  This method is public so it can be unit-tested.
        *
        * @param refId  the sequence dictionary index of the chromosome
        * @param min  genomic start position
        * @param max  genomic end position
-       * @param return an array of {minv: {filePointer, offset}, {maxv: {filePointer, offset}}
+       * @param return an array of objects representing chunks (file spans) {minv: {block, offset}, {maxv: {block, offset}}
        */
-      blocksForRange(refId, min, max) {
+      chunksForRange(refId, min, max) {
         const bam = this;
         const ba = bam.indices[refId];
         if (!ba) {
           return [];
         } else {
           const overlappingBins = reg2bins(min, max); // List of bin #s that overlap min, max
-          const chunks = [];
 
+          //console.log("bin ranges")
+          //for(let b of overlappingBins) {
+          //    console.log(`${b[0]} - ${b[1]}`)
+          //}
+
+          const chunks = [];
           // Find chunks in overlapping bins.  Leaf bins (< 4681) are not pruned
           for (let binRange of overlappingBins) {
             for (let bin = binRange[0]; bin <= binRange[1]; bin++) {
@@ -26806,8 +26842,7 @@
                   const ce = c[1];
                   chunks.push({
                     minv: cs,
-                    maxv: ce,
-                    bin: bin
+                    maxv: ce
                   });
                 }
               }
@@ -26816,65 +26851,20 @@
 
           // Use the linear index to find minimum file position of chunks that could contain alignments in the region
           const nintv = ba.linearIndex.length;
-          let lowest = null;
-          const minLin = Math.min(min >> 14, nintv - 1);
+          let lowest;
+          const minLin = Math.min(min >> 14, nintv - 1); // i.e. min / 16384
           const maxLin = Math.min(max >> 14, nintv - 1);
-          for (let i = minLin; i < maxLin; i++) {
+          for (let i = minLin; i <= maxLin; i++) {
             const vp = ba.linearIndex[i];
             if (vp) {
-              // todo -- I think, but am not sure, that the values in the linear index have to be in increasing order.  So the first non-null should be minimum
-              if (!lowest || vp.isLessThan(lowest)) {
-                lowest = vp;
-              }
+              lowest = vp; // lowest file offset that contains alignments overlapping (min, max)
+              break;
             }
           }
           return optimizeChunks(chunks, lowest);
         }
       }
     }
-    function optimizeChunks(chunks, lowest) {
-      const mergedChunks = [];
-      let lastChunk = null;
-      if (chunks.length === 0) return chunks;
-      chunks.sort(function (c0, c1) {
-        const dif = c0.minv.block - c1.minv.block;
-        if (dif !== 0) {
-          return dif;
-        } else {
-          return c0.minv.offset - c1.minv.offset;
-        }
-      });
-      chunks.forEach(function (chunk) {
-        if (!lowest || chunk.maxv.isGreaterThan(lowest)) {
-          if (lastChunk === null) {
-            mergedChunks.push(chunk);
-            lastChunk = chunk;
-          } else {
-            if (canMerge(lastChunk, chunk)) {
-              if (chunk.maxv.isGreaterThan(lastChunk.maxv)) {
-                lastChunk.maxv = chunk.maxv;
-              }
-            } else {
-              mergedChunks.push(chunk);
-              lastChunk = chunk;
-            }
-          }
-        }
-      });
-      return mergedChunks;
-    }
-
-    /**
-     * Merge 2 blocks if the gap between them is < 1kb and the total resulting size < 100mb
-     * @param chunk1
-     * @param chunk2
-     * @returns {boolean|boolean}
-     */
-    function canMerge(chunk1, chunk2) {
-      const gap = chunk2.minv.block - chunk1.maxv.block;
-      const total = chunk2.maxv.block - chunk1.minv.block;
-      return gap < 30000 && total < 10 * MB;
-    }
 
     /**
      * Calculate the list of bins that overlap with region [beg, end]
@@ -27006,7 +26996,7 @@
        * @param min  genomic start position
        * @param max  genomic end position
        */
-      blocksForRange(queryChr, min, max) {
+      chunksForRange(queryChr, min, max) {
         const chrIdx = this.chrIndex[queryChr];
         if (chrIdx) {
           const blocks = chrIdx.blocks;
@@ -27166,7 +27156,12 @@
       }
     }
 
-    class BGZipLineReader {
+    /**
+     * Class to iterate line-by-line over a BGZipped text file.  This class is useful for iterating from the start of
+     * the file.  Not useful for indexed queries.
+     */
+
+    class BGZLineReader {
       constructor(config) {
         this.config = config;
         this.filePtr = 0;
@@ -27206,7 +27201,7 @@
           }
         });
         const abuffer = await igvxhr.loadArrayBuffer(this.config.url, bsizeOptions);
-        const bufferSize = bgzBlockSize(abuffer);
+        const bufferSize = bgzBlockSize$1(abuffer);
         //console.log(`next block ${this.filePtr}  ${bufferSize}`);
 
         if (bufferSize === 0) {
@@ -27231,6 +27226,244 @@
       }
     }
 
+    function concatenateArrayBuffers(arrayBuffers) {
+      if (arrayBuffers.length === 1) {
+        return arrayBuffers[0];
+      }
+      let len = 0;
+      for (const b of arrayBuffers) {
+        len += b.byteLength;
+      }
+      const c = new Uint8Array(len);
+      let offset = 0;
+      for (const b of arrayBuffers) {
+        c.set(new Uint8Array(b), offset);
+        offset += b.byteLength;
+      }
+      return c.buffer;
+    }
+
+    /**
+     * Return the block size for the data buffer.
+     * @param data
+     * @returns {number}
+     */
+    const bgzBlockSize = data => {
+      const ba = ArrayBuffer.isView(data) ? data : new Uint8Array(data);
+      const bsize = (ba[17] << 8 | ba[16]) + 1;
+      return bsize;
+    };
+    class BGZBlockLoader {
+      constructor(config) {
+        this.config = config;
+        this.cacheBlocks = false != config.cacheBlocks; // Default to true
+        this.cache = undefined;
+      }
+
+      /**
+       * Return inflated data from startBlock through endBlock as an UInt8Array
+       *
+       * @param startBlock
+       * @param endBlock
+       * @returns {Promise<Uint8Array>}
+       */
+      async getData(startBlock, endBlock) {
+        const blocks = await this.getInflatedBlocks(startBlock, endBlock);
+        if (blocks.length === 1) {
+          return blocks[0];
+        }
+        let len = 0;
+        for (const b of blocks) {
+          len += b.byteLength;
+        }
+        const c = new Uint8Array(len);
+        let offset = 0;
+        for (const b of blocks) {
+          c.set(b, offset);
+          offset += b.byteLength;
+        }
+        return c;
+      }
+
+      /**
+       * Return the inflated data for the specified blocks as an array of Uint8Arrays.  This method is public so
+       * it can be unit tested. *
+       * @param startBlock
+       * @param endBlock
+       * @returns {Promise<*[Uint8Array]>}
+       */
+      async getInflatedBlocks(startBlock, endBlock) {
+        if (!this.cacheBlocks) {
+          const buffer = await this.loadBLockData(startBlock, endBlock);
+          return inflateBlocks(buffer);
+        } else {
+          const c = this.cache;
+          if (c && c.startBlock <= startBlock && c.endBlock >= endBlock) {
+            //console.log("Complete overlap")
+            const startOffset = startBlock - c.startBlock;
+            const endOffset = endBlock - c.startBlock;
+            return inflateBlocks(c.buffer, startOffset, endOffset);
+            // Don't update cache, still valid
+          } else {
+            let buffer;
+            if (!c || c.startBlock > endBlock || c.endBlock < startBlock) {
+              // no overlap with cache
+              buffer = await this.loadBLockData(startBlock, endBlock);
+            } else {
+              //console.log("Some overlap")
+              const arrayBuffers = [];
+
+              // Load blocks preceding cache start, if any
+              if (startBlock < c.startBlock) {
+                // load first blocks
+                const startBuffer = await this.loadBLockData(startBlock, c.startBlock, {
+                  skipEnd: true
+                });
+                arrayBuffers.push(startBuffer);
+              }
+
+              // Slice cached buffer as needed
+              let cachedBuffer;
+              if (startBlock <= c.startBlock && endBlock >= c.endBlock) {
+                cachedBuffer = c.buffer;
+              } else {
+                const start = Math.max(0, startBlock - c.startBlock);
+                let end;
+                if (endBlock >= c.endBlock) {
+                  end = c.buffer.byteLength;
+                } else {
+                  // We need to find the byte position of the end of "endBlock"
+                  const boundaries = findBlockBoundaries(c.buffer);
+                  for (let i = 0; i < boundaries.length - 1; i++) {
+                    if (c.startBlock + boundaries[i] === endBlock) {
+                      end = boundaries[i + 1];
+                      break;
+                    }
+                  }
+                  // Do something if end not found
+                }
+
+                cachedBuffer = c.buffer.slice(start, end);
+              }
+              arrayBuffers.push(cachedBuffer);
+
+              // Load end blocks, if any
+              if (endBlock > c.endBlock) {
+                const endBuffer = await this.loadBLockData(c.endBlock, endBlock, {
+                  skipStart: true
+                });
+                arrayBuffers.push(endBuffer);
+              }
+              buffer = concatenateArrayBuffers(arrayBuffers);
+            }
+            this.cache = {
+              startBlock,
+              endBlock,
+              buffer
+            };
+            return inflateBlocks(buffer);
+          }
+        }
+      }
+      async loadBLockData(startBlock, endBlock, options) {
+        const config = this.config;
+        const skipStart = options && options.skipStart;
+        const skipEnd = options && options.skipEnd;
+
+        // Get size of last block if not skipped
+        let lastBlockSize = 0;
+        if (!skipEnd) {
+          const bsizeOptions = buildOptions(config, {
+            range: {
+              start: endBlock,
+              size: 26
+            }
+          });
+          const abuffer = await igvxhr.loadArrayBuffer(config.url, bsizeOptions);
+          lastBlockSize = bgzBlockSize(abuffer);
+        }
+        if (skipStart) {
+          const bsizeOptions = buildOptions(config, {
+            range: {
+              start: startBlock,
+              size: 26
+            }
+          });
+          const abuffer = await igvxhr.loadArrayBuffer(config.url, bsizeOptions);
+          startBlock += bgzBlockSize(abuffer);
+        }
+
+        // Load data for all blocks
+        const loadOptions = buildOptions(config, {
+          range: {
+            start: startBlock,
+            size: endBlock + lastBlockSize - startBlock
+          }
+        });
+
+        //console.log(`${this.config.name}  Loaded ${startBlock} - ${endBlock + lastBlockSize}   (${(endBlock + lastBlockSize - startBlock) / 1000} kb)`)
+
+        return igvxhr.loadArrayBuffer(config.url, loadOptions);
+      }
+    }
+    function findBlockBoundaries(arrayBuffer) {
+      const byteLengh = arrayBuffer.byteLength;
+      let offset = 0;
+      const blockBoundaries = [0];
+      while (offset < byteLengh) {
+        //console.log("Cache block "  + offset)
+        const ba = new Uint8Array(arrayBuffer, offset);
+        const bsize = (ba[17] << 8 | ba[16]) + 1;
+        offset += bsize;
+        if (offset < byteLengh) {
+          blockBoundaries.push(offset);
+        }
+      }
+      return blockBoundaries;
+    }
+
+    /**
+     * Inflate compressed blocks within the data buffer*
+     * @param data
+     * @param startBlock - optional file location for start block.  Default == 0
+     * @param endBlock - optional file location for last block to decompress.
+     * @returns {*[]}
+     */
+    function inflateBlocks(data, startBlock, endBlock) {
+      startBlock = startBlock || 0;
+      const oBlockList = [];
+      let ptr = startBlock;
+      const lim = data.byteLength - 18;
+      while (ptr < lim) {
+        try {
+          //console.log(113873 + ptr)
+          const header = new Uint8Array(data, ptr, 18);
+          const xlen = header[11] << 8 | header[10];
+          const bsize = header[17] << 8 | header[16]; // Total block size, including header, minus 1
+          const start = 12 + xlen + ptr; // Start of CDATA
+          const bytesLeft = data.byteLength - start;
+          const cDataSize = bsize - xlen - 18;
+          if (bytesLeft < cDataSize || cDataSize <= 0) {
+            // This is unexpected.  Throw error?
+            break;
+          }
+          const cdata = new Uint8Array(data, start, cDataSize);
+          const unc = inflateRaw(cdata);
+          oBlockList.push(unc);
+          if (endBlock === ptr) {
+            break;
+          } else {
+            // Advance to next block
+            ptr += bsize + 1;
+          }
+        } catch (e) {
+          console.error(e);
+          break;
+        }
+      }
+      return oBlockList;
+    }
+
     /*
      * The MIT License (MIT)
      *
@@ -27332,7 +27565,8 @@
             }
             let dataWrapper;
             if (index.tabix) {
-              dataWrapper = new BGZipLineReader(this.config);
+              this._blockLoader = new BGZBlockLoader(this.config);
+              dataWrapper = new BGZLineReader(this.config);
             } else {
               // Tribble
               const maxSize = Object.values(index.chrIndex).flatMap(chr => chr.blocks).map(block => block.max).reduce((previous, current) => Math.min(previous, current), Number.MAX_SAFE_INTEGER);
@@ -27408,46 +27642,25 @@
           return [];
         }
         const genome = this.genome;
-        const blocks = this.index.blocksForRange(refId, start, end);
-        if (!blocks || blocks.length === 0) {
+        const chunks = this.index.chunksForRange(refId, start, end);
+        if (!chunks || chunks.length === 0) {
           return [];
         } else {
           const allFeatures = [];
-          for (let block of blocks) {
-            const startPos = block.minv.block;
-            const startOffset = block.minv.offset;
-            const endOffset = block.maxv.offset;
-            let endPos;
-            if (tabix) {
-              let lastBlockSize = 0;
-              if (endOffset > 0) {
-                const bsizeOptions = buildOptions(config, {
-                  range: {
-                    start: block.maxv.block,
-                    size: 26
-                  }
-                });
-                const abuffer = await igvxhr.loadArrayBuffer(config.url, bsizeOptions);
-                lastBlockSize = bgzBlockSize(abuffer);
-              }
-              endPos = block.maxv.block + lastBlockSize;
-            } else {
-              endPos = block.maxv.block;
-            }
-            const options = buildOptions(config, {
-              range: {
-                start: startPos,
-                size: endPos - startPos + 1
-              }
-            });
+          for (let chunk of chunks) {
             let inflated;
             if (tabix) {
-              const data = await igvxhr.loadArrayBuffer(config.url, options);
-              inflated = unbgzf(data);
+              inflated = await this._blockLoader.getData(chunk.minv.block, chunk.maxv.block);
             } else {
+              const options = buildOptions(config, {
+                range: {
+                  start: chunk.minv.block,
+                  size: chunk.maxv.block - chunk.minv.block + 1
+                }
+              });
               inflated = await igvxhr.loadString(config.url, options);
             }
-            const slicedData = startOffset ? inflated.slice(startOffset) : inflated;
+            const slicedData = chunk.minv.offset ? inflated.slice(chunk.minv.offset) : inflated;
             const dataWrapper = getDataWrapper(slicedData);
             let slicedFeatures = await parser.parseFeatures(dataWrapper);
 
@@ -29873,6 +30086,7 @@
     var documentAll$2 = typeof document == 'object' && document.all;
 
     // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
+    // eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing
     var IS_HTMLDDA = typeof documentAll$2 == 'undefined' && documentAll$2 !== undefined;
     var documentAll_1 = {
       all: documentAll$2,
@@ -30127,10 +30341,10 @@
       (module.exports = function (key, value) {
         return sharedStore[key] || (sharedStore[key] = value !== undefined ? value : {});
       })('versions', []).push({
-        version: '3.26.1',
+        version: '3.27.1',
         mode: 'global',
         copyright: '© 2014-2022 Denis Pushkarev (zloirock.ru)',
-        license: 'https://github.com/zloirock/core-js/blob/v3.26.1/LICENSE',
+        license: 'https://github.com/zloirock/core-js/blob/v3.27.1/LICENSE',
         source: 'https://github.com/zloirock/core-js'
       });
     });
@@ -33368,6 +33582,7 @@
         this.bamPath = config.url;
         this.baiPath = config.indexURL;
         BamUtils.setReaderDefaults(this, config);
+        this._blockLoader = new BGZBlockLoader(config);
       }
       async readAlignments(chr, bpStart, bpEnd) {
         const chrToIndex = await this.getChrIndex();
@@ -33378,37 +33593,14 @@
           return alignmentContainer;
         } else {
           const bamIndex = await this.getIndex();
-          const chunks = bamIndex.blocksForRange(chrId, bpStart, bpEnd);
+          const chunks = bamIndex.chunksForRange(chrId, bpStart, bpEnd);
           if (!chunks || chunks.length === 0) {
             return alignmentContainer;
           }
           for (let c of chunks) {
-            let lastBlockSize;
-            if (c.maxv.offset === 0) {
-              lastBlockSize = 0; // Don't need to read the last block.
-            } else {
-              const bsizeOptions = buildOptions(this.config, {
-                range: {
-                  start: c.maxv.block,
-                  size: 26
-                }
-              });
-              const abuffer = await igvxhr.loadArrayBuffer(this.bamPath, bsizeOptions);
-              lastBlockSize = bgzBlockSize(abuffer);
-            }
-            const fetchMin = c.minv.block;
-            const fetchMax = c.maxv.block + lastBlockSize;
-            const range = {
-              start: fetchMin,
-              size: fetchMax - fetchMin + 1
-            };
-            const compressed = await igvxhr.loadArrayBuffer(this.bamPath, buildOptions(this.config, {
-              range: range
-            }));
-            var ba = unbgzf(compressed); //new Uint8Array(BGZip.unbgzf(compressed)); //, c.maxv.block - c.minv.block + 1));
+            const ba = await this._blockLoader.getData(c.minv.block, c.maxv.block);
             const done = BamUtils.decodeBamRecords(ba, c.minv.offset, alignmentContainer, this.indexToChr, chrId, bpStart, bpEnd, this.filter);
             if (done) {
-              //    console.log(`Loaded ${counter} chunks out of  ${chunks.length}`);
               break;
             }
           }
@@ -33429,7 +33621,7 @@
               }
             });
             const abuffer = await igvxhr.loadArrayBuffer(this.bamPath, bsizeOptions);
-            const bsize = bgzBlockSize(abuffer);
+            const bsize = bgzBlockSize$1(abuffer);
             len = index.firstBlockPosition + bsize; // Insure we get the complete compressed block containing the header
           } else {
             len = 64000;
@@ -33967,7 +34159,7 @@
     var clear = global$1.clearImmediate;
     var process$1 = global$1.process;
     var Dispatch = global$1.Dispatch;
-    var Function$1 = global$1.Function;
+    var Function$2 = global$1.Function;
     var MessageChannel$1 = global$1.MessageChannel;
     var String$1 = global$1.String;
     var counter = 0;
@@ -34002,7 +34194,7 @@
     if (!set || !clear) {
       set = function setImmediate(handler) {
         validateArgumentsLength(arguments.length, 1);
-        var fn = isCallable(handler) ? handler : Function$1(handler);
+        var fn = isCallable(handler) ? handler : Function$2(handler);
         var args = arraySlice(arguments, 1);
         queue[++counter] = function () {
           functionApply(fn, undefined, args);
@@ -34068,7 +34260,36 @@
       clearImmediate: clearImmediate
     });
 
-    var setImmediate = task.set;
+    /* global Bun -- Deno case */
+    var engineIsBun = typeof Bun == 'function' && Bun && typeof Bun.version == 'string';
+
+    var Function$1 = global$1.Function;
+    // dirty IE9- and Bun 0.3.0- checks
+    var WRAP = /MSIE .\./.test(engineUserAgent) || engineIsBun && function () {
+      var version = global$1.Bun.version.split('.');
+      return version.length < 3 || version[0] == 0 && (version[1] < 3 || version[1] == 3 && version[2] == 0);
+    }();
+
+    // IE9- / Bun 0.3.0- setTimeout / setInterval / setImmediate additional parameters fix
+    // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#timers
+    // https://github.com/oven-sh/bun/issues/1633
+    var schedulersFix = function (scheduler, hasTimeArg) {
+      var firstParamIndex = hasTimeArg ? 2 : 1;
+      return WRAP ? function (handler, timeout /* , ...arguments */) {
+        var boundArgs = validateArgumentsLength(arguments.length, 1) > firstParamIndex;
+        var fn = isCallable(handler) ? handler : Function$1(handler);
+        var params = boundArgs ? arraySlice(arguments, firstParamIndex) : [];
+        var callback = boundArgs ? function () {
+          functionApply(fn, this, params);
+        } : fn;
+        return hasTimeArg ? scheduler(callback, timeout) : scheduler(callback);
+      } : scheduler;
+    };
+
+    var setTask = task.set;
+
+    // https://github.com/oven-sh/bun/issues/1633
+    var setImmediate = global$1.setImmediate ? schedulersFix(setTask, false) : setTask;
 
     // `setImmediate` method
     // http://w3c.github.io/setImmediate/#si-setImmediate
@@ -50411,7 +50632,9 @@
       hoverText(clickState) {
         if (true === this.showCoverage && clickState.y >= this.coverageTrack.top && clickState.y < this.coverageTrack.height) {
           const clickedObject = this.coverageTrack.getClickedObject(clickState);
-          return clickedObject.hoverText();
+          if (clickedObject) {
+            return clickedObject.hoverText();
+          }
         }
       }
       menuItemList() {