@gmod/cram 1.6.3 → 1.7.0

package/dist/cramFile/slice/index.js

@@ -8,41 +8,17 @@ 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 });
-var errors_1 = require("../../errors");
-var util_1 = require("../util");
-var constants_1 = __importDefault(require("../constants"));
-var decodeRecord_1 = __importDefault(require("./decodeRecord"));
+const errors_1 = require("../../errors");
+const util_1 = require("../util");
+const constants_1 = __importDefault(require("../constants"));
+const decodeRecord_1 = __importDefault(require("./decodeRecord"));
+const record_1 = __importDefault(require("../record"));
+const sectionParsers_1 = require("../sectionParsers");
+const getBits_1 = require("../codecs/getBits");
 /**
  * @private
  * Try to estimate the template length from a bunch of interrelated multi-segment reads.
@@ -52,22 +28,23 @@ var decodeRecord_1 = __importDefault(require("./decodeRecord"));
  */
 function calculateMultiSegmentMatedTemplateLength(allRecords, currentRecordNumber, thisRecord) {
     function getAllMatedRecords(startRecord) {
-        var records = [startRecord];
-        if (startRecord.mateRecordNumber >= 0) {
-            var mateRecord = allRecords[startRecord.mateRecordNumber];
+        const records = [startRecord];
+        if (startRecord.mateRecordNumber !== undefined &&
+            startRecord.mateRecordNumber >= 0) {
+            const mateRecord = allRecords[startRecord.mateRecordNumber];
             if (!mateRecord) {
                 throw new errors_1.CramMalformedError('intra-slice mate record not found, this file seems malformed');
             }
-            records.push.apply(records, getAllMatedRecords(mateRecord));
+            records.push(...getAllMatedRecords(mateRecord));
         }
         return records;
     }
-    var matedRecords = getAllMatedRecords(thisRecord);
-    var starts = matedRecords.map(function (r) { return r.alignmentStart; });
-    var ends = matedRecords.map(function (r) { return r.alignmentStart + r.readLength - 1; });
-    var estimatedTemplateLength = Math.max.apply(Math, ends) - Math.min.apply(Math, starts) + 1;
+    const matedRecords = getAllMatedRecords(thisRecord);
+    const starts = matedRecords.map(r => r.alignmentStart);
+    const ends = matedRecords.map(r => r.alignmentStart + r.readLength - 1);
+    const estimatedTemplateLength = Math.max(...ends) - Math.min(...starts) + 1;
     if (estimatedTemplateLength >= 0) {
-        matedRecords.forEach(function (r) {
+        matedRecords.forEach(r => {
             if (r.templateLength !== undefined) {
                 throw new errors_1.CramMalformedError('mate pair group has some members that have template lengths already, this file seems malformed');
             }
@@ -85,9 +62,9 @@ function calculateMultiSegmentMatedTemplateLength(allRecords, currentRecordNumbe
 function calculateIntraSliceMatePairTemplateLength(thisRecord, mateRecord) {
     // this just estimates the template length by using the simple (non-gapped) end coordinate of each
     // read, because gapping in the alignment doesn't mean the template is longer or shorter
-    var start = Math.min(thisRecord.alignmentStart, mateRecord.alignmentStart);
-    var end = Math.max(thisRecord.alignmentStart + thisRecord.readLength - 1, mateRecord.alignmentStart + mateRecord.readLength - 1);
-    var lengthEstimate = end - start + 1;
+    const start = Math.min(thisRecord.alignmentStart, mateRecord.alignmentStart);
+    const end = Math.max(thisRecord.alignmentStart + thisRecord.readLength - 1, mateRecord.alignmentStart + mateRecord.readLength - 1);
+    const lengthEstimate = end - start + 1;
     thisRecord.templateLength = lengthEstimate;
     mateRecord.templateLength = lengthEstimate;
 }
@@ -100,7 +77,7 @@ function associateIntraSliceMate(allRecords, currentRecordNumber, thisRecord, ma
     if (!mateRecord) {
         throw new errors_1.CramMalformedError('could not resolve intra-slice mate pairs, file seems truncated or malformed');
     }
-    var complicatedMultiSegment = !!(mateRecord.mate ||
+    const complicatedMultiSegment = !!(mateRecord.mate ||
         (mateRecord.mateRecordNumber !== undefined &&
             mateRecord.mateRecordNumber !== currentRecordNumber));
     // Deal with lossy read names
@@ -160,371 +137,299 @@ function associateIntraSliceMate(allRecords, currentRecordNumber, thisRecord, ma
     // complicated template length estimation
     delete thisRecord.mateRecordNumber;
 }
-var CramSlice = /** @class */ (function () {
-    function CramSlice(container, position) {
+class CramSlice {
+    constructor(container, containerPosition, _unused) {
         this.container = container;
+        this.containerPosition = containerPosition;
         this.file = container.file;
-        this.containerPosition = position;
     }
     // memoize
-    CramSlice.prototype.getHeader = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var sectionParsers, containerHeader, header;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.file.getSectionParsers()];
-                    case 1:
-                        sectionParsers = _a.sent();
-                        return [4 /*yield*/, this.container.getHeader()];
-                    case 2:
-                        containerHeader = _a.sent();
-                        return [4 /*yield*/, this.file.readBlock(containerHeader._endPosition + this.containerPosition)];
-                    case 3:
-                        header = _a.sent();
-                        if (header.contentType === 'MAPPED_SLICE_HEADER') {
-                            header.content = (0, util_1.parseItem)(header.content, sectionParsers.cramMappedSliceHeader.parser, 0, containerHeader._endPosition);
-                        }
-                        else if (header.contentType === 'UNMAPPED_SLICE_HEADER') {
-                            header.content = (0, util_1.parseItem)(header.content, sectionParsers.cramUnmappedSliceHeader.parser, 0, containerHeader._endPosition);
-                        }
-                        else {
-                            throw new errors_1.CramMalformedError("error reading slice header block, invalid content type ".concat(header._contentType));
-                        }
-                        return [2 /*return*/, header];
-                }
-            });
+    getHeader() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // fetch and parse the slice header
+            const sectionParsers = yield this.file.getSectionParsers();
+            const containerHeader = yield this.container.getHeader();
+            const header = yield this.file.readBlock(containerHeader._endPosition + this.containerPosition);
+            if (header === undefined) {
+                throw new Error();
+            }
+            if (header.contentType === 'MAPPED_SLICE_HEADER') {
+                const content = (0, util_1.parseItem)(header.content, sectionParsers.cramMappedSliceHeader.parser, 0, containerHeader._endPosition);
+                return Object.assign(Object.assign({}, header), { parsedContent: content });
+            }
+            else if (header.contentType === 'UNMAPPED_SLICE_HEADER') {
+                const content = (0, util_1.parseItem)(header.content, sectionParsers.cramUnmappedSliceHeader.parser, 0, containerHeader._endPosition);
+                return Object.assign(Object.assign({}, header), { parsedContent: content });
+            }
+            else {
+                throw new errors_1.CramMalformedError(`error reading slice header block, invalid content type ${header.contentType}`);
+            }
         });
-    };
+    }
     // memoize
-    CramSlice.prototype.getBlocks = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var header, blockPosition, blocks, i, _a, _b;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0: return [4 /*yield*/, this.getHeader()
-                        // read all the blocks into memory and store them
-                    ];
-                    case 1:
-                        header = _c.sent();
-                        blockPosition = header._endPosition;
-                        blocks = new Array(header.content.numBlocks);
-                        i = 0;
-                        _c.label = 2;
-                    case 2:
-                        if (!(i < blocks.length)) return [3 /*break*/, 5];
-                        _a = blocks;
-                        _b = i;
-                        return [4 /*yield*/, this.file.readBlock(blockPosition)];
-                    case 3:
-                        _a[_b] = _c.sent();
-                        blockPosition = blocks[i]._endPosition;
-                        _c.label = 4;
-                    case 4:
-                        i += 1;
-                        return [3 /*break*/, 2];
-                    case 5: return [2 /*return*/, blocks];
+    getBlocks() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const header = yield this.getHeader();
+            // read all the blocks into memory and store them
+            let blockPosition = header._endPosition;
+            const blocks = new Array(header.parsedContent.numBlocks);
+            for (let i = 0; i < blocks.length; i += 1) {
+                const block = yield this.file.readBlock(blockPosition);
+                if (block === undefined) {
+                    throw new Error();
                 }
-            });
+                blocks[i] = block;
+                blockPosition = blocks[i]._endPosition;
+            }
+            return blocks;
         });
-    };
+    }
     // no memoize
