@gmod/tabix 1.5.4 → 1.5.5

package/dist/tabixIndexedFile.js

@@ -8,50 +8,23 @@ 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 abortable_promise_cache_1 = __importDefault(require("abortable-promise-cache"));
-var quick_lru_1 = __importDefault(require("quick-lru"));
-var generic_filehandle_1 = require("generic-filehandle");
-var bgzf_filehandle_1 = require("@gmod/bgzf-filehandle");
-var util_1 = require("./util");
-var tbi_1 = __importDefault(require("./tbi"));
-var csi_1 = __importDefault(require("./csi"));
+const abortable_promise_cache_1 = __importDefault(require("abortable-promise-cache"));
+const quick_lru_1 = __importDefault(require("quick-lru"));
+const generic_filehandle_1 = require("generic-filehandle");
+const bgzf_filehandle_1 = require("@gmod/bgzf-filehandle");
+const util_1 = require("./util");
+const tbi_1 = __importDefault(require("./tbi"));
+const csi_1 = __importDefault(require("./csi"));
 function timeout(time) {
-    return new Promise(function (resolve) {
+    return new Promise(resolve => {
         setTimeout(resolve, time);
     });
 }
-var TabixIndexedFile = /** @class */ (function () {
+class TabixIndexedFile {
     /**
      * @param {object} args
      * @param {string} [args.path]
@@ -67,8 +40,7 @@ var TabixIndexedFile = /** @class */ (function () {
      * @param {number} [args.chunkCacheSize] maximum size in bytes of the chunk cache. default 5MB
      * @param {number} [args.blockCacheSize] maximum size in bytes of the block cache. default 5MB
      */
-    function TabixIndexedFile(_a) {
-        var path = _a.path, filehandle = _a.filehandle, tbiPath = _a.tbiPath, tbiFilehandle = _a.tbiFilehandle, csiPath = _a.csiPath, csiFilehandle = _a.csiFilehandle, _b = _a.chunkSizeLimit, chunkSizeLimit = _b === void 0 ? 50000000 : _b, _c = _a.renameRefSeqs, renameRefSeqs = _c === void 0 ? function (n) { return n; } : _c, _d = _a.chunkCacheSize, chunkCacheSize = _d === void 0 ? 5 * Math.pow(2, 20) : _d;
+    constructor({ path, filehandle, tbiPath, tbiFilehandle, csiPath, csiFilehandle, chunkSizeLimit = 50000000, renameRefSeqs = n => n, chunkCacheSize = 5 * Math.pow(2, 20), }) {
         if (filehandle) {
             this.filehandle = filehandle;
         }
@@ -81,31 +53,31 @@ var TabixIndexedFile = /** @class */ (function () {
         if (tbiFilehandle) {
             this.index = new tbi_1.default({
                 filehandle: tbiFilehandle,
-                renameRefSeqs: renameRefSeqs,
+                renameRefSeqs,
             });
         }
         else if (csiFilehandle) {
             this.index = new csi_1.default({
                 filehandle: csiFilehandle,
-                renameRefSeqs: renameRefSeqs,
+                renameRefSeqs,
             });
         }
         else if (tbiPath) {
             this.index = new tbi_1.default({
                 filehandle: new generic_filehandle_1.LocalFile(tbiPath),
-                renameRefSeqs: renameRefSeqs,
+                renameRefSeqs,
             });
         }
         else if (csiPath) {
             this.index = new csi_1.default({
                 filehandle: new generic_filehandle_1.LocalFile(csiPath),
-                renameRefSeqs: renameRefSeqs,
+                renameRefSeqs,
             });
         }
         else if (path) {
             this.index = new tbi_1.default({
-                filehandle: new generic_filehandle_1.LocalFile("".concat(path, ".tbi")),
-                renameRefSeqs: renameRefSeqs,
+                filehandle: new generic_filehandle_1.LocalFile(`${path}.tbi`),
+                renameRefSeqs,
             });
         }
         else {
@@ -127,133 +99,110 @@ var TabixIndexedFile = /** @class */ (function () {
      * @param {function|object} lineCallback callback called for each line in the region. can also pass a object param containing obj.lineCallback, obj.signal, etc
      * @returns {Promise} resolved when the whole read is finished, rejected on error
      */
-    TabixIndexedFile.prototype.getLines = function (refName, start, end, opts) {
-        return __awaiter(this, void 0, void 0, function () {
-            var signal, options, callback, metadata, chunks, i, size, last, chunkNum, previousStartCoordinate, c, _a, buffer, cpositions, dpositions, lines, blockStart, pos, i, line, _b, startCoordinate, overlaps;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        options = {};
-                        if (typeof opts === 'undefined') {
-                            throw new TypeError('line callback must be provided');
-                        }
-                        if (typeof opts === 'function') {
-                            callback = opts;
-                        }
-                        else {
-                            options = opts;
-                            callback = opts.lineCallback;
-                        }
-                        if (refName === undefined) {
-                            throw new TypeError('must provide a reference sequence name');
-                        }
-                        if (!callback) {
-                            throw new TypeError('line callback must be provided');
-                        }
-                        return [4 /*yield*/, this.index.getMetadata(options)];
-                    case 1:
-                        metadata = _c.sent();
-                        (0, util_1.checkAbortSignal)(signal);
-                        if (!start) {
-                            start = 0;
-                        }
-                        if (!end) {
-                            end = metadata.maxRefLength;
-                        }
-                        if (!(start <= end)) {
-                            throw new TypeError('invalid start and end coordinates. start must be less than or equal to end');
-                        }
-                        if (start === end) {
-                            return [2 /*return*/];
-                        }
-                        return [4 /*yield*/, this.index.blocksForRange(refName, start, end, options)];
-                    case 2:
-                        chunks = _c.sent();
-                        (0, util_1.checkAbortSignal)(signal);
-                        // check the chunks for any that are over the size limit.  if
-                        // any are, don't fetch any of them
-                        for (i = 0; i < chunks.length; i += 1) {
-                            size = chunks[i].fetchedSize();
-                            if (size > this.chunkSizeLimit) {
-                                throw new Error("Too much data. Chunk size ".concat(size.toLocaleString(), " bytes exceeds chunkSizeLimit of ").concat(this.chunkSizeLimit.toLocaleString(), "."));
-                            }
-                        }
-                        last = Date.now();
-                        chunkNum = 0;
-                        _c.label = 3;
-                    case 3:
-                        if (!(chunkNum < chunks.length)) return [3 /*break*/, 9];
-                        previousStartCoordinate = void 0;
-                        c = chunks[chunkNum];
-                        return [4 /*yield*/, this.chunkCache.get(c.toString(), c, signal)];
-                    case 4:
-                        _a = _c.sent(), buffer = _a.buffer, cpositions = _a.cpositions, dpositions = _a.dpositions;
-                        lines = (typeof TextDecoder !== 'undefined'
-                            ? new TextDecoder('utf-8').decode(buffer)
-                            : buffer.toString()).split('\n');
-                        lines.pop();
-                        (0, util_1.checkAbortSignal)(signal);
-                        blockStart = c.minv.dataPosition;
-                        pos = void 0;
-                        i = 0;
-                        _c.label = 5;
-                    case 5:
-                        if (!(i < lines.length)) return [3 /*break*/, 8];
-                        line = lines[i];
-                        for (pos = 0; blockStart >= dpositions[pos]; pos += 1) { }
-                        _b = this.checkLine(metadata, refName, start, end, line), startCoordinate = _b.startCoordinate, overlaps = _b.overlaps;
-                        // do a small check just to make sure that the lines are really sorted by start coordinate
-                        if (previousStartCoordinate !== undefined &&
-                            startCoordinate !== undefined &&
-                            previousStartCoordinate > startCoordinate) {
-                            throw new Error("Lines not sorted by start coordinate (".concat(previousStartCoordinate, " > ").concat(startCoordinate, "), this file is not usable with Tabix."));
-                        }
-                        previousStartCoordinate = startCoordinate;
-                        if (overlaps) {
-                            callback(line.trim(), 
-                            // cpositions[pos] refers to actual file offset of a bgzip block boundaries
-                            //
-                            // we multiply by (1 <<8) in order to make sure each block has a "unique"
-                            // address space so that data in that block could never overlap
-                            //
-                            // then the blockStart-dpositions is an uncompressed file offset from
-                            // that bgzip block boundary, and since the cpositions are multiplied by
-                            // (1 << 8) these uncompressed offsets get a unique space
-                            cpositions[pos] * (1 << 8) + (blockStart - dpositions[pos]));
-                        }
-                        else if (startCoordinate !== undefined && startCoordinate >= end) {
-                            // the lines were overlapping the region, but now have stopped, so
-                            // we must be at the end of the relevant data and we can stop
-                            // processing data now
-                            return [2 /*return*/];
-                        }
-                        blockStart += line.length + 1;
-                        if (!(last - Date.now() > 500)) return [3 /*break*/, 7];
+    getLines(refName, start, end, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let signal;
+            let options = {};
+            let callback;
+            if (typeof opts === 'undefined') {
+                throw new TypeError('line callback must be provided');
+            }
+            if (typeof opts === 'function') {
+                callback = opts;
+            }
+            else {
+                options = opts;
+                callback = opts.lineCallback;
+            }
+            if (refName === undefined) {
+                throw new TypeError('must provide a reference sequence name');
+            }
+            if (!callback) {
+                throw new TypeError('line callback must be provided');
+            }
+            const metadata = yield this.index.getMetadata(options);
+            (0, util_1.checkAbortSignal)(signal);
+            if (!start) {
+                start = 0;
+            }
+            if (!end) {
+                end = metadata.maxRefLength;
+            }
+            if (!(start <= end)) {
+                throw new TypeError('invalid start and end coordinates. start must be less than or equal to end');
+            }
+            if (start === end) {
+                return;
+            }
+            const chunks = yield this.index.blocksForRange(refName, start, end, options);
+            (0, util_1.checkAbortSignal)(signal);
+            // check the chunks for any that are over the size limit.  if
+            // any are, don't fetch any of them
+            for (let i = 0; i < chunks.length; i += 1) {
+                const size = chunks[i].fetchedSize();
+                if (size > this.chunkSizeLimit) {
+                    throw new Error(`Too much data. Chunk size ${size.toLocaleString()} bytes exceeds chunkSizeLimit of ${this.chunkSizeLimit.toLocaleString()}.`);
+                }
+            }
+            // now go through each chunk and parse and filter the lines out of it
+            let last = Date.now();
+            for (let chunkNum = 0; chunkNum < chunks.length; chunkNum += 1) {
+                let previousStartCoordinate;
+                const c = chunks[chunkNum];
+                const { buffer, cpositions, dpositions } = yield this.chunkCache.get(c.toString(), c, signal);
+                const lines = (typeof TextDecoder !== 'undefined'
+                    ? new TextDecoder('utf-8').decode(buffer)
+                    : buffer.toString()).split('\n');
+                lines.pop();
+                (0, util_1.checkAbortSignal)(signal);
+                let blockStart = c.minv.dataPosition;
+                let pos;
+                for (let i = 0; i < lines.length; i += 1) {
+                    const line = lines[i];
+                    for (pos = 0; blockStart >= dpositions[pos]; pos += 1) { }
+                    // filter the line for whether it is within the requested range
+                    const { startCoordinate, overlaps } = this.checkLine(metadata, refName, start, end, line);
+                    // do a small check just to make sure that the lines are really sorted by start coordinate
+                    if (previousStartCoordinate !== undefined &&
+                        startCoordinate !== undefined &&
+                        previousStartCoordinate > startCoordinate) {
+                        throw new Error(`Lines not sorted by start coordinate (${previousStartCoordinate} > ${startCoordinate}), this file is not usable with Tabix.`);
+                    }
+                    previousStartCoordinate = startCoordinate;
+                    if (overlaps) {
+                        callback(line.trim(), 
+                        // cpositions[pos] refers to actual file offset of a bgzip block boundaries
+                        //
+                        // we multiply by (1 <<8) in order to make sure each block has a "unique"
+                        // address space so that data in that block could never overlap
+                        //
+                        // then the blockStart-dpositions is an uncompressed file offset from
+                        // that bgzip block boundary, and since the cpositions are multiplied by
+                        // (1 << 8) these uncompressed offsets get a unique space
+                        cpositions[pos] * (1 << 8) + (blockStart - dpositions[pos]));
+                    }
+                    else if (startCoordinate !== undefined && startCoordinate >= end) {
+                        // the lines were overlapping the region, but now have stopped, so
+                        // we must be at the end of the relevant data and we can stop
+                        // processing data now
+                        return;
+                    }
+                    blockStart += line.length + 1;
+                    // yield if we have emitted beyond the yield limit
+                    if (last - Date.now() > 500) {
                         last = Date.now();
                         (0, util_1.checkAbortSignal)(signal);
-                        return [4 /*yield*/, timeout(1)];
-                    case 6:
-                        _c.sent();
-                        _c.label = 7;
-                    case 7:
-                        i += 1;
-                        return [3 /*break*/, 5];
-                    case 8:
-                        chunkNum += 1;
-                        return [3 /*break*/, 3];
-                    case 9: return [2 /*return*/];
+                        yield timeout(1);
+                    }
                 }
-            });
+            }
         });
-    };
-    TabixIndexedFile.prototype.getMetadata = function (opts) {
-        if (opts === void 0) { opts = {}; }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.index.getMetadata(opts)];
-            });
+    }
+    getMetadata(opts = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.index.getMetadata(opts);
         });
-    };
+    }
     /**
      * get a buffer containing the "header" region of
      * the file, which are the bytes up to the first
@@ -261,78 +210,58 @@ var TabixIndexedFile = /** @class */ (function () {
      *
      * @returns {Promise} for a buffer
      */
-    TabixIndexedFile.prototype.getHeaderBuffer = function (opts) {
-        if (opts === void 0) { opts = {}; }
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, firstDataLine, metaChar, maxBlockSize, maxFetch, bytes, e_1, lastNewline, newlineByte, metaByte, i;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.getMetadata(opts)];
-                    case 1:
-                        _a = _b.sent(), firstDataLine = _a.firstDataLine, metaChar = _a.metaChar, maxBlockSize = _a.maxBlockSize;
-                        (0, util_1.checkAbortSignal)(opts.signal);
-                        maxFetch = firstDataLine && firstDataLine.blockPosition
-                            ? firstDataLine.blockPosition + maxBlockSize
-                            : maxBlockSize;
-                        return [4 /*yield*/, this._readRegion(0, maxFetch, opts)];
-                    case 2:
-                        bytes = _b.sent();
-                        (0, util_1.checkAbortSignal)(opts.signal);
-                        _b.label = 3;
-                    case 3:
-                        _b.trys.push([3, 5, , 6]);
-                        return [4 /*yield*/, (0, bgzf_filehandle_1.unzip)(bytes)];
-                    case 4:
-                        bytes = _b.sent();
-                        return [3 /*break*/, 6];
-                    case 5:
-                        e_1 = _b.sent();
-                        console.error(e_1);
-                        throw new Error(
-                        //@ts-ignore
-                        "error decompressing block ".concat(e_1.code, " at 0 (length ").concat(maxFetch, ") ").concat(e_1));
-                    case 6:
-                        // trim off lines after the last non-meta line
-                        if (metaChar) {
-                            lastNewline = -1;
-                            newlineByte = '\n'.charCodeAt(0);
-                            metaByte = metaChar.charCodeAt(0);
-                            for (i = 0; i < bytes.length; i += 1) {
-                                if (i === lastNewline + 1 && bytes[i] !== metaByte) {
-                                    break;
-                                }
-                                if (bytes[i] === newlineByte) {
-                                    lastNewline = i;
-                                }
-                            }
-                            bytes = bytes.slice(0, lastNewline + 1);
-                        }
-                        return [2 /*return*/, bytes];
+    getHeaderBuffer(opts = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { firstDataLine, metaChar, maxBlockSize } = yield this.getMetadata(opts);
+            (0, util_1.checkAbortSignal)(opts.signal);
+            const maxFetch = firstDataLine && firstDataLine.blockPosition
+                ? firstDataLine.blockPosition + maxBlockSize
+                : maxBlockSize;
+            // TODO: what if we don't have a firstDataLine, and the header
+            // actually takes up more than one block? this case is not covered here
+            let bytes = yield this._readRegion(0, maxFetch, opts);
+            (0, util_1.checkAbortSignal)(opts.signal);
+            try {
+                bytes = yield (0, bgzf_filehandle_1.unzip)(bytes);
+            }
+            catch (e) {
+                console.error(e);
+                throw new Error(
+                //@ts-ignore
+                `error decompressing block ${e.code} at 0 (length ${maxFetch}) ${e}`);
+            }
+            // trim off lines after the last non-meta line
+            if (metaChar) {
+                // trim backward from the end
+                let lastNewline = -1;
+                const newlineByte = '\n'.charCodeAt(0);
+                const metaByte = metaChar.charCodeAt(0);
+                for (let i = 0; i < bytes.length; i += 1) {
+                    if (i === lastNewline + 1 && bytes[i] !== metaByte) {
+                        break;
+                    }
+                    if (bytes[i] === newlineByte) {
+                        lastNewline = i;
+                    }
                 }
-            });
+                bytes = bytes.slice(0, lastNewline + 1);
+            }
+            return bytes;
         });
-    };
+    }
     /**
      * get a string containing the "header" region of the
      * file, is the portion up to the first non-meta line
      *
      * @returns {Promise} for a string
      */
-    TabixIndexedFile.prototype.getHeader = function (opts) {
-        if (opts === void 0) { opts = {}; }
-        return __awaiter(this, void 0, void 0, function () {
-            var bytes;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getHeaderBuffer(opts)];
-                    case 1:
-                        bytes = _a.sent();
-                        (0, util_1.checkAbortSignal)(opts.signal);
-                        return [2 /*return*/, bytes.toString('utf8')];
-                }
-            });
+    getHeader(opts = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const bytes = yield this.getHeaderBuffer(opts);
+            (0, util_1.checkAbortSignal)(opts.signal);
+            return bytes.toString('utf8');
         });
-    };
+    }
     /**
      * get an array of reference sequence names, in the order in which
      * they occur in the file.
@@ -341,20 +270,12 @@ var TabixIndexedFile = /** @class */ (function () {
      *
      * @returns {Promise} for an array of string sequence names
      */
-    TabixIndexedFile.prototype.getReferenceSequenceNames = function (opts) {
-        if (opts === void 0) { opts = {}; }
-        return __awaiter(this, void 0, void 0, function () {
-            var metadata;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getMetadata(opts)];
-                    case 1:
-                        metadata = _a.sent();
-                        return [2 /*return*/, metadata.refIdToName];
-                }
-            });
+    getReferenceSequenceNames(opts = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const metadata = yield this.getMetadata(opts);
+            return metadata.refIdToName;
         });
