@gmod/cram 1.6.3 → 1.7.0

package/dist/cramFile/file.js

@@ -8,52 +8,25 @@ 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 unzip_1 = require("../unzip");
-var buffer_crc32_1 = __importDefault(require("buffer-crc32"));
-var quick_lru_1 = __importDefault(require("quick-lru"));
-var errors_1 = require("../errors");
-var rans_1 = __importDefault(require("../rans"));
-var sectionParsers_1 = require("./sectionParsers");
-var htscodecs_1 = __importDefault(require("@jkbonfield/htscodecs"));
-var container_1 = __importDefault(require("./container"));
-var io_1 = require("../io");
-var util_1 = require("./util");
-var sam_1 = require("../sam");
+const unzip_1 = require("../unzip");
+const buffer_crc32_1 = __importDefault(require("buffer-crc32"));
+const quick_lru_1 = __importDefault(require("quick-lru"));
+const errors_1 = require("../errors");
+const rans_1 = __importDefault(require("../rans"));
+const sectionParsers_1 = require("./sectionParsers");
+const htscodecs_1 = __importDefault(require("@jkbonfield/htscodecs"));
+const container_1 = __importDefault(require("./container"));
+const io_1 = require("../io");
+const util_1 = require("./util");
+const sam_1 = require("../sam");
 //source:https://abdulapopoola.com/2019/01/20/check-endianness-with-javascript/
 function getEndianness() {
-    var uInt32 = new Uint32Array([0x11223344]);
-    var uInt8 = new Uint8Array(uInt32.buffer);
+    const uInt32 = new Uint32Array([0x11223344]);
+    const uInt8 = new Uint8Array(uInt32.buffer);
     if (uInt8[0] === 0x44) {
         return 0; //little-endian
     }
@@ -64,26 +37,15 @@ function getEndianness() {
         return 2; //mixed-endian?
     }
 }
-var CramFile = /** @class */ (function () {
-    /**
-     * @param {object} args
-     * @param {object} [args.filehandle] - a filehandle that implements the stat() and
-     * read() methods of the Node filehandle API https://nodejs.org/api/fs.html#fs_class_filehandle
-     * @param {object} [args.path] - path to the cram file
-     * @param {object} [args.url] - url for the cram file.  also supports file:// urls for local files
-     * @param {function} [args.seqFetch] - a function with signature
-     * `(seqId, startCoordinate, endCoordinate)` that returns a promise for a string of sequence bases
-     * @param {number} [args.cacheSize] optional maximum number of CRAM records to cache.  default 20,000
-     * @param {boolean} [args.checkSequenceMD5] - default true. if false, disables verifying the MD5
-     * checksum of the reference sequence underlying a slice. In some applications, this check can cause an inconvenient amount (many megabases) of sequences to be fetched.
-     */
-    function CramFile(args) {
+class CramFile {
+    constructor(args) {
+        var _a;
         this.file = (0, io_1.open)(args.url, args.path, args.filehandle);
         this.validateChecksums = true;
         this.fetchReferenceSequenceCallback = args.seqFetch;
         this.options = {
-            checkSequenceMD5: args.checkSequenceMD5 !== false,
-            cacheSize: args.cacheSize !== undefined ? args.cacheSize : 20000,
+            checkSequenceMD5: args.checkSequenceMD5,
+            cacheSize: (_a = args.cacheSize) !== null && _a !== void 0 ? _a : 20000,
         };
         // cache of features in a slice, keyed by the
         // slice offset. caches all of the features in a slice, or none.
@@ -96,292 +58,210 @@ var CramFile = /** @class */ (function () {
             throw new Error('Detected big-endian machine, may be unable to run');
         }
     }
-    CramFile.prototype.toString = function () {
-        if (this.file.filename) {
-            return this.file.filename;
-        }
-        if (this.file.url) {
-            return this.file.url;
-        }
-        return '(cram file)';
-    };
+    // toString() {
+    //   if (this.file.filename) {
+    //     return this.file.filename
+    //   }
+    //   if (this.file.url) {
+    //     return this.file.url
+    //   }
+    //
+    //   return '(cram file)'
+    // }
     // can just read this object like a filehandle
-    CramFile.prototype.read = function (buffer, offset, length, position) {
+    read(buffer, offset, length, position) {
         return this.file.read(buffer, offset, length, position);
-    };
+    }
     // can just stat this object like a filehandle
-    CramFile.prototype.stat = function () {
+    stat() {
         return this.file.stat();
-    };
+    }
     // memoized
-    CramFile.prototype.getDefinition = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var headbytes, definition;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        headbytes = Buffer.allocUnsafe(sectionParsers_1.cramFileDefinition.maxLength);
-                        return [4 /*yield*/, this.file.read(headbytes, 0, sectionParsers_1.cramFileDefinition.maxLength, 0)];
-                    case 1:
-                        _a.sent();
-                        definition = sectionParsers_1.cramFileDefinition.parser.parse(headbytes).result;
-                        if (definition.majorVersion !== 2 && definition.majorVersion !== 3) {
-                            throw new errors_1.CramUnimplementedError("CRAM version ".concat(definition.majorVersion, " not supported"));
-                        }
-                        return [2 /*return*/, definition];
-                }
-            });
+    getDefinition() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const headbytes = Buffer.allocUnsafe(sectionParsers_1.cramFileDefinition.maxLength);
+            yield this.file.read(headbytes, 0, sectionParsers_1.cramFileDefinition.maxLength, 0);
+            const definition = sectionParsers_1.cramFileDefinition.parser.parse(headbytes)
+                .result;
+            if (definition.majorVersion !== 2 && definition.majorVersion !== 3) {
+                throw new errors_1.CramUnimplementedError(`CRAM version ${definition.majorVersion} not supported`);
+            }
+            return definition;
         });
