@gmod/bam 7.1.3 → 7.1.5

package/CHANGELOG.md

@@ -1,19 +1,17 @@
-## [7.1.3](https://github.com/GMOD/bam-js/compare/v7.1.2...v7.1.3) (2025-12-12)
+## [7.1.5](https://github.com/GMOD/bam-js/compare/v7.1.4...v7.1.5) (2025-12-13)
 
 
 
-## [7.1.2](https://github.com/GMOD/bam-js/compare/v7.1.1...v7.1.2) (2025-12-12)
+## [7.1.4](https://github.com/GMOD/bam-js/compare/v7.1.3...v7.1.4) (2025-12-13)
 
+## [7.1.3](https://github.com/GMOD/bam-js/compare/v7.1.2...v7.1.3) (2025-12-12)
 
+## [7.1.2](https://github.com/GMOD/bam-js/compare/v7.1.1...v7.1.2) (2025-12-12)
 
 ## [7.1.1](https://github.com/GMOD/bam-js/compare/v7.1.0...v7.1.1) (2025-12-12)
 
-
-
 # [7.1.0](https://github.com/GMOD/bam-js/compare/v7.0.6...v7.1.0) (2025-12-11)
 
-
-
 ## [7.0.6](https://github.com/GMOD/bam-js/compare/v7.0.5...v7.0.6) (2025-11-28)
 
 ## [7.0.5](https://github.com/GMOD/bam-js/compare/v7.0.4...v7.0.5) (2025-11-27)

package/dist/cigar.d.ts

@@ -0,0 +1,9 @@
+export declare const CIGAR_MATCH = 0;
+export declare const CIGAR_INS = 1;
+export declare const CIGAR_DEL = 2;
+export declare const CIGAR_REF_SKIP = 3;
+export declare const CIGAR_SOFT_CLIP = 4;
+export declare const CIGAR_HARD_CLIP = 5;
+export declare const CIGAR_PAD = 6;
+export declare const CIGAR_EQUAL = 7;
+export declare const CIGAR_DIFF = 8;

package/dist/cigar.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CIGAR_DIFF = exports.CIGAR_EQUAL = exports.CIGAR_PAD = exports.CIGAR_HARD_CLIP = exports.CIGAR_SOFT_CLIP = exports.CIGAR_REF_SKIP = exports.CIGAR_DEL = exports.CIGAR_INS = exports.CIGAR_MATCH = void 0;
+exports.CIGAR_MATCH = 0;
+exports.CIGAR_INS = 1;
+exports.CIGAR_DEL = 2;
+exports.CIGAR_REF_SKIP = 3;
+exports.CIGAR_SOFT_CLIP = 4;
+exports.CIGAR_HARD_CLIP = 5;
+exports.CIGAR_PAD = 6;
+exports.CIGAR_EQUAL = 7;
+exports.CIGAR_DIFF = 8;
+//# sourceMappingURL=cigar.js.map

package/dist/cigar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cigar.js","sourceRoot":"","sources":["../src/cigar.ts"],"names":[],"mappings":";;;AAAa,QAAA,WAAW,GAAG,CAAC,CAAA;AACf,QAAA,SAAS,GAAG,CAAC,CAAA;AACb,QAAA,SAAS,GAAG,CAAC,CAAA;AACb,QAAA,cAAc,GAAG,CAAC,CAAA;AAClB,QAAA,eAAe,GAAG,CAAC,CAAA;AACnB,QAAA,eAAe,GAAG,CAAC,CAAA;AACnB,QAAA,SAAS,GAAG,CAAC,CAAA;AACb,QAAA,WAAW,GAAG,CAAC,CAAA;AACf,QAAA,UAAU,GAAG,CAAC,CAAA"}

package/dist/record.d.ts

@@ -3,10 +3,18 @@ interface Bytes {
     end: number;
     byteArray: Uint8Array;
 }