-    };
+    }
     /**
      * @param {object} metadata metadata object from the parsed index,
      * containing columnNumbers, metaChar, and format
@@ -365,14 +286,13 @@ var TabixIndexedFile = /** @class */ (function () {
      * @returns {object} like `{startCoordinate, overlaps}`. overlaps is boolean,
      * true if line is a data line that overlaps the given region
      */
-    TabixIndexedFile.prototype.checkLine = function (_a, regionRefName, regionStart, regionEnd, line) {
-        var columnNumbers = _a.columnNumbers, metaChar = _a.metaChar, coordinateType = _a.coordinateType, format = _a.format;
+    checkLine({ columnNumbers, metaChar, coordinateType, format, }, regionRefName, regionStart, regionEnd, line) {
         // skip meta lines
         if (line.charAt(0) === metaChar) {
             return { overlaps: false };
         }
         // check ref/start/end using column metadata from index
-        var ref = columnNumbers.ref, start = columnNumbers.start, end = columnNumbers.end;
+        let { ref, start, end } = columnNumbers;
         if (!ref) {
             ref = 0;
         }
@@ -385,15 +305,15 @@ var TabixIndexedFile = /** @class */ (function () {
         if (format === 'VCF') {
             end = 8;
         }
-        var maxColumn = Math.max(ref, start, end);
+        const maxColumn = Math.max(ref, start, end);
         // this code is kind of complex, but it is fairly fast.
         // basically, we want to avoid doing a split, because if the lines are really long
         // that could lead to us allocating a bunch of extra memory, which is slow
-        var currentColumnNumber = 1; // cols are numbered starting at 1 in the index metadata
-        var currentColumnStart = 0;
-        var refSeq = '';
-        var startCoordinate = -Infinity;
-        for (var i = 0; i < line.length + 1; i += 1) {
+        let currentColumnNumber = 1; // cols are numbered starting at 1 in the index metadata
+        let currentColumnStart = 0;
+        let refSeq = '';
+        let startCoordinate = -Infinity;
+        for (let i = 0; i < line.length + 1; i += 1) {
             if (line[i] === '\t' || i === line.length) {
                 if (currentColumnNumber === ref) {
                     if (this.renameRefSeq(line.slice(currentColumnStart, i)) !==
@@ -408,12 +328,12 @@ var TabixIndexedFile = /** @class */ (function () {
                         startCoordinate -= 1;
                     }
                     if (startCoordinate >= regionEnd) {
-                        return { startCoordinate: startCoordinate, overlaps: false };
+                        return { startCoordinate, overlaps: false };
                     }
                     if (end === 0 || end === start) {
                         // if we have no end, we assume the feature is 1 bp long
                         if (startCoordinate + 1 <= regionStart) {
-                            return { startCoordinate: startCoordinate, overlaps: false };
+                            return { startCoordinate, overlaps: false };
                         }
                     }
                 }
@@ -421,9 +341,7 @@ var TabixIndexedFile = /** @class */ (function () {
                     refSeq = line.slice(currentColumnStart, i);
                 }
                 else if (currentColumnNumber === end) {
-                    var endCoordinate 
-                    // this will never match if there is no end column
-                    = void 0;
+                    let endCoordinate;
                     // this will never match if there is no end column
                     if (format === 'VCF') {
                         endCoordinate = this._getVcfEnd(startCoordinate, refSeq, line.slice(currentColumnStart, i));
@@ -442,21 +360,21 @@ var TabixIndexedFile = /** @class */ (function () {
                 }
             }
         }
-        return { startCoordinate: startCoordinate, overlaps: true };
-    };
-    TabixIndexedFile.prototype._getVcfEnd = function (startCoordinate, refSeq, info) {
-        var endCoordinate = startCoordinate + refSeq.length;
+        return { startCoordinate, overlaps: true };
+    }
+    _getVcfEnd(startCoordinate, refSeq, info) {
+        let endCoordinate = startCoordinate + refSeq.length;
         // ignore TRA features as they specify CHR2 and END
         // as being on a different chromosome
         // if CHR2 is on the same chromosome, still ignore it
         // because there should be another pairwise feature
         // at the end of this one
-        var isTRA = info.indexOf('SVTYPE=TRA') !== -1;
+        const isTRA = info.indexOf('SVTYPE=TRA') !== -1;
         if (info[0] !== '.' && !isTRA) {
-            var prevChar = ';';
-            for (var j = 0; j < info.length; j += 1) {
+            let prevChar = ';';
+            for (let j = 0; j < info.length; j += 1) {
                 if (prevChar === ';' && info.slice(j, j + 4) === 'END=') {
-                    var valueEnd = info.indexOf(';', j);
+                    let valueEnd = info.indexOf(';', j);
                     if (valueEnd === -1) {
                         valueEnd = info.length;
                     }
@@ -470,61 +388,42 @@ var TabixIndexedFile = /** @class */ (function () {
             return startCoordinate + 1;
         }
         return endCoordinate;
-    };
+    }
     /**
      * return the approximate number of data lines in the given reference sequence
      * @param {string} refSeq reference sequence name
      * @returns {Promise} for number of data lines present on that reference sequence
      */
-    TabixIndexedFile.prototype.lineCount = function (refName, opts) {
-        if (opts === void 0) { opts = {}; }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.index.lineCount(refName, opts)];
-            });
+    lineCount(refName, opts = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.index.lineCount(refName, opts);
         });
-    };
-    TabixIndexedFile.prototype._readRegion = function (position, compressedSize, opts) {
-        if (opts === void 0) { opts = {}; }
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, bytesRead, buffer;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.filehandle.read(Buffer.alloc(compressedSize), 0, compressedSize, position, opts)];
-                    case 1:
-                        _a = _b.sent(), bytesRead = _a.bytesRead, buffer = _a.buffer;
-                        return [2 /*return*/, bytesRead < compressedSize ? buffer.slice(0, bytesRead) : buffer];
-                }
-            });
+    }
+    _readRegion(position, compressedSize, opts = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { bytesRead, buffer } = yield this.filehandle.read(Buffer.alloc(compressedSize), 0, compressedSize, position, opts);
+            return bytesRead < compressedSize ? buffer.slice(0, bytesRead) : buffer;
         });
-    };
+    }
     /**
      * read and uncompress the data in a chunk (composed of one or more
      * contiguous bgzip blocks) of the file
      * @param {Chunk} chunk
      * @returns {Promise} for a string chunk of the file
      */
-    TabixIndexedFile.prototype.readChunk = function (chunk, opts) {
-        if (opts === void 0) { opts = {}; }
-        return __awaiter(this, void 0, void 0, function () {
-            var compressedData;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this._readRegion(chunk.minv.blockPosition, chunk.fetchedSize(), opts)];
-                    case 1:
-                        compressedData = _a.sent();
-                        try {
-                            return [2 /*return*/, (0, bgzf_filehandle_1.unzipChunkSlice)(compressedData, chunk)];
-                        }
-                        catch (e) {
-                            throw new Error("error decompressing chunk ".concat(chunk.toString(), " ").concat(e));
-                        }
-                        return [2 /*return*/];
-                }
-            });
+    readChunk(chunk, opts = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // fetch the uncompressed data, uncompress carefully a block at a time,
+            // and stop when done
+            const compressedData = yield this._readRegion(chunk.minv.blockPosition, chunk.fetchedSize(), opts);
+            try {
+                return (0, bgzf_filehandle_1.unzipChunkSlice)(compressedData, chunk);
+            }
+            catch (e) {
+                throw new Error(`error decompressing chunk ${chunk.toString()} ${e}`);
+            }
         });
-    };
-    return TabixIndexedFile;
-}());
+    }
+}
 exports.default = TabixIndexedFile;
 //# sourceMappingURL=tabixIndexedFile.js.map