-    };
+    }
     // memoize
-    CramFile.prototype.getSamHeader = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var firstContainer, content, headerLength, textStart, text;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getContainerById(0)];
-                    case 1:
-                        firstContainer = _a.sent();
-                        if (!firstContainer) {
-                            throw new errors_1.CramMalformedError('file contains no containers');
-                        }
-                        return [4 /*yield*/, firstContainer.getFirstBlock()
-                            // find the end of the trailing zeros in the header text
-                        ];
-                    case 2:
-                        content = (_a.sent()).content;
-                        headerLength = content.readInt32LE(0);
-                        textStart = 4;
-                        text = content.toString('utf8', textStart, textStart + headerLength);
-                        this.header = text;
-                        return [2 /*return*/, (0, sam_1.parseHeaderText)(text)];
-                }
-            });
+    getSamHeader() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const firstContainer = yield this.getContainerById(0);
+            if (!firstContainer) {
+                throw new errors_1.CramMalformedError('file contains no containers');
+            }
+            const firstBlock = yield firstContainer.getFirstBlock();
+            if (firstBlock === undefined) {
+                return (0, sam_1.parseHeaderText)('');
+            }
+            const content = firstBlock.content;
+            // find the end of the trailing zeros in the header text
+            const headerLength = content.readInt32LE(0);
+            const textStart = 4;
+            // let textEnd = content.length - 1
+            // while (textEnd >= textStart && !content[textEnd]) textEnd -= 1
+            // trim off the trailing zeros
+            const text = content.toString('utf8', textStart, textStart + headerLength);
+            this.header = text;
+            return (0, sam_1.parseHeaderText)(text);
         });
-    };
-    CramFile.prototype.getHeaderText = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getSamHeader()];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/, this.header];
-                }
-            });
+    }
+    getHeaderText() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.getSamHeader();
+            return this.header;
         });
-    };
+    }
     // memoize
-    CramFile.prototype.getSectionParsers = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var majorVersion;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getDefinition()];
-                    case 1:
-                        majorVersion = (_a.sent()).majorVersion;
-                        return [2 /*return*/, (0, sectionParsers_1.getSectionParsers)(majorVersion)];
-                }
-            });
+    getSectionParsers() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { majorVersion } = yield this.getDefinition();
+            return (0, sectionParsers_1.getSectionParsers)(majorVersion);
         });