-    CramSlice.prototype.getCoreDataBlock = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var blocks;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getBlocks()
-                        // the core data block is always the first block in the slice
-                    ];
-                    case 1:
-                        blocks = _a.sent();
-                        // the core data block is always the first block in the slice
-                        return [2 /*return*/, blocks[0]];
-                }
-            });
+    getCoreDataBlock() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const blocks = yield this.getBlocks();
+            // the core data block is always the first block in the slice
+            return blocks[0];
         });
-    };
+    }
     // memoize
-    CramSlice.prototype._getBlocksContentIdIndex = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var blocks, blocksByContentId;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getBlocks()];
-                    case 1:
-                        blocks = _a.sent();
-                        blocksByContentId = {};
-                        blocks.forEach(function (block) {
-                            if (block.contentType === 'EXTERNAL_DATA') {
-                                blocksByContentId[block.contentId] = block;
-                            }
-                        });
-                        return [2 /*return*/, blocksByContentId];
+    _getBlocksContentIdIndex() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const blocks = yield this.getBlocks();
+            const blocksByContentId = {};
+            blocks.forEach(block => {
+                if (block.contentType === 'EXTERNAL_DATA') {
+                    blocksByContentId[block.contentId] = block;
                 }
             });
+            return blocksByContentId;
         });
