@gmod/bam 1.1.13 → 1.1.16

package/CHANGELOG.md

@@ -1,7 +1,22 @@
-## [1.1.13](https://github.com/GMOD/bam-js/compare/v1.1.12...v1.1.13) (2022-02-25)
+## [1.1.16](https://github.com/GMOD/bam-js/compare/v1.1.15...v1.1.16) (2022-03-30)
+
+
+
+- Add src directory for better source maps
+
+## [1.1.15](https://github.com/GMOD/bam-js/compare/v1.1.14...v1.1.15) (2022-03-18)
 
 
 
+- Fix for htsget failing with message 'input must be buffer, number, or string, received object'
+- Speed improvement by caching chunks of features
+
+## [1.1.14](https://github.com/GMOD/bam-js/compare/v1.1.13...v1.1.14) (2022-03-14)
+
+- Fix seq function for corner case
+
+## [1.1.13](https://github.com/GMOD/bam-js/compare/v1.1.12...v1.1.13) (2022-02-25)
+
 - Optimize qual and sequence string record functions for less GC pressure
 
 <a name="1.1.12"></a>

package/dist/bamFile.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
-import Chunk from './chunk';
 import { GenericFilehandle } from 'generic-filehandle';
+import Chunk from './chunk';
 import BAMFeature from './record';
 import { BamOpts, BaseOpts } from './util';
 export declare const BAM_MAGIC = 21840194;
@@ -14,6 +14,7 @@ export default class BamFile {
     protected chrToIndex: any;
     protected indexToChr: any;
     private yieldThreadTime;
+    private featureCache;
     /**
      * @param {object} args
      * @param {string} [args.bamPath]
@@ -56,7 +57,7 @@ export default class BamFile {
     getRecordsForRange(chr: string, min: number, max: number, opts?: BamOpts): Promise<BAMFeature[]>;
     streamRecordsForRange(chr: string, min: number, max: number, opts?: BamOpts): AsyncGenerator<BAMFeature[], void, unknown>;
     _fetchChunkFeatures(chunks: Chunk[], chrId: number, min: number, max: number, opts: BamOpts): AsyncGenerator<BAMFeature[], void, unknown>;
-    fetchPairs(chrId: number, featPromises: Promise<BAMFeature[]>[], opts: BamOpts): Promise<BAMFeature[]>;
+    fetchPairs(chrId: number, feats: BAMFeature[][], opts: BamOpts): Promise<BAMFeature[]>;
     _readChunk({ chunk, opts }: {
         chunk: Chunk;
         opts: BaseOpts;

package/dist/bamFile.js

@@ -1,4 +1,15 @@
 "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) {
@@ -75,17 +86,67 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BAM_MAGIC = void 0;
-var bai_1 = __importDefault(require("./bai"));
-var csi_1 = __importDefault(require("./csi"));
 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"));
+//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");
 exports.BAM_MAGIC = 21840194;
 var blockLen = 1 << 16;
+function flat(arr) {
+    var _a;
+    return (_a = []).concat.apply(_a, 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;
+                    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];
+            }
+        });
+    });
+}
 var BamFile = /** @class */ (function () {
     /**
      * @param {object} args
@@ -96,6 +157,34 @@ var BamFile = /** @class */ (function () {
      */
     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;
+        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];
+                        }
+                    });
+                });
+            },
+        });
         this.renameRefSeq = renameRefSeqs;
         if (bamFilehandle) {
             this.bam = bamFilehandle;
@@ -205,108 +294,63 @@ var BamFile = /** @class */ (function () {
             });
         });
     };
-    // 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
+    // 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 res, bytesRead, buffer, uncba, nRef, p, chrToIndex, indexToChr, i, lName, refName, lRef;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+            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)];
                         }
-                        return [4 /*yield*/, this.bam.read(Buffer.alloc(refSeqBytes + blockLen), 0, refSeqBytes, 0, opts)];
+                        size = refSeqBytes + blockLen;
+                        return [4 /*yield*/, this.bam.read(Buffer.alloc(size), 0, refSeqBytes, 0, opts)];
                     case 1:
-                        res = _a.sent();
-                        bytesRead = res.bytesRead;
-                        buffer = res.buffer;
+                        _a = _b.sent(), bytesRead = _a.bytesRead, buffer = _a.buffer;
                         if (!bytesRead) {
                             throw new Error('Error reading refseqs from header');
                         }
-                        if (bytesRead < refSeqBytes) {
-                            buffer = buffer.subarray(0, bytesRead);
-                        }
-                        else {
-                            buffer = buffer.subarray(0, refSeqBytes);
-                        }
-                        return [4 /*yield*/, (0, bgzf_filehandle_1.unzip)(buffer)];
+                        return [4 /*yield*/, (0, bgzf_filehandle_1.unzip)(buffer.subarray(0, Math.min(bytesRead, refSeqBytes)))];
                     case 2:
-                        uncba = _a.sent();
+                        uncba = _b.sent();
                         nRef = uncba.readInt32LE(start);
                         p = start + 4;
                         chrToIndex = {};
                         indexToChr = [];
-                        i = 0;
-                        _a.label = 3;
-                    case 3:
-                        if (!(i < nRef)) return [3 /*break*/, 6];
-                        return [4 /*yield*/, (0, util_1.abortBreakPoint)(opts.signal)];
-                    case 4:
-                        _a.sent();
-                        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)];
+                        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)];
+                            }
                         }
-                        _a.label = 5;
-                    case 5:
-                        i += 1;
-                        return [3 /*break*/, 3];
-                    case 6: return [2 /*return*/, { chrToIndex: chrToIndex, indexToChr: indexToChr }];
+                        return [2 /*return*/, { chrToIndex: chrToIndex, indexToChr: indexToChr }];
                 }
             });
         });
     };
     BamFile.prototype.getRecordsForRange = function (chr, min, max, opts) {
-        var e_1, _a;
         if (opts === void 0) { opts = {
             viewAsPairs: false,
             pairAcrossChr: false,
             maxInsertSize: 200000,
         }; }
         return __awaiter(this, void 0, void 0, function () {
-            var records, _b, _c, chunk, e_1_1;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
                     case 0:
-                        records = [];
-                        _d.label = 1;
-                    case 1:
-                        _d.trys.push([1, 6, 7, 12]);
-                        _b = __asyncValues(this.streamRecordsForRange(chr, min, max, opts));
-                        _d.label = 2;
-                    case 2: return [4 /*yield*/, _b.next()];
-                    case 3:
-                        if (!(_c = _d.sent(), !_c.done)) return [3 /*break*/, 5];
-                        chunk = _c.value;
-                        records = records.concat(chunk);
-                        _d.label = 4;
-                    case 4: return [3 /*break*/, 2];
-                    case 5: return [3 /*break*/, 12];
-                    case 6:
-                        e_1_1 = _d.sent();
-                        e_1 = { error: e_1_1 };
-                        return [3 /*break*/, 12];
-                    case 7:
-                        _d.trys.push([7, , 10, 11]);
-                        if (!(_c && !_c.done && (_a = _b.return))) return [3 /*break*/, 9];
-                        return [4 /*yield*/, _a.call(_b)];
-                    case 8:
-                        _d.sent();
-                        _d.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*/, records];
+                        _a = flat;
+                        return [4 /*yield*/, gen2array(this.streamRecordsForRange(chr, min, max, opts))];
+                    case 1: return [2 /*return*/, _a.apply(void 0, [_b.sent()])];
                 }
             });
         });
