igv 2.13.7 → 2.13.8

package/dist/igv.esm.js

@@ -15473,7 +15473,7 @@ function download(filename, data) {
 
   const { Deflate, deflate, deflateRaw, gzip } = deflate_1$1;
 
-  const { Inflate, inflate: inflate$3, inflateRaw, ungzip: ungzip$2 } = inflate_1$1;
+  const { Inflate, inflate: inflate$3, inflateRaw: inflateRaw$2, ungzip: ungzip$2 } = inflate_1$1;
 
 
 
@@ -15483,7 +15483,7 @@ function download(filename, data) {
   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;
 
@@ -15517,7 +15517,7 @@ function download(filename, data) {
 
 pako.deflateRaw;
 pako.deflate;
-pako.inflateRaw;
+const inflateRaw = pako.inflateRaw;
 const inflate = pako.inflate;
 pako.gzip;
 
@@ -15595,7 +15595,7 @@ function unbgzf(data, lim) {
     }
 }
 
-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;
@@ -20792,7 +20792,7 @@ function buildOptions(config, options) {
 const doAutoscale = function (features) {
     var min, max;
 
-    if (features.length > 0) {
+    if (features && features.length > 0) {
         min = Number.MAX_VALUE;
         max = -Number.MAX_VALUE;
 
@@ -24215,7 +24215,7 @@ const Cytoband = function (start, end, name, typestain) {
     }
 };
 
-const _version = "2.13.7";
+const _version = "2.13.8";
 function version() {
     return _version
 }
@@ -29233,12 +29233,88 @@ class VPointer {
             (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
@@ -29365,7 +29441,7 @@ class CSIIndex {
      * @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) {
@@ -29391,7 +29467,7 @@ class CSIIndex {
 
             const lowestOffset = ba.loffset[overlappingBins[0]];
 
-            return optimizeChunks$1(chunks, lowestOffset)
+            return optimizeChunks(chunks, lowestOffset)
         }
 
     }
@@ -29428,58 +29504,11 @@ class CSIIndex {
 
 }
 
-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();
@@ -29601,14 +29630,14 @@ class BamIndex {
     }
 
     /**
-     * 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];
@@ -29617,8 +29646,13 @@ class BamIndex {
             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++) {
@@ -29627,7 +29661,7 @@ class BamIndex {
                         for (let c of binChunks) {
                             const cs = c[0];
                             const ce = c[1];
-                            chunks.push({minv: cs, maxv: ce, bin: bin});
+                            chunks.push({minv: cs, maxv: ce});
                         }
                     }
                 }
@@ -29635,16 +29669,15 @@ class BamIndex {
 
             // 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
                 }
             }
 
@@ -29653,56 +29686,7 @@ class BamIndex {
     }
 }
 
-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]
@@ -29840,7 +29824,7 @@ class TribbleIndex {
      * @param min  genomic start position
      * @param max  genomic end position
      */
-    blocksForRange(queryChr, min, max) { //function (refId, min, max) {
+    chunksForRange(queryChr, min, max) { //function (refId, min, max) {
         const chrIdx = this.chrIndex[queryChr];
 
         if (chrIdx) {
@@ -30007,7 +29991,12 @@ class ByteArrayDataWrapper {
 
 }
 
-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;
@@ -30053,7 +30042,7 @@ class BGZipLineReader {
             }
         });
         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) {
@@ -30074,6 +30063,250 @@ class BGZipLineReader {
 
 }
 
+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)
  *
@@ -30131,6 +30364,7 @@ class FeatureFileReader {
         if (this.config.format === "vcf" && !this.config.indexURL) {
             console.warn("Warning: index file not specified.  The entire vcf file will be loaded.");
         }
+
     }
 
     async defaultVisibilityWindow() {
@@ -30188,7 +30422,8 @@ class FeatureFileReader {
 
                 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)
@@ -30274,51 +30509,27 @@ class FeatureFileReader {
         }
 
         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);
 
@@ -36420,6 +36631,8 @@ class BamReader {
         this.bamPath = config.url;
         this.baiPath = config.indexURL;
         BamUtils.setReaderDefaults(this, config);
+
+        this._blockLoader = new BGZBlockLoader(config);
     }
 
     async readAlignments(chr, bpStart, bpEnd) {
@@ -36435,32 +36648,16 @@ class BamReader {
         } 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));
+            for (let c of chunks) {
+                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
                 }
             }
@@ -36477,7 +36674,7 @@ class BamReader {
             if (index.firstBlockPosition) {
                 const bsizeOptions = buildOptions(this.config, {range: {start: index.firstBlockPosition, size: 26}});
                 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;
@@ -40152,7 +40349,9 @@ class BAMTrack extends TrackBase {
     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()
+            }
         }
 
     }