-    };
-    CramSlice.prototype.getBlockByContentId = function (id) {
-        return __awaiter(this, void 0, void 0, function () {
-            var blocksByContentId;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this._getBlocksContentIdIndex()];
-                    case 1:
-                        blocksByContentId = _a.sent();
-                        return [2 /*return*/, blocksByContentId[id]];
+    }
+    getBlockByContentId(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const blocksByContentId = yield this._getBlocksContentIdIndex();
+            return blocksByContentId[id];
+        });
+    }
+    getReferenceRegion() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // read the slice header
+            const sliceHeader = (yield this.getHeader()).parsedContent;
+            if (!(0, sectionParsers_1.isMappedSliceHeader)(sliceHeader)) {
+                throw new Error();
+            }
+            if (sliceHeader.refSeqId < 0) {
+                return undefined;
+            }
+            const compressionScheme = yield this.container.getCompressionScheme();
+            if (compressionScheme === undefined) {
+                throw new Error();
+            }
+            // console.log(JSON.stringify(sliceHeader, null, '  '))
+            if (sliceHeader.refBaseBlockId >= 0) {
+                const refBlock = yield this.getBlockByContentId(sliceHeader.refBaseBlockId);
+                if (!refBlock) {
+                    throw new errors_1.CramMalformedError('embedded reference specified, but reference block does not exist');
                 }
-            });
+                // TODO: we do not read anything named 'span'
+                // if (sliceHeader.span > refBlock.uncompressedSize) {
+                //   throw new CramMalformedError('Embedded reference is too small')
+                // }
+                // TODO verify
+                return {
+                    seq: refBlock.data.toString('utf8'),
+                    start: sliceHeader.refSeqStart,
+                    end: sliceHeader.refSeqStart + sliceHeader.refSeqSpan - 1,
+                    span: sliceHeader.refSeqSpan,
+                };
+            }
+            if (compressionScheme.referenceRequired ||
+                this.file.fetchReferenceSequenceCallback) {
+                if (!this.file.fetchReferenceSequenceCallback) {
+                    throw new Error('reference sequence not embedded, and seqFetch callback not provided, cannot fetch reference sequence');
+                }
+                const seq = yield this.file.fetchReferenceSequenceCallback(sliceHeader.refSeqId, sliceHeader.refSeqStart, sliceHeader.refSeqStart + sliceHeader.refSeqSpan - 1);
+                if (seq.length !== sliceHeader.refSeqSpan) {
+                    throw new errors_1.CramArgumentError('seqFetch callback returned a reference sequence of the wrong length');
+                }
+                return {
+                    seq,
+                    start: sliceHeader.refSeqStart,
+                    end: sliceHeader.refSeqStart + sliceHeader.refSeqSpan - 1,
+                    span: sliceHeader.refSeqSpan,
+                };
+            }
+            return undefined;
         });
