@gmod/tabix 1.5.0 → 1.5.3

package/esm/tabixIndexedFile.js

@@ -0,0 +1,398 @@
+import AbortablePromiseCache from 'abortable-promise-cache';
+import LRU from 'quick-lru';
+import { LocalFile } from 'generic-filehandle';
+import { unzip, unzipChunkSlice } from '@gmod/bgzf-filehandle';
+import { checkAbortSignal } from './util';
+import TBI from './tbi';
+import CSI from './csi';
+function timeout(time) {
+    return new Promise(resolve => {
+        setTimeout(resolve, time);
+    });
+}
+export default 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 LocalFile(path);
+        }
+        else {
+            throw new TypeError('must provide either filehandle or path');
+        }
+        if (tbiFilehandle) {
+            this.index = new TBI({
+                filehandle: tbiFilehandle,
+                renameRefSeqs,
+            });
+        }
+        else if (csiFilehandle) {
+            this.index = new CSI({
+                filehandle: csiFilehandle,
+                renameRefSeqs,
+            });
+        }
+        else if (tbiPath) {
+            this.index = new TBI({
+                filehandle: new LocalFile(tbiPath),
+                renameRefSeqs,
+            });
+        }
+        else if (csiPath) {
+            this.index = new CSI({
+                filehandle: new LocalFile(csiPath),
+                renameRefSeqs,
+            });
+        }
+        else if (path) {
+            this.index = new TBI({
+                filehandle: new 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 AbortablePromiseCache({
+            cache: new LRU({
+                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);
+        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);
+        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();
+            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();
+                    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);
+        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);
+        checkAbortSignal(opts.signal);
+        try {
+            bytes = await 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);
+        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 unzipChunkSlice(compressedData, chunk);
+        }
+        catch (e) {
+            throw new Error(`error decompressing chunk ${chunk.toString()} ${e}`);
+        }
+    }
+}
+//# sourceMappingURL=tabixIndexedFile.js.map

package/esm/tabixIndexedFile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tabixIndexedFile.js","sourceRoot":"","sources":["../src/tabixIndexedFile.ts"],"names":[],"mappings":"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"}

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,216 @@
+import Long from 'long';
+import VirtualOffset, { fromBytes } from './virtualOffset';
+import Chunk from './chunk';
+import { unzip } from '@gmod/bgzf-filehandle';
+import { longToNumber, optimizeChunks, checkAbortSignal } from './util';
+import IndexFile from './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)],
+    ];
+}
+export default class TabixIndex extends IndexFile {
+    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 unzip((await this.filehandle.readFile(opts)));
+        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 = fromBytes(bytes, currOffset);
+                        const v = fromBytes(bytes, currOffset + 8);
+                        currOffset += 16;
+                        firstDataLine = this._findFirstData(firstDataLine, u);
+                        chunks[k] = new Chunk(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] = 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 = longToNumber(Long.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(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(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 optimizeChunks(chunks, lowest);
+    }
+}
+//# sourceMappingURL=tbi.js.map