-    };
-    CramFile.prototype.getContainerById = function (containerNumber) {
-        return __awaiter(this, void 0, void 0, function () {
-            var sectionParsers, position, fileSize, cramContainerHeader1, currentContainer, i, currentHeader, j, block;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getSectionParsers()];
-                    case 1:
-                        sectionParsers = _a.sent();
-                        position = sectionParsers.cramFileDefinition.maxLength;
-                        return [4 /*yield*/, this.file.stat()];
-                    case 2:
-                        fileSize = (_a.sent()).size;
-                        cramContainerHeader1 = sectionParsers.cramContainerHeader1;
-                        i = 0;
-                        _a.label = 3;
-                    case 3:
-                        if (!(i <= containerNumber)) return [3 /*break*/, 11];
-                        // if we are about to go off the end of the file
-                        // and have not found that container, it does not exist
-                        if (position + cramContainerHeader1.maxLength + 8 >= fileSize) {
-                            return [2 /*return*/, undefined];
-                        }
-                        currentContainer = this.getContainerAtPosition(position);
-                        return [4 /*yield*/, currentContainer.getHeader()];
-                    case 4:
-                        currentHeader = _a.sent();
-                        if (!currentHeader) {
-                            throw new errors_1.CramMalformedError("container ".concat(containerNumber, " not found in file"));
+    }
+    getContainerById(containerNumber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sectionParsers = yield this.getSectionParsers();
+            let position = sectionParsers.cramFileDefinition.maxLength;
+            const { size: fileSize } = yield this.file.stat();
+            const { cramContainerHeader1 } = sectionParsers;
+            // skip with a series of reads to the proper container
+            let currentContainer;
+            for (let i = 0; i <= containerNumber; i += 1) {
+                // if we are about to go off the end of the file
+                // and have not found that container, it does not exist
+                if (position + cramContainerHeader1.maxLength + 8 >= fileSize) {
+                    return undefined;
+                }
+                currentContainer = this.getContainerAtPosition(position);
+                const currentHeader = yield currentContainer.getHeader();
+                if (!currentHeader) {
+                    throw new errors_1.CramMalformedError(`container ${containerNumber} not found in file`);
+                }
+                // if this is the first container, read all the blocks in the
+                // container to determine its length, because we cannot trust
+                // the container header's given length due to a bug somewhere
+                // in htslib
+                if (i === 0) {
+                    position = currentHeader._endPosition;
+                    for (let j = 0; j < currentHeader.numBlocks; j += 1) {
+                        const block = yield this.readBlock(position);
+                        if (block === undefined) {
+                            return undefined;
                         }
-                        if (!(i === 0)) return [3 /*break*/, 9];
-                        position = currentHeader._endPosition;
-                        j = 0;
-                        _a.label = 5;
-                    case 5:
-                        if (!(j < currentHeader.numBlocks)) return [3 /*break*/, 8];
-                        return [4 /*yield*/, this.readBlock(position)];
-                    case 6:
-                        block = _a.sent();
                         position = block._endPosition;
-                        _a.label = 7;
-                    case 7:
-                        j += 1;
-                        return [3 /*break*/, 5];
-                    case 8: return [3 /*break*/, 10];
-                    case 9:
-                        // otherwise, just traverse to the next container using the container's length
-                        position += currentHeader._size + currentHeader.length;
-                        _a.label = 10;
-                    case 10:
-                        i += 1;
-                        return [3 /*break*/, 3];
-                    case 11: return [2 /*return*/, currentContainer];
+                    }
                 }
-            });
-        });
-    };
-    CramFile.prototype.checkCrc32 = function (position, length, recordedCrc32, description) {
-        return __awaiter(this, void 0, void 0, function () {
-            var b, calculatedCrc32;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        b = Buffer.allocUnsafe(length);
-                        return [4 /*yield*/, this.file.read(b, 0, length, position)];
-                    case 1:
-                        _a.sent();
-                        calculatedCrc32 = buffer_crc32_1.default.unsigned(b);
-                        if (calculatedCrc32 !== recordedCrc32) {
-                            throw new errors_1.CramMalformedError("crc mismatch in ".concat(description, ": recorded CRC32 = ").concat(recordedCrc32, ", but calculated CRC32 = ").concat(calculatedCrc32));
-                        }
-                        return [2 /*return*/];
+                else {
+                    // otherwise, just traverse to the next container using the container's length
+                    position += currentHeader._size + currentHeader.length;
                 }
-            });
+            }
+            return currentContainer;
         });
-    };
+    }
+    checkCrc32(position, length, recordedCrc32, description) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const b = Buffer.allocUnsafe(length);
+            yield this.file.read(b, 0, length, position);
+            const calculatedCrc32 = buffer_crc32_1.default.unsigned(b);
+            if (calculatedCrc32 !== recordedCrc32) {
+                throw new errors_1.CramMalformedError(`crc mismatch in ${description}: recorded CRC32 = ${recordedCrc32}, but calculated CRC32 = ${calculatedCrc32}`);
+            }
+        });
+    }
     /**
      * @returns {Promise[number]} the number of containers in the file
      */