-    };
-    CramSlice.prototype.getReferenceRegion = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var sliceHeader, compressionScheme, refBlock, seq;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getHeader()];
-                    case 1:
-                        sliceHeader = (_a.sent()).content;
-                        if (sliceHeader.refSeqId < 0) {
-                            return [2 /*return*/, undefined];
-                        }
-                        return [4 /*yield*/, this.container.getCompressionScheme()
-                            // console.log(JSON.stringify(sliceHeader, null, '  '))
-                        ];
-                    case 2:
-                        compressionScheme = _a.sent();
-                        // console.log(JSON.stringify(sliceHeader, null, '  '))
-                        if (sliceHeader.refBaseBlockId >= 0) {
-                            refBlock = this.getBlockByContentId(sliceHeader.refBaseBlockId);
-                            if (!refBlock) {
-                                throw new errors_1.CramMalformedError('embedded reference specified, but reference block does not exist');
-                            }
-                            if (sliceHeader.span > refBlock.uncompressedSize) {
-                                throw new errors_1.CramMalformedError('Embedded reference is too small');
-                            }
-                            return [2 /*return*/, {
-                                    seq: refBlock.data.toString('utf8'),
-                                    start: sliceHeader.refSeqStart,
-                                    end: sliceHeader.refSeqStart + sliceHeader.refSeqSpan - 1,
-                                    span: sliceHeader.refSeqSpan,
-                                }];
-                        }
-                        if (!(compressionScheme.referenceRequired ||
-                            this.file.fetchReferenceSequenceCallback)) return [3 /*break*/, 4];
-                        if (!this.file.fetchReferenceSequenceCallback) {
-                            throw new Error('reference sequence not embedded, and seqFetch callback not provided, cannot fetch reference sequence');
-                        }
-                        return [4 /*yield*/, this.file.fetchReferenceSequenceCallback(sliceHeader.refSeqId, sliceHeader.refSeqStart, sliceHeader.refSeqStart + sliceHeader.refSeqSpan - 1)];
-                    case 3:
-                        seq = _a.sent();
-                        if (seq.length !== sliceHeader.refSeqSpan) {
-                            throw new errors_1.CramArgumentError('seqFetch callback returned a reference sequence of the wrong length');
+    }
+    getAllRecords() {
+        return this.getRecords(() => true);
+    }
+    _fetchRecords() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { majorVersion } = yield this.file.getDefinition();
+            const compressionScheme = yield this.container.getCompressionScheme();
+            if (compressionScheme === undefined) {
+                throw new Error();
+            }
+            const sliceHeader = yield this.getHeader();
+            if (sliceHeader === undefined) {
+                throw new Error();
+            }
+            const blocksByContentId = yield this._getBlocksContentIdIndex();
+            // check MD5 of reference if available
+            if (majorVersion > 1 &&
+                this.file.options.checkSequenceMD5 &&
+                (0, sectionParsers_1.isMappedSliceHeader)(sliceHeader.parsedContent) &&
+                sliceHeader.parsedContent.refSeqId >= 0 &&
+                sliceHeader.parsedContent.md5.join('') !== '0000000000000000') {
+                const refRegion = yield this.getReferenceRegion();
+                if (refRegion) {
+                    const { seq, start, end } = refRegion;
+                    const seqMd5 = (0, util_1.sequenceMD5)(seq);
+                    const storedMd5 = sliceHeader.parsedContent.md5
+                        .map(byte => (byte < 16 ? '0' : '') + byte.toString(16))
+                        .join('');
+                    if (seqMd5 !== storedMd5) {
+                        throw new errors_1.CramMalformedError(`MD5 checksum reference mismatch for ref ${sliceHeader.parsedContent.refSeqId} pos ${start}..${end}. recorded MD5: ${storedMd5}, calculated MD5: ${seqMd5}`);
+                    }
+                }
+            }
+            // tracks the read position within the block. codec.decode() methods
+            // advance the byte and bit positions in the cursor as they decode
+            // data note that we are only decoding a single block here, the core
+            // data block
+            const coreDataBlock = yield this.getCoreDataBlock();
+            const cursors = {
+                lastAlignmentStart: (0, sectionParsers_1.isMappedSliceHeader)(sliceHeader.parsedContent)
+                    ? sliceHeader.parsedContent.refSeqStart
+                    : 0,
+                coreBlock: { bitPosition: 7, bytePosition: 0 },
+                externalBlocks: {
+                    map: new Map(),
+                    getCursor(contentId) {
+                        let r = this.map.get(contentId);
+                        if (r === undefined) {
+                            r = { bitPosition: 7, bytePosition: 0 };
+                            this.map.set(contentId, r);
                         }
-                        return [2 /*return*/, {
-                                seq: seq,
-                                start: sliceHeader.refSeqStart,
-                                end: sliceHeader.refSeqStart + sliceHeader.refSeqSpan - 1,
-                                span: sliceHeader.refSeqSpan,
-                            }];
-                    case 4: return [2 /*return*/, undefined];
+                        return r;
+                    },
+                },
+            };
+            const decodeDataSeries = (dataSeriesName) => {
+                const codec = compressionScheme.getCodecForDataSeries(dataSeriesName);
+                if (!codec) {
+                    throw new errors_1.CramMalformedError(`no codec defined for ${dataSeriesName} data series`);
                 }
-            });
+                // console.log(dataSeriesName, Object.getPrototypeOf(codec))
+                const decoded = codec.decode(this, coreDataBlock, blocksByContentId, cursors);
+                return decoded;
+            };
+            let records = new Array(sliceHeader.parsedContent.numRecords);
+            for (let i = 0; i < records.length; i += 1) {
+                try {
+                    const init = (0, decodeRecord_1.default)(this, decodeDataSeries, compressionScheme, sliceHeader, coreDataBlock, blocksByContentId, cursors, majorVersion, i);
+                    records[i] = new record_1.default(Object.assign(Object.assign({}, init), { uniqueId: sliceHeader.contentPosition +
+                            sliceHeader.parsedContent.recordCounter +
+                            i +
+                            1 }));
+                }
+                catch (e) {
+                    if (e instanceof getBits_1.CramBufferOverrunError) {
+                        console.warn('read attempted beyond end of buffer, file seems truncated.');
+                        records = records.filter(r => !!r);
+                        break;
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+            }
+            // interpret `recordsToNextFragment` attributes to make standard `mate`
+            // objects Resolve mate pair cross-references between records in this slice
+            for (let i = 0; i < records.length; i += 1) {
+                const { mateRecordNumber } = records[i];
+                if (mateRecordNumber !== undefined && mateRecordNumber >= 0) {
+                    associateIntraSliceMate(records, i, records[i], records[mateRecordNumber]);
+                }
+            }
+            return records;
         });