@@ -364,152 +408,111 @@ var BamFile = /** @class */ (function () {
     };
     BamFile.prototype._fetchChunkFeatures = function (chunks, chrId, min, max, opts) {
         return __asyncGenerator(this, arguments, function _fetchChunkFeatures_1() {
-            var _a, viewAsPairs, featPromises, done, i, _b, data, cpositions, dpositions, chunk, promise, i;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+            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;
-                        featPromises = [];
+                        feats = [];
                         done = false;
                         i = 0;
-                        _c.label = 1;
+                        _b.label = 1;
                     case 1:
-                        if (!(i < chunks.length)) return [3 /*break*/, 5];
-                        return [4 /*yield*/, __await(this._readChunk({
-                                chunk: chunks[i],
+                        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:
-                        _b = _c.sent(), data = _b.data, cpositions = _b.cpositions, dpositions = _b.dpositions, chunk = _b.chunk;
-                        promise = this.readBamFeatures(data, cpositions, dpositions, chunk).then(function (records) {
-                            var recs = [];
-                            for (var i_1 = 0; i_1 < records.length; i_1 += 1) {
-                                var 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);
-                                    }
+                        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);
                                 }
                             }
-                            return recs;
-                        });
-                        featPromises.push(promise);
-                        return [4 /*yield*/, __await(promise)];
-                    case 3:
-                        _c.sent();
-                        if (done) {
-                            return [3 /*break*/, 5];
                         }
-                        _c.label = 4;
+                        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];
+                        }
+                        _b.label = 5;
+                    case 5:
                         i++;
                         return [3 /*break*/, 1];
-                    case 5:
-                        (0, util_1.checkAbortSignal)(opts.signal);
-                        i = 0;
-                        _c.label = 6;
                     case 6:
-                        if (!(i < featPromises.length)) return [3 /*break*/, 10];
-                        return [4 /*yield*/, __await(featPromises[i])];
-                    case 7: return [4 /*yield*/, _c.sent()];
-                    case 8:
-                        _c.sent();
-                        _c.label = 9;
-                    case 9:
-                        i++;
-                        return [3 /*break*/, 6];
-                    case 10:
                         (0, util_1.checkAbortSignal)(opts.signal);
-                        if (!viewAsPairs) return [3 /*break*/, 13];
-                        return [4 /*yield*/, __await(this.fetchPairs(chrId, featPromises, opts))];
-                    case 11: return [4 /*yield*/, _c.sent()];
-                    case 12:
-                        _c.sent();
-                        _c.label = 13;
-                    case 13: return [2 /*return*/];
+                        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*/];
                 }
             });
         });
     };
-    BamFile.prototype.fetchPairs = function (chrId, featPromises, opts) {
+    BamFile.prototype.fetchPairs = function (chrId, feats, opts) {
         return __awaiter(this, void 0, void 0, function () {
-            var _a, pairAcrossChr, _b, maxInsertSize, unmatedPairs, readIds, matePromises, mateBlocks, mateChunks, i, mateTotalSize, mateFeatPromises, newMateFeats, featuresRet, newMates;
+            var _a, pairAcrossChr, _b, maxInsertSize, unmatedPairs, readIds, matePromises, mateChunks, _c, mateTotalSize, mateFeatPromises, _d;
             var _this = this;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+            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 = {};
-                        return [4 /*yield*/, Promise.all(featPromises.map(function (f) { return __awaiter(_this, void 0, void 0, function () {
-                                var ret, readNames, i, name_1, id;
-                                return __generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0: return [4 /*yield*/, f];
-                                        case 1:
-                                            ret = _a.sent();
-                                            readNames = {};
-                                            for (i = 0; i < ret.length; i++) {
-                                                name_1 = ret[i].name();
-                                                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;
-                                                }
-                                            });
-                                            return [2 /*return*/];
-                                    }
-                                });
-                            }); }))];
-                    case 1:
-                        _c.sent();
+                        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 = [];
-                        return [4 /*yield*/, Promise.all(featPromises.map(function (f) { return __awaiter(_this, void 0, void 0, function () {
-                                var ret, i, name_2;
-                                return __generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0: return [4 /*yield*/, f];
-                                        case 1:
-                                            ret = _a.sent();
-                                            for (i = 0; i < ret.length; i++) {
-                                                name_2 = ret[i].name();
-                                                if (unmatedPairs[name_2] &&
-                                                    (pairAcrossChr ||
-                                                        (ret[i]._next_refid() === chrId &&
-                                                            Math.abs(ret[i].get('start') - ret[i]._next_pos()) <
-                                                                maxInsertSize))) {
-                                                    matePromises.push(this.index.blocksForRange(ret[i]._next_refid(), ret[i]._next_pos(), ret[i]._next_pos() + 1, opts));
-                                                }
-                                            }
-                                            return [2 /*return*/];
-                                    }
-                                });
-                            }); }))];
-                    case 2:
-                        _c.sent();
+                        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 3:
-                        mateBlocks = _c.sent();
-                        mateChunks = [];
-                        for (i = 0; i < mateBlocks.length; i++) {
-                            mateChunks = mateChunks.concat(mateBlocks[i]);
-                        }
-                        // filter out duplicate chunks (the blocks are lists of chunks, blocks are
-                        // concatenated, then filter dup chunks)
-                        mateChunks = mateChunks
+                    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
@@ -542,17 +545,9 @@ var BamFile = /** @class */ (function () {
                                 }
                             });
                         }); });
