@jbrowse/plugin-alignments 2.16.0 → 2.17.0

package/dist/MismatchParser/index.d.ts

@@ -1,41 +1,15 @@
 import { Feature } from '@jbrowse/core/util';
 import type { Buffer } from 'buffer';
-export interface Mismatch {
-    qual?: number;
-    start: number;
-    length: number;
-    type: string;
-    base: string;
-    altbase?: string;
-    seq?: string;
-    cliplen?: number;
-}
+import { Mismatch } from '../shared/types';
 export declare function parseCigar(cigar?: string): string[];
-export declare function cigarToMismatches(ops: string[], seq?: string, ref?: string, qual?: Buffer): Mismatch[];
-/**
- * parse a SAM MD tag to find mismatching bases of the template versus the
- * reference @returns array of mismatches and their positions
- */
-export declare function mdToMismatches(mdstring: string, ops: string[], cigarMismatches: Mismatch[], seq: string, qual?: Buffer): Mismatch[];
-export declare function getMismatches(cigar: string, md?: string, seq?: string, ref?: string, qual?: Buffer): Mismatch[];
-export declare function getNextRefPos(cigarOps: string[], positions: number[]): Generator<number, void, unknown>;
-export declare function getModificationProbabilities(feature: Feature): number[] | undefined;
-export declare function getMethBins(feature: Feature): {
-    methBins: number[];
-    methProbs: number[];
-};
-export declare function getModificationPositions(mm: string, fseq: string, fstrand: number): {
-    type: string;
-    positions: number[];
-}[];
-export declare function getModificationTypes(mm: string): string[];
+export declare function getMismatches(cigar?: string, md?: string, seq?: string, ref?: string, qual?: Buffer): Mismatch[];
 export declare function getOrientedCigar(flip: boolean, cigar: string[]): string[];
 export declare function getOrientedMismatches(flip: boolean, cigar: string): Mismatch[];
 export declare function getLengthOnRef(cigar: string): number;
 export declare function getLength(cigar: string): number;
 export declare function getLengthSansClipping(cigar: string): number;
 export declare function getClip(cigar: string, strand: number): number;
-export declare function getTag(f: Feature, tag: string): any;
+export declare function getTag(feature: Feature, tag: string): any;
 export declare function featurizeSA(SA: string | undefined, id: string, strand: number, readName: string, normalize?: boolean): {
     refName: string;
     start: number;
@@ -51,3 +25,4 @@ export declare function featurizeSA(SA: string | undefined, id: string, strand:
         refName: string;
     };
 }[];
+export { getNextRefPos } from './getNextRefPos';

package/dist/MismatchParser/index.js

@@ -1,14 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNextRefPos = void 0;
 exports.parseCigar = parseCigar;
-exports.cigarToMismatches = cigarToMismatches;
-exports.mdToMismatches = mdToMismatches;
 exports.getMismatches = getMismatches;
-exports.getNextRefPos = getNextRefPos;
-exports.getModificationProbabilities = getModificationProbabilities;
-exports.getMethBins = getMethBins;
-exports.getModificationPositions = getModificationPositions;
-exports.getModificationTypes = getModificationTypes;
 exports.getOrientedCigar = getOrientedCigar;
 exports.getOrientedMismatches = getOrientedMismatches;
 exports.getLengthOnRef = getLengthOnRef;
@@ -17,333 +11,27 @@ exports.getLengthSansClipping = getLengthSansClipping;
 exports.getClip = getClip;
 exports.getTag = getTag;
 exports.featurizeSA = featurizeSA;
-const util_1 = require("@jbrowse/core/util");
-const util_2 = require("../util");
-const mdRegex = new RegExp(/(\d+|\^[a-z]+|[a-z])/gi);
-const modificationRegex = new RegExp(/([A-Z])([-+])([^,.?]+)([.?])?/);
+const mdToMismatches_1 = require("./mdToMismatches");
+const cigarToMismatches_1 = require("./cigarToMismatches");
 const cigarRegex = new RegExp(/([MIDNSHPX=])/);
 const startClip = new RegExp(/(\d+)[SH]$/);
 const endClip = new RegExp(/^(\d+)([SH])/);
 function parseCigar(cigar = '') {
     return cigar.split(cigarRegex).slice(0, -1);
 }
