@gmod/cram 3.0.7 → 4.0.0

package/dist/cramFile/slice/index.js

@@ -1,24 +1,15 @@
 "use strict";
-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) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const errors_1 = require("../../errors");
-const util_1 = require("../util");
+const getBits_1 = require("../codecs/getBits");
 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");
+const util_1 = require("../util");
 /**
  * @private
  * Try to estimate the template length from a bunch of interrelated multi-segment reads.
@@ -143,287 +134,275 @@ class CramSlice {
         this.file = container.file;
     }
     // memoize
-    getHeader() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // fetch and parse the slice header
-            const { majorVersion } = yield this.file.getDefinition();
-            const sectionParsers = (0, sectionParsers_1.getSectionParsers)(majorVersion);
-            const containerHeader = yield this.container.getHeader();
-            if (!containerHeader) {
-                throw new Error('no container header detected');
-            }
-            const header = yield this.file.readBlock(containerHeader._endPosition + this.containerPosition);
-            if (header === undefined) {
-                throw new Error('block header undefined');
-            }
-            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}`);
-            }
-        });
+    async getHeader() {
+        // fetch and parse the slice header
+        const { majorVersion } = await this.file.getDefinition();
+        const sectionParsers = (0, sectionParsers_1.getSectionParsers)(majorVersion);
+        const containerHeader = await this.container.getHeader();
+        if (!containerHeader) {
+            throw new Error('no container header detected');
+        }
+        const header = await this.file.readBlock(containerHeader._endPosition + this.containerPosition);
+        if (header === undefined) {
+            throw new Error('block header undefined');
+        }
+        if (header.contentType === 'MAPPED_SLICE_HEADER') {
+            const content = (0, util_1.parseItem)(header.content, sectionParsers.cramMappedSliceHeader.parser, 0, containerHeader._endPosition);
+            return { ...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 { ...header, parsedContent: content };
+        }
+        else {
+            throw new errors_1.CramMalformedError(`error reading slice header block, invalid content type ${header.contentType}`);
+        }
     }
     // memoize
-    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++) {
-                const block = yield this.file.readBlock(blockPosition);
-                if (block === undefined) {
-                    throw new Error('block undefined');
-                }
-                blocks[i] = block;
-                blockPosition = blocks[i]._endPosition;
+    async getBlocks() {
+        const header = await 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++) {
+            const block = await this.file.readBlock(blockPosition);
+            if (block === undefined) {
+                throw new Error('block undefined');
             }
-            return blocks;
-        });
+            blocks[i] = block;
+            blockPosition = blocks[i]._endPosition;
+        }
+        return blocks;
     }
     // no memoize
-    getCoreDataBlock() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const blocks = yield this.getBlocks();
-            return blocks[0];
-        });
+    async getCoreDataBlock() {
+        const blocks = await this.getBlocks();
+        return blocks[0];
     }
     // memoize
-    _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;
+    async _getBlocksContentIdIndex() {
+        const blocks = await this.getBlocks();
+        const blocksByContentId = {};
+        blocks.forEach(block => {
+            if (block.contentType === 'EXTERNAL_DATA') {
+                blocksByContentId[block.contentId] = block;
+            }
         });
+        return blocksByContentId;
     }
-    getBlockByContentId(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const blocksByContentId = yield this._getBlocksContentIdIndex();
-            return blocksByContentId[id];
-        });
+    async getBlockByContentId(id) {
+        const blocksByContentId = await 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('slice header not mapped');
-            }
-            if (sliceHeader.refSeqId < 0) {
-                return undefined;
+    async getReferenceRegion() {
+        // read the slice header
+        const sliceHeader = (await this.getHeader()).parsedContent;
+        if (!(0, sectionParsers_1.isMappedSliceHeader)(sliceHeader)) {
+            throw new Error('slice header not mapped');
+        }
+        if (sliceHeader.refSeqId < 0) {
+            return undefined;
+        }
+        const compressionScheme = await this.container.getCompressionScheme();
+        if (compressionScheme === undefined) {
+            throw new Error('compression scheme undefined');
+        }
+        if (sliceHeader.refBaseBlockId >= 0) {
+            const refBlock = await this.getBlockByContentId(sliceHeader.refBaseBlockId);
+            if (!refBlock) {
+                throw new errors_1.CramMalformedError('embedded reference specified, but reference block does not exist');
             }
-            const compressionScheme = yield this.container.getCompressionScheme();
-            if (compressionScheme === undefined) {
-                throw new Error('compression scheme undefined');
+            // 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');
             }
-            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,
-                };
+            const seq = await 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');
             }
-            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;
-        });
+            return {
+                seq,
+                start: sliceHeader.refSeqStart,
+                end: sliceHeader.refSeqStart + sliceHeader.refSeqSpan - 1,
+                span: sliceHeader.refSeqSpan,
+            };
+        }
+        return undefined;
     }
     getAllRecords() {
         return this.getRecords(() => true);
     }
-    _fetchRecords() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            const { majorVersion } = yield this.file.getDefinition();
-            const compressionScheme = yield this.container.getCompressionScheme();
-            if (compressionScheme === undefined) {
-                throw new Error('compression scheme undefined');
-            }
-            const sliceHeader = yield this.getHeader();
-            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 &&
-                ((_a = sliceHeader.parsedContent.md5) === null || _a === void 0 ? void 0 : _a.join('')) !== '0000000000000000') {
-                const refRegion = yield this.getReferenceRegion();
-                if (refRegion) {
-                    const { seq, start, end } = refRegion;
-                    const seqMd5 = (0, util_1.sequenceMD5)(seq);
-                    const storedMd5 = (_b = sliceHeader.parsedContent.md5) === null || _b === void 0 ? void 0 : _b.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}`);
-                    }
+    async _fetchRecords() {
+        const { majorVersion } = await this.file.getDefinition();
+        const compressionScheme = await this.container.getCompressionScheme();
+        if (compressionScheme === undefined) {
+            throw new Error('compression scheme undefined');
+        }
+        const sliceHeader = await this.getHeader();
+        const blocksByContentId = await 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 = await 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 r;
-                    },
+        }
+        // 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 = await 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 r;
                 },
-            };
-            const decodeDataSeries = (dataSeriesName) => {
-                const codec = compressionScheme.getCodecForDataSeries(dataSeriesName);
-                if (!codec) {
-                    throw new errors_1.CramMalformedError(`no codec defined for ${dataSeriesName} data series`);
+            },
+        };
+        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;
+        };
+        const 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({
+                    ...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.');
+                    break;
                 }
-                // console.log(dataSeriesName, Object.getPrototypeOf(codec))
-                const decoded = codec.decode(this, coreDataBlock, blocksByContentId, cursors);
-                return decoded;
-            };
-            const 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.');
-                        break;
-                    }
-                    else {
-                        throw e;
-                    }
+                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]);
-                }
+        }
+        // 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;
-        });
+        }
+        return records;
     }
-    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('compression scheme undefined');
+    async getRecords(filterFunction) {
+        // 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 = await 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 = await 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 = await this.container.getCompressionScheme();
+                if (compressionScheme === undefined) {
+                    throw new Error('compression scheme undefined');
+                }
+                const refRegions = {};
+                // iterate over the records to find the spans of the reference
+                // sequences we need to fetch
+                for (const record of records) {
+                    const seqId = singleRefId !== undefined ? singleRefId : record.sequenceId;
+                    let refRegion = refRegions[seqId];
+                    if (!refRegion) {
+                        refRegion = {
+                            id: seqId,
+                            start: record.alignmentStart,
+                            end: Number.NEGATIVE_INFINITY,
+                            seq: null,
+                        };
+                        refRegions[seqId] = refRegion;
+                    }
+                    const end = record.alignmentStart +
+                        (record.lengthOnRef || record.readLength) -
+                        1;
+                    if (end > refRegion.end) {
+                        refRegion.end = end;
+                    }
+                    if (record.alignmentStart < refRegion.start) {
+                        refRegion.start = record.alignmentStart;
                     }
-                    const refRegions = {};
-                    // iterate over the records to find the spans of the reference
-                    // sequences we need to fetch
-                    for (const record of records) {
-                        const seqId = singleRefId !== undefined ? singleRefId : record.sequenceId;
-                        let refRegion = refRegions[seqId];
-                        if (!refRegion) {
-                            refRegion = {
-                                id: seqId,
-                                start: record.alignmentStart,
-                                end: Number.NEGATIVE_INFINITY,
-                                seq: null,
-                            };
-                            refRegions[seqId] = refRegion;
-                        }
-                        const end = record.alignmentStart +
-                            (record.lengthOnRef || record.readLength) -
-                            1;
-                        if (end > refRegion.end) {
-                            refRegion.end = end;
-                        }
-                        if (record.alignmentStart < refRegion.start) {
-                            refRegion.start = record.alignmentStart;
-                        }
+                }
+                // fetch the `seq` for all of the ref regions
+                await Promise.all(Object.values(refRegions).map(async (refRegion) => {
+                    if (refRegion.id !== -1 &&
+                        refRegion.start <= refRegion.end &&
+                        this.file.fetchReferenceSequenceCallback) {
+                        refRegion.seq = await this.file.fetchReferenceSequenceCallback(refRegion.id, refRegion.start, refRegion.end);
                     }
-                    // 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 &&
-                            this.file.fetchReferenceSequenceCallback) {
-                            refRegion.seq = yield this.file.fetchReferenceSequenceCallback(refRegion.id, refRegion.start, refRegion.end);
-                        }
-                    })));
-                    // now decorate all the records with them
-                    for (const record of records) {
-                        const seqId = singleRefId !== undefined ? singleRefId : record.sequenceId;
-                        const refRegion = refRegions[seqId];
-                        if (refRegion === null || refRegion === void 0 ? void 0 : refRegion.seq) {
-                            const seq = refRegion.seq;
-                            record.addReferenceSequence(Object.assign(Object.assign({}, refRegion), { seq }), compressionScheme);
-                        }
+                }));
+                // now decorate all the records with them
+                for (const record of records) {
+                    const seqId = singleRefId !== undefined ? singleRefId : record.sequenceId;
+                    const refRegion = refRegions[seqId];
+                    if (refRegion?.seq) {
+                        const seq = refRegion.seq;
+                        record.addReferenceSequence({ ...refRegion, seq }, compressionScheme);
                     }
                 }
             }
-            return records;
-        });
+        }
+        return records;
     }
 }
 exports.default = CramSlice;