@gmod/bbi 2.0.3 → 2.0.5

package/dist/blockView.js

@@ -1,15 +1,4 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -19,55 +8,27 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BlockView = void 0;
-var binary_parser_1 = require("binary-parser");
-var abortable_promise_cache_1 = __importDefault(require("abortable-promise-cache"));
-var quick_lru_1 = __importDefault(require("quick-lru"));
+const binary_parser_1 = require("binary-parser");
+const abortable_promise_cache_1 = __importDefault(require("abortable-promise-cache"));
+const quick_lru_1 = __importDefault(require("quick-lru"));
 // locals
-var range_1 = __importDefault(require("./range"));
-var unzip_1 = require("./unzip");
-var util_1 = require("./util");
-var BIG_WIG_TYPE_GRAPH = 1;
-var BIG_WIG_TYPE_VSTEP = 2;
-var BIG_WIG_TYPE_FSTEP = 3;
+const range_1 = __importDefault(require("./range"));
+const unzip_1 = require("./unzip");
+const util_1 = require("./util");
+const BIG_WIG_TYPE_GRAPH = 1;
+const BIG_WIG_TYPE_VSTEP = 2;
+const BIG_WIG_TYPE_FSTEP = 3;
 function coordFilter(s1, e1, s2, e2) {
     return s1 < e2 && e1 >= s2;
 }
 function getParsers(isBigEndian) {
-    var _a;
-    var le = isBigEndian ? 'big' : 'little';
-    var summaryParser = new binary_parser_1.Parser()
+    const le = isBigEndian ? 'big' : 'little';
+    const summaryParser = new binary_parser_1.Parser()
         .endianess(le)
         .uint32('chromId')
         .uint32('start')
@@ -78,7 +39,7 @@ function getParsers(isBigEndian) {
         .floatle('sumData')
         .floatle('sumSqData')
         .saveOffset('offset');
-    var leafParser = new binary_parser_1.Parser()
+    const leafParser = new binary_parser_1.Parser()
         .endianess(le)
         .uint8('isLeaf')
         .skip(1)
@@ -111,7 +72,7 @@ function getParsers(isBigEndian) {
             }),
         },
     });
-    var bigBedParser = new binary_parser_1.Parser()
+    const bigBedParser = new binary_parser_1.Parser()
         .endianess(le)
         .uint32('chromId')
         .int32('start')
@@ -120,7 +81,7 @@ function getParsers(isBigEndian) {
         zeroTerminated: true,
     })
         .saveOffset('offset');
-    var bigWigParser = new binary_parser_1.Parser()
+    const bigWigParser = new binary_parser_1.Parser()
         .endianess(le)
         .skip(4)
         .int32('blockStart')