-function cigarToMismatches(ops, seq, ref, qual) {
-    let roffset = 0; // reference offset
-    let soffset = 0; // seq offset
-    const mismatches = [];
-    const hasRefAndSeq = ref && seq;
-    for (let i = 0; i < ops.length; i += 2) {
-        const len = +ops[i];
-        const op = ops[i + 1];
-        if (op === 'M' || op === '=' || op === 'E') {
-            if (hasRefAndSeq) {
-                for (let j = 0; j < len; j++) {
-                    if (
-                    // @ts-ignore in the full yarn build of the repo, this says that object is possibly undefined for some reason, ignored
-                    seq[soffset + j].toUpperCase() !== ref[roffset + j].toUpperCase()) {
-                        mismatches.push({
-                            start: roffset + j,
-                            type: 'mismatch',
-                            base: seq[soffset + j],
-                            altbase: ref[roffset + j],
-                            length: 1,
-                        });
-                    }
-                }
-            }
-            soffset += len;
-        }
-        if (op === 'I') {
-            mismatches.push({
-                start: roffset,
-                type: 'insertion',
-                base: `${len}`,
-                length: 0,
-            });
-            soffset += len;
-        }
-        else if (op === 'D') {
-            mismatches.push({
-                start: roffset,
-                type: 'deletion',
-                base: '*',
-                length: len,
-            });
-        }
-        else if (op === 'N') {
-            mismatches.push({
-                start: roffset,
-                type: 'skip',
-                base: 'N',
-                length: len,
-            });
-        }
-        else if (op === 'X') {
-            const r = (seq === null || seq === void 0 ? void 0 : seq.slice(soffset, soffset + len)) || [];
-            const q = (qual === null || qual === void 0 ? void 0 : qual.subarray(soffset, soffset + len)) || [];
-            for (let j = 0; j < len; j++) {
-                mismatches.push({
-                    start: roffset + j,
-                    type: 'mismatch',
-                    base: r[j],
-                    qual: q[j],
-                    length: 1,
-                });
-            }
-            soffset += len;
-        }
-        else if (op === 'H') {
-            mismatches.push({
-                start: roffset,
-                type: 'hardclip',
-                base: `H${len}`,
-                cliplen: len,
-                length: 1,
-            });
-        }
-        else if (op === 'S') {
-            mismatches.push({
-                start: roffset,
-                type: 'softclip',
-                base: `S${len}`,
-                cliplen: len,
-                length: 1,
-            });
-            soffset += len;
-        }
-        if (op !== 'I' && op !== 'S' && op !== 'H') {
-            roffset += len;
-        }
-    }
-    return mismatches;
-}
-/**
- * parse a SAM MD tag to find mismatching bases of the template versus the
- * reference @returns array of mismatches and their positions
- */
-function mdToMismatches(mdstring, ops, cigarMismatches, seq, qual) {
-    let curr = { start: 0, base: '', length: 0, type: 'mismatch' };
-    let lastCigar = 0;
-    let lastTemplateOffset = 0;
-    let lastRefOffset = 0;
-    let lastSkipPos = 0;
-    const mismatchRecords = [];
-    const skips = cigarMismatches.filter(cigar => cigar.type === 'skip');
-    // convert a position on the reference sequence to a position
-    // on the template sequence, taking into account hard and soft
-    // clipping of reads
-    function nextRecord() {
-        mismatchRecords.push(curr);
-        // get a new mismatch record ready
-        curr = {
-            start: curr.start + curr.length,
-            length: 0,
-            base: '',
-            type: 'mismatch',
-        };
-    }
-    function getTemplateCoordLocal(refCoord) {
-        let templateOffset = lastTemplateOffset;
-        let refOffset = lastRefOffset;
-        for (let i = lastCigar; i < ops.length && refOffset <= refCoord; i += 2, lastCigar = i) {
-            const len = +ops[i];
-            const op = ops[i + 1];
-            if (op === 'S' || op === 'I') {
-                templateOffset += len;
-            }
-            else if (op === 'D' || op === 'P' || op === 'N') {
-                refOffset += len;
-            }
-            else if (op !== 'H') {
-                templateOffset += len;
-                refOffset += len;
-            }
-        }
-        lastTemplateOffset = templateOffset;
-        lastRefOffset = refOffset;
-        return templateOffset - (refOffset - refCoord);
-    }
-    // now actually parse the MD string
-    const md = mdstring.match(mdRegex) || [];
-    for (const token of md) {
-        const num = +token;
-        if (!Number.isNaN(num)) {
-            curr.start += num;
-        }
-        else if (token.startsWith('^')) {
-            curr.start += token.length - 1;
-        }
-        else {
-            // mismatch
-            // eslint-disable-next-line @typescript-eslint/prefer-for-of
-            for (let j = 0; j < token.length; j += 1) {
-                curr.length = 1;
-                while (lastSkipPos < skips.length) {
-                    const mismatch = skips[lastSkipPos];
-                    if (curr.start >= mismatch.start) {
-                        curr.start += mismatch.length;
-                        lastSkipPos++;
-                    }
-                    else {
-                        break;
-                    }
-                }
-                const s = getTemplateCoordLocal(curr.start);
-                curr.base = seq[s] || 'X';
-                curr.qual = qual === null || qual === void 0 ? void 0 : qual[s];
-                curr.altbase = token;
-                nextRecord();
-            }
-        }
-    }
-    return mismatchRecords;
-}
 function getMismatches(cigar, md, seq, ref, qual) {
     let mismatches = [];
     const ops = parseCigar(cigar);
     // parse the CIGAR tag if it has one
     if (cigar) {
-        mismatches = mismatches.concat(cigarToMismatches(ops, seq, ref, qual));
+        mismatches = mismatches.concat((0, cigarToMismatches_1.cigarToMismatches)(ops, seq, ref, qual));
     }
     // now let's look for CRAM or MD mismatches
     if (md && seq) {
-        mismatches = mismatches.concat(mdToMismatches(md, ops, mismatches, seq, qual));
+        mismatches = mismatches.concat((0, mdToMismatches_1.mdToMismatches)(md, ops, mismatches, seq, qual));
     }
     return mismatches;
 }
