@gmod/cram 3.0.7 → 4.0.1

package/dist/cramFile/file.d.ts

@@ -1,11 +1,10 @@
-import { Buffer } from 'buffer';
 import QuickLRU from 'quick-lru';
-import { BlockHeader, CompressionMethod } from './sectionParsers';
 import CramContainer from './container';
 import CramRecord from './record';
-import { Filehandle } from './filehandle';
+import { BlockHeader, CompressionMethod } from './sectionParsers';
+import type { GenericFilehandle } from 'generic-filehandle2';
 export interface CramFileSource {
-    filehandle?: Filehandle;
+    filehandle?: GenericFilehandle;
     url?: string;
     path?: string;
 }
@@ -19,7 +18,7 @@ export type CramFileBlock = BlockHeader & {
     _endPosition: number;
     contentPosition: number;
     _size: number;
-    content: Buffer;
+    content: Uint8Array;
     crc32?: number;
 };
 export default class CramFile {
@@ -33,11 +32,8 @@ export default class CramFile {
     featureCache: QuickLRU<string, Promise<CramRecord[]>>;
     private header;
     constructor(args: CramFileArgs);
-    read(buffer: Buffer, offset: number, length: number, position: number): Promise<{
-        bytesRead: number;
-        buffer: Buffer;
-    }>;
-    stat(): Promise<import("generic-filehandle").Stats>;
+    stat(): Promise<import("generic-filehandle2").Stats>;
+    read(length: number, position: number): Promise<Uint8Array<ArrayBuffer>>;
     getDefinition(): Promise<{
         magic: string;
         majorVersion: number;
@@ -71,14 +67,14 @@ export default class CramFile {
     }) | undefined>;
     _parseSection<T>(section: {
         maxLength: number;
-        parser: (buffer: Buffer, offset: number) => {
+        parser: (buffer: Uint8Array, offset: number) => {
             offset: number;
             value: T;
         };
-    }, position: number, size?: number, preReadBuffer?: Buffer): Promise<(T & {
+    }, position: number, size?: number, preReadBuffer?: Uint8Array): Promise<(T & {
         _endPosition: number;
         _size: number;
     }) | undefined>;
-    _uncompress(compressionMethod: CompressionMethod, inputBuffer: Buffer, outputBuffer: Buffer): Promise<void>;
+    _uncompress(compressionMethod: CompressionMethod, inputBuffer: Uint8Array, uncompressedSize: number): Promise<any>;
     readBlock(position: number): Promise<CramFileBlock | undefined>;
 }

package/dist/cramFile/file.js

@@ -1,32 +1,21 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const buffer_1 = require("buffer");
-const crc32_1 = __importDefault(require("crc/crc32"));
-const quick_lru_1 = __importDefault(require("quick-lru"));
-const htscodecs_1 = __importDefault(require("../htscodecs"));
 const bzip2_1 = __importDefault(require("bzip2"));
+const crc32_1 = __importDefault(require("crc/calculators/crc32"));
+const quick_lru_1 = __importDefault(require("quick-lru"));
 const xz_decompress_1 = require("xz-decompress");
 const errors_1 = require("../errors");
-// locals
-const unzip_1 = require("../unzip");
+const htscodecs_1 = __importDefault(require("../htscodecs"));
+const io_1 = require("../io");
 const rans_1 = __importDefault(require("../rans"));
-const sectionParsers_1 = require("./sectionParsers");
+const sam_1 = require("../sam");
+const unzip_1 = require("../unzip");
 const container_1 = __importDefault(require("./container"));
-const io_1 = require("../io");
+const sectionParsers_1 = require("./sectionParsers");
 const util_1 = require("./util");
-const sam_1 = require("../sam");
 function bufferToStream(buf) {
     return new ReadableStream({
         start(controller) {
@@ -51,13 +40,12 @@ function getEndianness() {
 }
 class CramFile {
     constructor(args) {
-        var _a;
         this.file = (0, io_1.open)(args.url, args.path, args.filehandle);
         this.validateChecksums = true;
         this.fetchReferenceSequenceCallback = args.seqFetch;
         this.options = {
             checkSequenceMD5: args.checkSequenceMD5,
-            cacheSize: (_a = args.cacheSize) !== null && _a !== void 0 ? _a : 20000,
+            cacheSize: args.cacheSize ?? 20000,
         };
         // cache of features in a slice, keyed by the slice offset. caches all of
         // the features in a slice, or none. the cache is actually used by the
@@ -69,269 +57,252 @@ class CramFile {
             throw new Error('Detected big-endian machine, may be unable to run');
         }
     }
-    // can just read this object like a filehandle
-    read(buffer, offset, length, position) {
-        return this.file.read(buffer, offset, length, position);
-    }
     // can just stat this object like a filehandle
     stat() {
         return this.file.stat();
     }
+    // can just stat this object like a filehandle
+    read(length, position) {
+        return this.file.read(length, position);
+    }
     // memoized
-    getDefinition() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { maxLength, parser } = (0, sectionParsers_1.cramFileDefinition)();
-            const headbytes = buffer_1.Buffer.allocUnsafe(maxLength);
-            yield this.file.read(headbytes, 0, maxLength, 0);
-            const definition = parser(headbytes).value;
-            if (definition.majorVersion !== 2 && definition.majorVersion !== 3) {
-                throw new errors_1.CramUnimplementedError(`CRAM version ${definition.majorVersion} not supported`);
-            }
-            return definition;
-        });
+    async getDefinition() {
+        const { maxLength, parser } = (0, sectionParsers_1.cramFileDefinition)();
+        const headbytes = await this.file.read(maxLength, 0);
+        const definition = parser(headbytes).value;
+        if (definition.majorVersion !== 2 && definition.majorVersion !== 3) {
+            throw new errors_1.CramUnimplementedError(`CRAM version ${definition.majorVersion} not supported`);
+        }
+        return definition;
     }
     // memoize
-    getSamHeader() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const firstContainer = yield this.getContainerById(0);
-            if (!firstContainer) {
-                throw new errors_1.CramMalformedError('file contains no containers');
-            }
-            const firstBlock = yield firstContainer.getFirstBlock();
-            if (firstBlock === undefined) {
-                return (0, sam_1.parseHeaderText)('');
-            }
+    async getSamHeader() {
+        const firstContainer = await this.getContainerById(0);
+        if (!firstContainer) {
+            throw new errors_1.CramMalformedError('file contains no containers');
+        }
+        const firstBlock = await firstContainer.getFirstBlock();
+        if (firstBlock === undefined) {
+            return (0, sam_1.parseHeaderText)('');
+        }
+        else {
             const content = firstBlock.content;
-            const headerLength = content.readInt32LE(0);
+            const dataView = new DataView(content.buffer);
+            const headerLength = dataView.getInt32(0, true);
             const textStart = 4;
-            const text = content.toString('utf8', textStart, textStart + headerLength);
+            const decoder = new TextDecoder('utf8');
+            const text = decoder.decode(content.subarray(textStart, textStart + headerLength));
             this.header = text;
             return (0, sam_1.parseHeaderText)(text);
-        });
+        }
     }
-    getHeaderText() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.getSamHeader();
-            return this.header;
-        });
+    async getHeaderText() {
+        await this.getSamHeader();
+        return this.header;
     }
-    getContainerById(containerNumber) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { majorVersion } = yield this.getDefinition();
-            const sectionParsers = (0, sectionParsers_1.getSectionParsers)(majorVersion);
-            let position = sectionParsers.cramFileDefinition.maxLength;
-            const { size: fileSize } = yield this.file.stat();
-            const { cramContainerHeader1 } = sectionParsers;
-            // skip with a series of reads to the proper container
-            let currentContainer;
-            for (let i = 0; i <= containerNumber; i++) {
-                // if we are about to go off the end of the file
-                // and have not found that container, it does not exist
-                if (position + cramContainerHeader1.maxLength + 8 >= fileSize) {
-                    return undefined;
-                }
-                currentContainer = this.getContainerAtPosition(position);
-                const currentHeader = yield currentContainer.getHeader();
-                if (!currentHeader) {
-                    throw new errors_1.CramMalformedError(`container ${containerNumber} not found in file`);
-                }
-                // if this is the first container, read all the blocks in the container
-                // to determine its length, because we cannot trust the container
-                // header's given length due to a bug somewhere in htslib
-                if (i === 0) {
-                    position = currentHeader._endPosition;
-                    for (let j = 0; j < currentHeader.numBlocks; j++) {
-                        const block = yield this.readBlock(position);
-                        if (block === undefined) {
-                            return undefined;
-                        }
-                        position = block._endPosition;
+    async getContainerById(containerNumber) {
+        const { majorVersion } = await this.getDefinition();
+        const sectionParsers = (0, sectionParsers_1.getSectionParsers)(majorVersion);
+        let position = sectionParsers.cramFileDefinition.maxLength;
+        const { size: fileSize } = await this.file.stat();
+        const { cramContainerHeader1 } = sectionParsers;
+        // skip with a series of reads to the proper container
+        let currentContainer;
+        for (let i = 0; i <= containerNumber; i++) {
+            // if we are about to go off the end of the file
+            // and have not found that container, it does not exist
+            if (position + cramContainerHeader1.maxLength + 8 >= fileSize) {
+                return undefined;
+            }
+            currentContainer = this.getContainerAtPosition(position);
+            const currentHeader = await currentContainer.getHeader();
+            if (!currentHeader) {
+                throw new errors_1.CramMalformedError(`container ${containerNumber} not found in file`);
+            }
+            // if this is the first container, read all the blocks in the container
+            // to determine its length, because we cannot trust the container
+            // header's given length due to a bug somewhere in htslib
+            if (i === 0) {
+                position = currentHeader._endPosition;
+                for (let j = 0; j < currentHeader.numBlocks; j++) {
+                    const block = await this.readBlock(position);
+                    if (block === undefined) {
+                        return undefined;
                     }
-                }
-                else {
-                    // otherwise, just traverse to the next container using the container's
-                    // length
-                    position += currentHeader._size + currentHeader.length;
+                    position = block._endPosition;
                 }
             }
-            return currentContainer;
-        });
-    }
-    checkCrc32(position, length, recordedCrc32, description) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const b = buffer_1.Buffer.allocUnsafe(length);
-            yield this.file.read(b, 0, length, position);
-            const calculatedCrc32 = crc32_1.default.unsigned(b);
-            if (calculatedCrc32 !== recordedCrc32) {
-                throw new errors_1.CramMalformedError(`crc mismatch in ${description}: recorded CRC32 = ${recordedCrc32}, but calculated CRC32 = ${calculatedCrc32}`);
+            else {
+                // otherwise, just traverse to the next container using the container's
+                // length
+                position += currentHeader._size + currentHeader.length;
             }
-        });
+        }
+        return currentContainer;
+    }
+    async checkCrc32(position, length, recordedCrc32, description) {
+        const b = await this.file.read(length, position);
+        // this shift >>> 0 is equivalent to crc32(b).unsigned but uses the
+        // internal calculator of crc32 to avoid accidentally importing buffer
+        // https://github.com/alexgorbatchev/crc/blob/31fc3853e417b5fb5ec83335428805842575f699/src/define_crc.ts#L5
+        const calculatedCrc32 = (0, crc32_1.default)(b) >>> 0;
+        if (calculatedCrc32 !== recordedCrc32) {
+            throw new errors_1.CramMalformedError(`crc mismatch in ${description}: recorded CRC32 = ${recordedCrc32}, but calculated CRC32 = ${calculatedCrc32}`);
+        }
     }
     /**
      * @returns {Promise[number]} the number of containers in the file
      */
