@gmod/bam 1.1.16 → 1.1.18

package/dist/bamFile.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,33 +8,6 @@ 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 __asyncValues = (this && this.__asyncValues) || function (o) {
     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
     var m = o[Symbol.asyncIterator], i;
@@ -70,84 +32,57 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar
     function reject(value) { resume("throw", value); }
     function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
 };
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BAM_MAGIC = void 0;
-var buffer_crc32_1 = __importDefault(require("buffer-crc32"));
-var bgzf_filehandle_1 = require("@gmod/bgzf-filehandle");
-var object_entries_ponyfill_1 = __importDefault(require("object.entries-ponyfill"));
-var generic_filehandle_1 = require("generic-filehandle");
-var abortable_promise_cache_1 = __importDefault(require("abortable-promise-cache"));
-var quick_lru_1 = __importDefault(require("quick-lru"));
+const buffer_crc32_1 = __importDefault(require("buffer-crc32"));
+const bgzf_filehandle_1 = require("@gmod/bgzf-filehandle");
+const object_entries_ponyfill_1 = __importDefault(require("object.entries-ponyfill"));
+const generic_filehandle_1 = require("generic-filehandle");
+const abortable_promise_cache_1 = __importDefault(require("abortable-promise-cache"));
+const quick_lru_1 = __importDefault(require("quick-lru"));
 //locals
-var bai_1 = __importDefault(require("./bai"));
-var csi_1 = __importDefault(require("./csi"));
-var record_1 = __importDefault(require("./record"));
-var sam_1 = require("./sam");
-var util_1 = require("./util");
+const bai_1 = __importDefault(require("./bai"));
+const csi_1 = __importDefault(require("./csi"));
+const record_1 = __importDefault(require("./record"));
+const sam_1 = require("./sam");
+const util_1 = require("./util");
 exports.BAM_MAGIC = 21840194;
-var blockLen = 1 << 16;
+const blockLen = 1 << 16;
 function flat(arr) {
-    var _a;
-    return (_a = []).concat.apply(_a, arr);
+    return [].concat(...arr);
 }
 function gen2array(gen) {
-    var gen_1, gen_1_1;
-    var e_1, _a;
-    return __awaiter(this, void 0, void 0, function () {
-        var out, x, e_1_1;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    out = [];
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 6, 7, 12]);
-                    gen_1 = __asyncValues(gen);
-                    _b.label = 2;
-                case 2: return [4 /*yield*/, gen_1.next()];
-                case 3:
-                    if (!(gen_1_1 = _b.sent(), !gen_1_1.done)) return [3 /*break*/, 5];
-                    x = gen_1_1.value;
+    var _a, gen_1, gen_1_1;
+    var _b, e_1, _c, _d;
+    return __awaiter(this, void 0, void 0, function* () {
+        const out = [];
+        try {
+            for (_a = true, gen_1 = __asyncValues(gen); gen_1_1 = yield gen_1.next(), _b = gen_1_1.done, !_b;) {
+                _d = gen_1_1.value;
+                _a = false;
+                try {
+                    const x = _d;
                     out.push(x);
-                    _b.label = 4;
-                case 4: return [3 /*break*/, 2];
-                case 5: return [3 /*break*/, 12];
-                case 6:
-                    e_1_1 = _b.sent();
-                    e_1 = { error: e_1_1 };
-                    return [3 /*break*/, 12];
-                case 7:
-                    _b.trys.push([7, , 10, 11]);
-                    if (!(gen_1_1 && !gen_1_1.done && (_a = gen_1.return))) return [3 /*break*/, 9];
-                    return [4 /*yield*/, _a.call(gen_1)];
-                case 8:
-                    _b.sent();
-                    _b.label = 9;
-                case 9: return [3 /*break*/, 11];
-                case 10:
-                    if (e_1) throw e_1.error;
-                    return [7 /*endfinally*/];
-                case 11: return [7 /*endfinally*/];
-                case 12: return [2 /*return*/, out];
+                }
+                finally {
+                    _a = true;
+                }
             }
-        });
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_a && !_b && (_c = gen_1.return)) yield _c.call(gen_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return out;
     });
 }