@@ -132,16 +93,16 @@ function getParsers(isBigEndian) {
         .uint16('itemCount')
         .choice({
         tag: 'blockType',
-        choices: (_a = {},
-            _a[BIG_WIG_TYPE_FSTEP] = new binary_parser_1.Parser().array('items', {
+        choices: {
+            [BIG_WIG_TYPE_FSTEP]: new binary_parser_1.Parser().array('items', {
                 length: 'itemCount',
                 type: new binary_parser_1.Parser().floatle('score'),
             }),
-            _a[BIG_WIG_TYPE_VSTEP] = new binary_parser_1.Parser().array('items', {
+            [BIG_WIG_TYPE_VSTEP]: new binary_parser_1.Parser().array('items', {
                 length: 'itemCount',
                 type: new binary_parser_1.Parser().endianess(le).int32('start').floatle('score'),
             }),
-            _a[BIG_WIG_TYPE_GRAPH] = new binary_parser_1.Parser().array('items', {
+            [BIG_WIG_TYPE_GRAPH]: new binary_parser_1.Parser().array('items', {
                 length: 'itemCount',
                 type: new binary_parser_1.Parser()
                     .endianess(le)
@@ -149,13 +110,13 @@ function getParsers(isBigEndian) {
                     .int32('end')
                     .floatle('score'),
             }),
-            _a),
+        },
     });
     return {
-        bigWigParser: bigWigParser,
-        bigBedParser: bigBedParser,
-        summaryParser: summaryParser,
-        leafParser: leafParser,
+        bigWigParser,
+        bigBedParser,
+        summaryParser,
+        leafParser,
     };
 }
 /**
@@ -165,9 +126,8 @@ function getParsers(isBigEndian) {
  * Explorer by Thomas Down.
  * @constructs
  */
-var BlockView = /** @class */ (function () {
-    function BlockView(bbi, refsByName, cirTreeOffset, isBigEndian, isCompressed, blockType) {
-        var _this = this;
+class BlockView {
+    constructor(bbi, refsByName, cirTreeOffset, isBigEndian, isCompressed, blockType) {
         this.bbi = bbi;
         this.refsByName = refsByName;
         this.cirTreeOffset = cirTreeOffset;
@@ -176,160 +136,131 @@ var BlockView = /** @class */ (function () {
         this.blockType = blockType;
         this.featureCache = new abortable_promise_cache_1.default({
             cache: new quick_lru_1.default({ maxSize: 1000 }),
-            fill: function (requestData, signal) { return __awaiter(_this, void 0, void 0, function () {
-                var len, off, buffer;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            len = Number(requestData.length);
-                            off = Number(requestData.offset);
-                            return [4 /*yield*/, this.bbi.read(Buffer.alloc(len), 0, len, off, {
-                                    signal: signal,
-                                })];
-                        case 1:
-                            buffer = (_a.sent()).buffer;
-                            return [2 /*return*/, buffer];
-                    }
+            fill: (requestData, signal) => __awaiter(this, void 0, void 0, function* () {
+                const len = Number(requestData.length);
+                const off = Number(requestData.offset);
+                const { buffer } = yield this.bbi.read(Buffer.alloc(len), 0, len, off, {
+                    signal,
                 });
-            }); },
+                return buffer;
+            }),
         });
         if (!(cirTreeOffset >= 0)) {
             throw new Error('invalid cirTreeOffset!');
         }
-        var parsers = getParsers(isBigEndian);
+        const parsers = getParsers(isBigEndian);
         this.leafParser = parsers.leafParser;
         this.bigBedParser = parsers.bigBedParser;
     }
-    BlockView.prototype.readWigData = function (chrName, start, end, observer, opts) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, refsByName, bbi, cirTreeOffset, isBigEndian, chrId_1, request_1, off, buffer, cirBlockSize_1, blocksToFetch_1, outstanding_1, cirFobRecur2_1, filterFeats_1, cirFobStartFetch_1, cirFobRecur_1, e_1;
-            var _this = this;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _b.trys.push([0, 2, , 3]);
-                        _a = this, refsByName = _a.refsByName, bbi = _a.bbi, cirTreeOffset = _a.cirTreeOffset, isBigEndian = _a.isBigEndian;
-                        chrId_1 = refsByName[chrName];
-                        if (chrId_1 === undefined) {
-                            observer.complete();
-                        }
-                        request_1 = { chrId: chrId_1, start: start, end: end };
-                        if (!this.cirTreePromise) {
-                            off = Number(cirTreeOffset);
-                            this.cirTreePromise = bbi.read(Buffer.alloc(48), 0, 48, off, opts);
+    readWigData(chrName, start, end, observer, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { refsByName, bbi, cirTreeOffset, isBigEndian } = this;
+                const chrId = refsByName[chrName];
+                if (chrId === undefined) {
+                    observer.complete();
+                }
+                const request = { chrId, start, end };
+                if (!this.cirTreePromise) {
+                    this.cirTreePromise = bbi.read(Buffer.alloc(48), 0, 48, Number(cirTreeOffset), opts);
+                }
+                const { buffer } = yield this.cirTreePromise;
+                const cirBlockSize = isBigEndian
+                    ? buffer.readUInt32BE(4)
+                    : buffer.readUInt32LE(4);
+                let blocksToFetch = [];
+                let outstanding = 0;
+                const cirFobRecur2 = (cirBlockData, offset, level) => {
+                    try {
+                        const data = cirBlockData.subarray(offset);
+                        const p = this.leafParser.parse(data);
+                        if (p.blocksToFetch) {
+                            blocksToFetch = blocksToFetch.concat(p.blocksToFetch
+                                .filter(filterFeats)
+                                .map((l) => ({
+                                offset: l.blockOffset,
+                                length: l.blockSize,
+                            })));
                         }
-                        return [4 /*yield*/, this.cirTreePromise];
-                    case 1:
-                        buffer = (_b.sent()).buffer;
-                        cirBlockSize_1 = isBigEndian
-                            ? buffer.readUInt32BE(4)
-                            : buffer.readUInt32LE(4);
-                        blocksToFetch_1 = [];
-                        outstanding_1 = 0;
-                        cirFobRecur2_1 = function (cirBlockData, offset, level) {
-                            try {
-                                var data = cirBlockData.subarray(offset);
-                                var p = _this.leafParser.parse(data);
-                                if (p.blocksToFetch) {
-                                    blocksToFetch_1 = blocksToFetch_1.concat(p.blocksToFetch
-                                        .filter(filterFeats_1)
-                                        .map(function (l) { return ({
-                                        offset: l.blockOffset,
-                                        length: l.blockSize,
-                                    }); }));
-                                }
-                                if (p.recurOffsets) {
-                                    var recurOffsets = p.recurOffsets
-                                        .filter(filterFeats_1)
-                                        .map(function (l) { return Number(l.blockOffset); });
-                                    if (recurOffsets.length > 0) {
-                                        cirFobRecur_1(recurOffsets, level + 1);
-                                    }
-                                }
+                        if (p.recurOffsets) {
+                            const recurOffsets = p.recurOffsets
+                                .filter(filterFeats)
+                                .map(l => Number(l.blockOffset));
+                            if (recurOffsets.length > 0) {
+                                cirFobRecur(recurOffsets, level + 1);
                             }
-                            catch (e) {
-                                observer.error(e);
-                            }
-                        };
-                        filterFeats_1 = function (b) {
-                            var startChrom = b.startChrom, startBase = b.startBase, endChrom = b.endChrom, endBase = b.endBase;
-                            return ((startChrom < chrId_1 || (startChrom === chrId_1 && startBase <= end)) &&
-                                (endChrom > chrId_1 || (endChrom === chrId_1 && endBase >= start)));
-                        };
-                        cirFobStartFetch_1 = function (off, fr, level) { return __awaiter(_this, void 0, void 0, function () {
-                            var length_1, offset, resultBuffer, i, e_2;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0:
-                                        _a.trys.push([0, 2, , 3]);
-                                        length_1 = fr.max() - fr.min();
-                                        offset = fr.min();
-                                        return [4 /*yield*/, this.featureCache.get("".concat(length_1, "_").concat(offset), { length: length_1, offset: offset }, opts.signal)];
-                                    case 1:
-                                        resultBuffer = _a.sent();
-                                        for (i = 0; i < off.length; i += 1) {
-                                            if (fr.contains(off[i])) {
-                                                cirFobRecur2_1(resultBuffer, off[i] - offset, level);
-                                                outstanding_1 -= 1;
-                                                if (outstanding_1 === 0) {
-                                                    this.readFeatures(observer, blocksToFetch_1, __assign(__assign({}, opts), { request: request_1 }));
-                                                }
-                                            }
-                                        }
-                                        return [3 /*break*/, 3];
-                                    case 2:
-                                        e_2 = _a.sent();
-                                        observer.error(e_2);
-                                        return [3 /*break*/, 3];
-                                    case 3: return [2 /*return*/];
-                                }
-                            });
-                        }); };
-                        cirFobRecur_1 = function (offset, level) {
-                            try {
-                                outstanding_1 += offset.length;
-                                var maxCirBlockSpan = 4 + Number(cirBlockSize_1) * 32; // Upper bound on size, based on a completely full leaf node.
-                                var spans = new range_1.default(offset[0], offset[0] + maxCirBlockSpan);
-                                for (var i = 1; i < offset.length; i += 1) {
-                                    var blockSpan = new range_1.default(offset[i], offset[i] + maxCirBlockSpan);
-                                    spans = spans.union(blockSpan);
+                        }
+                    }
+                    catch (e) {
+                        observer.error(e);
+                    }
+                };
+                const filterFeats = (b) => {
+                    const { startChrom, startBase, endChrom, endBase } = b;
+                    return ((startChrom < chrId || (startChrom === chrId && startBase <= end)) &&
+                        (endChrom > chrId || (endChrom === chrId && endBase >= start)));
+                };
+                const cirFobStartFetch = (off, fr, level) => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        const length = fr.max() - fr.min();
+                        const offset = fr.min();
+                        const resultBuffer = yield this.featureCache.get(`${length}_${offset}`, { length, offset }, opts.signal);
+                        for (let i = 0; i < off.length; i += 1) {
+                            if (fr.contains(off[i])) {
+                                cirFobRecur2(resultBuffer, off[i] - offset, level);
+                                outstanding -= 1;
+                                if (outstanding === 0) {
+                                    this.readFeatures(observer, blocksToFetch, Object.assign(Object.assign({}, opts), { request }));
                                 }
-                                spans.getRanges().map(function (fr) { return cirFobStartFetch_1(offset, fr, level); });
-                            }
-                            catch (e) {
-                                observer.error(e);
                             }
-                        };
-                        return [2 /*return*/, cirFobRecur_1([Number(cirTreeOffset) + 48], 1)];
-                    case 2:
-                        e_1 = _b.sent();
-                        observer.error(e_1);
-                        return [3 /*break*/, 3];
-                    case 3: return [2 /*return*/];
-                }
-            });
+                        }
+                    }
+                    catch (e) {
+                        observer.error(e);
+                    }
+                });
+                const cirFobRecur = (offset, level) => {
+                    try {
+                        outstanding += offset.length;
+                        const maxCirBlockSpan = 4 + Number(cirBlockSize) * 32; // Upper bound on size, based on a completely full leaf node.
+                        let spans = new range_1.default(offset[0], offset[0] + maxCirBlockSpan);
+                        for (let i = 1; i < offset.length; i += 1) {
+                            const blockSpan = new range_1.default(offset[i], offset[i] + maxCirBlockSpan);
+                            spans = spans.union(blockSpan);
+                        }
+                        spans.getRanges().map(fr => cirFobStartFetch(offset, fr, level));
+                    }
+                    catch (e) {
+                        observer.error(e);
+                    }
+                };
+                return cirFobRecur([Number(cirTreeOffset) + 48], 1);
+            }
+            catch (e) {
+                observer.error(e);
+            }
         });
-    };
-    BlockView.prototype.parseSummaryBlock = function (buffer, startOffset, request) {
-        var features = [];
-        var offset = startOffset;
-        var dataView = new DataView(buffer.buffer, buffer.byteOffset, buffer.length);
+    }
+    parseSummaryBlock(buffer, startOffset, request) {
+        const features = [];
+        let offset = startOffset;
+        const dataView = new DataView(buffer.buffer, buffer.byteOffset, buffer.length);
         while (offset < buffer.byteLength) {
             // this was extracted from looking at the runtime code generated by
             // binary-parser
-            var chromId = dataView.getUint32(offset, true);
+            const chromId = dataView.getUint32(offset, true);
             offset += 4;
-            var start = dataView.getUint32(offset, true);
+            const start = dataView.getUint32(offset, true);
             offset += 4;
-            var end = dataView.getUint32(offset, true);
+            const end = dataView.getUint32(offset, true);
             offset += 4;
-            var validCnt = dataView.getUint32(offset, true);
+            const validCnt = dataView.getUint32(offset, true);
             offset += 4;
-            var minScore = dataView.getFloat32(offset, true);
+            const minScore = dataView.getFloat32(offset, true);
             offset += 4;
-            var maxScore = dataView.getFloat32(offset, true);
+            const maxScore = dataView.getFloat32(offset, true);
             offset += 4;
-            var sumData = dataView.getFloat32(offset, true);
+            const sumData = dataView.getFloat32(offset, true);
             offset += 4;
             // unused
             // const sumSqData = dataView.getFloat32(offset, true)
@@ -339,148 +270,121 @@ var BlockView = /** @class */ (function () {
                     coordFilter(start, end, request.start, request.end)
                 : true) {
                 features.push({
-                    start: start,
-                    end: end,
-                    maxScore: maxScore,
-                    minScore: minScore,
+                    start,
+                    end,
+                    maxScore,
+                    minScore,
                     summary: true,
                     score: sumData / (validCnt || 1),
                 });
             }
         }
         return features;
-    };
-    BlockView.prototype.parseBigBedBlock = function (data, startOffset, offset, request) {
-        var items = [];
-        var currOffset = startOffset;
+    }
+    parseBigBedBlock(data, startOffset, offset, request) {
+        const items = [];
+        let currOffset = startOffset;
         while (currOffset < data.byteLength) {
-            var res = this.bigBedParser.parse(data.subarray(currOffset));
-            items.push(__assign(__assign({}, res), { uniqueId: "bb-".concat(offset + currOffset) }));
+            const res = this.bigBedParser.parse(data.subarray(currOffset));
+            items.push(Object.assign(Object.assign({}, res), { uniqueId: `bb-${offset + currOffset}` }));
             currOffset += res.offset;
         }
         return request
-            ? items.filter(function (f) {
-                return coordFilter(f.start, f.end, request.start, request.end);
-            })
+            ? items.filter((f) => coordFilter(f.start, f.end, request.start, request.end))
             : items;
-    };
-    BlockView.prototype.parseBigWigBlock = function (buffer, startOffset, request) {
-        var b = buffer.subarray(startOffset);
-        var dataView = new DataView(b.buffer, b.byteOffset, b.length);
-        var offset = 0;
+    }
+    parseBigWigBlock(buffer, startOffset, request) {
+        const b = buffer.subarray(startOffset);
+        const dataView = new DataView(b.buffer, b.byteOffset, b.length);
+        let offset = 0;
         offset += 4;
-        var blockStart = dataView.getInt32(offset, true);
+        const blockStart = dataView.getInt32(offset, true);
         offset += 8;
-        var itemStep = dataView.getUint32(offset, true);
+        const itemStep = dataView.getUint32(offset, true);
         offset += 4;
-        var itemSpan = dataView.getUint32(offset, true);
+        const itemSpan = dataView.getUint32(offset, true);
         offset += 4;
-        var blockType = dataView.getUint8(offset);
+        const blockType = dataView.getUint8(offset);
         offset += 2;
-        var itemCount = dataView.getUint16(offset, true);
+        const itemCount = dataView.getUint16(offset, true);
         offset += 2;
-        var items = new Array(itemCount);
+        const items = new Array(itemCount);
         switch (blockType) {
             case 1:
-                for (var i = 0; i < itemCount; i++) {
-                    var start = dataView.getInt32(offset, true);
+                for (let i = 0; i < itemCount; i++) {
+                    const start = dataView.getInt32(offset, true);
                     offset += 4;
-                    var end = dataView.getInt32(offset, true);
+                    const end = dataView.getInt32(offset, true);
                     offset += 4;
-                    var score = dataView.getFloat32(offset, true);
+                    const score = dataView.getFloat32(offset, true);
                     offset += 4;
-                    items[i] = { start: start, end: end, score: score };
+                    items[i] = { start, end, score };
                 }
                 break;
             case 2:
-                for (var i = 0; i < itemCount; i++) {
-                    var start = dataView.getInt32(offset, true);
+                for (let i = 0; i < itemCount; i++) {
+                    const start = dataView.getInt32(offset, true);
                     offset += 4;
-                    var score = dataView.getFloat32(offset, true);
+                    const score = dataView.getFloat32(offset, true);
                     offset += 4;
-                    items[i] = { score: score, start: start, end: start + itemSpan };
+                    items[i] = { score, start, end: start + itemSpan };
                 }
                 break;
             case 3:
-                for (var i = 0; i < itemCount; i++) {
-                    var score = dataView.getFloat32(offset, true);
+                for (let i = 0; i < itemCount; i++) {
+                    const score = dataView.getFloat32(offset, true);
                     offset += 4;
-                    var start = blockStart + i * itemStep;
-                    items[i] = { score: score, start: start, end: start + itemSpan };
+                    const start = blockStart + i * itemStep;
+                    items[i] = { score, start, end: start + itemSpan };
                 }
                 break;
         }
         return request
-            ? items.filter(function (f) {
-                return coordFilter(f.start, f.end, request.start, request.end);
-            })
+            ? items.filter((f) => coordFilter(f.start, f.end, request.start, request.end))
             : items;
-    };
-    BlockView.prototype.readFeatures = function (observer, blocks, opts) {
-        if (opts === void 0) { opts = {}; }
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, blockType_1, isCompressed_1, signal_1, request_2, blockGroupsToFetch, e_3;
-            var _this = this;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _b.trys.push([0, 2, , 3]);
-                        _a = this, blockType_1 = _a.blockType, isCompressed_1 = _a.isCompressed;
-                        signal_1 = opts.signal, request_2 = opts.request;
-                        blockGroupsToFetch = (0, util_1.groupBlocks)(blocks);
-                        (0, util_1.checkAbortSignal)(signal_1);
-                        return [4 /*yield*/, Promise.all(blockGroupsToFetch.map(function (blockGroup) { return __awaiter(_this, void 0, void 0, function () {
-                                var length, offset, data;
-                                var _this = this;
-                                return __generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0:
-                                            (0, util_1.checkAbortSignal)(signal_1);
-                                            length = blockGroup.length, offset = blockGroup.offset;
-                                            return [4 /*yield*/, this.featureCache.get("".concat(length, "_").concat(offset), blockGroup, signal_1)];
-                                        case 1:
-                                            data = _a.sent();
-                                            blockGroup.blocks.forEach(function (block) {
-                                                (0, util_1.checkAbortSignal)(signal_1);
-                                                var blockOffset = Number(block.offset) - Number(blockGroup.offset);
-                                                var resultData = data;
-                                                if (isCompressed_1) {
-                                                    resultData = (0, unzip_1.unzip)(data.subarray(blockOffset));
-                                                    blockOffset = 0;
-                                                }
-                                                (0, util_1.checkAbortSignal)(signal_1);
-                                                switch (blockType_1) {
-                                                    case 'summary':
-                                                        observer.next(_this.parseSummaryBlock(resultData, blockOffset, request_2));
-                                                        break;
-                                                    case 'bigwig':
-                                                        observer.next(_this.parseBigWigBlock(resultData, blockOffset, request_2));
-                                                        break;
-                                                    case 'bigbed':
-                                                        observer.next(_this.parseBigBedBlock(resultData, blockOffset, Number(block.offset) * (1 << 8), request_2));
-                                                        break;
-                                                    default:
-                                                        console.warn("Don't know what to do with ".concat(blockType_1));
-                                                }
-                                            });
-                                            return [2 /*return*/];
-                                    }
-                                });
-                            }); }))];
-                    case 1:
-                        _b.sent();
-                        observer.complete();
-                        return [3 /*break*/, 3];
-                    case 2:
-                        e_3 = _b.sent();
-                        observer.error(e_3);
-                        return [3 /*break*/, 3];
-                    case 3: return [2 /*return*/];
-                }
-            });
+    }
+    readFeatures(observer, blocks, opts = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { blockType, isCompressed } = this;
+                const { signal, request } = opts;
+                const blockGroupsToFetch = (0, util_1.groupBlocks)(blocks);
+                (0, util_1.checkAbortSignal)(signal);
+                yield Promise.all(blockGroupsToFetch.map((blockGroup) => __awaiter(this, void 0, void 0, function* () {
+                    (0, util_1.checkAbortSignal)(signal);
+                    const { length, offset } = blockGroup;
+                    const data = yield this.featureCache.get(`${length}_${offset}`, blockGroup, signal);
+                    blockGroup.blocks.forEach(block => {
+                        (0, util_1.checkAbortSignal)(signal);
+                        let blockOffset = Number(block.offset) - Number(blockGroup.offset);
+                        let resultData = data;
+                        if (isCompressed) {
+                            resultData = (0, unzip_1.unzip)(data.subarray(blockOffset));
+                            blockOffset = 0;
+                        }
+                        (0, util_1.checkAbortSignal)(signal);
+                        switch (blockType) {
+                            case 'summary':
+                                observer.next(this.parseSummaryBlock(resultData, blockOffset, request));
+                                break;
+                            case 'bigwig':
+                                observer.next(this.parseBigWigBlock(resultData, blockOffset, request));
+                                break;
+                            case 'bigbed':
+                                observer.next(this.parseBigBedBlock(resultData, blockOffset, Number(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 BlockView;
-}());
+    }
+}
 exports.BlockView = BlockView;
 //# sourceMappingURL=blockView.js.map