@gmod/bbi 8.1.1 → 9.0.0

package/dist/block-view.js

@@ -6,13 +6,241 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BlockView = void 0;
 const abortable_promise_cache_1 = __importDefault(require("@gmod/abortable-promise-cache"));
 const quick_lru_1 = __importDefault(require("@jbrowse/quick-lru"));
-const range_ts_1 = __importDefault(require("./range.js"));
+const range_ts_1 = require("./range.js");
 const unzip_ts_1 = require("./unzip.js");
 const util_ts_1 = require("./util.js");
 const decoder = new TextDecoder('utf8');
+const CIR_TREE_MAGIC = 0x2468ace0;
 function coordFilter(s1, e1, s2, e2) {
     return s1 < e2 && e1 >= s2;
 }
+function parseSummaryBlock(b, startOffset, request) {
+    const features = [];
+    let offset = startOffset;
+    const dataView = new DataView(b.buffer, b.byteOffset, b.length);
+    while (offset < b.byteLength) {
+        const chromId = dataView.getUint32(offset, true);
+        offset += 4;
+        const start = dataView.getUint32(offset, true);
+        offset += 4;
+        const end = dataView.getUint32(offset, true);
+        offset += 4;
+        const validCnt = dataView.getUint32(offset, true);
+        offset += 4;
+        const minScore = dataView.getFloat32(offset, true);
+        offset += 4;
+        const maxScore = dataView.getFloat32(offset, true);
+        offset += 4;
+        const sumData = dataView.getFloat32(offset, true);
+        offset += 8;
+        if (!request ||
+            (chromId === request.chrId &&
+                coordFilter(start, end, request.start, request.end))) {
+            features.push({
+                start,
+                end,
+                maxScore,
+                minScore,
+                summary: true,
+                score: sumData / (validCnt || 1),
+            });
+        }
+    }
+    return features;
+}
+function parseBigBedBlock(data, startOffset, offset, request) {
+    const items = [];
+    let currOffset = startOffset;
+    const dataView = new DataView(data.buffer, data.byteOffset, data.length);
+    while (currOffset < data.byteLength) {
+        const c2 = currOffset;
+        const chromId = dataView.getUint32(currOffset, true);
+        currOffset += 4;
+        const start = dataView.getInt32(currOffset, true);
+        currOffset += 4;
+        const end = dataView.getInt32(currOffset, true);
+        currOffset += 4;
+        let i = currOffset;
+        for (; i < data.length; i++) {
+            if (data[i] === 0) {
+                break;
+            }
+        }
+        const b = data.subarray(currOffset, i);
+        const rest = decoder.decode(b);
+        currOffset = i + 1;
+        if (!request ||
+            (chromId === request.chrId &&
+                coordFilter(start, end, request.start, request.end))) {
+            items.push({
+                start,
+                end,
+                rest,
+                uniqueId: `bb-${offset + c2}`,
+            });
+        }
+    }
+    return items;
+}
+function parseBigWigBlock(buffer, startOffset, req) {
+    const b = buffer.subarray(startOffset);
+    const dataView = new DataView(b.buffer, b.byteOffset, b.length);
+    const blockStart = dataView.getInt32(4, true);
+    const itemStep = dataView.getUint32(12, true);
+    const itemSpan = dataView.getUint32(16, true);
+    const blockType = dataView.getUint8(20);
+    const itemCount = dataView.getUint16(22, true);
+    let offset = 24;
+    const items = [];
+    switch (blockType) {
+        case 1: {
+            for (let i = 0; i < itemCount; i++) {
+                const start = dataView.getInt32(offset, true);
+                offset += 4;
+                const end = dataView.getInt32(offset, true);
+                offset += 4;
+                const score = dataView.getFloat32(offset, true);
+                offset += 4;
+                if (!req || coordFilter(start, end, req.start, req.end)) {
+                    items.push({ start, end, score });
+                }
+            }
+            break;
+        }
+        case 2: {
+            for (let i = 0; i < itemCount; i++) {
+                const start = dataView.getInt32(offset, true);
+                offset += 4;
+                const score = dataView.getFloat32(offset, true);
+                offset += 4;
+                const end = start + itemSpan;
+                if (!req || coordFilter(start, end, req.start, req.end)) {
+                    items.push({ score, start, end });
+                }
+            }
+            break;
+        }
+        case 3: {
+            for (let i = 0; i < itemCount; i++) {
+                const score = dataView.getFloat32(offset, true);
+                offset += 4;
+                const start = blockStart + i * itemStep;
+                const end = start + itemSpan;
+                if (!req || coordFilter(start, end, req.start, req.end)) {
+                    items.push({ score, start, end });
+                }
+            }
+            break;
+        }
+    }
+    return items;
+}
+function parseBigWigBlockAsArrays(buffer, startOffset, req) {
+    const dataView = new DataView(buffer.buffer, buffer.byteOffset + startOffset, buffer.length - startOffset);
+    const blockStart = dataView.getInt32(4, true);
+    const itemStep = dataView.getUint32(12, true);
+    const itemSpan = dataView.getUint32(16, true);
+    const blockType = dataView.getUint8(20);
+    const itemCount = dataView.getUint16(22, true);
+    const starts = new Int32Array(itemCount);
+    const ends = new Int32Array(itemCount);
+    const scores = new Float32Array(itemCount);
+    if (!req) {
+        switch (blockType) {
+            case 1: {
+                let offset = 24;
+                for (let i = 0; i < itemCount; i++) {
+                    starts[i] = dataView.getInt32(offset, true);
+                    ends[i] = dataView.getInt32(offset + 4, true);
+                    scores[i] = dataView.getFloat32(offset + 8, true);
+                    offset += 12;
+                }
+                return { starts, ends, scores };
+            }
+            case 2: {
+                let offset = 24;
+                for (let i = 0; i < itemCount; i++) {
+                    const start = dataView.getInt32(offset, true);
+                    starts[i] = start;
+                    ends[i] = start + itemSpan;
+                    scores[i] = dataView.getFloat32(offset + 4, true);
+                    offset += 8;
+                }
+                return { starts, ends, scores };
+            }
+            case 3: {
+                let offset = 24;
+                for (let i = 0; i < itemCount; i++) {
+                    const start = blockStart + i * itemStep;
+                    starts[i] = start;
+                    ends[i] = start + itemSpan;
+                    scores[i] = dataView.getFloat32(offset, true);
+                    offset += 4;
+                }
+                return { starts, ends, scores };
+            }
+        }
+        return { starts, ends, scores };
+    }
+    const reqStart = req.start;
+    const reqEnd = req.end;
+    let idx = 0;
+    switch (blockType) {
+        case 1: {
+            let offset = 24;
+            for (let i = 0; i < itemCount; i++) {
+                const start = dataView.getInt32(offset, true);
+                const end = dataView.getInt32(offset + 4, true);
+                if (start < reqEnd && end >= reqStart) {
+                    starts[idx] = start;
+                    ends[idx] = end;
+                    scores[idx] = dataView.getFloat32(offset + 8, true);
+                    idx++;
+                }
+                offset += 12;
+            }
+            break;
+        }
+        case 2: {
+            let offset = 24;
+            for (let i = 0; i < itemCount; i++) {
+                const start = dataView.getInt32(offset, true);
+                const end = start + itemSpan;
+                if (start < reqEnd && end >= reqStart) {
+                    starts[idx] = start;
+                    ends[idx] = end;
+                    scores[idx] = dataView.getFloat32(offset + 4, true);
+                    idx++;
+                }
+                offset += 8;
+            }
+            break;
+        }
+        case 3: {
+            let offset = 24;
+            for (let i = 0; i < itemCount; i++) {
+                const start = blockStart + i * itemStep;
+                const end = start + itemSpan;
+                if (start < reqEnd && end >= reqStart) {
+                    starts[idx] = start;
+                    ends[idx] = end;
+                    scores[idx] = dataView.getFloat32(offset, true);
+                    idx++;
+                }
+                offset += 4;
+            }
+            break;
+        }
+    }
+    if (idx < itemCount) {
+        return {
+            starts: starts.subarray(0, idx),
+            ends: ends.subarray(0, idx),
+            scores: scores.subarray(0, idx),
+        };
+    }
+    return { starts, ends, scores };
+}
 /**
  * View into a subset of the data in a BigWig file.
  *
@@ -46,456 +274,158 @@ class BlockView {
             throw new Error('invalid rTreeOffset!');
         }
     }
-    async readWigData(chrName, start, end, observer, opts) {
-        try {
-            const chrId = this.refsByName[chrName];
-            if (chrId === undefined) {
-                observer.complete();
-                return;
-            }
-            const request = { chrId, start, end };
-            if (!this.rTreePromise) {
-                this.rTreePromise = this.bbi.read(48, this.rTreeOffset, opts);
-            }
-            const buffer = await this.rTreePromise;
-            const dataView = new DataView(buffer.buffer, buffer.byteOffset, buffer.length);
-            // Maximum number of children per R-tree node - used to calculate memory bounds
-            const rTreeBlockSize = dataView.getUint32(4, true);
-            const blocksToFetch = [];
-            let outstanding = 0;
-            // R-tree leaf nodes contain the actual data blocks to fetch
-            const processLeafNode = (dataView, startOffset, count) => {
-                let offset = startOffset;
-                for (let i = 0; i < count; i++) {
-                    const startChrom = dataView.getUint32(offset, true);
-                    offset += 4;
-                    const startBase = dataView.getUint32(offset, true);
-                    offset += 4;
-                    const endChrom = dataView.getUint32(offset, true);
-                    offset += 4;
-                    const endBase = dataView.getUint32(offset, true);
-                    offset += 4;
-                    const blockOffset = Number(dataView.getBigUint64(offset, true));
-                    offset += 8;
-                    const blockSize = Number(dataView.getBigUint64(offset, true));
-                    offset += 8;
-                    if (blockIntersectsQuery({ startChrom, startBase, endBase, endChrom })) {
-                        blocksToFetch.push({
-                            offset: blockOffset,
-                            length: blockSize,
-                        });
-                    }
-                }
-            };
-            // R-tree non-leaf nodes contain pointers to child nodes
-            const processNonLeafNode = (dataView, startOffset, count, level) => {
-                const recurOffsets = [];
-                let offset = startOffset;
-                for (let i = 0; i < count; i++) {
-                    const startChrom = dataView.getUint32(offset, true);
-                    offset += 4;
-                    const startBase = dataView.getUint32(offset, true);
-                    offset += 4;
-                    const endChrom = dataView.getUint32(offset, true);
-                    offset += 4;
-                    const endBase = dataView.getUint32(offset, true);
-                    offset += 4;
-                    const blockOffset = Number(dataView.getBigUint64(offset, true));
-                    offset += 8;
-                    if (blockIntersectsQuery({ startChrom, startBase, endChrom, endBase })) {
-                        recurOffsets.push(blockOffset);
-                    }
-                }
-                if (recurOffsets.length > 0) {
-                    traverseRTree(recurOffsets, level + 1);
-                }
-            };
-            const processRTreeNode = (rTreeBlockData, offset2, level) => {
-                try {
-                    const data = rTreeBlockData.subarray(offset2);
-                    const dataView = new DataView(data.buffer, data.byteOffset, data.length);
-                    let offset = 0;
-                    const isLeaf = dataView.getUint8(offset);
-                    offset += 2; // 1 skip for reserved byte
-                    const count = dataView.getUint16(offset, true);
-                    offset += 2;
-                    if (isLeaf === 1) {
-                        processLeafNode(dataView, offset, count);
-                    }
-                    else if (isLeaf === 0) {
-                        processNonLeafNode(dataView, offset, count, level);
-                    }
-                }
-                catch (e) {
-                    observer.error(e);
-                }
-            };
-            const blockIntersectsQuery = (b) => {
-                const { startChrom, startBase, endChrom, endBase } = b;
-                return ((startChrom < chrId || (startChrom === chrId && startBase <= end)) &&
-                    (endChrom > chrId || (endChrom === chrId && endBase >= start)));
-            };
-            const fetchAndProcessRTreeBlocks = async (offsets, range, level) => {
-                try {
-                    const length = range.max - range.min;
-                    const offset = range.min;
-                    const resultBuffer = await this.featureCache.get(`${length}_${offset}`, { length, offset }, opts?.signal);
-                    for (const element of offsets) {
-                        if (range.contains(element)) {
-                            processRTreeNode(resultBuffer, element - offset, level);
-                            outstanding -= 1;
-                            if (outstanding === 0) {
-                                this.readFeatures(observer, blocksToFetch, {
-                                    ...opts,
-                                    request,
-                                }).catch((e) => {
-                                    observer.error(e);
-                                });
+    async _collectBlocks(chrName, start, end, opts) {
+        const chrId = this.refsByName[chrName];
+        if (chrId === undefined) {
+            return undefined;
+        }
+        if (!this.rTreePromise) {
+            this.rTreePromise = this.bbi.read(48, this.rTreeOffset, opts);
+        }
+        const buffer = await this.rTreePromise;
+        const dataView = new DataView(buffer.buffer, buffer.byteOffset, buffer.length);
+        const magic = dataView.getUint32(0, true);
+        if (magic !== CIR_TREE_MAGIC) {
+            throw new Error(`invalid cirTree magic: 0x${magic.toString(16)} (expected 0x${CIR_TREE_MAGIC.toString(16)}) at offset ${this.rTreeOffset}, file may be corrupt or unsupported`);
+        }
+        const rTreeBlockSize = dataView.getUint32(4, true);
+        // Upper bound on size, based on a completely full leaf node.
+        const maxRTreeBlockSpan = 4 + rTreeBlockSize * 32;
+        const blockIntersectsQuery = (startChrom, startBase, endChrom, endBase) => (startChrom < chrId || (startChrom === chrId && startBase <= end)) &&
+            (endChrom > chrId || (endChrom === chrId && endBase >= start));
+        const blocks = [];
+        let currentOffsets = [this.rTreeOffset + 48];
+        while (currentOffsets.length > 0) {
+            const spans = (0, range_ts_1.mergeRanges)(currentOffsets.map(o => ({ min: o, max: o + maxRTreeBlockSpan })));
+            const nextOffsets = [];
+            for (const { min, max } of spans) {
+                const length = max - min;
+                const offset = min;
+                const resultBuffer = await this.featureCache.get(`${length}_${offset}`, { length, offset }, opts?.signal);
+                for (const element of currentOffsets) {
+                    if (min <= element && element <= max) {
+                        const data = resultBuffer.subarray(element - offset);
+                        const dv = new DataView(data.buffer, data.byteOffset, data.length);
+                        const isLeaf = dv.getUint8(0);
+                        const count = dv.getUint16(2, true);
+                        let nodeOffset = 4;
+                        if (isLeaf === 1) {
+                            for (let i = 0; i < count; i++) {
+                                const startChrom = dv.getUint32(nodeOffset, true);
+                                const startBase = dv.getUint32(nodeOffset + 4, true);
+                                const endChrom = dv.getUint32(nodeOffset + 8, true);
+                                const endBase = dv.getUint32(nodeOffset + 12, true);
+                                const blockOffset = Number(dv.getBigUint64(nodeOffset + 16, true));
+                                const blockSize = Number(dv.getBigUint64(nodeOffset + 24, true));
+                                nodeOffset += 32;
+                                if (blockIntersectsQuery(startChrom, startBase, endChrom, endBase)) {
+                                    blocks.push({ offset: blockOffset, length: blockSize });
+                                }
+                            }
+                        }
+                        else if (isLeaf === 0) {
+                            for (let i = 0; i < count; i++) {
+                                const startChrom = dv.getUint32(nodeOffset, true);
+                                const startBase = dv.getUint32(nodeOffset + 4, true);
+                                const endChrom = dv.getUint32(nodeOffset + 8, true);
+                                const endBase = dv.getUint32(nodeOffset + 12, true);
+                                const childOffset = Number(dv.getBigUint64(nodeOffset + 16, true));
+                                nodeOffset += 24;
+                                if (blockIntersectsQuery(startChrom, startBase, endChrom, endBase)) {
+                                    nextOffsets.push(childOffset);
+                                }
                             }
                         }
                     }
                 }
-                catch (e) {
-                    observer.error(e);
-                }
-            };
-            const traverseRTree = (offsets, level) => {
-                try {
-                    outstanding += offsets.length;
-                    // Upper bound on size, based on a completely full leaf node.
-                    const maxRTreeBlockSpan = 4 + rTreeBlockSize * 32;
-                    let spans = new range_ts_1.default([
-                        {
-                            min: offsets[0],
-                            max: offsets[0] + maxRTreeBlockSpan,
-                        },
-                    ]);
-                    for (let i = 1; i < offsets.length; i += 1) {
-                        const blockSpan = new range_ts_1.default([
-                            {
-                                min: offsets[i],
-                                max: offsets[i] + maxRTreeBlockSpan,
-                            },
-                        ]);
-                        spans = spans.union(blockSpan);
-                    }
-                    spans.getRanges().forEach(range => {
-                        fetchAndProcessRTreeBlocks(offsets, range, level).catch((e) => {
-                            observer.error(e);
-                        });
-                    });
-                }
-                catch (e) {
-                    observer.error(e);
-                }
-            };
-            traverseRTree([this.rTreeOffset + 48], 1);
-            return;
-        }
-        catch (e) {
-            observer.error(e);
-        }
-    }
-    parseSummaryBlock(b, startOffset, request) {
-        const features = [];
-        let offset = startOffset;
-        const dataView = new DataView(b.buffer, b.byteOffset, b.length);
-        while (offset < b.byteLength) {
-            const chromId = dataView.getUint32(offset, true);
-            offset += 4;
-            const start = dataView.getUint32(offset, true);
-            offset += 4;
-            const end = dataView.getUint32(offset, true);
-            offset += 4;
-            const validCnt = dataView.getUint32(offset, true);
-            offset += 4;
-            const minScore = dataView.getFloat32(offset, true);
-            offset += 4;
-            const maxScore = dataView.getFloat32(offset, true);
-            offset += 4;
-            const sumData = dataView.getFloat32(offset, true);
-            offset += 8;
-            if (!request ||
-                (chromId === request.chrId &&
-                    coordFilter(start, end, request.start, request.end))) {
-                features.push({
-                    start,
-                    end,
-                    maxScore,
-                    minScore,
-                    summary: true,
-                    score: sumData / (validCnt || 1),
-                });
             }
+            currentOffsets = nextOffsets;
         }
-        return features;
+        return { blocks, chrId };
     }
-    parseBigBedBlock(data, startOffset, offset, request) {
-        const items = [];
-        let currOffset = startOffset;
-        const dataView = new DataView(data.buffer, data.byteOffset, data.length);
-        while (currOffset < data.byteLength) {
-            const c2 = currOffset;
-            const chromId = dataView.getUint32(currOffset, true);
-            currOffset += 4;
-            const start = dataView.getInt32(currOffset, true);
-            currOffset += 4;
-            const end = dataView.getInt32(currOffset, true);
-            currOffset += 4;
-            let i = currOffset;
-            for (; i < data.length; i++) {
-                if (data[i] === 0) {
-                    break;
-                }
-            }
-            const b = data.subarray(currOffset, i);
-            const rest = decoder.decode(b);
-            currOffset = i + 1;
-            if (!request ||
-                (chromId === request.chrId &&
-                    coordFilter(start, end, request.start, request.end))) {
-                items.push({
-                    start,
-                    end,
-                    rest,
-                    uniqueId: `bb-${offset + c2}`,
-                });
-            }
+    async readWigData(chrName, start, end, opts) {
+        const collected = await this._collectBlocks(chrName, start, end, opts);
+        if (!collected) {
+            return [];
         }
-        return items;
+        const { blocks, chrId } = collected;
+        return this.readFeatures(blocks, {
+            ...opts,
+            request: { chrId, start, end },
+        });
     }
-    parseBigWigBlock(buffer, startOffset, req) {
-        const b = buffer.subarray(startOffset);
-        const dataView = new DataView(b.buffer, b.byteOffset, b.length);
-        let offset = 0;
-        offset += 4;
-        const blockStart = dataView.getInt32(offset, true);
-        offset += 8;
-        const itemStep = dataView.getUint32(offset, true);
-        offset += 4;
-        const itemSpan = dataView.getUint32(offset, true);
-        offset += 4;
-        const blockType = dataView.getUint8(offset);
-        offset += 2;
-        const itemCount = dataView.getUint16(offset, true);
-        offset += 2;
-        const items = [];
-        switch (blockType) {
-            case 1: {
-                for (let i = 0; i < itemCount; i++) {
-                    const start = dataView.getInt32(offset, true);
-                    offset += 4;
-                    const end = dataView.getInt32(offset, true);
-                    offset += 4;
-                    const score = dataView.getFloat32(offset, true);
-                    offset += 4;
-                    if (!req || coordFilter(start, end, req.start, req.end)) {
-                        items.push({
-                            start,
-                            end,
-                            score,
-                        });
-                    }
-                }
-                break;
-            }
-            case 2: {
-                for (let i = 0; i < itemCount; i++) {
-                    const start = dataView.getInt32(offset, true);
-                    offset += 4;
-                    const score = dataView.getFloat32(offset, true);
-                    offset += 4;
-                    const end = start + itemSpan;
-                    if (!req || coordFilter(start, end, req.start, req.end)) {
-                        items.push({
-                            score,
-                            start,
-                            end,
-                        });
-                    }
-                }
-                break;
-            }
-            case 3: {
-                for (let i = 0; i < itemCount; i++) {
-                    const score = dataView.getFloat32(offset, true);
-                    offset += 4;
-                    const start = blockStart + i * itemStep;
-                    const end = start + itemSpan;
-                    if (!req || coordFilter(start, end, req.start, req.end)) {
-                        items.push({
-                            score,
-                            start,
-                            end,
-                        });
-                    }
-                }
-                break;
-            }
+    async readWigDataAsArrays(chrName, start, end, opts) {
+        const collected = await this._collectBlocks(chrName, start, end, opts);
+        const blocks = collected?.blocks ?? [];
+        const request = collected
+            ? { chrId: collected.chrId, start, end }
+            : undefined;
+        const optsWithReq = { ...opts, request };
+        if (this.blockType === 'summary') {
+            return this._readSummaryFeaturesAsArrays(blocks, optsWithReq);
         }
-        return items;
+        return this._readBigWigFeaturesAsArrays(blocks, optsWithReq);
     }
-    parseBigWigBlockAsArrays(buffer, startOffset, req) {
-        const dataView = new DataView(buffer.buffer, buffer.byteOffset + startOffset, buffer.length - startOffset);
-        const blockStart = dataView.getInt32(4, true);
-        const itemStep = dataView.getUint32(12, true);
-        const itemSpan = dataView.getUint32(16, true);
-        const blockType = dataView.getUint8(20);
-        const itemCount = dataView.getUint16(22, true);
-        const starts = new Int32Array(itemCount);
-        const ends = new Int32Array(itemCount);
-        const scores = new Float32Array(itemCount);
-        if (!req) {
-            switch (blockType) {
-                case 1: {
-                    let offset = 24;
-                    for (let i = 0; i < itemCount; i++) {
-                        starts[i] = dataView.getInt32(offset, true);
-                        ends[i] = dataView.getInt32(offset + 4, true);
-                        scores[i] = dataView.getFloat32(offset + 8, true);
-                        offset += 12;
-                    }
-                    return { starts, ends, scores };
-                }
-                case 2: {
-                    let offset = 24;
-                    for (let i = 0; i < itemCount; i++) {
-                        const start = dataView.getInt32(offset, true);
-                        starts[i] = start;
-                        ends[i] = start + itemSpan;
-                        scores[i] = dataView.getFloat32(offset + 4, true);
-                        offset += 8;
-                    }
-                    return { starts, ends, scores };
-                }
-                case 3: {
-                    let offset = 24;
-                    for (let i = 0; i < itemCount; i++) {
-                        const start = blockStart + i * itemStep;
-                        starts[i] = start;
-                        ends[i] = start + itemSpan;
-                        scores[i] = dataView.getFloat32(offset, true);
-                        offset += 4;
-                    }
-                    return { starts, ends, scores };
+    async readFeatures(blocks, opts = {}) {
+        const { blockType, uncompressBufSize } = this;
+        const { signal, request } = opts;
+        const blockGroupsToFetch = (0, util_ts_1.groupBlocks)(blocks);
+        const allFeatures = [];
+        for (const blockGroup of blockGroupsToFetch) {
+            const data = await this.bbi.read(blockGroup.length, blockGroup.offset, {
+                signal,
+            });
+            const groupOffset = blockGroup.offset;
+            const subBlocks = blockGroup.blocks;
+            let decompressedData;
+            let decompressedOffsets;
+            if (uncompressBufSize > 0) {
+                const localBlocks = [];
+                for (const block of subBlocks) {
+                    localBlocks.push({
+                        offset: block.offset - groupOffset,
+                        length: block.length,
+                    });
                 }
+                const result = await (0, unzip_ts_1.unzipBatch)(data, localBlocks, uncompressBufSize);
+                decompressedData = result.data;
+                decompressedOffsets = result.offsets;
             }
-            return { starts, ends, scores };
-        }
-        const reqStart = req.start;
-        const reqEnd = req.end;
-        let idx = 0;
-        switch (blockType) {
-            case 1: {
-                let offset = 24;
-                for (let i = 0; i < itemCount; i++) {
-                    const start = dataView.getInt32(offset, true);
-                    const end = dataView.getInt32(offset + 4, true);
-                    if (start < reqEnd && end >= reqStart) {
-                        starts[idx] = start;
-                        ends[idx] = end;
-                        scores[idx] = dataView.getFloat32(offset + 8, true);
-                        idx++;
-                    }
-                    offset += 12;
+            else {
+                decompressedData = data;
+                decompressedOffsets = [];
+                for (const block of subBlocks) {
+                    decompressedOffsets.push(block.offset - groupOffset);
                 }
-                break;
+                decompressedOffsets.push(data.length);
             }
-            case 2: {
-                let offset = 24;
-                for (let i = 0; i < itemCount; i++) {
-                    const start = dataView.getInt32(offset, true);
-                    const end = start + itemSpan;
-                    if (start < reqEnd && end >= reqStart) {
-                        starts[idx] = start;
-                        ends[idx] = end;
-                        scores[idx] = dataView.getFloat32(offset + 4, true);
-                        idx++;
-                    }
-                    offset += 8;
+            for (let i = 0; i < subBlocks.length; i++) {
+                const start = decompressedOffsets[i];
+                const end = decompressedOffsets[i + 1];
+                const resultData = decompressedData.subarray(start, end);
+                let features;
+                switch (blockType) {
+                    case 'summary':
+                        features = parseSummaryBlock(resultData, 0, request);
+                        break;
+                    case 'bigwig':
+                        features = parseBigWigBlock(resultData, 0, request);
+                        break;
+                    case 'bigbed':
+                        features = parseBigBedBlock(resultData, 0, subBlocks[i].offset * (1 << 8), request);
+                        break;
+                    default:
+                        features = [];
+                        console.warn(`Don't know what to do with ${blockType}`);
                 }
-                break;
-            }
-            case 3: {
-                let offset = 24;
-                for (let i = 0; i < itemCount; i++) {
-                    const start = blockStart + i * itemStep;
-                    const end = start + itemSpan;
-                    if (start < reqEnd && end >= reqStart) {
-                        starts[idx] = start;
-                        ends[idx] = end;
-                        scores[idx] = dataView.getFloat32(offset, true);
-                        idx++;
-                    }
-                    offset += 4;
+                for (const f of features) {
+                    allFeatures.push(f);
                 }
-                break;
             }
         }
-        if (idx < itemCount) {
-            return {
-                starts: starts.subarray(0, idx),
-                ends: ends.subarray(0, idx),
-                scores: scores.subarray(0, idx),
-            };
-        }
-        return { starts, ends, scores };
-    }
-    async readFeatures(observer, blocks, opts = {}) {
-        try {
-            const { blockType, uncompressBufSize } = this;
-            const { signal, request } = opts;
-            const blockGroupsToFetch = (0, util_ts_1.groupBlocks)(blocks);
-            await Promise.all(blockGroupsToFetch.map(async (blockGroup) => {
-                const { length, offset } = blockGroup;
-                const data = await this.featureCache.get(`${length}_${offset}`, blockGroup, signal);
-                const localBlocks = blockGroup.blocks.map(block => ({
-                    offset: block.offset - blockGroup.offset,
-                    length: block.length,
-                }));
-                let decompressedData;
-                let decompressedOffsets;
-                if (uncompressBufSize > 0) {
-                    const result = await (0, unzip_ts_1.unzipBatch)(data, localBlocks, uncompressBufSize);
-                    decompressedData = result.data;
-                    decompressedOffsets = result.offsets;
-                }
-                else {
-                    decompressedData = data;
-                    decompressedOffsets = localBlocks.map(b => b.offset);
-                    decompressedOffsets.push(data.length);
-                }
-                for (let i = 0; i < blockGroup.blocks.length; i++) {
-                    const block = blockGroup.blocks[i];
-                    const start = decompressedOffsets[i];
-                    const end = decompressedOffsets[i + 1];
-                    const resultData = decompressedData.subarray(start, end);
-                    switch (blockType) {
-                        case 'summary': {
-                            observer.next(this.parseSummaryBlock(resultData, 0, request));
-                            break;
-                        }
-                        case 'bigwig': {
-                            observer.next(this.parseBigWigBlock(resultData, 0, request));
-                            break;
-                        }
-                        case 'bigbed': {
-                            observer.next(this.parseBigBedBlock(resultData, 0, block.offset * (1 << 8), request));
-                            break;
-                        }
-                        default: {
-                            console.warn(`Don't know what to do with ${blockType}`);
-                        }
-                    }
-                }
-            }));
-            observer.complete();
-        }
-        catch (e) {
-            observer.error(e);
-        }
+        return allFeatures;
     }
-    async readBigWigFeaturesAsArrays(blocks, opts = {}) {
+    async _readBigWigFeaturesAsArrays(blocks, opts = {}) {
         const { uncompressBufSize } = this;
         const { signal, request } = opts;
         const blockGroupsToFetch = (0, util_ts_1.groupBlocks)(blocks);
@@ -503,9 +433,9 @@ class BlockView {
         const allEnds = [];
         const allScores = [];
         let totalCount = 0;
-        await Promise.all(blockGroupsToFetch.map(async (blockGroup) => {
+        for (const blockGroup of blockGroupsToFetch) {
             const { length, offset } = blockGroup;
-            const data = await this.featureCache.get(`${length}_${offset}`, blockGroup, signal);
+            const data = await this.bbi.read(length, offset, { signal });
             const localBlocks = blockGroup.blocks.map(block => ({
                 offset: block.offset - blockGroup.offset,
                 length: block.length,
@@ -522,7 +452,7 @@ class BlockView {
             else {
                 for (const block of localBlocks) {
                     const blockData = data.subarray(block.offset, block.offset + block.length);
-                    const result = this.parseBigWigBlockAsArrays(blockData, 0, request);
+                    const result = parseBigWigBlockAsArrays(blockData, 0, request);
                     if (result.starts.length > 0) {
                         allStarts.push(result.starts);
                         allEnds.push(result.ends);
@@ -531,7 +461,7 @@ class BlockView {
                     }
                 }
             }
-        }));
+        }
         if (allStarts.length === 0) {
             return {
                 starts: new Int32Array(0),
@@ -560,7 +490,7 @@ class BlockView {
         }
         return { starts, ends, scores, isSummary: false };
     }
-    async readSummaryFeaturesAsArrays(blocks, opts = {}) {
+    async _readSummaryFeaturesAsArrays(blocks, opts = {}) {
         const { uncompressBufSize } = this;
         const { signal, request } = opts;
         const blockGroupsToFetch = (0, util_ts_1.groupBlocks)(blocks);
@@ -570,9 +500,9 @@ class BlockView {
         const allMinScores = [];
         const allMaxScores = [];
         let totalCount = 0;
-        await Promise.all(blockGroupsToFetch.map(async (blockGroup) => {
+        for (const blockGroup of blockGroupsToFetch) {
             const { length, offset } = blockGroup;
-            const data = await this.featureCache.get(`${length}_${offset}`, blockGroup, signal);
+            const data = await this.bbi.read(length, offset, { signal });
             const localBlocks = blockGroup.blocks.map(block => ({
                 offset: block.offset - blockGroup.offset,
                 length: block.length,
@@ -591,7 +521,7 @@ class BlockView {
             else {
                 for (const block of localBlocks) {
                     const blockData = data.subarray(block.offset, block.offset + block.length);
-                    const features = this.parseSummaryBlock(blockData, 0, request);
+                    const features = parseSummaryBlock(blockData, 0, request);
                     if (features.length > 0) {
                         const starts = new Int32Array(features.length);
                         const ends = new Int32Array(features.length);
@@ -615,7 +545,7 @@ class BlockView {
                     }
                 }
             }
-        }));
+        }
         if (allStarts.length === 0) {
             return {
                 starts: new Int32Array(0),