-// get relative reference sequence positions for positions given relative to
-// the read sequence
-function* getNextRefPos(cigarOps, positions) {
-    let readPos = 0;
-    let refPos = 0;
-    let currPos = 0;
-    for (let i = 0; i < cigarOps.length && currPos < positions.length; i += 2) {
-        const len = +cigarOps[i];
-        const op = cigarOps[i + 1];
-        if (op === 'S' || op === 'I') {
-            for (let i = 0; i < len && currPos < positions.length; i++) {
-                if (positions[currPos] === readPos + i) {
-                    currPos++;
-                }
-            }
-            readPos += len;
-        }
-        else if (op === 'D' || op === 'N') {
-            refPos += len;
-        }
-        else if (op === 'M' || op === 'X' || op === '=') {
-            for (let i = 0; i < len && currPos < positions.length; i++) {
-                if (positions[currPos] === readPos + i) {
-                    yield refPos + i;
-                    currPos++;
-                }
-            }
-            readPos += len;
-            refPos += len;
-        }
-    }
-}
-function getModificationProbabilities(feature) {
-    var _a;
-    const m = (0, util_2.getTagAlt)(feature, 'ML', 'Ml') || [];
-    return m
-        ? (typeof m === 'string' ? m.split(',').map(e => +e) : m).map(e => e / 255)
-        : (_a = (0, util_2.getTagAlt)(feature, 'MP', 'Mp')) === null || _a === void 0 ? void 0 : _a.split('').map(s => s.charCodeAt(0) - 33).map(elt => Math.min(1, elt / 50));
-}
-function getMethBins(feature) {
-    const fstart = feature.get('start');
-    const fend = feature.get('end');
-    const fstrand = feature.get('strand');
-    const flen = fend - fstart;
-    const mm = (0, util_2.getTagAlt)(feature, 'MM', 'Mm') || '';
-    const methBins = new Array(flen);
-    const methProbs = new Array(flen);
-    const seq = feature.get('seq');
-    if (seq) {
-        const ops = parseCigar(feature.get('CIGAR'));
-        const probabilities = getModificationProbabilities(feature);
-        const modifications = getModificationPositions(mm, seq, fstrand);
-        let probIndex = 0;
-        for (const { type, positions } of modifications) {
-            if (type === 'm') {
-                for (const ref of getNextRefPos(ops, positions)) {
-                    const prob = (probabilities === null || probabilities === void 0 ? void 0 : probabilities[probIndex]) || 0;
-                    probIndex++;
-                    if (ref >= 0 && ref < flen) {
-                        methBins[ref] = 1;
-                        methProbs[ref] = prob;
-                    }
-                }
-            }
-        }
-    }
-    return { methBins, methProbs };
-}
-function getModificationPositions(mm, fseq, fstrand) {
-    const seq = fstrand === -1 ? (0, util_1.revcom)(fseq) : fseq;
-    const mods = mm.split(';').filter(mod => !!mod);
-    const result = [];
-    for (const mod of mods) {
-        const [basemod, ...skips] = mod.split(',');
-        // regexes based on parse_mm.pl from hts-specs
-        const matches = modificationRegex.exec(basemod);
-        if (!matches) {
-            throw new Error('bad format for MM tag');
-        }
-        const [, base, strand, typestr] = matches;
-        // can be a multi e.g. C+mh for both meth (m) and hydroxymeth (h) so
-        // split, and they can also be chemical codes (ChEBI) e.g. C+16061
-        const types = typestr.split(/(\d+|.)/).filter(f => !!f);
-        if (strand === '-') {
-            console.warn('unsupported negative strand modifications');
-            // make sure to return a somewhat matching type even in this case
-            result.push({ type: 'unsupported', positions: [] });
-        }
-        // this logic also based on parse_mm.pl from hts-specs is that in the
-        // sequence of the read, if we have a modification type e.g. C+m;2 and a
-        // sequence ACGTACGTAC we skip the two instances of C and go to the last
-        // C
-        for (const type of types) {
-            let i = 0;
-            const positions = [];
-            for (const d of skips) {
-                let delta = +d;
-                do {
-                    if (base === 'N' || base === seq[i]) {
-                        delta--;
-                    }
-                    i++;
-                } while (delta >= 0 && i < seq.length);
-                const temp = i - 1;
-                positions.push(fstrand === -1 ? seq.length - 1 - temp : temp);
-            }
-            if (fstrand === -1) {
-                positions.sort((a, b) => a - b);
-            }
-            result.push({
-                type,
-                positions,
-            });
-        }
-    }
-    return result;
-}
-function getModificationTypes(mm) {
-    return mm
-        .split(';')
-        .filter(mod => !!mod)
-        .flatMap(mod => {
-        const basemod = mod.split(',')[0];
-        const matches = modificationRegex.exec(basemod);
-        if (!matches) {
-            throw new Error(`bad format for MM tag: ${mm}`);
-        }
-        const typestr = matches[3];
-        // can be a multi e.g. C+mh for both meth (m) and hydroxymeth (h) so
-        // split, and they can also be chemical codes (ChEBI) e.g. C+16061
-        return typestr.split(/(\d+|.)/).filter(f => !!f);
-    });
-}
 function getOrientedCigar(flip, cigar) {
     if (flip) {
         const ret = [];
@@ -364,7 +52,7 @@ function getOrientedCigar(flip, cigar) {
 }
 function getOrientedMismatches(flip, cigar) {
     const p = parseCigar(cigar);
-    return cigarToMismatches(flip ? getOrientedCigar(flip, p) : p);
+    return (0, cigarToMismatches_1.cigarToMismatches)(flip ? getOrientedCigar(flip, p) : p);
 }
 function getLengthOnRef(cigar) {
     const cigarOps = parseCigar(cigar);
@@ -407,9 +95,8 @@ function getClip(cigar, strand) {
         ? +(startClip.exec(cigar) || [])[1] || 0
         : +(endClip.exec(cigar) || [])[1] || 0;
 }
-function getTag(f, tag) {
-    const tags = f.get('tags');
-    return tags ? tags[tag] : f.get(tag);
+function getTag(feature, tag) {
+    return feature.get('tags')[tag];
 }
 // produces a list of "feature-like" object from parsing supplementary
 // alignments in the SA tag
@@ -447,3 +134,5 @@ function featurizeSA(SA, id, strand, readName, normalize) {
         };
     })) || []);
 }