-    CramFile.prototype.containerCount = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var sectionParsers, fileSize, cramContainerHeader1, containerCount, position, currentHeader, j, block;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getSectionParsers()];
-                    case 1:
-                        sectionParsers = _a.sent();
-                        return [4 /*yield*/, this.file.stat()];
-                    case 2:
-                        fileSize = (_a.sent()).size;
-                        cramContainerHeader1 = sectionParsers.cramContainerHeader1;
-                        containerCount = 0;
-                        position = sectionParsers.cramFileDefinition.maxLength;
-                        _a.label = 3;
-                    case 3:
-                        if (!(position + cramContainerHeader1.maxLength + 8 < fileSize)) return [3 /*break*/, 11];
-                        return [4 /*yield*/, this.getContainerAtPosition(position).getHeader()];
-                    case 4:
-                        currentHeader = _a.sent();
-                        if (!currentHeader) {
-                            return [3 /*break*/, 11];
+    containerCount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sectionParsers = yield this.getSectionParsers();
+            const { size: fileSize } = yield this.file.stat();
+            const { cramContainerHeader1 } = sectionParsers;
+            let containerCount = 0;
+            let position = sectionParsers.cramFileDefinition.maxLength;
+            while (position + cramContainerHeader1.maxLength + 8 < fileSize) {
+                const currentHeader = yield this.getContainerAtPosition(position).getHeader();
+                if (!currentHeader) {
+                    break;
+                }
+                // if this is the first container, read all the blocks in the
+                // container, because we cannot trust the container
+                // header's given length due to a bug somewhere in htslib
+                if (containerCount === 0) {
+                    position = currentHeader._endPosition;
+                    for (let j = 0; j < currentHeader.numBlocks; j += 1) {
+                        const block = yield this.readBlock(position);
+                        if (block === undefined) {
+                            return undefined;
                         }
-                        if (!(containerCount === 0)) return [3 /*break*/, 9];
-                        position = currentHeader._endPosition;
-                        j = 0;
-                        _a.label = 5;
-                    case 5:
-                        if (!(j < currentHeader.numBlocks)) return [3 /*break*/, 8];
-                        return [4 /*yield*/, this.readBlock(position)];
-                    case 6:
-                        block = _a.sent();
                         position = block._endPosition;
-                        _a.label = 7;
-                    case 7:
-                        j += 1;
-                        return [3 /*break*/, 5];
-                    case 8: return [3 /*break*/, 10];
-                    case 9:
-                        // otherwise, just traverse to the next container using the container's length
-                        position += currentHeader._size + currentHeader.length;
-                        _a.label = 10;
-                    case 10:
-                        containerCount += 1;
-                        return [3 /*break*/, 3];
-                    case 11: return [2 /*return*/, containerCount];
+                    }
+                }
+                else {
+                    // otherwise, just traverse to the next container using the container's length
+                    position += currentHeader._size + currentHeader.length;
                 }
-            });
+                containerCount += 1;
+            }
+            return containerCount;
         });
-    };
-    CramFile.prototype.getContainerAtPosition = function (position) {
+    }
+    getContainerAtPosition(position) {
         return new container_1.default(this, position);
-    };
-    CramFile.prototype.readBlockHeader = function (position) {
-        return __awaiter(this, void 0, void 0, function () {
-            var sectionParsers, cramBlockHeader, fileSize, buffer;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getSectionParsers()];
-                    case 1:
-                        sectionParsers = _a.sent();
-                        cramBlockHeader = sectionParsers.cramBlockHeader;
-                        return [4 /*yield*/, this.file.stat()];
-                    case 2:
-                        fileSize = (_a.sent()).size;
-                        if (position + cramBlockHeader.maxLength >= fileSize) {
-                            return [2 /*return*/, undefined];
-                        }
-                        buffer = Buffer.allocUnsafe(cramBlockHeader.maxLength);
-                        return [4 /*yield*/, this.file.read(buffer, 0, cramBlockHeader.maxLength, position)];
-                    case 3:
-                        _a.sent();
-                        return [2 /*return*/, (0, util_1.parseItem)(buffer, cramBlockHeader.parser, 0, position)];
-                }
-            });
+    }
+    readBlockHeader(position) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sectionParsers = yield this.getSectionParsers();
+            const { cramBlockHeader } = sectionParsers;
+            const { size: fileSize } = yield this.file.stat();
+            if (position + cramBlockHeader.maxLength >= fileSize) {
+                return undefined;
+            }
+            const buffer = Buffer.allocUnsafe(cramBlockHeader.maxLength);
+            yield this.file.read(buffer, 0, cramBlockHeader.maxLength, position);
+            return (0, util_1.parseItem)(buffer, cramBlockHeader.parser, 0, position);
         });