+                        _d = flat;
                         return [4 /*yield*/, Promise.all(mateFeatPromises)];
-                    case 4:
-                        newMateFeats = _c.sent();
-                        featuresRet = [];
-                        if (newMateFeats.length) {
-                            newMates = newMateFeats.reduce(function (result, current) {
-                                return result.concat(current);
-                            });
-                            featuresRet = featuresRet.concat(newMates);
-                        }
-                        return [2 /*return*/, featuresRet];
+                    case 2: return [2 /*return*/, _d.apply(void 0, [_e.sent()])];
                 }
             });
         });
@@ -560,28 +555,17 @@ var BamFile = /** @class */ (function () {
     BamFile.prototype._readChunk = function (_a) {
         var chunk = _a.chunk, opts = _a.opts;
         return __awaiter(this, void 0, void 0, function () {
-            var signal, bufsize, res, bytesRead, buffer, _b, data, cpositions, dpositions;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+            var size, _b, buffer, bytesRead, _c, data, cpositions, dpositions;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
                     case 0:
-                        signal = opts.signal;
-                        bufsize = chunk.fetchedSize();
-                        return [4 /*yield*/, this.bam.read(Buffer.alloc(bufsize), 0, bufsize, chunk.minv.blockPosition, opts)];
+                        size = chunk.fetchedSize();
+                        return [4 /*yield*/, this.bam.read(Buffer.alloc(size), 0, size, chunk.minv.blockPosition, opts)];
                     case 1:
-                        res = _c.sent();
-                        bytesRead = res.bytesRead;
-                        buffer = res.buffer;
-                        (0, util_1.checkAbortSignal)(signal);
-                        if (bytesRead < bufsize) {
-                            buffer = buffer.subarray(0, bytesRead);
-                        }
-                        else {
-                            buffer = buffer.subarray(0, bufsize);
-                        }
-                        return [4 /*yield*/, (0, bgzf_filehandle_1.unzipChunkSlice)(buffer, chunk)];
+                        _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:
-                        _b = _c.sent(), data = _b.buffer, cpositions = _b.cpositions, dpositions = _b.dpositions;
-                        (0, util_1.checkAbortSignal)(signal);
+                        _c = _d.sent(), data = _c.buffer, cpositions = _c.cpositions, dpositions = _c.dpositions;
                         return [2 /*return*/, { data: data, cpositions: cpositions, dpositions: dpositions, chunk: chunk }];
                 }
             });
@@ -635,7 +619,8 @@ var BamFile = /** @class */ (function () {
                                     (blockStart - dpositions[pos]) +
                                     chunk.minv.dataPosition +
                                     1
-                                : buffer_crc32_1.default.signed(ba.subarray(blockStart, blockEnd)),
+                                : // 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];