@gmod/bam 1.1.8 → 1.1.9

package/esm/bai.js

@@ -0,0 +1,191 @@
+import Long from 'long';
+import { fromBytes } from './virtualOffset';
+import Chunk from './chunk';
+import IndexFile from './indexFile';
+import { longToNumber, abortBreakPoint, optimizeChunks } from './util';
+const BAI_MAGIC = 21578050; // BAI\1
+function roundDown(n, multiple) {
+    return n - (n % multiple);
+}
+function roundUp(n, multiple) {
+    return n - (n % multiple) + multiple;
+}
+export default class BAI extends IndexFile {
+    parsePseudoBin(bytes, offset) {
+        const lineCount = longToNumber(Long.fromBytesLE(Array.prototype.slice.call(bytes, offset + 16, offset + 24), true));
+        return { lineCount };
+    }
+    async lineCount(refId, opts = {}) {
+        const prom = await this.parse(opts);
+        const index = prom.indices[refId];
+        if (!index) {
+            return -1;
+        }
+        const ret = index.stats || {};
+        return ret.lineCount === undefined ? -1 : ret.lineCount;
+    }
+    fetchBai(opts = {}) {
+        if (!this.baiP) {
+            this.baiP = this.filehandle.readFile(opts).catch(e => {
+                this.baiP = undefined;
+                throw e;
+            });
+        }
+        return this.baiP;
+    }
+    // fetch and parse the index
+    async _parse(opts = {}) {
+        const data = { bai: true, maxBlockSize: 1 << 16 };
+        const bytes = await this.fetchBai();
+        // check BAI magic numbers
+        if (bytes.readUInt32LE(0) !== BAI_MAGIC) {
+            throw new Error('Not a BAI file');
+        }
+        data.refCount = bytes.readInt32LE(4);
+        const depth = 5;
+        const binLimit = ((1 << ((depth + 1) * 3)) - 1) / 7;
+        // read the indexes for each reference sequence
+        data.indices = new Array(data.refCount);
+        let currOffset = 8;
+        for (let i = 0; i < data.refCount; i += 1) {
+            await abortBreakPoint(opts.signal);
+            // the binning index
+            const binCount = bytes.readInt32LE(currOffset);
+            let stats;
+            currOffset += 4;
+            const binIndex = {};
+            for (let j = 0; j < binCount; j += 1) {
+                const bin = bytes.readUInt32LE(currOffset);
+                currOffset += 4;
+                if (bin === binLimit + 1) {
+                    currOffset += 4;
+                    stats = this.parsePseudoBin(bytes, currOffset);
+                    currOffset += 32;
+                }
+                else if (bin > binLimit + 1) {
+                    throw new Error('bai index contains too many bins, please use CSI');
+                }
+                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;
+                        this._findFirstData(data, u);
+                        chunks[k] = new Chunk(u, v, bin);
+                    }
+                    binIndex[bin] = chunks;
+                }
+            }
+            const linearCount = bytes.readInt32LE(currOffset);
+            currOffset += 4;
+            // as we're going through the linear index, figure out
+            // the smallest virtual offset in the indexes, which
+            // tells us where the BAM header ends
+            const linearIndex = new Array(linearCount);
+            for (let k = 0; k < linearCount; k += 1) {
+                linearIndex[k] = fromBytes(bytes, currOffset);
+                currOffset += 8;
+                this._findFirstData(data, linearIndex[k]);
+            }
+            data.indices[i] = { binIndex, linearIndex, stats };
+        }
+        return data;
+    }
+    async indexCov(seqId, start, end, opts = {}) {
+        const v = 16384;
+        const range = start !== undefined;
+        const indexData = await this.parse(opts);
+        const seqIdx = indexData.indices[seqId];
+        if (!seqIdx) {
+            return [];
+        }
+        const { linearIndex = [], stats } = seqIdx;
+        if (!linearIndex.length) {
+            return [];
+        }
+        const e = end !== undefined ? roundUp(end, v) : (linearIndex.length - 1) * v;
+        const s = start !== undefined ? roundDown(start, v) : 0;
+        let depths;
+        if (range) {
+            depths = new Array((e - s) / v);
+        }
+        else {
+            depths = new Array(linearIndex.length - 1);
+        }
+        const totalSize = linearIndex[linearIndex.length - 1].blockPosition;
+        if (e > (linearIndex.length - 1) * v) {
+            throw new Error('query outside of range of linear index');
+        }
+        let currentPos = linearIndex[s / v].blockPosition;
+        for (let i = s / v, j = 0; i < e / v; i++, j++) {
+            depths[j] = {
+                score: linearIndex[i + 1].blockPosition - currentPos,
+                start: i * v,
+                end: i * v + v,
+            };
+            currentPos = linearIndex[i + 1].blockPosition;
+        }
+        return depths.map(d => {
+            return { ...d, score: (d.score * stats.lineCount) / totalSize };
+        });
+    }
+    /**
+     * calculate the list of bins that may overlap with region [beg,end) (zero-based half-open)
+     * @returns {Array[number]}
+     */
+    reg2bins(beg, end) {
+        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)],
+        ];
+    }
+    async blocksForRange(refId, min, max, opts = {}) {
+        if (min < 0) {
+            min = 0;
+        }
+        const indexData = await this.parse(opts);
+        if (!indexData) {
+            return [];
+        }
+        const ba = indexData.indices[refId];
+        if (!ba) {
+            return [];
+        }
+        const overlappingBins = this.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=bai.js.map

package/esm/bai.js.map

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

package/esm/bamFile.d.ts

@@ -0,0 +1,77 @@
+/// <reference types="node" />
+import Chunk from './chunk';
+import { GenericFilehandle } from 'generic-filehandle';
+import BAMFeature from './record';
+import { BamOpts, BaseOpts } from './util';
+export declare const BAM_MAGIC = 21840194;
+export default class BamFile {
+    private renameRefSeq;
+    private bam;
+    private index;
+    private chunkSizeLimit;
+    private fetchSizeLimit;
+    private header;
+    protected chrToIndex: any;
+    protected indexToChr: any;
+    private yieldThreadTime;
+    /**
+     * @param {object} args
+     * @param {string} [args.bamPath]
+     * @param {FileHandle} [args.bamFilehandle]
+     * @param {string} [args.baiPath]
+     * @param {FileHandle} [args.baiFilehandle]
+     */
+    constructor({ bamFilehandle, bamPath, bamUrl, baiPath, baiFilehandle, baiUrl, csiPath, csiFilehandle, csiUrl, fetchSizeLimit, chunkSizeLimit, yieldThreadTime, renameRefSeqs, }: {
+        bamFilehandle?: GenericFilehandle;
+        bamPath?: string;
+        bamUrl?: string;
+        baiPath?: string;
+        baiFilehandle?: GenericFilehandle;
+        baiUrl?: string;
+        csiPath?: string;
+        csiFilehandle?: GenericFilehandle;
+        csiUrl?: string;
+        fetchSizeLimit?: number;
+        chunkSizeLimit?: number;
+        renameRefSeqs?: (a: string) => string;
+        yieldThreadTime?: number;
+    });
+    getHeader(origOpts?: AbortSignal | BaseOpts): Promise<{
+        tag: string;
+        data: {
+            tag: string;
+            value: string;
+        }[];
+    }[]>;
+    getHeaderText(opts?: BaseOpts): Promise<any>;
+    _readRefSeqs(start: number, refSeqBytes: number, opts?: BaseOpts): Promise<{
+        chrToIndex: {
+            [key: string]: number;
+        };
+        indexToChr: {
+            refName: string;
+            length: number;
+        }[];
+    }>;
+    getRecordsForRange(chr: string, min: number, max: number, opts?: BamOpts): Promise<BAMFeature[]>;
+    streamRecordsForRange(chr: string, min: number, max: number, opts?: BamOpts): AsyncGenerator<BAMFeature[], void, unknown>;
+    _fetchChunkFeatures(chunks: Chunk[], chrId: number, min: number, max: number, opts: BamOpts): AsyncGenerator<BAMFeature[], void, unknown>;
+    fetchPairs(chrId: number, featPromises: Promise<BAMFeature[]>[], opts: BamOpts): Promise<BAMFeature[]>;
+    _readChunk({ chunk, opts }: {
+        chunk: Chunk;
+        opts: BaseOpts;
+    }): Promise<{
+        data: any;
+        cpositions: any;
+        dpositions: any;
+        chunk: Chunk;
+    }>;
+    readBamFeatures(ba: Buffer, cpositions: number[], dpositions: number[], chunk: Chunk): Promise<BAMFeature[]>;
+    hasRefSeq(seqName: string): Promise<boolean>;
+    lineCount(seqName: string): Promise<number>;
+    indexCov(seqName: string, start?: number, end?: number): Promise<{
+        start: number;
+        end: number;
+        score: number;
+    }[]>;
+}

package/esm/bamFile.js

@@ -0,0 +1,388 @@
+import BAI from './bai';
+import CSI from './csi';
+import crc32 from 'buffer-crc32';
+import { unzip, unzipChunkSlice } from '@gmod/bgzf-filehandle';
+import entries from 'object.entries-ponyfill';
+import { LocalFile, RemoteFile } from 'generic-filehandle';
+import BAMFeature from './record';
+import { parseHeaderText } from './sam';
+import { abortBreakPoint, checkAbortSignal, timeout, makeOpts, } from './util';
+export const BAM_MAGIC = 21840194;
+const blockLen = 1 << 16;
+export default class BamFile {
+    /**
+     * @param {object} args
+     * @param {string} [args.bamPath]
+     * @param {FileHandle} [args.bamFilehandle]
+     * @param {string} [args.baiPath]
+     * @param {FileHandle} [args.baiFilehandle]
+     */
+    constructor({ bamFilehandle, bamPath, bamUrl, baiPath, baiFilehandle, baiUrl, csiPath, csiFilehandle, csiUrl, fetchSizeLimit, chunkSizeLimit, yieldThreadTime = 100, renameRefSeqs = n => n, }) {
+        this.renameRefSeq = renameRefSeqs;
+        if (bamFilehandle) {
+            this.bam = bamFilehandle;
+        }
+        else if (bamPath) {
+            this.bam = new LocalFile(bamPath);
+        }
+        else if (bamUrl) {
+            this.bam = new RemoteFile(bamUrl);
+        }
+        else {
+            throw new Error('unable to initialize bam');
+        }
+        if (csiFilehandle) {
+            this.index = new CSI({ filehandle: csiFilehandle });
+        }
+        else if (csiPath) {
+            this.index = new CSI({ filehandle: new LocalFile(csiPath) });
+        }
+        else if (csiUrl) {
+            this.index = new CSI({ filehandle: new RemoteFile(csiUrl) });
+        }
+        else if (baiFilehandle) {
+            this.index = new BAI({ filehandle: baiFilehandle });
+        }
+        else if (baiPath) {
+            this.index = new BAI({ filehandle: new LocalFile(baiPath) });
+        }
+        else if (baiUrl) {
+            this.index = new BAI({ filehandle: new RemoteFile(baiUrl) });
+        }
+        else if (bamPath) {
+            this.index = new BAI({ filehandle: new LocalFile(`${bamPath}.bai`) });
+        }
+        else if (bamUrl) {
+            this.index = new BAI({ filehandle: new RemoteFile(`${bamUrl}.bai`) });
+        }
+        else {
+            throw new Error('unable to infer index format');
+        }
+        this.fetchSizeLimit = fetchSizeLimit || 500000000; // 500MB
+        this.chunkSizeLimit = chunkSizeLimit || 300000000; // 300MB
+        this.yieldThreadTime = yieldThreadTime;
+    }
+    async getHeader(origOpts = {}) {
+        const opts = makeOpts(origOpts);
+        const indexData = await this.index.parse(opts);
+        const ret = indexData.firstDataLine
+            ? indexData.firstDataLine.blockPosition + 65535
+            : undefined;
+        let buffer;
+        if (ret) {
+            const res = await this.bam.read(Buffer.alloc(ret + blockLen), 0, ret + blockLen, 0, opts);
+            const { bytesRead } = res;
+            ({ buffer } = res);
+            if (!bytesRead) {
+                throw new Error('Error reading header');
+            }
+            if (bytesRead < ret) {
+                buffer = buffer.slice(0, bytesRead);
+            }
+            else {
+                buffer = buffer.slice(0, ret);
+            }
+        }
+        else {
+            buffer = (await this.bam.readFile(opts));
+        }
+        const uncba = await unzip(buffer);
+        if (uncba.readInt32LE(0) !== BAM_MAGIC) {
+            throw new Error('Not a BAM file');
+        }
+        const headLen = uncba.readInt32LE(4);
+        this.header = uncba.toString('utf8', 8, 8 + headLen);
+        const { chrToIndex, indexToChr } = await this._readRefSeqs(headLen + 8, 65535, opts);
+        this.chrToIndex = chrToIndex;
+        this.indexToChr = indexToChr;
+        return parseHeaderText(this.header);
+    }
+    async getHeaderText(opts = {}) {
+        await this.getHeader(opts);
+        return this.header;
+    }
+    // the full length of the refseq block is not given in advance so this grabs a chunk and
+    // doubles it if all refseqs haven't been processed
+    async _readRefSeqs(start, refSeqBytes, opts = {}) {
+        if (start > refSeqBytes) {
+            return this._readRefSeqs(start, refSeqBytes * 2, opts);
+        }
+        const res = await this.bam.read(Buffer.alloc(refSeqBytes + blockLen), 0, refSeqBytes, 0, opts);
+        const { bytesRead } = res;
+        let { buffer } = res;
+        if (!bytesRead) {
+            throw new Error('Error reading refseqs from header');
+        }
+        if (bytesRead < refSeqBytes) {
+            buffer = buffer.slice(0, bytesRead);
+        }
+        else {
+            buffer = buffer.slice(0, refSeqBytes);
+        }
+        const uncba = await unzip(buffer);
+        const nRef = uncba.readInt32LE(start);
+        let p = start + 4;
+        const chrToIndex = {};
+        const indexToChr = [];
+        for (let i = 0; i < nRef; i += 1) {
+            await abortBreakPoint(opts.signal);
+            const lName = uncba.readInt32LE(p);
+            const refName = this.renameRefSeq(uncba.toString('utf8', p + 4, p + 4 + lName - 1));
+            const lRef = uncba.readInt32LE(p + lName + 4);
+            chrToIndex[refName] = i;
+            indexToChr.push({ refName, length: lRef });
+            p = p + 8 + lName;
+            if (p > uncba.length) {
+                console.warn(`BAM header is very big.  Re-fetching ${refSeqBytes} bytes.`);
+                return this._readRefSeqs(start, refSeqBytes * 2, opts);
+            }
+        }
+        return { chrToIndex, indexToChr };
+    }
+    async getRecordsForRange(chr, min, max, opts = {
+        viewAsPairs: false,
+        pairAcrossChr: false,
+        maxInsertSize: 200000,
+    }) {
+        let records = [];
+        for await (const chunk of this.streamRecordsForRange(chr, min, max, opts)) {
+            records = records.concat(chunk);
+        }
+        return records;
+    }
+    async *streamRecordsForRange(chr, min, max, opts = {
+        viewAsPairs: false,
+        pairAcrossChr: false,
+        maxInsertSize: 200000,
+    }) {
+        // todo regularize refseq names
+        opts.viewAsPairs = opts.viewAsPairs || false;
+        opts.pairAcrossChr = opts.pairAcrossChr || false;
+        opts.maxInsertSize =
+            opts.maxInsertSize !== undefined ? opts.maxInsertSize : 200000;
+        const chrId = this.chrToIndex && this.chrToIndex[chr];
+        let chunks;
+        if (!(chrId >= 0)) {
+            chunks = [];
+        }
+        else {
+            chunks = await this.index.blocksForRange(chrId, min - 1, max, opts);
+            if (!chunks) {
+                throw new Error('Error in index fetch');
+            }
+        }
+        for (let i = 0; i < chunks.length; i += 1) {
+            await abortBreakPoint(opts.signal);
+            const size = chunks[i].fetchedSize();
+            if (size > this.chunkSizeLimit) {
+                throw new Error(`Too many BAM features. BAM chunk size ${size} bytes exceeds chunkSizeLimit of ${this.chunkSizeLimit}`);
+            }
+        }
+        const totalSize = chunks
+            .map((s) => s.fetchedSize())
+            .reduce((a, b) => a + b, 0);
+        if (totalSize > this.fetchSizeLimit) {
+            throw new Error(`data size of ${totalSize.toLocaleString()} bytes exceeded fetch size limit of ${this.fetchSizeLimit.toLocaleString()} bytes`);
+        }
+        yield* this._fetchChunkFeatures(chunks, chrId, min, max, opts);
+    }
+    async *_fetchChunkFeatures(chunks, chrId, min, max, opts) {
+        const featPromises = [];
+        let done = false;
+        for (let i = 0; i < chunks.length; i++) {
+            const { data, cpositions, dpositions, chunk } = await this._readChunk({
+                chunk: chunks[i],
+                opts,
+            });
+            const promise = this.readBamFeatures(data, cpositions, dpositions, chunk).then(records => {
+                const recs = [];
+                for (let i = 0; i < records.length; i += 1) {
+                    const feature = records[i];
+                    if (feature.seq_id() === chrId) {
+                        if (feature.get('start') >= max) {
+                            // past end of range, can stop iterating
+                            done = true;
+                            break;
+                        }
+                        else if (feature.get('end') >= min) {
+                            // must be in range
+                            recs.push(feature);
+                        }
+                    }
+                }
+                return recs;
+            });
+            featPromises.push(promise);
+            await promise;
+            if (done) {
+                break;
+            }
+        }
+        checkAbortSignal(opts.signal);
+        for (let i = 0; i < featPromises.length; i++) {
+            yield featPromises[i];
+        }
+        checkAbortSignal(opts.signal);
+        if (opts.viewAsPairs) {
+            yield this.fetchPairs(chrId, featPromises, opts);
+        }
+    }
+    async fetchPairs(chrId, featPromises, opts) {
+        const unmatedPairs = {};
+        const readIds = {};
+        await Promise.all(featPromises.map(async (f) => {
+            const ret = await f;
+            const readNames = {};
+            for (let i = 0; i < ret.length; i++) {
+                const name = ret[i].name();
+                const id = ret[i].id();
+                if (!readNames[name]) {
+                    readNames[name] = 0;
+                }
+                readNames[name]++;
+                readIds[id] = 1;
+            }
+            entries(readNames).forEach(([k, v]) => {
+                if (v === 1) {
+                    unmatedPairs[k] = true;
+                }
+            });
+        }));
+        const matePromises = [];
+        await Promise.all(featPromises.map(async (f) => {
+            const ret = await f;
+            for (let i = 0; i < ret.length; i++) {
+                const name = ret[i].name();
+                if (unmatedPairs[name] &&
+                    (opts.pairAcrossChr ||
+                        (ret[i]._next_refid() === chrId &&
+                            Math.abs(ret[i].get('start') - ret[i]._next_pos()) <
+                                (opts.maxInsertSize || 200000)))) {
+                    matePromises.push(this.index.blocksForRange(ret[i]._next_refid(), ret[i]._next_pos(), ret[i]._next_pos() + 1, opts));
+                }
+            }
+        }));
+        const mateBlocks = await Promise.all(matePromises);
+        let mateChunks = [];
+        for (let i = 0; i < mateBlocks.length; i++) {
+            mateChunks = mateChunks.concat(mateBlocks[i]);
+        }
+        // filter out duplicate chunks (the blocks are lists of chunks, blocks are concatenated, then filter dup chunks)
+        mateChunks = mateChunks
+            .sort()
+            .filter((item, pos, ary) => !pos || item.toString() !== ary[pos - 1].toString());
+        const mateTotalSize = mateChunks
+            .map(s => s.fetchedSize())
+            .reduce((a, b) => a + b, 0);
+        if (mateTotalSize > this.fetchSizeLimit) {
+            throw new Error(`data size of ${mateTotalSize.toLocaleString()} bytes exceeded fetch size limit of ${this.fetchSizeLimit.toLocaleString()} bytes`);
+        }
+        const mateFeatPromises = mateChunks.map(async (c) => {
+            const { data, cpositions, dpositions, chunk } = await this._readChunk({
+                chunk: c,
+                opts,
+            });
+            const feats = await this.readBamFeatures(data, cpositions, dpositions, chunk);
+            const mateRecs = [];
+            for (let i = 0; i < feats.length; i += 1) {
+                const feature = feats[i];
+                if (unmatedPairs[feature.get('name')] && !readIds[feature.id()]) {
+                    mateRecs.push(feature);
+                }
+            }
+            return mateRecs;
+        });
+        const newMateFeats = await Promise.all(mateFeatPromises);
+        let featuresRet = [];
+        if (newMateFeats.length) {
+            const newMates = newMateFeats.reduce((result, current) => result.concat(current));
+            featuresRet = featuresRet.concat(newMates);
+        }
+        return featuresRet;
+    }
+    async _readChunk({ chunk, opts }) {
+        const { signal } = opts;
+        const bufsize = chunk.fetchedSize();
+        const res = await this.bam.read(Buffer.alloc(bufsize), 0, bufsize, chunk.minv.blockPosition, opts);
+        const { bytesRead } = res;
+        let { buffer } = res;
+        checkAbortSignal(signal);
+        if (bytesRead < bufsize) {
+            buffer = buffer.slice(0, bytesRead);
+        }
+        else {
+            buffer = buffer.slice(0, bufsize);
+        }
+        const { buffer: data, cpositions, dpositions, } = await unzipChunkSlice(buffer, chunk);
+        checkAbortSignal(signal);
+        return { data, cpositions, dpositions, chunk };
+    }
+    async readBamFeatures(ba, cpositions, dpositions, chunk) {
+        let blockStart = 0;
+        const sink = [];
+        let pos = 0;
+        let last = +Date.now();
+        while (blockStart + 4 < ba.length) {
+            const blockSize = ba.readInt32LE(blockStart);
+            const blockEnd = blockStart + 4 + blockSize - 1;
+            // increment position to the current decompressed status
+            if (dpositions) {
+                while (blockStart + chunk.minv.dataPosition >= dpositions[pos++]) { }
+                pos--;
+            }
+            // only try to read the feature if we have all the bytes for it
+            if (blockEnd < ba.length) {
+                const feature = new BAMFeature({
+                    bytes: {
+                        byteArray: ba,
+                        start: blockStart,
+                        end: blockEnd,
+                    },
+                    // the below results in an automatically calculated file-offset based ID
+                    // if the info for that is available, otherwise crc32 of the features
+                    //
+                    // 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
+                    //
+                    // this has an extra chunk.minv.dataPosition added on because it blockStart
+                    // starts at 0 instead of chunk.minv.dataPosition
+                    //
+                    // the +1 is just to avoid any possible uniqueId 0 but this does not realistically happen
+                    fileOffset: cpositions
+                        ? cpositions[pos] * (1 << 8) +
+                            (blockStart - dpositions[pos]) +
+                            chunk.minv.dataPosition +
+                            1
+                        : crc32.signed(ba.slice(blockStart, blockEnd)),
+                });
+                sink.push(feature);
+                if (this.yieldThreadTime && +Date.now() - last > this.yieldThreadTime) {
+                    await timeout(1);
+                    last = +Date.now();
+                }
+            }
+            blockStart = blockEnd + 1;
+        }
+        return sink;
+    }
+    async hasRefSeq(seqName) {
+        const refId = this.chrToIndex && this.chrToIndex[seqName];
+        return this.index.hasRefSeq(refId);
+    }
+    async lineCount(seqName) {
+        const refId = this.chrToIndex && this.chrToIndex[seqName];
+        return this.index.lineCount(refId);
+    }
+    async indexCov(seqName, start, end) {
+        await this.index.parse();
+        const seqId = this.chrToIndex && this.chrToIndex[seqName];
+        return this.index.indexCov(seqId, start, end);
+    }
+}
+//# sourceMappingURL=bamFile.js.map