-    };
-    CramFile.prototype._parseSection = function (section, position, size, preReadBuffer) {
-        if (size === void 0) { size = section.maxLength; }
-        return __awaiter(this, void 0, void 0, function () {
-            var buffer, fileSize, data;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!preReadBuffer) return [3 /*break*/, 1];
-                        buffer = preReadBuffer;
-                        return [3 /*break*/, 4];
-                    case 1: return [4 /*yield*/, this.file.stat()];
-                    case 2:
-                        fileSize = (_a.sent()).size;
-                        if (position + size >= fileSize) {
-                            return [2 /*return*/, undefined];
-                        }
-                        buffer = Buffer.allocUnsafe(size);
-                        return [4 /*yield*/, this.file.read(buffer, 0, size, position)];
-                    case 3:
-                        _a.sent();
-                        _a.label = 4;
-                    case 4:
-                        data = (0, util_1.parseItem)(buffer, section.parser, 0, position);
-                        if (data._size !== size) {
-                            throw new errors_1.CramMalformedError("section read error: requested size ".concat(size, " does not equal parsed size ").concat(data._size));
-                        }
-                        return [2 /*return*/, data];
+    }
+    _parseSection(section, position, size = section.maxLength, preReadBuffer = undefined) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let buffer;
+            if (preReadBuffer) {
+                buffer = preReadBuffer;
+            }
+            else {
+                const { size: fileSize } = yield this.file.stat();
+                if (position + size >= fileSize) {
+                    return undefined;
                 }
-            });
+                buffer = Buffer.allocUnsafe(size);
+                yield this.file.read(buffer, 0, size, position);
+            }
+            const data = (0, util_1.parseItem)(buffer, section.parser, 0, position);
+            if (data._size !== size) {
+                throw new errors_1.CramMalformedError(`section read error: requested size ${size} does not equal parsed size ${data._size}`);
+            }
+            return data;
         });