-    containerCount() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { majorVersion } = yield this.getDefinition();
-            const sectionParsers = (0, sectionParsers_1.getSectionParsers)(majorVersion);
-            const { size: fileSize } = yield this.file.stat();
-            const { cramContainerHeader1 } = sectionParsers;
-            let containerCount = 0;
-            let position = sectionParsers.cramFileDefinition.maxLength;
-            while (position + cramContainerHeader1.maxLength + 8 < fileSize) {
-                const currentHeader = yield this.getContainerAtPosition(position).getHeader();
-                if (!currentHeader) {
-                    break;
-                }
-                // if this is the first container, read all the blocks in the container,
-                // because we cannot trust the container header's given length due to a
-                // bug somewhere in htslib
-                if (containerCount === 0) {
-                    position = currentHeader._endPosition;
-                    for (let j = 0; j < currentHeader.numBlocks; j++) {
-                        const block = yield this.readBlock(position);
-                        if (block === undefined) {
-                            return undefined;
-                        }
-                        position = block._endPosition;
+    async containerCount() {
+        const { majorVersion } = await this.getDefinition();
+        const sectionParsers = (0, sectionParsers_1.getSectionParsers)(majorVersion);
+        const { size: fileSize } = await this.file.stat();
+        const { cramContainerHeader1 } = sectionParsers;
+        let containerCount = 0;
+        let position = sectionParsers.cramFileDefinition.maxLength;
+        while (position + cramContainerHeader1.maxLength + 8 < fileSize) {
+            const currentHeader = await this.getContainerAtPosition(position).getHeader();
+            if (!currentHeader) {
+                break;
+            }
+            // if this is the first container, read all the blocks in the container,
+            // because we cannot trust the container header's given length due to a
+            // bug somewhere in htslib
+            if (containerCount === 0) {
+                position = currentHeader._endPosition;
+                for (let j = 0; j < currentHeader.numBlocks; j++) {
+                    const block = await this.readBlock(position);
+                    if (block === undefined) {
+                        return undefined;
                     }
+                    position = block._endPosition;
                 }
-                else {
-                    // otherwise, just traverse to the next container using the container's
-                    // length
-                    position += currentHeader._size + currentHeader.length;
-                }
-                containerCount += 1;
             }
-            return containerCount;
-        });
+            else {
+                // otherwise, just traverse to the next container using the container's
+                // length
+                position += currentHeader._size + currentHeader.length;
+            }
+            containerCount += 1;
+        }
+        return containerCount;
     }
     getContainerAtPosition(position) {
         return new container_1.default(this, position);
     }
-    readBlockHeader(position) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { majorVersion } = yield this.getDefinition();
-            const sectionParsers = (0, sectionParsers_1.getSectionParsers)(majorVersion);
-            const { cramBlockHeader } = sectionParsers;
-            const { size: fileSize } = yield this.file.stat();
-            if (position + cramBlockHeader.maxLength >= fileSize) {
+    async readBlockHeader(position) {
+        const { majorVersion } = await this.getDefinition();
+        const sectionParsers = (0, sectionParsers_1.getSectionParsers)(majorVersion);
+        const { cramBlockHeader } = sectionParsers;
+        const { size: fileSize } = await this.file.stat();
+        if (position + cramBlockHeader.maxLength >= fileSize) {
+            return undefined;
+        }
+        const buffer = await this.file.read(cramBlockHeader.maxLength, position);
+        return (0, util_1.parseItem)(buffer, cramBlockHeader.parser, 0, position);
+    }
+    async _parseSection(section, position, size = section.maxLength, preReadBuffer) {
+        let buffer;
+        if (preReadBuffer) {
+            buffer = preReadBuffer;
+        }
+        else {
+            const { size: fileSize } = await this.file.stat();
+            if (position + size >= fileSize) {
                 return undefined;
             }
-            const buffer = buffer_1.Buffer.allocUnsafe(cramBlockHeader.maxLength);
-            yield this.file.read(buffer, 0, cramBlockHeader.maxLength, position);
-            return (0, util_1.parseItem)(buffer, cramBlockHeader.parser, 0, position);
-        });
+            buffer = await this.file.read(size, position);
+        }
+        const data = (0, util_1.parseItem)(buffer, section.parser, 0, position);
+        if (data._size !== size) {
+            throw new errors_1.CramMalformedError(`section read error: requested size ${size} does not equal parsed size ${data._size}`);
+        }
+        return data;
     }