+interface CIGAR_AND_LENGTH {
+    length_on_ref: number;
+    NUMERIC_CIGAR: Uint32Array;
+}
 export default class BamRecord {
     fileOffset: number;
     private bytes;
     private _dataView;
+    private _cachedFlags?;
+    private _cachedTags?;
+    private _cachedCigarAndLength?;
+    private _cachedNUMERIC_MD?;
     constructor(args: {
         bytes: Bytes;
         fileOffset: number;
@@ -19,43 +27,27 @@ export default class BamRecord {
     get id(): number;
     get mq(): number | undefined;
     get score(): number | undefined;
-    get qual(): Uint8Array<ArrayBufferLike> | undefined;
+    get qual(): Uint8Array<ArrayBufferLike> | null;
     get strand(): 1 | -1;
     get b0(): number;
     get name(): string;
     get NUMERIC_MD(): Uint8Array<ArrayBufferLike> | undefined;
     get tags(): Record<string, unknown>;
-    /**
-     * @returns {boolean} true if the read is paired, regardless of whether both
-     * segments are mapped
-     */
+    private _computeTags;
     isPaired(): boolean;
-    /** @returns {boolean} true if the read is paired, and both segments are mapped */
     isProperlyPaired(): boolean;
-    /** @returns {boolean} true if the read itself is unmapped; conflictive with isProperlyPaired */
     isSegmentUnmapped(): boolean;
-    /** @returns {boolean} true if the read itself is unmapped; conflictive with isProperlyPaired */
     isMateUnmapped(): boolean;
-    /** @returns {boolean} true if the read is mapped to the reverse strand */
     isReverseComplemented(): boolean;
-    /** @returns {boolean} true if the mate is mapped to the reverse strand */
     isMateReverseComplemented(): boolean;
-    /** @returns {boolean} true if this is read number 1 in a pair */
     isRead1(): boolean;
-    /** @returns {boolean} true if this is read number 2 in a pair */
     isRead2(): boolean;
-    /** @returns {boolean} true if this is a secondary alignment */
     isSecondary(): boolean;
-    /** @returns {boolean} true if this read has failed QC checks */
     isFailedQc(): boolean;
-    /** @returns {boolean} true if the read is an optical or PCR duplicate */
     isDuplicate(): boolean;
-    /** @returns {boolean} true if this is a supplementary alignment */
     isSupplementary(): boolean;
-    get cigarAndLength(): {
-        NUMERIC_CIGAR: Uint32Array<ArrayBufferLike>;
-        length_on_ref: number;
-    };
+    get cigarAndLength(): CIGAR_AND_LENGTH;
+    private _computeCigarAndLength;
     get length_on_ref(): number;
     get NUMERIC_CIGAR(): Uint32Array<ArrayBufferLike>;
     get CIGAR(): string;

package/dist/record.js

@@ -3,20 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const cigar_ts_1 = require("./cigar.js");
 const constants_ts_1 = __importDefault(require("./constants.js"));
 const SEQRET_DECODER = '=ACMGRSVTWYHKDBN'.split('');
 const ASCII_CIGAR_CODES = [
     77, 73, 68, 78, 83, 72, 80, 61, 88, 63, 63, 63, 63, 63, 63, 63,
 ];
-// const CIGAR_MATCH = 0
-const CIGAR_INS = 1;
-// const CIGAR_DEL = 2
-const CIGAR_REF_SKIP = 3;
-const CIGAR_SOFT_CLIP = 4;
-const CIGAR_HARD_CLIP = 5;
-// const CIGAR_PAD = 6
 // ops that don't consume reference: INS, SOFT_CLIP, HARD_CLIP
-const CIGAR_SKIP_MASK = (1 << CIGAR_INS) | (1 << CIGAR_SOFT_CLIP) | (1 << CIGAR_HARD_CLIP);
+const CIGAR_SKIP_MASK = (1 << cigar_ts_1.CIGAR_INS) | (1 << cigar_ts_1.CIGAR_SOFT_CLIP) | (1 << cigar_ts_1.CIGAR_HARD_CLIP);
 class BamRecord {
     constructor(args) {
         this.bytes = args.bytes;
@@ -27,7 +21,12 @@ class BamRecord {
         return this.bytes.byteArray;
     }
     get flags() {
-        return ((this._dataView.getInt32(this.bytes.start + 16, true) & 0xffff0000) >> 16);
+        if (this._cachedFlags === undefined) {
+            this._cachedFlags =
+                (this._dataView.getInt32(this.bytes.start + 16, true) & 0xffff0000) >>
+                    16;
+        }
+        return this._cachedFlags;
     }
     get ref_id() {
         return this._dataView.getInt32(this.bytes.start + 4, true);
@@ -50,13 +49,15 @@ class BamRecord {
     }
     get qual() {
         if (this.isSegmentUnmapped()) {
-            return;
+            return null;
+        }
+        else {
+            const p = this.b0 +
+                this.read_name_length +
+                this.num_cigar_bytes +
+                this.num_seq_bytes;
+            return this.byteArray.subarray(p, p + this.seq_length);
         }
-        const p = this.b0 +
-            this.read_name_length +
-            this.num_cigar_bytes +
-            this.num_seq_bytes;
-        return this.byteArray.subarray(p, p + this.seq_length);
     }
     get strand() {
         return this.isReverseComplemented() ? -1 : 1;
@@ -72,115 +73,127 @@ class BamRecord {
         return str;
     }
     get NUMERIC_MD() {
-        let p = this.b0 +
-            this.read_name_length +
-            this.num_cigar_bytes +
-            this.num_seq_bytes +
-            this.seq_length;
-        const blockEnd = this.bytes.end;
-        while (p < blockEnd) {
-            const tag = String.fromCharCode(this.byteArray[p]) +
-                String.fromCharCode(this.byteArray[p + 1]);
-            const type = String.fromCharCode(this.byteArray[p + 2]);
-            p += 3;
-            if (tag === 'MD' && type === 'Z') {
-                const start = p;
-                while (p < blockEnd && this.byteArray[p] !== 0) {
-                    p++;
-                }
-                return this.byteArray.subarray(start, p);
-            }
-            switch (type) {
-                case 'A':
-                    p += 1;
-                    break;
-                case 'i':
-                case 'I':
-                case 'f':
-                    p += 4;
-                    break;
-                case 'c':
-                case 'C':
-                    p += 1;
-                    break;
-                case 's':
-                case 'S':
-                    p += 2;
-                    break;
-                case 'Z':
-                case 'H':
-                    while (p <= blockEnd && this.byteArray[p++] !== 0) { }
-                    break;
-                case 'B': {
-                    const Btype = String.fromCharCode(this.byteArray[p++]);
-                    const limit = this._dataView.getInt32(p, true);
-                    p += 4;
-                    if (Btype === 'i' || Btype === 'I' || Btype === 'f') {
-                        p += limit << 2;
-                    }
-                    else if (Btype === 's' || Btype === 'S') {
-                        p += limit << 1;
+        if (this._cachedNUMERIC_MD === undefined) {
+            let p = this.b0 +
+                this.read_name_length +
+                this.num_cigar_bytes +
+                this.num_seq_bytes +
+                this.seq_length;
+            const blockEnd = this.bytes.end;
+            const ba = this.byteArray;
+            while (p < blockEnd) {
+                const tag1 = ba[p];
+                const tag2 = ba[p + 1];
+                const type = ba[p + 2];
+                p += 3;
+                // 'M' = 0x4D, 'D' = 0x44, 'Z' = 0x5A
+                if (tag1 === 0x4d && tag2 === 0x44 && type === 0x5a) {
+                    const start = p;
+                    while (p < blockEnd && ba[p] !== 0) {
+                        p++;
                     }
-                    else if (Btype === 'c' || Btype === 'C') {
-                        p += limit;
+                    this._cachedNUMERIC_MD = ba.subarray(start, p);
+                }
+                switch (type) {
+                    case 0x41: // 'A'
+                        p += 1;
+                        break;
+                    case 0x69: // 'i'
+                    case 0x49: // 'I'
+                    case 0x66: // 'f'
+                        p += 4;
+                        break;
+                    case 0x63: // 'c'
+                    case 0x43: // 'C'
+                        p += 1;
+                        break;
+                    case 0x73: // 's'
+                    case 0x53: // 'S'
+                        p += 2;
+                        break;
+                    case 0x5a: // 'Z'
+                    case 0x48: // 'H'
+                        while (p <= blockEnd && ba[p++] !== 0) { }
+                        break;
+                    case 0x42: {
+                        // 'B'
+                        const Btype = ba[p++];
+                        const limit = this._dataView.getInt32(p, true);
+                        p += 4;
+                        if (Btype === 0x69 || Btype === 0x49 || Btype === 0x66) {
+                            p += limit << 2;
+                        }
+                        else if (Btype === 0x73 || Btype === 0x53) {
+                            p += limit << 1;
+                        }
+                        else if (Btype === 0x63 || Btype === 0x43) {
+                            p += limit;
+                        }
+                        break;
                     }
-                    break;
                 }
             }
         }
-        return undefined;
+        return this._cachedNUMERIC_MD === null ? undefined : this._cachedNUMERIC_MD;
     }
     get tags() {
+        if (this._cachedTags === undefined) {
+            this._cachedTags = this._computeTags();
+        }
+        return this._cachedTags;
+    }
+    _computeTags() {
         let p = this.b0 +
             this.read_name_length +
             this.num_cigar_bytes +
             this.num_seq_bytes +
             this.seq_length;
         const blockEnd = this.bytes.end;
+        const ba = this.byteArray;
         const tags = {};
         while (p < blockEnd) {
-            const tag = String.fromCharCode(this.byteArray[p]) +
-                String.fromCharCode(this.byteArray[p + 1]);
-            const type = String.fromCharCode(this.byteArray[p + 2]);
+            const tag = String.fromCharCode(ba[p], ba[p + 1]);
+            const type = ba[p + 2];
             p += 3;
             switch (type) {
-                case 'A':
-                    tags[tag] = String.fromCharCode(this.byteArray[p]);
+                case 0x41: // 'A'
+                    tags[tag] = String.fromCharCode(ba[p]);
                     p += 1;
                     break;
-                case 'i':
+                case 0x69: // 'i'
                     tags[tag] = this._dataView.getInt32(p, true);
                     p += 4;
                     break;
-                case 'I':
+                case 0x49: // 'I'
                     tags[tag] = this._dataView.getUint32(p, true);
                     p += 4;
                     break;
-                case 'c':
+                case 0x63: // 'c'
                     tags[tag] = this._dataView.getInt8(p);
                     p += 1;
                     break;
-                case 'C':
+                case 0x43: // 'C'
                     tags[tag] = this._dataView.getUint8(p);
                     p += 1;
                     break;
-                case 's':
+                case 0x73: // 's'
                     tags[tag] = this._dataView.getInt16(p, true);
                     p += 2;
                     break;
-                case 'S':
+                case 0x53: // 'S'
                     tags[tag] = this._dataView.getUint16(p, true);
                     p += 2;
                     break;
-                case 'f':
+                case 0x66: // 'f'
                     tags[tag] = this._dataView.getFloat32(p, true);
                     p += 4;
                     break;
-                case 'Z':
-                case 'H': {
+                case 0x5a: // 'Z'
+                case 0x48: {
+                    // 'H'
                     const value = [];
                     while (p <= blockEnd) {
-                        const cc = this.byteArray[p++];
+                        const cc = ba[p++];
                         if (cc !== 0) {
                             value.push(String.fromCharCode(cc));
                         }
@@ -191,66 +204,73 @@ class BamRecord {
                     tags[tag] = value.join('');
                     break;
                 }
-                case 'B': {
-                    const cc = this.byteArray[p++];
-                    const Btype = String.fromCharCode(cc);
+                case 0x42: {
+                    // 'B'
+                    const Btype = ba[p++];
                     const limit = this._dataView.getInt32(p, true);
                     p += 4;
-                    const absOffset = this.byteArray.byteOffset + p;
-                    if (Btype === 'i') {
+                    const absOffset = ba.byteOffset + p;
+                    if (Btype === 0x69) {
+                        // 'i'
                         if (absOffset % 4 === 0) {
-                            tags[tag] = new Int32Array(this.byteArray.buffer, absOffset, limit);
+                            tags[tag] = new Int32Array(ba.buffer, absOffset, limit);
                         }
                         else {
-                            const bytes = this.byteArray.slice(p, p + (limit << 2));
+                            const bytes = ba.slice(p, p + (limit << 2));
                             tags[tag] = new Int32Array(bytes.buffer, bytes.byteOffset, limit);
                         }
                         p += limit << 2;
                     }
-                    else if (Btype === 'I') {
+                    else if (Btype === 0x49) {
+                        // 'I'
                         if (absOffset % 4 === 0) {
-                            tags[tag] = new Uint32Array(this.byteArray.buffer, absOffset, limit);
+                            tags[tag] = new Uint32Array(ba.buffer, absOffset, limit);
                         }
                         else {
-                            const bytes = this.byteArray.slice(p, p + (limit << 2));
+                            const bytes = ba.slice(p, p + (limit << 2));
                             tags[tag] = new Uint32Array(bytes.buffer, bytes.byteOffset, limit);
                         }
                         p += limit << 2;
                     }
-                    else if (Btype === 's') {
+                    else if (Btype === 0x73) {
+                        // 's'
                         if (absOffset % 2 === 0) {
-                            tags[tag] = new Int16Array(this.byteArray.buffer, absOffset, limit);
+                            tags[tag] = new Int16Array(ba.buffer, absOffset, limit);
                         }
                         else {
-                            const bytes = this.byteArray.slice(p, p + (limit << 1));
+                            const bytes = ba.slice(p, p + (limit << 1));
                             tags[tag] = new Int16Array(bytes.buffer, bytes.byteOffset, limit);
                         }
                         p += limit << 1;
                     }
-                    else if (Btype === 'S') {
+                    else if (Btype === 0x53) {
+                        // 'S'
                         if (absOffset % 2 === 0) {
-                            tags[tag] = new Uint16Array(this.byteArray.buffer, absOffset, limit);
+                            tags[tag] = new Uint16Array(ba.buffer, absOffset, limit);
                         }
                         else {
-                            const bytes = this.byteArray.slice(p, p + (limit << 1));
+                            const bytes = ba.slice(p, p + (limit << 1));
                             tags[tag] = new Uint16Array(bytes.buffer, bytes.byteOffset, limit);
                         }
                         p += limit << 1;
                     }
-                    else if (Btype === 'c') {
-                        tags[tag] = new Int8Array(this.byteArray.buffer, absOffset, limit);
+                    else if (Btype === 0x63) {
+                        // 'c'
+                        tags[tag] = new Int8Array(ba.buffer, absOffset, limit);
                         p += limit;
                     }
-                    else if (Btype === 'C') {
-                        tags[tag] = new Uint8Array(this.byteArray.buffer, absOffset, limit);
+                    else if (Btype === 0x43) {
+                        // 'C'
+                        tags[tag] = new Uint8Array(ba.buffer, absOffset, limit);
                         p += limit;
                     }
-                    else if (Btype === 'f') {
+                    else if (Btype === 0x66) {
+                        // 'f'
                         if (absOffset % 4 === 0) {
-                            tags[tag] = new Float32Array(this.byteArray.buffer, absOffset, limit);
+                            tags[tag] = new Float32Array(ba.buffer, absOffset, limit);
                         }
                         else {
-                            const bytes = this.byteArray.slice(p, p + (limit << 2));
+                            const bytes = ba.slice(p, p + (limit << 2));
                             tags[tag] = new Float32Array(bytes.buffer, bytes.byteOffset, limit);
                         }
                         p += limit << 2;
@@ -264,58 +284,49 @@ class BamRecord {
         }
         return tags;
     }
-    /**
-     * @returns {boolean} true if the read is paired, regardless of whether both
-     * segments are mapped
-     */
     isPaired() {
         return !!(this.flags & constants_ts_1.default.BAM_FPAIRED);
     }
-    /** @returns {boolean} true if the read is paired, and both segments are mapped */
     isProperlyPaired() {
         return !!(this.flags & constants_ts_1.default.BAM_FPROPER_PAIR);
     }
-    /** @returns {boolean} true if the read itself is unmapped; conflictive with isProperlyPaired */
     isSegmentUnmapped() {
         return !!(this.flags & constants_ts_1.default.BAM_FUNMAP);
     }
-    /** @returns {boolean} true if the read itself is unmapped; conflictive with isProperlyPaired */
     isMateUnmapped() {
         return !!(this.flags & constants_ts_1.default.BAM_FMUNMAP);
     }
-    /** @returns {boolean} true if the read is mapped to the reverse strand */
     isReverseComplemented() {
         return !!(this.flags & constants_ts_1.default.BAM_FREVERSE);
     }
-    /** @returns {boolean} true if the mate is mapped to the reverse strand */
     isMateReverseComplemented() {
         return !!(this.flags & constants_ts_1.default.BAM_FMREVERSE);
     }
-    /** @returns {boolean} true if this is read number 1 in a pair */
     isRead1() {
         return !!(this.flags & constants_ts_1.default.BAM_FREAD1);
     }
-    /** @returns {boolean} true if this is read number 2 in a pair */
     isRead2() {
         return !!(this.flags & constants_ts_1.default.BAM_FREAD2);
     }
-    /** @returns {boolean} true if this is a secondary alignment */
     isSecondary() {
         return !!(this.flags & constants_ts_1.default.BAM_FSECONDARY);
     }
-    /** @returns {boolean} true if this read has failed QC checks */
     isFailedQc() {
         return !!(this.flags & constants_ts_1.default.BAM_FQCFAIL);
     }
-    /** @returns {boolean} true if the read is an optical or PCR duplicate */
     isDuplicate() {
         return !!(this.flags & constants_ts_1.default.BAM_FDUP);
     }
-    /** @returns {boolean} true if this is a supplementary alignment */
     isSupplementary() {
         return !!(this.flags & constants_ts_1.default.BAM_FSUPPLEMENTARY);
     }
     get cigarAndLength() {
+        if (this._cachedCigarAndLength === undefined) {
+            this._cachedCigarAndLength = this._computeCigarAndLength();
+        }
+        return this._cachedCigarAndLength;
+    }
+    _computeCigarAndLength() {
         if (this.isSegmentUnmapped()) {
             return {
                 length_on_ref: 0,
@@ -329,14 +340,14 @@ class BamRecord {
         const cigop = this._dataView.getInt32(p, true);
         const lop = cigop >> 4;
         const op = cigop & 0xf;
-        if (op === CIGAR_SOFT_CLIP && lop === this.seq_length) {
+        if (op === cigar_ts_1.CIGAR_SOFT_CLIP && lop === this.seq_length) {
             // if there is a CG the second CIGAR field will be a N tag the represents
             // the length on ref
             p += 4;
             const cigop = this._dataView.getInt32(p, true);
             const lop = cigop >> 4;
             const op = cigop & 0xf;
-            if (op !== CIGAR_REF_SKIP) {
+            if (op !== cigar_ts_1.CIGAR_REF_SKIP) {
                 console.warn('CG tag with no N tag');
             }
             const cgArray = this.tags.CG;
@@ -345,24 +356,22 @@ class BamRecord {
                 length_on_ref: lop,
             };
         }
-        else {
-            const absOffset = this.byteArray.byteOffset + p;
-            const cigarView = absOffset % 4 === 0
-                ? new Uint32Array(this.byteArray.buffer, absOffset, numCigarOps)
-                : new Uint32Array(this.byteArray.slice(p, p + (numCigarOps << 2)).buffer, 0, numCigarOps);
-            let lref = 0;
-            for (let c = 0; c < numCigarOps; ++c) {
-                const cigop = cigarView[c];
-                const op = cigop & 0xf;
-                if (!((1 << op) & CIGAR_SKIP_MASK)) {
-                    lref += cigop >> 4;
-                }
+        const absOffset = this.byteArray.byteOffset + p;
+        const cigarView = absOffset % 4 === 0
+            ? new Uint32Array(this.byteArray.buffer, absOffset, numCigarOps)
+            : new Uint32Array(this.byteArray.slice(p, p + (numCigarOps << 2)).buffer, 0, numCigarOps);
+        let lref = 0;
+        for (let c = 0; c < numCigarOps; ++c) {
+            const cigop = cigarView[c];
+            const op = cigop & 0xf;
+            if (!((1 << op) & CIGAR_SKIP_MASK)) {
+                lref += cigop >> 4;
             }
-            return {
-                NUMERIC_CIGAR: cigarView,
-                length_on_ref: lref,
-            };
         }
+        return {
+            NUMERIC_CIGAR: cigarView,
+            length_on_ref: lref,
+        };
     }
     get length_on_ref() {
         return this.cigarAndLength.length_on_ref;
@@ -395,8 +404,7 @@ class BamRecord {
     }
     get NUMERIC_SEQ() {
         const p = this.b0 + this.read_name_length + this.num_cigar_bytes;
-        const seqBytes = this.byteArray.subarray(p, p + this.num_seq_bytes);
-        return new Uint8Array(seqBytes.buffer, seqBytes.byteOffset, this.num_seq_bytes);
+        return this.byteArray.subarray(p, p + this.num_seq_bytes);
     }
     get seq() {
         const numeric = this.NUMERIC_SEQ;
@@ -493,27 +501,4 @@ class BamRecord {
     }
 }
 exports.default = BamRecord;
-function cacheGetter(ctor, prop) {
-    const desc = Object.getOwnPropertyDescriptor(ctor.prototype, prop);
-    if (!desc) {
-        throw new Error('OH NO, NO PROPERTY DESCRIPTOR');
-    }
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    const getter = desc.get;
-    if (!getter) {
-        throw new Error('OH NO, NOT A GETTER');
-    }
-    Object.defineProperty(ctor.prototype, prop, {
-        get() {
-            const ret = getter.call(this);
-            Object.defineProperty(this, prop, { value: ret });
-            return ret;
-        },
-    });
-}
-cacheGetter(BamRecord, 'tags');
-cacheGetter(BamRecord, 'cigarAndLength');
-cacheGetter(BamRecord, 'seq');
-cacheGetter(BamRecord, 'qual');
-cacheGetter(BamRecord, 'end');
 //# sourceMappingURL=record.js.map