-var BamFile = /** @class */ (function () {
+class BamFile {
     /**
      * @param {object} args
      * @param {string} [args.bamPath]
@@ -155,35 +90,21 @@ var BamFile = /** @class */ (function () {
      * @param {string} [args.baiPath]
      * @param {FileHandle} [args.baiFilehandle]
      */
-    function BamFile(_a) {
-        var bamFilehandle = _a.bamFilehandle, bamPath = _a.bamPath, bamUrl = _a.bamUrl, baiPath = _a.baiPath, baiFilehandle = _a.baiFilehandle, baiUrl = _a.baiUrl, csiPath = _a.csiPath, csiFilehandle = _a.csiFilehandle, csiUrl = _a.csiUrl, fetchSizeLimit = _a.fetchSizeLimit, chunkSizeLimit = _a.chunkSizeLimit, _b = _a.yieldThreadTime, yieldThreadTime = _b === void 0 ? 100 : _b, _c = _a.renameRefSeqs, renameRefSeqs = _c === void 0 ? function (n) { return n; } : _c;
-        var _this = this;
+    constructor({ bamFilehandle, bamPath, bamUrl, baiPath, baiFilehandle, baiUrl, csiPath, csiFilehandle, csiUrl, fetchSizeLimit, chunkSizeLimit, yieldThreadTime = 100, renameRefSeqs = n => n, }) {
         this.featureCache = new abortable_promise_cache_1.default({
             //@ts-ignore
             cache: new quick_lru_1.default({
                 maxSize: 50,
             }),
             //@ts-ignore
-            fill: function (_a, signal) {
-                var chunk = _a.chunk, opts = _a.opts;
-                return __awaiter(_this, void 0, void 0, function () {
-                    var _b, data, cpositions, dpositions, feats;
-                    return __generator(this, function (_c) {
-                        switch (_c.label) {
-                            case 0: return [4 /*yield*/, this._readChunk({
-                                    chunk: chunk,
-                                    opts: __assign(__assign({}, opts), { signal: signal }),
-                                })];
-                            case 1:
-                                _b = _c.sent(), data = _b.data, cpositions = _b.cpositions, dpositions = _b.dpositions;
-                                return [4 /*yield*/, this.readBamFeatures(data, cpositions, dpositions, chunk)];
-                            case 2:
-                                feats = _c.sent();
-                                return [2 /*return*/, feats];
-                        }
-                    });
+            fill: ({ chunk, opts }, signal) => __awaiter(this, void 0, void 0, function* () {
+                const { data, cpositions, dpositions } = yield this._readChunk({
+                    chunk,
+                    opts: Object.assign(Object.assign({}, opts), { signal }),
                 });
-            },
+                const feats = yield this.readBamFeatures(data, cpositions, dpositions, chunk);
+                return feats;
+            }),
         });
         this.renameRefSeq = renameRefSeqs;
         if (bamFilehandle) {
@@ -217,10 +138,10 @@ var BamFile = /** @class */ (function () {
             this.index = new bai_1.default({ filehandle: new generic_filehandle_1.RemoteFile(baiUrl) });
         }
         else if (bamPath) {
-            this.index = new bai_1.default({ filehandle: new generic_filehandle_1.LocalFile("".concat(bamPath, ".bai")) });
+            this.index = new bai_1.default({ filehandle: new generic_filehandle_1.LocalFile(`${bamPath}.bai`) });
         }
         else if (bamUrl) {
-            this.index = new bai_1.default({ filehandle: new generic_filehandle_1.RemoteFile("".concat(bamUrl, ".bai")) });
+            this.index = new bai_1.default({ filehandle: new generic_filehandle_1.RemoteFile(`${bamUrl}.bai`) });
         }
         else {
             throw new Error('unable to infer index format');
@@ -229,461 +150,315 @@ var BamFile = /** @class */ (function () {
         this.chunkSizeLimit = chunkSizeLimit || 300000000; // 300MB
         this.yieldThreadTime = yieldThreadTime;
     }
-    BamFile.prototype.getHeader = function (origOpts) {
-        if (origOpts === void 0) { origOpts = {}; }
-        return __awaiter(this, void 0, void 0, function () {
-            var opts, indexData, ret, buffer, res, bytesRead, uncba, headLen, _a, chrToIndex, indexToChr;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        opts = (0, util_1.makeOpts)(origOpts);
-                        return [4 /*yield*/, this.index.parse(opts)];
-                    case 1:
-                        indexData = _b.sent();
-                        ret = indexData.firstDataLine
-                            ? indexData.firstDataLine.blockPosition + 65535
-                            : undefined;
-                        if (!ret) return [3 /*break*/, 3];
-                        return [4 /*yield*/, this.bam.read(Buffer.alloc(ret + blockLen), 0, ret + blockLen, 0, opts)];
-                    case 2:
-                        res = _b.sent();
-                        bytesRead = res.bytesRead;
-                        (buffer = res.buffer);
-                        if (!bytesRead) {
-                            throw new Error('Error reading header');
-                        }
-                        if (bytesRead < ret) {
-                            buffer = buffer.subarray(0, bytesRead);
-                        }
-                        else {
-                            buffer = buffer.subarray(0, ret);
-                        }
-                        return [3 /*break*/, 5];
-                    case 3: return [4 /*yield*/, this.bam.readFile(opts)];
-                    case 4:
-                        buffer = (_b.sent());
-                        _b.label = 5;
-                    case 5: return [4 /*yield*/, (0, bgzf_filehandle_1.unzip)(buffer)];
-                    case 6:
-                        uncba = _b.sent();
-                        if (uncba.readInt32LE(0) !== exports.BAM_MAGIC) {
-                            throw new Error('Not a BAM file');
-                        }
-                        headLen = uncba.readInt32LE(4);
-                        this.header = uncba.toString('utf8', 8, 8 + headLen);
-                        return [4 /*yield*/, this._readRefSeqs(headLen + 8, 65535, opts)];
-                    case 7:
-                        _a = _b.sent(), chrToIndex = _a.chrToIndex, indexToChr = _a.indexToChr;
-                        this.chrToIndex = chrToIndex;
-                        this.indexToChr = indexToChr;
-                        return [2 /*return*/, (0, sam_1.parseHeaderText)(this.header)];
+    getHeader(origOpts = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const opts = (0, util_1.makeOpts)(origOpts);
+            const indexData = yield this.index.parse(opts);
+            const ret = indexData.firstDataLine
+                ? indexData.firstDataLine.blockPosition + 65535
+                : undefined;
+            let buffer;
+            if (ret) {
+                const res = yield this.bam.read(Buffer.alloc(ret + blockLen), 0, ret + blockLen, 0, opts);
+                const { bytesRead } = res;
+                ({ buffer } = res);
+                if (!bytesRead) {
+                    throw new Error('Error reading header');
                 }
-            });
-        });
-    };
-    BamFile.prototype.getHeaderText = function (opts) {
-        if (opts === void 0) { opts = {}; }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getHeader(opts)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/, this.header];
+                if (bytesRead < ret) {
+                    buffer = buffer.subarray(0, bytesRead);
                 }
-            });
+                else {
+                    buffer = buffer.subarray(0, ret);
+                }
+            }
+            else {
+                buffer = (yield this.bam.readFile(opts));
+            }
+            const uncba = yield (0, bgzf_filehandle_1.unzip)(buffer);
+            if (uncba.readInt32LE(0) !== exports.BAM_MAGIC) {
+                throw new Error('Not a BAM file');
+            }
+            const headLen = uncba.readInt32LE(4);
+            this.header = uncba.toString('utf8', 8, 8 + headLen);
+            const { chrToIndex, indexToChr } = yield this._readRefSeqs(headLen + 8, 65535, opts);
+            this.chrToIndex = chrToIndex;
+            this.indexToChr = indexToChr;
+            return (0, sam_1.parseHeaderText)(this.header);
         });
-    };
+    }
+    getHeaderText(opts = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.getHeader(opts);
+            return this.header;
+        });
+    }
     // the full length of the refseq block is not given in advance so this grabs
     // a chunk and doubles it if all refseqs haven't been processed
-    BamFile.prototype._readRefSeqs = function (start, refSeqBytes, opts) {
-        if (opts === void 0) { opts = {}; }
-        return __awaiter(this, void 0, void 0, function () {
-            var size, _a, bytesRead, buffer, uncba, nRef, p, chrToIndex, indexToChr, i, lName, refName, lRef;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (start > refSeqBytes) {
-                            return [2 /*return*/, this._readRefSeqs(start, refSeqBytes * 2, opts)];
-                        }
-                        size = refSeqBytes + blockLen;
-                        return [4 /*yield*/, this.bam.read(Buffer.alloc(size), 0, refSeqBytes, 0, opts)];
-                    case 1:
-                        _a = _b.sent(), bytesRead = _a.bytesRead, buffer = _a.buffer;
-                        if (!bytesRead) {
-                            throw new Error('Error reading refseqs from header');
-                        }
-                        return [4 /*yield*/, (0, bgzf_filehandle_1.unzip)(buffer.subarray(0, Math.min(bytesRead, refSeqBytes)))];
-                    case 2:
-                        uncba = _b.sent();
-                        nRef = uncba.readInt32LE(start);
-                        p = start + 4;
-                        chrToIndex = {};
-                        indexToChr = [];
-                        for (i = 0; i < nRef; i += 1) {
-                            lName = uncba.readInt32LE(p);
-                            refName = this.renameRefSeq(uncba.toString('utf8', p + 4, p + 4 + lName - 1));
-                            lRef = uncba.readInt32LE(p + lName + 4);
-                            chrToIndex[refName] = i;
-                            indexToChr.push({ refName: refName, length: lRef });
-                            p = p + 8 + lName;
-                            if (p > uncba.length) {
-                                console.warn("BAM header is very big.  Re-fetching ".concat(refSeqBytes, " bytes."));
-                                return [2 /*return*/, this._readRefSeqs(start, refSeqBytes * 2, opts)];
-                            }
-                        }
-                        return [2 /*return*/, { chrToIndex: chrToIndex, indexToChr: indexToChr }];
+    _readRefSeqs(start, refSeqBytes, opts = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (start > refSeqBytes) {
+                return this._readRefSeqs(start, refSeqBytes * 2, opts);
+            }
+            const size = refSeqBytes + blockLen;
+            const { bytesRead, buffer } = yield this.bam.read(Buffer.alloc(size), 0, refSeqBytes, 0, opts);
+            if (!bytesRead) {
+                throw new Error('Error reading refseqs from header');
+            }
+            const uncba = yield (0, bgzf_filehandle_1.unzip)(buffer.subarray(0, Math.min(bytesRead, refSeqBytes)));
+            const nRef = uncba.readInt32LE(start);
+            let p = start + 4;
+            const chrToIndex = {};
+            const indexToChr = [];
+            for (let i = 0; i < nRef; i += 1) {
+                const lName = uncba.readInt32LE(p);
+                const refName = this.renameRefSeq(uncba.toString('utf8', p + 4, p + 4 + lName - 1));
+                const lRef = uncba.readInt32LE(p + lName + 4);
+                chrToIndex[refName] = i;
+                indexToChr.push({ refName, length: lRef });
+                p = p + 8 + lName;
+                if (p > uncba.length) {
+                    console.warn(`BAM header is very big.  Re-fetching ${refSeqBytes} bytes.`);
+                    return this._readRefSeqs(start, refSeqBytes * 2, opts);
                 }
-            });
+            }
+            return { chrToIndex, indexToChr };
         });
-    };
-    BamFile.prototype.getRecordsForRange = function (chr, min, max, opts) {
-        if (opts === void 0) { opts = {
-            viewAsPairs: false,
-            pairAcrossChr: false,
-            maxInsertSize: 200000,
-        }; }
-        return __awaiter(this, void 0, void 0, function () {
-            var _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _a = flat;
-                        return [4 /*yield*/, gen2array(this.streamRecordsForRange(chr, min, max, opts))];
-                    case 1: return [2 /*return*/, _a.apply(void 0, [_b.sent()])];
-                }
-            });
+    }
+    getRecordsForRange(chr, min, max, opts = {
+        viewAsPairs: false,
+        pairAcrossChr: false,
+        maxInsertSize: 200000,
+    }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return flat(yield gen2array(this.streamRecordsForRange(chr, min, max, opts)));
         });
-    };
-    BamFile.prototype.streamRecordsForRange = function (chr, min, max, opts) {
-        if (opts === void 0) { opts = {}; }
-        return __asyncGenerator(this, arguments, function streamRecordsForRange_1() {
-            var signal, chrId, chunks, i, size, totalSize;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        signal = opts.signal;
-                        chrId = this.chrToIndex && this.chrToIndex[chr];
-                        if (!!(chrId >= 0)) return [3 /*break*/, 1];
-                        chunks = [];
-                        return [3 /*break*/, 3];
-                    case 1: return [4 /*yield*/, __await(this.index.blocksForRange(chrId, min - 1, max, opts))];
-                    case 2:
-                        chunks = _a.sent();
-                        if (!chunks) {
-                            throw new Error('Error in index fetch');
-                        }
-                        _a.label = 3;
-                    case 3:
-                        i = 0;
-                        _a.label = 4;
-                    case 4:
-                        if (!(i < chunks.length)) return [3 /*break*/, 7];
-                        return [4 /*yield*/, __await((0, util_1.abortBreakPoint)(signal))];
-                    case 5:
-                        _a.sent();
-                        size = chunks[i].fetchedSize();
-                        if (size > this.chunkSizeLimit) {
-                            throw new Error("Too many BAM features. BAM chunk size ".concat(size, " bytes exceeds chunkSizeLimit of ").concat(this.chunkSizeLimit));
-                        }
-                        _a.label = 6;
-                    case 6:
-                        i += 1;
-                        return [3 /*break*/, 4];
-                    case 7:
-                        totalSize = chunks
-                            .map(function (s) { return s.fetchedSize(); })
-                            .reduce(function (a, b) { return a + b; }, 0);
-                        if (totalSize > this.fetchSizeLimit) {
-                            throw new Error("data size of ".concat(totalSize.toLocaleString(), " bytes exceeded fetch size limit of ").concat(this.fetchSizeLimit.toLocaleString(), " bytes"));
-                        }
-                        return [5 /*yield**/, __values(__asyncDelegator(__asyncValues(this._fetchChunkFeatures(chunks, chrId, min, max, opts))))];
-                    case 8: return [4 /*yield*/, __await.apply(void 0, [_a.sent()])];
-                    case 9:
-                        _a.sent();
-                        return [2 /*return*/];
+    }
+    streamRecordsForRange(chr, min, max, opts = {}) {
+        return __asyncGenerator(this, arguments, function* streamRecordsForRange_1() {
+            const { signal } = opts;
+            const chrId = this.chrToIndex && this.chrToIndex[chr];
+            let chunks;
+            if (!(chrId >= 0)) {
+                chunks = [];
+            }
+            else {
+                chunks = yield __await(this.index.blocksForRange(chrId, min - 1, max, opts));
+                if (!chunks) {
+                    throw new Error('Error in index fetch');
                 }
-            });
+            }
+            for (let i = 0; i < chunks.length; i += 1) {
+                yield __await((0, util_1.abortBreakPoint)(signal));
+                const size = chunks[i].fetchedSize();
+                if (size > this.chunkSizeLimit) {
+                    throw new Error(`Too many BAM features. BAM chunk size ${size} bytes exceeds chunkSizeLimit of ${this.chunkSizeLimit}`);
+                }
+            }
+            const totalSize = chunks
+                .map(s => s.fetchedSize())
+                .reduce((a, b) => a + b, 0);
+            if (totalSize > this.fetchSizeLimit) {
+                throw new Error(`data size of ${totalSize.toLocaleString()} bytes exceeded fetch size limit of ${this.fetchSizeLimit.toLocaleString()} bytes`);
+            }
+            yield __await(yield* __asyncDelegator(__asyncValues(this._fetchChunkFeatures(chunks, chrId, min, max, opts))));
         });
-    };
-    BamFile.prototype._fetchChunkFeatures = function (chunks, chrId, min, max, opts) {
-        return __asyncGenerator(this, arguments, function _fetchChunkFeatures_1() {
-            var _a, viewAsPairs, feats, done, i, c, records, recs, i_1, feature;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _a = opts.viewAsPairs, viewAsPairs = _a === void 0 ? false : _a;
-                        feats = [];
-                        done = false;
-                        i = 0;
-                        _b.label = 1;
-                    case 1:
-                        if (!(i < chunks.length)) return [3 /*break*/, 6];
-                        c = chunks[i];
-                        return [4 /*yield*/, __await(this.featureCache.get(c.toString(), {
-                                chunk: c,
-                                opts: opts,
-                            }, opts.signal))];
-                    case 2:
-                        records = (_b.sent());
-                        recs = [];
-                        for (i_1 = 0; i_1 < records.length; i_1 += 1) {
-                            feature = records[i_1];
-                            if (feature.seq_id() === chrId) {
-                                if (feature.get('start') >= max) {
-                                    // past end of range, can stop iterating
-                                    done = true;
-                                    break;
-                                }
-                                else if (feature.get('end') >= min) {
-                                    // must be in range
-                                    recs.push(feature);
-                                }
-                            }
+    }
+    _fetchChunkFeatures(chunks, chrId, min, max, opts) {
+        return __asyncGenerator(this, arguments, function* _fetchChunkFeatures_1() {
+            const { viewAsPairs = false } = opts;
+            const feats = [];
+            let done = false;
+            for (let i = 0; i < chunks.length; i++) {
+                const c = chunks[i];
+                const records = (yield __await(this.featureCache.get(c.toString(), {
+                    chunk: c,
+                    opts,
+                }, opts.signal)));
+                const recs = [];
+                for (let i = 0; i < records.length; i += 1) {
+                    const feature = records[i];
+                    if (feature.seq_id() === chrId) {
+                        if (feature.get('start') >= max) {
+                            // past end of range, can stop iterating
+                            done = true;
+                            break;
                         }
-                        feats.push(recs);
-                        return [4 /*yield*/, __await(recs)];
-                    case 3: return [4 /*yield*/, _b.sent()];
-                    case 4:
-                        _b.sent();
-                        if (done) {
-                            return [3 /*break*/, 6];
+                        else if (feature.get('end') >= min) {
+                            // must be in range
+                            recs.push(feature);
                         }
-                        _b.label = 5;
-                    case 5:
-                        i++;
-                        return [3 /*break*/, 1];
-                    case 6:
-                        (0, util_1.checkAbortSignal)(opts.signal);
-                        if (!viewAsPairs) return [3 /*break*/, 9];
-                        return [4 /*yield*/, __await(this.fetchPairs(chrId, feats, opts))];
-                    case 7: return [4 /*yield*/, _b.sent()];
-                    case 8:
-                        _b.sent();
-                        _b.label = 9;
-                    case 9: return [2 /*return*/];
+                    }
                 }
-            });
+                feats.push(recs);
+                yield yield __await(recs);
+                if (done) {
+                    break;
+                }
+            }
+            (0, util_1.checkAbortSignal)(opts.signal);
+            if (viewAsPairs) {
+                yield yield __await(this.fetchPairs(chrId, feats, opts));
+            }
         });
-    };
-    BamFile.prototype.fetchPairs = function (chrId, feats, opts) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, pairAcrossChr, _b, maxInsertSize, unmatedPairs, readIds, matePromises, mateChunks, _c, mateTotalSize, mateFeatPromises, _d;
-            var _this = this;
-            return __generator(this, function (_e) {
-                switch (_e.label) {
-                    case 0:
-                        _a = opts.pairAcrossChr, pairAcrossChr = _a === void 0 ? false : _a, _b = opts.maxInsertSize, maxInsertSize = _b === void 0 ? 200000 : _b;
-                        unmatedPairs = {};
-                        readIds = {};
-                        feats.map(function (ret) {
-                            var readNames = {};
-                            for (var i = 0; i < ret.length; i++) {
-                                var name_1 = ret[i].name();
-                                var id = ret[i].id();
-                                if (!readNames[name_1]) {
-                                    readNames[name_1] = 0;
-                                }
-                                readNames[name_1]++;
-                                readIds[id] = 1;
-                            }
-                            (0, object_entries_ponyfill_1.default)(readNames).forEach(function (_a) {
-                                var k = _a[0], v = _a[1];
-                                if (v === 1) {
-                                    unmatedPairs[k] = true;
-                                }
-                            });
-                        });
-                        matePromises = [];
-                        feats.map(function (ret) {
-                            for (var i = 0; i < ret.length; i++) {
-                                var f = ret[i];
-                                var name_2 = f.name();
-                                var start = f.get('start');
-                                var pnext = f._next_pos();
-                                var rnext = f._next_refid();
-                                if (unmatedPairs[name_2] &&
-                                    (pairAcrossChr ||
-                                        (rnext === chrId && Math.abs(start - pnext) < maxInsertSize))) {
-                                    matePromises.push(_this.index.blocksForRange(rnext, pnext, pnext + 1, opts));
-                                }
-                            }
-                        });
-                        _c = flat;
-                        return [4 /*yield*/, Promise.all(matePromises)];
-                    case 1:
-                        mateChunks = _c.apply(void 0, [_e.sent()])
-                            .sort()
-                            .filter(function (item, pos, ary) { return !pos || item.toString() !== ary[pos - 1].toString(); });
-                        mateTotalSize = mateChunks
-                            .map(function (s) { return s.fetchedSize(); })
-                            .reduce(function (a, b) { return a + b; }, 0);
-                        if (mateTotalSize > this.fetchSizeLimit) {
-                            throw new Error("data size of ".concat(mateTotalSize.toLocaleString(), " bytes exceeded fetch size limit of ").concat(this.fetchSizeLimit.toLocaleString(), " bytes"));
-                        }
-                        mateFeatPromises = mateChunks.map(function (c) { return __awaiter(_this, void 0, void 0, function () {
-                            var _a, data, cpositions, dpositions, chunk, feats, mateRecs, i, feature;
-                            return __generator(this, function (_b) {
-                                switch (_b.label) {
-                                    case 0: return [4 /*yield*/, this._readChunk({
-                                            chunk: c,
-                                            opts: opts,
-                                        })];
-                                    case 1:
-                                        _a = _b.sent(), data = _a.data, cpositions = _a.cpositions, dpositions = _a.dpositions, chunk = _a.chunk;
-                                        return [4 /*yield*/, this.readBamFeatures(data, cpositions, dpositions, chunk)];
-                                    case 2:
-                                        feats = _b.sent();
-                                        mateRecs = [];
-                                        for (i = 0; i < feats.length; i += 1) {
-                                            feature = feats[i];
-                                            if (unmatedPairs[feature.get('name')] && !readIds[feature.id()]) {
-                                                mateRecs.push(feature);
-                                            }
-                                        }
-                                        return [2 /*return*/, mateRecs];
-                                }
-                            });
-                        }); });
-                        _d = flat;
-                        return [4 /*yield*/, Promise.all(mateFeatPromises)];
-                    case 2: return [2 /*return*/, _d.apply(void 0, [_e.sent()])];
+    }
+    fetchPairs(chrId, feats, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { pairAcrossChr = false, maxInsertSize = 200000 } = opts;
+            const unmatedPairs = {};
+            const readIds = {};
+            feats.map(ret => {
+                const readNames = {};
+                for (let i = 0; i < ret.length; i++) {
+                    const name = ret[i].name();
+                    const id = ret[i].id();
+                    if (!readNames[name]) {
+                        readNames[name] = 0;
+                    }
+                    readNames[name]++;
+                    readIds[id] = 1;
                 }
+                (0, object_entries_ponyfill_1.default)(readNames).forEach(([k, v]) => {
+                    if (v === 1) {
+                        unmatedPairs[k] = true;
+                    }
+                });
             });
-        });
-    };
-    BamFile.prototype._readChunk = function (_a) {
-        var chunk = _a.chunk, opts = _a.opts;
-        return __awaiter(this, void 0, void 0, function () {
-            var size, _b, buffer, bytesRead, _c, data, cpositions, dpositions;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        size = chunk.fetchedSize();
-                        return [4 /*yield*/, this.bam.read(Buffer.alloc(size), 0, size, chunk.minv.blockPosition, opts)];
-                    case 1:
-                        _b = _d.sent(), buffer = _b.buffer, bytesRead = _b.bytesRead;
-                        return [4 /*yield*/, (0, bgzf_filehandle_1.unzipChunkSlice)(buffer.subarray(0, Math.min(bytesRead, size)), chunk)];
-                    case 2:
-                        _c = _d.sent(), data = _c.buffer, cpositions = _c.cpositions, dpositions = _c.dpositions;
-                        return [2 /*return*/, { data: data, cpositions: cpositions, dpositions: dpositions, chunk: chunk }];
+            const matePromises = [];
+            feats.map(ret => {
+                for (let i = 0; i < ret.length; i++) {
+                    const f = ret[i];
+                    const name = f.name();
+                    const start = f.get('start');
+                    const pnext = f._next_pos();
+                    const rnext = f._next_refid();
+                    if (unmatedPairs[name] &&
+                        (pairAcrossChr ||
+                            (rnext === chrId && Math.abs(start - pnext) < maxInsertSize))) {
+                        matePromises.push(this.index.blocksForRange(rnext, pnext, pnext + 1, opts));
+                    }
                 }
             });
+            // filter out duplicate chunks (the blocks are lists of chunks, blocks are
+            // concatenated, then filter dup chunks)
+            const mateChunks = flat(yield Promise.all(matePromises))
+                .sort()
+                .filter((item, pos, ary) => !pos || item.toString() !== ary[pos - 1].toString());
+            const mateTotalSize = mateChunks
+                .map(s => s.fetchedSize())
+                .reduce((a, b) => a + b, 0);
+            if (mateTotalSize > this.fetchSizeLimit) {
+                throw new Error(`data size of ${mateTotalSize.toLocaleString()} bytes exceeded fetch size limit of ${this.fetchSizeLimit.toLocaleString()} bytes`);
+            }
+            const mateFeatPromises = mateChunks.map((c) => __awaiter(this, void 0, void 0, function* () {
+                const { data, cpositions, dpositions, chunk } = yield this._readChunk({
+                    chunk: c,
+                    opts,
+                });
+                const feats = yield this.readBamFeatures(data, cpositions, dpositions, chunk);
+                const mateRecs = [];
+                for (let i = 0; i < feats.length; i += 1) {
+                    const feature = feats[i];
+                    if (unmatedPairs[feature.get('name')] && !readIds[feature.id()]) {
+                        mateRecs.push(feature);
+                    }
+                }
+                return mateRecs;
+            }));
+            return flat(yield Promise.all(mateFeatPromises));
         });
-    };
-    BamFile.prototype.readBamFeatures = function (ba, cpositions, dpositions, chunk) {
-        return __awaiter(this, void 0, void 0, function () {
-            var blockStart, sink, pos, last, blockSize, blockEnd, feature;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        blockStart = 0;
-                        sink = [];
-                        pos = 0;
-                        last = +Date.now();
-                        _a.label = 1;
-                    case 1:
-                        if (!(blockStart + 4 < ba.length)) return [3 /*break*/, 4];
-                        blockSize = ba.readInt32LE(blockStart);
-                        blockEnd = blockStart + 4 + blockSize - 1;
-                        // increment position to the current decompressed status
-                        if (dpositions) {
-                            while (blockStart + chunk.minv.dataPosition >= dpositions[pos++]) { }
-                            pos--;
-                        }
-                        if (!(blockEnd < ba.length)) return [3 /*break*/, 3];
-                        feature = new record_1.default({
-                            bytes: {
-                                byteArray: ba,
-                                start: blockStart,
-                                end: blockEnd,
-                            },
-                            // the below results in an automatically calculated file-offset based ID
-                            // if the info for that is available, otherwise crc32 of the features
-                            //
-                            // cpositions[pos] refers to actual file offset of a bgzip block boundaries
-                            //
-                            // we multiply by (1 <<8) in order to make sure each block has a "unique"
-                            // address space so that data in that block could never overlap
-                            //
-                            // then the blockStart-dpositions is an uncompressed file offset from
-                            // that bgzip block boundary, and since the cpositions are multiplied by
-                            // (1 << 8) these uncompressed offsets get a unique space
-                            //
-                            // this has an extra chunk.minv.dataPosition added on because it blockStart
-                            // starts at 0 instead of chunk.minv.dataPosition
-                            //
-                            // the +1 is just to avoid any possible uniqueId 0 but this does not realistically happen
-                            fileOffset: cpositions
-                                ? cpositions[pos] * (1 << 8) +
-                                    (blockStart - dpositions[pos]) +
-                                    chunk.minv.dataPosition +
-                                    1
-                                : // must be slice, not subarray for buffer polyfill on web
-                                    buffer_crc32_1.default.signed(ba.slice(blockStart, blockEnd)),
-                        });
-                        sink.push(feature);
-                        if (!(this.yieldThreadTime && +Date.now() - last > this.yieldThreadTime)) return [3 /*break*/, 3];
-                        return [4 /*yield*/, (0, util_1.timeout)(1)];
-                    case 2:
-                        _a.sent();
+    }
+    _readChunk({ chunk, opts }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const size = chunk.fetchedSize();
+            const { buffer, bytesRead } = yield this.bam.read(Buffer.alloc(size), 0, size, chunk.minv.blockPosition, opts);
+            const { buffer: data, cpositions, dpositions, } = yield (0, bgzf_filehandle_1.unzipChunkSlice)(buffer.subarray(0, Math.min(bytesRead, size)), chunk);
+            return { data, cpositions, dpositions, chunk };
+        });
+    }
+    readBamFeatures(ba, cpositions, dpositions, chunk) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let blockStart = 0;
+            const sink = [];
+            let pos = 0;
+            let last = +Date.now();
+            while (blockStart + 4 < ba.length) {
+                const blockSize = ba.readInt32LE(blockStart);
+                const blockEnd = blockStart + 4 + blockSize - 1;
+                // increment position to the current decompressed status
+                if (dpositions) {
+                    while (blockStart + chunk.minv.dataPosition >= dpositions[pos++]) { }
+                    pos--;
+                }
+                // only try to read the feature if we have all the bytes for it
+                if (blockEnd < ba.length) {
+                    const feature = new record_1.default({
+                        bytes: {
+                            byteArray: ba,
+                            start: blockStart,
+                            end: blockEnd,
+                        },
+                        // the below results in an automatically calculated file-offset based ID
+                        // if the info for that is available, otherwise crc32 of the features
+                        //
+                        // cpositions[pos] refers to actual file offset of a bgzip block boundaries
+                        //
+                        // we multiply by (1 <<8) in order to make sure each block has a "unique"
+                        // address space so that data in that block could never overlap
+                        //
+                        // then the blockStart-dpositions is an uncompressed file offset from
+                        // that bgzip block boundary, and since the cpositions are multiplied by
+                        // (1 << 8) these uncompressed offsets get a unique space
+                        //
+                        // this has an extra chunk.minv.dataPosition added on because it blockStart
+                        // starts at 0 instead of chunk.minv.dataPosition
+                        //
+                        // the +1 is just to avoid any possible uniqueId 0 but this does not realistically happen
+                        fileOffset: cpositions
+                            ? cpositions[pos] * (1 << 8) +
+                                (blockStart - dpositions[pos]) +
+                                chunk.minv.dataPosition +
+                                1
+                            : // must be slice, not subarray for buffer polyfill on web
+                                buffer_crc32_1.default.signed(ba.slice(blockStart, blockEnd)),
+                    });
+                    sink.push(feature);
+                    if (this.yieldThreadTime && +Date.now() - last > this.yieldThreadTime) {
+                        yield (0, util_1.timeout)(1);
                         last = +Date.now();
-                        _a.label = 3;
-                    case 3:
-                        blockStart = blockEnd + 1;
-                        return [3 /*break*/, 1];
-                    case 4: return [2 /*return*/, sink];
+                    }
                 }
-            });
+                blockStart = blockEnd + 1;
+            }
+            return sink;
         });