-    _parseSection(section_1, position_1) {
-        return __awaiter(this, arguments, void 0, function* (section, position, size = section.maxLength, preReadBuffer) {
-            let buffer;
-            if (preReadBuffer) {
-                buffer = preReadBuffer;
-            }
-            else {
-                const { size: fileSize } = yield this.file.stat();
-                if (position + size >= fileSize) {
-                    return undefined;
+    async _uncompress(compressionMethod, inputBuffer, uncompressedSize) {
+        if (compressionMethod === 'gzip') {
+            return (0, unzip_1.unzip)(inputBuffer);
+        }
+        else if (compressionMethod === 'bzip2') {
+            const bits = bzip2_1.default.array(inputBuffer);
+            let size = bzip2_1.default.header(bits);
+            let chunk;
+            const chunks = [];
+            do {
+                chunk = bzip2_1.default.decompress(bits, size);
+                if (chunk !== -1) {
+                    chunks.push(chunk);
+                    size -= chunk.length;
                 }
-                buffer = buffer_1.Buffer.allocUnsafe(size);
-                yield this.file.read(buffer, 0, size, position);
-            }
-            const data = (0, util_1.parseItem)(buffer, section.parser, 0, position);
-            if (data._size !== size) {
-                throw new errors_1.CramMalformedError(`section read error: requested size ${size} does not equal parsed size ${data._size}`);
-            }
-            return data;
-        });
-    }
-    _uncompress(compressionMethod, inputBuffer, outputBuffer) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (compressionMethod === 'gzip') {
-                const result = (0, unzip_1.unzip)(inputBuffer);
-                result.copy(outputBuffer);
-            }
-            else if (compressionMethod === 'bzip2') {
-                const bits = bzip2_1.default.array(inputBuffer);
-                let size = bzip2_1.default.header(bits);
-                let j = 0;
-                let chunk;
-                do {
-                    chunk = bzip2_1.default.decompress(bits, size);
-                    if (chunk !== -1) {
-                        buffer_1.Buffer.from(chunk).copy(outputBuffer, j);
-                        j += chunk.length;
-                        size -= chunk.length;
-                    }
-                } while (chunk !== -1);
-            }
-            else if (compressionMethod === 'lzma') {
-                const decompressedResponse = new Response(new xz_decompress_1.XzReadableStream(bufferToStream(inputBuffer)));
-                const ret = buffer_1.Buffer.from(yield decompressedResponse.arrayBuffer());
-                ret.copy(outputBuffer);
-            }
-            else if (compressionMethod === 'rans') {
-                (0, rans_1.default)(inputBuffer, outputBuffer);
-                // htscodecs r4x8 is slower, but compatible.
-                // htscodecs.r4x8_uncompress(inputBuffer, outputBuffer);
-            }
-            else if (compressionMethod === 'rans4x16') {
-                htscodecs_1.default.r4x16_uncompress(inputBuffer, outputBuffer);
-            }
-            else if (compressionMethod === 'arith') {
-                htscodecs_1.default.arith_uncompress(inputBuffer, outputBuffer);
-            }
-            else if (compressionMethod === 'fqzcomp') {
-                htscodecs_1.default.fqzcomp_uncompress(inputBuffer, outputBuffer);
-            }
-            else if (compressionMethod === 'tok3') {
-                htscodecs_1.default.tok3_uncompress(inputBuffer, outputBuffer);
-            }
-            else {
-                throw new errors_1.CramUnimplementedError(`${compressionMethod} decompression not yet implemented`);
-            }
-        });
+            } while (chunk !== -1);
+            return (0, util_1.concatUint8Array)(chunks);
+        }
+        else if (compressionMethod === 'lzma') {
+            const decompressedResponse = new Response(new xz_decompress_1.XzReadableStream(bufferToStream(inputBuffer)));
+            return new Uint8Array(await decompressedResponse.arrayBuffer());
+        }
+        else if (compressionMethod === 'rans') {
+            const outputBuffer = new Uint8Array(uncompressedSize);
+            (0, rans_1.default)(inputBuffer, outputBuffer);
+            return outputBuffer;
+            // htscodecs r4x8 is slower, but compatible.
+            // htscodecs.r4x8_uncompress(inputBuffer, outputBuffer);
+        }
+        else if (compressionMethod === 'rans4x16') {
+            return htscodecs_1.default.r4x16_uncompress(inputBuffer);
+        }
+        else if (compressionMethod === 'arith') {
+            return htscodecs_1.default.arith_uncompress(inputBuffer);
+        }
+        else if (compressionMethod === 'fqzcomp') {
+            return htscodecs_1.default.fqzcomp_uncompress(inputBuffer);
+        }
+        else if (compressionMethod === 'tok3') {
+            return htscodecs_1.default.tok3_uncompress(inputBuffer);
+        }
+        else {
+            throw new errors_1.CramUnimplementedError(`${compressionMethod} decompression not yet implemented`);
+        }
     }