-    };
-    CramFile.prototype._uncompress = function (compressionMethod, inputBuffer, outputBuffer) {
+    }
+    _uncompress(compressionMethod, inputBuffer, outputBuffer) {
         if (compressionMethod === 'gzip') {
-            var result = (0, unzip_1.unzip)(inputBuffer);
+            const result = (0, unzip_1.unzip)(inputBuffer);
             result.copy(outputBuffer);
         }
         else if (compressionMethod === 'bzip2') {
-            var bits = bzip2.array(inputBuffer);
-            var size = bzip2.header(bits);
-            var j = 0;
+            const bits = bzip2.array(inputBuffer);
+            let size = bzip2.header(bits);
+            let j = 0;
+            let chunk;
             do {
-                var chunk = bzip2.decompress(bits, size);
+                chunk = bzip2.decompress(bits, size);
                 if (chunk != -1) {
                     Buffer.from(chunk).copy(outputBuffer, j);
                     j += chunk.length;
@@ -407,68 +287,54 @@ var CramFile = /** @class */ (function () {
             htscodecs_1.default.tok3_uncompress(inputBuffer, outputBuffer);
         }
         else {
-            throw new errors_1.CramUnimplementedError("".concat(compressionMethod, " decompression not yet implemented"));
+            throw new errors_1.CramUnimplementedError(`${compressionMethod} decompression not yet implemented`);
         }
-    };
-    CramFile.prototype.readBlock = function (position) {
-        return __awaiter(this, void 0, void 0, function () {
-            var majorVersion, sectionParsers, block, blockContentPosition, uncompressedData, compressedData, crc;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getDefinition()];
-                    case 1:
-                        majorVersion = (_a.sent()).majorVersion;
-                        return [4 /*yield*/, this.getSectionParsers()];
-                    case 2:
-                        sectionParsers = _a.sent();
-                        return [4 /*yield*/, this.readBlockHeader(position)];
-                    case 3:
-                        block = _a.sent();
-                        blockContentPosition = block._endPosition;
-                        block.contentPosition = block._endPosition;
-                        uncompressedData = Buffer.allocUnsafe(block.uncompressedSize);
-                        if (!(block.compressionMethod !== 'raw')) return [3 /*break*/, 5];
-                        compressedData = Buffer.allocUnsafe(block.compressedSize);
-                        return [4 /*yield*/, this.read(compressedData, 0, block.compressedSize, blockContentPosition)];
-                    case 4:
-                        _a.sent();
-                        this._uncompress(block.compressionMethod, compressedData, uncompressedData);
-                        return [3 /*break*/, 7];
-                    case 5: return [4 /*yield*/, this.read(uncompressedData, 0, block.uncompressedSize, blockContentPosition)];
-                    case 6:
-                        _a.sent();
-                        _a.label = 7;
-                    case 7:
-                        block.content = uncompressedData;
-                        if (!(majorVersion >= 3)) return [3 /*break*/, 11];
-                        return [4 /*yield*/, this._parseSection(sectionParsers.cramBlockCrc32, blockContentPosition + block.compressedSize)];
-                    case 8:
-                        crc = _a.sent();
-                        block.crc32 = crc.crc32;
-                        if (!this.validateChecksums) return [3 /*break*/, 10];
-                        return [4 /*yield*/, this.checkCrc32(position, block._size + block.compressedSize, block.crc32, 'block data')];
-                    case 9:
-                        _a.sent();
-                        _a.label = 10;
-                    case 10:
-                        // make the endposition and size reflect the whole block
-                        block._endPosition = crc._endPosition;
-                        block._size =
-                            block.compressedSize + sectionParsers.cramBlockCrc32.maxLength;
-                        return [3 /*break*/, 12];
-                    case 11:
-                        block._endPosition = blockContentPosition + block.compressedSize;
-                        block._size = block.compressedSize;
-                        _a.label = 12;
-                    case 12: return [2 /*return*/, block];
+    }
+    readBlock(position) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { majorVersion } = yield this.getDefinition();
+            const sectionParsers = yield this.getSectionParsers();
+            const blockHeader = yield this.readBlockHeader(position);
+            if (blockHeader === undefined) {
+                return undefined;
+            }
+            const blockContentPosition = blockHeader._endPosition;
+            const uncompressedData = Buffer.allocUnsafe(blockHeader.uncompressedSize);
+            const block = Object.assign(Object.assign({}, blockHeader), { _endPosition: blockContentPosition, contentPosition: blockContentPosition, content: uncompressedData });
+            if (blockHeader.compressionMethod !== 'raw') {
+                const compressedData = Buffer.allocUnsafe(blockHeader.compressedSize);
+                yield this.read(compressedData, 0, blockHeader.compressedSize, blockContentPosition);
+                this._uncompress(blockHeader.compressionMethod, compressedData, uncompressedData);
+            }
+            else {
+                yield this.read(uncompressedData, 0, blockHeader.uncompressedSize, blockContentPosition);
+            }
+            if (majorVersion >= 3) {
+                // parse the crc32
+                const crc = yield this._parseSection(sectionParsers.cramBlockCrc32, blockContentPosition + blockHeader.compressedSize);
+                if (crc === undefined) {
+                    return undefined;
                 }
-            });
+                block.crc32 = crc.crc32;
+                // check the block data crc32
+                if (this.validateChecksums) {
+                    yield this.checkCrc32(position, blockHeader._size + blockHeader.compressedSize, crc.crc32, 'block data');
+                }
+                // make the endposition and size reflect the whole block
+                block._endPosition = crc._endPosition;
+                block._size =
+                    block.compressedSize + sectionParsers.cramBlockCrc32.maxLength;
+            }
+            else {
+                block._endPosition = blockContentPosition + block.compressedSize;
+                block._size = block.compressedSize;
+            }
+            return block;
         });
-    };
-    return CramFile;
-}());
+    }
+}
 exports.default = CramFile;
 'getDefinition getSectionParsers getSamHeader'
     .split(' ')
-    .forEach(function (method) { return (0, util_1.tinyMemoize)(CramFile, method); });
+    .forEach(method => (0, util_1.tinyMemoize)(CramFile, method));
 //# sourceMappingURL=file.js.map