@gmod/tabix 1.5.0 → 1.5.1

package/esm/tabixIndexedFile.js

@@ -0,0 +1,403 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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(resolve => {
+        setTimeout(resolve, time);
+    });
+}
+class TabixIndexedFile {
+    /**
+     * @param {object} args
+     * @param {string} [args.path]
+     * @param {filehandle} [args.filehandle]
+     * @param {string} [args.tbiPath]
+     * @param {filehandle} [args.tbiFilehandle]
+     * @param {string} [args.csiPath]
+     * @param {filehandle} [args.csiFilehandle]
+     * @param {chunkSizeLimit} default 50MiB
+     * @param {function} [args.renameRefSeqs] optional function with sig `string => string` to transform
+     * reference sequence names for the purpose of indexing and querying. note that the data that is returned is
+     * not altered, just the names of the reference sequences that are used for querying.
+     * @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
+     */
+    constructor({ path, filehandle, tbiPath, tbiFilehandle, csiPath, csiFilehandle, chunkSizeLimit = 50000000, renameRefSeqs = n => n, chunkCacheSize = 5 * 2 ** 20, }) {
+        if (filehandle) {
+            this.filehandle = filehandle;
+        }
+        else if (path) {
+            this.filehandle = new generic_filehandle_1.LocalFile(path);
+        }
+        else {
+            throw new TypeError('must provide either filehandle or path');
+        }
+        if (tbiFilehandle) {
+            this.index = new tbi_1.default({
+                filehandle: tbiFilehandle,
+                renameRefSeqs,
+            });
+        }
+        else if (csiFilehandle) {
+            this.index = new csi_1.default({
+                filehandle: csiFilehandle,
+                renameRefSeqs,
+            });
+        }
+        else if (tbiPath) {
+            this.index = new tbi_1.default({
+                filehandle: new generic_filehandle_1.LocalFile(tbiPath),
+                renameRefSeqs,
+            });
+        }
+        else if (csiPath) {
+            this.index = new csi_1.default({
+                filehandle: new generic_filehandle_1.LocalFile(csiPath),
+                renameRefSeqs,
+            });
+        }
+        else if (path) {
+            this.index = new tbi_1.default({
+                filehandle: new generic_filehandle_1.LocalFile(`${path}.tbi`),
+                renameRefSeqs,
+            });
+        }
+        else {
+            throw new TypeError('must provide one of tbiFilehandle, tbiPath, csiFilehandle, or csiPath');
+        }
+        this.chunkSizeLimit = chunkSizeLimit;
+        this.renameRefSeq = renameRefSeqs;
+        this.chunkCache = new abortable_promise_cache_1.default({
+            cache: new quick_lru_1.default({
+                maxSize: Math.floor(chunkCacheSize / (1 << 16)),
+            }),
+            fill: this.readChunk.bind(this),
+        });
+    }
+    /**
+     * @param {string} refName name of the reference sequence
+     * @param {number} start start of the region (in 0-based half-open coordinates)
+     * @param {number} end end of the region (in 0-based half-open coordinates)
+     * @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
+     */
+    async getLines(refName, start, end, opts) {
+        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 = await 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 = await 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 } = await 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);
+                    await timeout(1);
+                }
+            }
+        }
+    }
+    async getMetadata(opts = {}) {
+        return this.index.getMetadata(opts);
+    }
+    /**
+     * get a buffer containing the "header" region of
+     * the file, which are the bytes up to the first
+     * non-meta line
+     *
+     * @returns {Promise} for a buffer
+     */
+    async getHeaderBuffer(opts = {}) {
+        const { firstDataLine, metaChar, maxBlockSize } = await 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 = await this._readRegion(0, maxFetch, opts);
+        (0, util_1.checkAbortSignal)(opts.signal);
+        try {
+            bytes = await (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
+     */
+    async getHeader(opts = {}) {
+        const bytes = await 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.
+     *
+     * reference sequence renaming is not applied to these names.
+     *
+     * @returns {Promise} for an array of string sequence names
+     */
+    async getReferenceSequenceNames(opts = {}) {
+        const metadata = await this.getMetadata(opts);
+        return metadata.refIdToName;
+    }
+    /**
+     * @param {object} metadata metadata object from the parsed index,
+     * containing columnNumbers, metaChar, and format
+     * @param {string} regionRefName
+     * @param {number} regionStart region start coordinate (0-based-half-open)
+     * @param {number} regionEnd region end coordinate (0-based-half-open)
+     * @param {array[string]} line
+     * @returns {object} like `{startCoordinate, overlaps}`. overlaps is boolean,
+     * true if line is a data line that overlaps the given region
+     */
+    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
+        let { ref, start, end } = columnNumbers;
+        if (!ref) {
+            ref = 0;
+        }
+        if (!start) {
+            start = 0;
+        }
+        if (!end) {
+            end = 0;
+        }
+        if (format === 'VCF') {
+            end = 8;
+        }
+        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
+        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)) !==
+                        regionRefName) {
+                        return { overlaps: false };
+                    }
+                }
+                else if (currentColumnNumber === start) {
+                    startCoordinate = parseInt(line.slice(currentColumnStart, i), 10);
+                    // we convert to 0-based-half-open
+                    if (coordinateType === '1-based-closed') {
+                        startCoordinate -= 1;
+                    }
+                    if (startCoordinate >= regionEnd) {
+                        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, overlaps: false };
+                        }
+                    }
+                }
+                else if (format === 'VCF' && currentColumnNumber === 4) {
+                    refSeq = line.slice(currentColumnStart, i);
+                }
+                else if (currentColumnNumber === end) {
+                    let endCoordinate;
+                    // this will never match if there is no end column
+                    if (format === 'VCF') {
+                        endCoordinate = this._getVcfEnd(startCoordinate, refSeq, line.slice(currentColumnStart, i));
+                    }
+                    else {
+                        endCoordinate = parseInt(line.slice(currentColumnStart, i), 10);
+                    }
+                    if (endCoordinate <= regionStart) {
+                        return { overlaps: false };
+                    }
+                }
+                currentColumnStart = i + 1;
+                currentColumnNumber += 1;
+                if (currentColumnNumber > maxColumn) {
+                    break;
+                }
+            }
+        }
+        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
+        const isTRA = info.indexOf('SVTYPE=TRA') !== -1;
+        if (info[0] !== '.' && !isTRA) {
+            let prevChar = ';';
+            for (let j = 0; j < info.length; j += 1) {
+                if (prevChar === ';' && info.slice(j, j + 4) === 'END=') {
+                    let valueEnd = info.indexOf(';', j);
+                    if (valueEnd === -1) {
+                        valueEnd = info.length;
+                    }
+                    endCoordinate = parseInt(info.slice(j + 4, valueEnd), 10);
+                    break;
+                }
+                prevChar = info[j];
+            }
+        }
+        else if (isTRA) {
+            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
+     */
+    async lineCount(refName, opts = {}) {
+        return this.index.lineCount(refName, opts);
+    }
+    async _readRegion(position, compressedSize, opts = {}) {
+        const { bytesRead, buffer } = await 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
+     */
+    async readChunk(chunk, opts = {}) {
+        // fetch the uncompressed data, uncompress carefully a block at a time,
+        // and stop when done
+        const compressedData = await 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}`);
+        }
+    }
+}
+exports.default = TabixIndexedFile;

package/esm/tbi.d.ts

@@ -0,0 +1,45 @@
+/// <reference types="node" />
+import VirtualOffset from './virtualOffset';
+import Chunk from './chunk';
+import IndexFile, { Options } from './indexFile';
+export default class TabixIndex extends IndexFile {
+    lineCount(refName: string, opts?: Options): Promise<any>;
+    _parse(opts?: Options): Promise<{
+        indices: {
+            binIndex: {
+                [key: number]: Chunk[];
+            };
+            linearIndex: any[];
+            stats: {
+                lineCount: number;
+            } | undefined;
+        }[];
+        metaChar: string | null;
+        maxBinNumber: number;
+        maxRefLength: number;
+        skipLines: any;
+        firstDataLine: VirtualOffset | undefined;
+        columnNumbers: {
+            ref: any;
+            start: any;
+            end: any;
+        };
+        coordinateType: string;
+        format: string;
+        refIdToName: string[];
+        refNameToId: {
+            [key: string]: number;
+        };
+        maxBlockSize: number;
+    }>;
+    parsePseudoBin(bytes: Buffer, offset: number): {
+        lineCount: number;
+    };
+    _parseNameBytes(namesBytes: Buffer): {
+        refNameToId: {
+            [key: string]: number;
+        };
+        refIdToName: string[];
+    };
+    blocksForRange(refName: string, min: number, max: number, opts?: Options): Promise<Chunk[]>;
+}

package/esm/tbi.js

@@ -0,0 +1,240 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const long_1 = __importDefault(require("long"));
+const virtualOffset_1 = __importStar(require("./virtualOffset"));
+const chunk_1 = __importDefault(require("./chunk"));
+const bgzf_filehandle_1 = require("@gmod/bgzf-filehandle");
+const util_1 = require("./util");
+const indexFile_1 = __importDefault(require("./indexFile"));
+const TBI_MAGIC = 21578324; // TBI\1
+const TAD_LIDX_SHIFT = 14;
+/**
+ * calculate the list of bins that may overlap with region [beg,end) (zero-based half-open)
+ */
+function reg2bins(beg, end) {
+    beg += 1; // < convert to 1-based closed
+    end -= 1;
+    return [
+        [0, 0],
+        [1 + (beg >> 26), 1 + (end >> 26)],
+        [9 + (beg >> 23), 9 + (end >> 23)],
+        [73 + (beg >> 20), 73 + (end >> 20)],
+        [585 + (beg >> 17), 585 + (end >> 17)],
+        [4681 + (beg >> 14), 4681 + (end >> 14)],
+    ];
+}
+class TabixIndex extends indexFile_1.default {
+    async lineCount(refName, opts = {}) {
+        const indexData = await this.parse(opts);
+        if (!indexData) {
+            return -1;
+        }
+        const refId = indexData.refNameToId[refName];
+        const idx = indexData.indices[refId];
+        if (!idx) {
+            return -1;
+        }
+        const { stats } = indexData.indices[refId];
+        if (stats) {
+            return stats.lineCount;
+        }
+        return -1;
+    }
+    // memoize
+    // fetch and parse the index
+    async _parse(opts = {}) {
+        const bytes = await (0, bgzf_filehandle_1.unzip)((await this.filehandle.readFile(opts)));
+        (0, util_1.checkAbortSignal)(opts.signal);
+        // check TBI magic numbers
+        if (bytes.readUInt32LE(0) !== TBI_MAGIC /* "TBI\1" */) {
+            throw new Error('Not a TBI file');
+            // TODO: do we need to support big-endian TBI files?
+        }
+        // number of reference sequences in the index
+        const refCount = bytes.readInt32LE(4);
+        const formatFlags = bytes.readInt32LE(8);
+        const coordinateType = formatFlags & 0x10000 ? 'zero-based-half-open' : '1-based-closed';
+        const formatOpts = {
+            0: 'generic',
+            1: 'SAM',
+            2: 'VCF',
+        };
+        const format = formatOpts[formatFlags & 0xf];
+        if (!format) {
+            throw new Error(`invalid Tabix preset format flags ${formatFlags}`);
+        }
+        const columnNumbers = {
+            ref: bytes.readInt32LE(12),
+            start: bytes.readInt32LE(16),
+            end: bytes.readInt32LE(20),
+        };
+        const metaValue = bytes.readInt32LE(24);
+        const depth = 5;
+        const maxBinNumber = ((1 << ((depth + 1) * 3)) - 1) / 7;
+        const maxRefLength = 2 ** (14 + depth * 3);
+        const metaChar = metaValue ? String.fromCharCode(metaValue) : null;
+        const skipLines = bytes.readInt32LE(28);
+        // read sequence dictionary
+        const nameSectionLength = bytes.readInt32LE(32);
+        const { refNameToId, refIdToName } = this._parseNameBytes(bytes.slice(36, 36 + nameSectionLength));
+        // read the indexes for each reference sequence
+        let currOffset = 36 + nameSectionLength;
+        let firstDataLine;
+        const indices = new Array(refCount).fill(0).map(() => {
+            // the binning index
+            const binCount = bytes.readInt32LE(currOffset);
+            currOffset += 4;
+            const binIndex = {};
+            let stats;
+            for (let j = 0; j < binCount; j += 1) {
+                const bin = bytes.readUInt32LE(currOffset);
+                currOffset += 4;
+                if (bin > maxBinNumber + 1) {
+                    throw new Error('tabix index contains too many bins, please use a CSI index');
+                }
+                else if (bin === maxBinNumber + 1) {
+                    const chunkCount = bytes.readInt32LE(currOffset);
+                    currOffset += 4;
+                    if (chunkCount === 2) {
+                        stats = this.parsePseudoBin(bytes, currOffset);
+                    }
+                    currOffset += 16 * chunkCount;
+                }
+                else {
+                    const chunkCount = bytes.readInt32LE(currOffset);
+                    currOffset += 4;
+                    const chunks = new Array(chunkCount);
+                    for (let k = 0; k < chunkCount; k += 1) {
+                        const u = (0, virtualOffset_1.fromBytes)(bytes, currOffset);
+                        const v = (0, virtualOffset_1.fromBytes)(bytes, currOffset + 8);
+                        currOffset += 16;
+                        firstDataLine = this._findFirstData(firstDataLine, u);
+                        chunks[k] = new chunk_1.default(u, v, bin);
+                    }
+                    binIndex[bin] = chunks;
+                }
+            }
+            // the linear index
+            const linearCount = bytes.readInt32LE(currOffset);
+            currOffset += 4;
+            const linearIndex = new Array(linearCount);
+            for (let k = 0; k < linearCount; k += 1) {
+                linearIndex[k] = (0, virtualOffset_1.fromBytes)(bytes, currOffset);
+                currOffset += 8;
+                firstDataLine = this._findFirstData(firstDataLine, linearIndex[k]);
+            }
+            return { binIndex, linearIndex, stats };
+        });
+        return {
+            indices,
+            metaChar,
+            maxBinNumber,
+            maxRefLength,
+            skipLines,
+            firstDataLine,
+            columnNumbers,
+            coordinateType,
+            format,
+            refIdToName,
+            refNameToId,
+            maxBlockSize: 1 << 16,
+        };
+    }
+    parsePseudoBin(bytes, offset) {
+        const lineCount = (0, util_1.longToNumber)(long_1.default.fromBytesLE(bytes.slice(offset + 16, offset + 24), true));
+        return { lineCount };
+    }
+    _parseNameBytes(namesBytes) {
+        let currRefId = 0;
+        let currNameStart = 0;
+        const refIdToName = [];
+        const refNameToId = {};
+        for (let i = 0; i < namesBytes.length; i += 1) {
+            if (!namesBytes[i]) {
+                if (currNameStart < i) {
+                    let refName = namesBytes.toString('utf8', currNameStart, i);
+                    refName = this.renameRefSeq(refName);
+                    refIdToName[currRefId] = refName;
+                    refNameToId[refName] = currRefId;
+                }
+                currNameStart = i + 1;
+                currRefId += 1;
+            }
+        }
+        return { refNameToId, refIdToName };
+    }
+    async blocksForRange(refName, min, max, opts = {}) {
+        if (min < 0) {
+            min = 0;
+        }
+        const indexData = await this.parse(opts);
+        if (!indexData) {
+            return [];
+        }
+        const refId = indexData.refNameToId[refName];
+        const ba = indexData.indices[refId];
+        if (!ba) {
+            return [];
+        }
+        const minOffset = ba.linearIndex.length
+            ? ba.linearIndex[min >> TAD_LIDX_SHIFT >= ba.linearIndex.length
+                ? ba.linearIndex.length - 1
+                : min >> TAD_LIDX_SHIFT]
+            : new virtualOffset_1.default(0, 0);
+        if (!minOffset) {
+            console.warn('querying outside of possible tabix range');
+        }
+        // const { linearIndex, binIndex } = indexes
+        const overlappingBins = reg2bins(min, max); // List of bin #s that overlap min, max
+        const chunks = [];
+        // Find chunks in overlapping bins.  Leaf bins (< 4681) are not pruned
+        for (const [start, end] of overlappingBins) {
+            for (let bin = start; bin <= end; bin++) {
+                if (ba.binIndex[bin]) {
+                    const binChunks = ba.binIndex[bin];
+                    for (let c = 0; c < binChunks.length; ++c) {
+                        chunks.push(new chunk_1.default(binChunks[c].minv, binChunks[c].maxv, bin));
+                    }
+                }
+            }
+        }
+        // Use the linear index to find minimum file position of chunks that could
+        // contain alignments in the region
+        const nintv = ba.linearIndex.length;
+        let lowest = null;
+        const minLin = Math.min(min >> 14, nintv - 1);
+        const maxLin = Math.min(max >> 14, nintv - 1);
+        for (let i = minLin; i <= maxLin; ++i) {
+            const vp = ba.linearIndex[i];
+            if (vp) {
+                if (!lowest || vp.compareTo(lowest) < 0) {
+                    lowest = vp;
+                }
+            }
+        }
+        return (0, util_1.optimizeChunks)(chunks, lowest);
+    }
+}
+exports.default = TabixIndex;