-    };
-    BamFile.prototype.hasRefSeq = function (seqName) {
-        return __awaiter(this, void 0, void 0, function () {
-            var refId;
-            return __generator(this, function (_a) {
-                refId = this.chrToIndex && this.chrToIndex[seqName];
-                return [2 /*return*/, this.index.hasRefSeq(refId)];
-            });
+    }
+    hasRefSeq(seqName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const refId = this.chrToIndex && this.chrToIndex[seqName];
+            return this.index.hasRefSeq(refId);
         });
-    };
-    BamFile.prototype.lineCount = function (seqName) {
-        return __awaiter(this, void 0, void 0, function () {
-            var refId;
-            return __generator(this, function (_a) {
-                refId = this.chrToIndex && this.chrToIndex[seqName];
-                return [2 /*return*/, this.index.lineCount(refId)];
-            });
+    }
+    lineCount(seqName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const refId = this.chrToIndex && this.chrToIndex[seqName];
+            return this.index.lineCount(refId);
         });
-    };
-    BamFile.prototype.indexCov = function (seqName, start, end) {
-        return __awaiter(this, void 0, void 0, function () {
-            var seqId;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.index.parse()];
-                    case 1:
-                        _a.sent();
-                        seqId = this.chrToIndex && this.chrToIndex[seqName];
-                        return [2 /*return*/, this.index.indexCov(seqId, start, end)];
-                }
-            });
+    }
+    indexCov(seqName, start, end) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.index.parse();
+            const seqId = this.chrToIndex && this.chrToIndex[seqName];
+            return this.index.indexCov(seqId, start, end);
         });
-    };
-    BamFile.prototype.blocksForRange = function (seqName, start, end, opts) {
-        return __awaiter(this, void 0, void 0, function () {
-            var seqId;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.index.parse()];
-                    case 1:
-                        _a.sent();
-                        seqId = this.chrToIndex && this.chrToIndex[seqName];
-                        return [2 /*return*/, this.index.blocksForRange(seqId, start, end, opts)];
-                }
-            });
+    }
+    blocksForRange(seqName, start, end, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.index.parse();
+            const seqId = this.chrToIndex && this.chrToIndex[seqName];
+            return this.index.blocksForRange(seqId, start, end, opts);
         });
-    };
-    return BamFile;
-}());
+    }
+}
 exports.default = BamFile;
 //# sourceMappingURL=bamFile.js.map