-    readBlock(position) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { majorVersion } = yield this.getDefinition();
-            const sectionParsers = (0, sectionParsers_1.getSectionParsers)(majorVersion);
-            const blockHeader = yield this.readBlockHeader(position);
-            if (blockHeader === undefined) {
+    async readBlock(position) {
+        const { majorVersion } = await this.getDefinition();
+        const sectionParsers = (0, sectionParsers_1.getSectionParsers)(majorVersion);
+        const blockHeader = await this.readBlockHeader(position);
+        if (blockHeader === undefined) {
+            return undefined;
+        }
+        const blockContentPosition = blockHeader._endPosition;
+        const d = await this.file.read(blockHeader.compressedSize, blockContentPosition);
+        const uncompressedData = blockHeader.compressionMethod !== 'raw'
+            ? await this._uncompress(blockHeader.compressionMethod, d, blockHeader.uncompressedSize)
+            : d;
+        const block = {
+            ...blockHeader,
+            _endPosition: blockContentPosition,
+            contentPosition: blockContentPosition,
+            content: uncompressedData,
+        };
+        if (majorVersion >= 3) {
+            // parse the crc32
+            const crc = await this._parseSection(sectionParsers.cramBlockCrc32, blockContentPosition + blockHeader.compressedSize);
+            if (crc === undefined) {
                 return undefined;
             }
-            const blockContentPosition = blockHeader._endPosition;
-            const uncompressedData = buffer_1.Buffer.allocUnsafe(blockHeader.uncompressedSize);
-            const block = Object.assign(Object.assign({}, blockHeader), { _endPosition: blockContentPosition, contentPosition: blockContentPosition, content: uncompressedData });
-            if (blockHeader.compressionMethod !== 'raw') {
-                const compressedData = buffer_1.Buffer.allocUnsafe(blockHeader.compressedSize);
-                yield this.read(compressedData, 0, blockHeader.compressedSize, blockContentPosition);
-                yield this._uncompress(blockHeader.compressionMethod, compressedData, uncompressedData);
-            }
-            else {
-                yield this.read(uncompressedData, 0, blockHeader.uncompressedSize, blockContentPosition);
-            }
-            if (majorVersion >= 3) {
-                // parse the crc32
-                const crc = yield this._parseSection(sectionParsers.cramBlockCrc32, blockContentPosition + blockHeader.compressedSize);
-                if (crc === undefined) {
-                    return undefined;
-                }
-                block.crc32 = crc.crc32;
-                // check the block data crc32
-                if (this.validateChecksums) {
-                    yield this.checkCrc32(position, blockHeader._size + blockHeader.compressedSize, crc.crc32, 'block data');
-                }
-                // make the endposition and size reflect the whole block
-                block._endPosition = crc._endPosition;
-                block._size =
-                    block.compressedSize + sectionParsers.cramBlockCrc32.maxLength;
+            block.crc32 = crc.crc32;
+            // check the block data crc32
+            if (this.validateChecksums) {
+                await this.checkCrc32(position, blockHeader._size + blockHeader.compressedSize, crc.crc32, 'block data');
             }
-            else {
-                block._endPosition = blockContentPosition + block.compressedSize;
-                block._size = block.compressedSize;
-            }
-            return block;
-        });
+            // make the endposition and size reflect the whole block
+            block._endPosition = crc._endPosition;
+            block._size =
+                block.compressedSize + sectionParsers.cramBlockCrc32.maxLength;
+        }
+        else {
+            block._endPosition = blockContentPosition + block.compressedSize;
+            block._size = block.compressedSize;
+        }
+        return block;
     }
 }
 exports.default = CramFile;