-    };
-    CramSlice.prototype.getAllRecords = function () {
-        return this.getRecords(function () { return true; });
-    };
-    CramSlice.prototype._fetchRecords = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var majorVersion, compressionScheme, sliceHeader, blocksByContentId, refRegion, seq, start, end, seqMd5, storedMd5, coreDataBlock, cursors, decodeDataSeries, records, i, i, mateRecordNumber;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.file.getDefinition()];
-                    case 1:
-                        majorVersion = (_a.sent()).majorVersion;
-                        return [4 /*yield*/, this.container.getCompressionScheme()];
-                    case 2:
-                        compressionScheme = _a.sent();
-                        return [4 /*yield*/, this.getHeader()];
-                    case 3:
-                        sliceHeader = _a.sent();
-                        return [4 /*yield*/, this._getBlocksContentIdIndex()
-                            // check MD5 of reference if available
-                        ];
-                    case 4:
-                        blocksByContentId = _a.sent();
-                        if (!(majorVersion > 1 &&
-                            this.file.options.checkSequenceMD5 &&
-                            sliceHeader.content.refSeqId >= 0 &&
-                            sliceHeader.content.md5.join('') !== '0000000000000000')) return [3 /*break*/, 6];
-                        return [4 /*yield*/, this.getReferenceRegion()];
-                    case 5:
-                        refRegion = _a.sent();
-                        if (refRegion) {
-                            seq = refRegion.seq, start = refRegion.start, end = refRegion.end;
-                            seqMd5 = (0, util_1.sequenceMD5)(seq);
-                            storedMd5 = sliceHeader.content.md5
-                                .map(function (byte) { return (byte < 16 ? '0' : '') + byte.toString(16); })
-                                .join('');
-                            if (seqMd5 !== storedMd5) {
-                                throw new errors_1.CramMalformedError("MD5 checksum reference mismatch for ref ".concat(sliceHeader.content.refSeqId, " pos ").concat(start, "..").concat(end, ". recorded MD5: ").concat(storedMd5, ", calculated MD5: ").concat(seqMd5));
-                            }
-                        }
-                        _a.label = 6;
-                    case 6: return [4 /*yield*/, this.getCoreDataBlock()];
-                    case 7:
-                        coreDataBlock = _a.sent();
-                        cursors = {
-                            lastAlignmentStart: sliceHeader.content.refSeqStart || 0,
-                            coreBlock: { bitPosition: 7, bytePosition: 0 },
-                            externalBlocks: {
-                                map: new Map(),
-                                getCursor: function (contentId) {
-                                    var r = this.map.get(contentId);
-                                    if (r === undefined) {
-                                        r = { bitPosition: 7, bytePosition: 0 };
-                                        this.map.set(contentId, r);
-                                    }
-                                    return r;
-                                },
-                            },
-                        };
-                        decodeDataSeries = function (dataSeriesName) {
-                            var codec = compressionScheme.getCodecForDataSeries(dataSeriesName);
-                            if (!codec) {
-                                throw new errors_1.CramMalformedError("no codec defined for ".concat(dataSeriesName, " data series"));
-                            }
-                            // console.log(dataSeriesName, Object.getPrototypeOf(codec))
-                            return codec.decode(_this, coreDataBlock, blocksByContentId, cursors);
-                        };
-                        records = new Array(sliceHeader.content.numRecords);
-                        for (i = 0; i < records.length; i += 1) {
-                            try {
-                                records[i] = (0, decodeRecord_1.default)(this, decodeDataSeries, compressionScheme, sliceHeader, coreDataBlock, blocksByContentId, cursors, majorVersion, i);
-                                records[i].uniqueId =
-                                    sliceHeader.contentPosition +
-                                        sliceHeader.content.recordCounter +
-                                        i +
-                                        1;
-                            }
-                            catch (e) {
-                                if (e instanceof errors_1.CramBufferOverrunError) {
-                                    console.warn('read attempted beyond end of buffer, file seems truncated.');
-                                    records = records.filter(function (r) { return !!r; });
-                                    break;
-                                }
-                                else {
-                                    throw e;
-                                }
-                            }
+    }
+    getRecords(filterFunction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // fetch the features if necessary, using the file-level feature cache
+            const cacheKey = this.container.filePosition + this.containerPosition;
+            let recordsPromise = this.file.featureCache.get(cacheKey.toString());
+            if (!recordsPromise) {
+                recordsPromise = this._fetchRecords();
+                this.file.featureCache.set(cacheKey.toString(), recordsPromise);
+            }
+            const unfiltered = yield recordsPromise;
+            const records = unfiltered.filter(filterFunction);
+            // if we can fetch reference sequence, add the reference sequence to the records
+            if (records.length && this.file.fetchReferenceSequenceCallback) {
+                const sliceHeader = yield this.getHeader();
+                if ((0, sectionParsers_1.isMappedSliceHeader)(sliceHeader.parsedContent) &&
+                    (sliceHeader.parsedContent.refSeqId >= 0 || // single-ref slice
+                        sliceHeader.parsedContent.refSeqId === -2) // multi-ref slice
+                ) {
+                    const singleRefId = sliceHeader.parsedContent.refSeqId >= 0
+                        ? sliceHeader.parsedContent.refSeqId
+                        : undefined;
+                    const compressionScheme = yield this.container.getCompressionScheme();
+                    if (compressionScheme === undefined) {
+                        throw new Error();
+                    }
+                    const refRegions = {}; // seqId => { start, end, seq }
+                    // iterate over the records to find the spans of the reference sequences we need to fetch
+                    for (let i = 0; i < records.length; i += 1) {
+                        const seqId = singleRefId !== undefined ? singleRefId : records[i].sequenceId;
+                        let refRegion = refRegions[seqId];
+                        if (!refRegion) {
+                            refRegion = {
+                                id: seqId,
+                                start: records[i].alignmentStart,
+                                end: -Infinity,
+                                seq: null,
+                            };
+                            refRegions[seqId] = refRegion;
                         }
-                        // interpret `recordsToNextFragment` attributes to make standard `mate`
-                        // objects Resolve mate pair cross-references between records in this slice
-                        for (i = 0; i < records.length; i += 1) {
-                            mateRecordNumber = records[i].mateRecordNumber;
-                            if (mateRecordNumber >= 0) {
-                                associateIntraSliceMate(records, i, records[i], records[mateRecordNumber]);
-                            }
+                        const end = records[i].alignmentStart +
+                            (records[i].lengthOnRef || records[i].readLength) -
+                            1;
+                        if (end > refRegion.end) {
+                            refRegion.end = end;
                         }
-                        return [2 /*return*/, records];
-                }
-            });
-        });
-    };
-    CramSlice.prototype.getRecords = function (filterFunction) {
-        return __awaiter(this, void 0, void 0, function () {
-            var cacheKey, recordsPromise, records, sliceHeader, singleRefId, compressionScheme, refRegions, i, seqId, refRegion, end, i, seqId, refRegion;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        cacheKey = this.container.filePosition + this.containerPosition;
-                        recordsPromise = this.file.featureCache.get(cacheKey);
-                        if (!recordsPromise) {
-                            recordsPromise = this._fetchRecords();
-                            this.file.featureCache.set(cacheKey, recordsPromise);
+                        if (records[i].alignmentStart < refRegion.start) {
+                            refRegion.start = records[i].alignmentStart;
                         }
-                        return [4 /*yield*/, recordsPromise];
-                    case 1:
-                        records = (_a.sent()).filter(filterFunction);
-                        if (!(records.length && this.file.fetchReferenceSequenceCallback)) return [3 /*break*/, 5];
-                        return [4 /*yield*/, this.getHeader()];
-                    case 2:
-                        sliceHeader = _a.sent();
-                        if (!(sliceHeader.content.refSeqId >= 0 || // single-ref slice
-                            sliceHeader.content.refSeqId === -2) // multi-ref slice
-                        ) return [3 /*break*/, 5]; // multi-ref slice
-                        singleRefId = sliceHeader.content.refSeqId >= 0
-                            ? sliceHeader.content.refSeqId
-                            : undefined;
-                        return [4 /*yield*/, this.container.getCompressionScheme()];
-                    case 3:
-                        compressionScheme = _a.sent();
-                        refRegions = {} // seqId => { start, end, seq }
-                        ;
-                        // iterate over the records to find the spans of the reference sequences we need to fetch
-                        for (i = 0; i < records.length; i += 1) {
-                            seqId = singleRefId !== undefined ? singleRefId : records[i].sequenceId;
-                            refRegion = refRegions[seqId];
-                            if (!refRegion) {
-                                refRegion = {
-                                    id: seqId,
-                                    start: records[i].alignmentStart,
-                                    end: -Infinity,
-                                };
-                                refRegions[seqId] = refRegion;
-                            }
-                            end = records[i].alignmentStart +
-                                (records[i].lengthOnRef || records[i].readLength) -
-                                1;
-                            if (end > refRegion.end) {
-                                refRegion.end = end;
-                            }
-                            if (records[i].alignmentStart < refRegion.start) {
-                                refRegion.start = records[i].alignmentStart;
-                            }
+                    }
+                    // fetch the `seq` for all of the ref regions
+                    yield Promise.all(Object.values(refRegions).map((refRegion) => __awaiter(this, void 0, void 0, function* () {
+                        if (refRegion.id !== -1 && refRegion.start <= refRegion.end) {
+                            refRegion.seq = yield this.file.fetchReferenceSequenceCallback(refRegion.id, refRegion.start, refRegion.end);
                         }
-                        // fetch the `seq` for all of the ref regions
-                        return [4 /*yield*/, Promise.all(Object.values(refRegions).map(function (refRegion) { return __awaiter(_this, void 0, void 0, function () {
-                                var _a;
-                                return __generator(this, function (_b) {
-                                    switch (_b.label) {
-                                        case 0:
-                                            if (!(refRegion.id !== -1 && refRegion.start <= refRegion.end)) return [3 /*break*/, 2];
-                                            _a = refRegion;
-                                            return [4 /*yield*/, this.file.fetchReferenceSequenceCallback(refRegion.id, refRegion.start, refRegion.end)];
-                                        case 1:
-                                            _a.seq = _b.sent();
-                                            _b.label = 2;
-                                        case 2: return [2 /*return*/];
-                                    }
-                                });
-                            }); }))
-                            // now decorate all the records with them
-                        ];
-                    case 4:
-                        // fetch the `seq` for all of the ref regions
-                        _a.sent();
-                        // now decorate all the records with them
-                        for (i = 0; i < records.length; i += 1) {
-                            seqId = singleRefId !== undefined ? singleRefId : records[i].sequenceId;
-                            refRegion = refRegions[seqId];
-                            if (refRegion && refRegion.seq) {
-                                records[i].addReferenceSequence(refRegion, compressionScheme);
-                            }
+                    })));
+                    // now decorate all the records with them
+                    for (let i = 0; i < records.length; i += 1) {
+                        const seqId = singleRefId !== undefined ? singleRefId : records[i].sequenceId;
+                        const refRegion = refRegions[seqId];
+                        if (refRegion && refRegion.seq) {
+                            const seq = refRegion.seq;
+                            records[i].addReferenceSequence(Object.assign(Object.assign({}, refRegion), { seq }), compressionScheme);
                         }
-                        _a.label = 5;
-                    case 5: return [2 /*return*/, records];
+                    }
                 }
-            });
+            }
+            return records;
         });
-    };
-    return CramSlice;
-}());
+    }
+}
 exports.default = CramSlice;
 // memoize several methods in the class for performance
 'getHeader getBlocks _getBlocksContentIdIndex'
     .split(' ')
-    .forEach(function (method) { return (0, util_1.tinyMemoize)(CramSlice, method); });
+    .forEach(method => (0, util_1.tinyMemoize)(CramSlice, method));
 //# sourceMappingURL=index.js.map