+var getNextRefPos_1 = require("./getNextRefPos");
+Object.defineProperty(exports, "getNextRefPos", { enumerable: true, get: function () { return getNextRefPos_1.getNextRefPos; } });

package/dist/MismatchParser/mdToMismatches.d.ts

@@ -0,0 +1,3 @@
+import { Mismatch } from '../shared/types';
+import { Buffer } from 'buffer';
+export declare function mdToMismatches(mdstring: string, ops: string[], cigarMismatches: Mismatch[], seq: string, qual?: Buffer | number[] | null): Mismatch[];

package/dist/MismatchParser/mdToMismatches.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mdToMismatches = mdToMismatches;
+const mdRegex = new RegExp(/(\d+|\^[a-z]+|[a-z])/gi);
+function mdToMismatches(mdstring, ops, cigarMismatches, seq, qual) {
+    let curr = { start: 0, base: '', length: 0, type: 'mismatch' };
+    let lastCigar = 0;
+    let lastTemplateOffset = 0;
+    let lastRefOffset = 0;
+    let lastSkipPos = 0;
+    const mismatchRecords = [];
+    const skips = cigarMismatches.filter(cigar => cigar.type === 'skip');
+    // convert a position on the reference sequence to a position on the template
+    // sequence, taking into account hard and soft clipping of reads
+    function nextRecord() {
+        mismatchRecords.push(curr);
+        // get a new mismatch record ready
+        curr = {
+            start: curr.start + curr.length,
+            length: 0,
+            base: '',
+            type: 'mismatch',
+        };
+    }
+    function getTemplateCoordLocal(refCoord) {
+        let templateOffset = lastTemplateOffset;
+        let refOffset = lastRefOffset;
+        for (let i = lastCigar; i < ops.length && refOffset <= refCoord; i += 2, lastCigar = i) {
+            const len = +ops[i];
+            const op = ops[i + 1];
+            if (op === 'S' || op === 'I') {
+                templateOffset += len;
+            }
+            else if (op === 'D' || op === 'P' || op === 'N') {
+                refOffset += len;
+            }
+            else if (op !== 'H') {
+                templateOffset += len;
+                refOffset += len;
+            }
+        }
+        lastTemplateOffset = templateOffset;
+        lastRefOffset = refOffset;
+        return templateOffset - (refOffset - refCoord);
+    }
+    // now actually parse the MD string
+    const md = mdstring.match(mdRegex) || [];
+    for (const token of md) {
+        const num = +token;
+        if (!Number.isNaN(num)) {
+            curr.start += num;
+        }
+        else if (token.startsWith('^')) {
+            curr.start += token.length - 1;
+        }
+        else {
+            // mismatch
+            // eslint-disable-next-line @typescript-eslint/prefer-for-of
+            for (let j = 0; j < token.length; j += 1) {
+                curr.length = 1;
+                while (lastSkipPos < skips.length) {
+                    const mismatch = skips[lastSkipPos];
+                    if (curr.start >= mismatch.start) {
+                        curr.start += mismatch.length;
+                        lastSkipPos++;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                const s = getTemplateCoordLocal(curr.start);
+                curr.base = seq[s] || 'X';
+                curr.qual = qual === null || qual === void 0 ? void 0 : qual[s];
+                curr.altbase = token;
+                nextRecord();
+            }
+        }
+    }
+    return mismatchRecords;
+}

package/dist/ModificationParser/index.d.ts

@@ -0,0 +1,19 @@
+import { Feature } from '@jbrowse/core/util';
+export declare function getModProbabilities(feature: Feature): number[] | undefined;
+export declare function getModPositions(mm: string, fseq: string, fstrand: number): {
+    type: string;
+    positions: number[];
+    base: string;
+    strand: string;
+}[];
+export declare function getModTypes(mm: string): {
+    type: string;
+    base: string;
+    strand: string;
+}[];
+export declare function getMethBins(feature: Feature, cigarOps: string[]): {
+    methBins: number[];
+    hydroxyMethBins: number[];
+    methProbs: number[];
+    hydroxyMethProbs: number[];
+};

package/dist/ModificationParser/index.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModProbabilities = getModProbabilities;
+exports.getModPositions = getModPositions;
+exports.getModTypes = getModTypes;
+exports.getMethBins = getMethBins;
+const util_1 = require("@jbrowse/core/util");
+const util_2 = require("../util");
+const MismatchParser_1 = require("../MismatchParser");
+const modificationRegex = new RegExp(/([A-Z])([-+])([^,.?]+)([.?])?/);
+// ML stores probabilities as array of numerics and MP is scaled phred scores
+// https://github.com/samtools/hts-specs/pull/418/files#diff-e765c6479316309f56b636f88189cdde8c40b854c7bdcce9ee7fe87a4e76febcR596
+//
+// if we have ML or Ml, it is an 8bit probability, divide by 255
+//
+// if we have MP or Mp it is phred scaled ASCII, which can go up to 90 but has
+// very high likelihood basecalls at that point, we really only care about low
+// qual calls <20 approx
+function getModProbabilities(feature) {
+    var _a;
+    const m = (0, util_2.getTagAlt)(feature, 'ML', 'Ml') || [];
+    return m
+        ? (typeof m === 'string' ? m.split(',').map(e => +e) : m).map(e => e / 255)
+        : (_a = (0, util_2.getTagAlt)(feature, 'MP', 'Mp')) === null || _a === void 0 ? void 0 : _a.split('').map(s => s.charCodeAt(0) - 33).map(elt => Math.min(1, elt / 50));
+}
+function getModPositions(mm, fseq, fstrand) {
+    const seq = fstrand === -1 ? (0, util_1.revcom)(fseq) : fseq;
+    const mods = mm.split(';').filter(mod => !!mod);
+    const result = [];
+    for (const mod of mods) {
+        const [basemod, ...skips] = mod.split(',');
+        // regexes based on parse_mm.pl from hts-specs
+        // https://github.com/samtools/hts-specs/blob/master/test/SAMtags/parse_mm.pl
+        const matches = modificationRegex.exec(basemod);
+        if (!matches) {
+            throw new Error('bad format for MM tag');
+        }
+        const [, base, strand, typestr] = matches;
+        // can be a multi e.g. C+mh for both meth (m) and hydroxymeth (h) so split,
+        // and they can also be chemical codes (ChEBI) e.g. C+16061
+        const types = typestr.split(/(\d+|.)/).filter(f => !!f);
+        if (strand === '-') {
+            console.warn('unsupported negative strand modifications');
+            result.push({
+                type: 'unsupported',
+                positions: [],
+                base: base,
+                strand: strand,
+            });
+        }
+        // this logic based on parse_mm.pl from hts-specs
+        for (const type of types) {
+            let i = 0;
+            const positions = [];
+            for (const d of skips) {
+                let delta = +d;
+                do {
+                    if (base === 'N' || base === seq[i]) {
+                        delta--;
+                    }
+                    i++;
+                } while (delta >= 0 && i < seq.length);
+                if (fstrand === -1) {
+                    const pos = seq.length - i;
+                    if (pos >= 0) {
+                        // avoid negative-number-positions in array, seen in #4629 cause
+                        // unknown, could warrant some further investigation
+                        positions.unshift(pos);
+                    }
+                }
+                else {
+                    positions.push(i - 1);
+                }
+            }
+            result.push({
+                type,
+                base: base,
+                strand: strand,
+                positions,
+            });
+        }
+    }
+    return result;
+}
+function getModTypes(mm) {
+    return mm
+        .split(';')
+        .filter(mod => !!mod)
+        .flatMap(mod => {
+        const basemod = mod.split(',')[0];
+        const matches = modificationRegex.exec(basemod);
+        if (!matches) {
+            throw new Error('bad format for MM tag');
+        }
+        const [, base, strand, typestr] = matches;
+        // can be a multi e.g. C+mh for both meth (m) and hydroxymeth (h) so
+        // split, and they can also be chemical codes (ChEBI) e.g. C+16061
+        return typestr
+            .split(/(\d+|.)/)
+            .filter(f => !!f)
+            .map(type => ({
+            type,
+            base: base,
+            strand: strand,
+        }));
+    });
+}
+function getMethBins(feature, cigarOps) {
+    const fstart = feature.get('start');
+    const fend = feature.get('end');
+    const fstrand = feature.get('strand');
+    const flen = fend - fstart;
+    const mm = (0, util_2.getTagAlt)(feature, 'MM', 'Mm') || '';
+    const methBins = [];
+    const hydroxyMethBins = [];
+    const methProbs = [];
+    const hydroxyMethProbs = [];
+    const seq = feature.get('seq');
+    if (seq) {
+        const probabilities = getModProbabilities(feature);
+        const modifications = getModPositions(mm, seq, fstrand);
+        let probIndex = 0;
+        for (const { type, positions } of modifications) {
+            for (const { ref, idx } of (0, MismatchParser_1.getNextRefPos)(cigarOps, positions)) {
+                const idx2 = probIndex + (fstrand === -1 ? positions.length - 1 - idx : idx);
+                const prob = (probabilities === null || probabilities === void 0 ? void 0 : probabilities[idx2]) || 0;
+                if (type === 'm') {
+                    if (ref >= 0 && ref < flen) {
+                        methBins[ref] = 1;
+                        methProbs[ref] = prob;
+                    }
+                }
+                else if (type === 'h') {
+                    if (ref >= 0 && ref < flen) {
+                        hydroxyMethBins[ref] = 1;
+                        hydroxyMethProbs[ref] = prob;
+                    }
+                }
+            }
+            probIndex += positions.length;
+        }
+    }
+    return { methBins, hydroxyMethBins, methProbs, hydroxyMethProbs };
+}