@jbrowse/modifications-utils 5.0.0-beta.1 → 5.0.0-beta.10

package/README.md

@@ -25,9 +25,15 @@ cytosines in `context` are considered (default CpG); plants also use CHG/CHH.
 
 Parse MM tag to extract modification positions on the read sequence.
 
+Only the calls placed inside `[readStart, readEnd)` are kept, and each entry's
+`probStart` moves past the calls dropped ahead of them, so ML indexing is
+unchanged. The deltas count from the read's 5' end, which is the END of `fseq`
+on a reverse read: the bases between that end and the window are still counted,
+but only as a tally, and nothing past the far side of the window is walked.
+
 ```js
 // type signature
-(mm: string, fseq: string, fstrand: number) => ModWithPositions[]
+(mm: string, fseq: string, fstrand: number, readStart?: number, readEnd?: number) => ModWithPositions[]
 ```
 
 [Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/modifications-utils/src/getModPositions.ts)
@@ -63,6 +69,20 @@ survive. A caller that needs the numbers themselves still wants
 
 [Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/modifications-utils/src/getModProbabilities.ts)
 
+### getModTag
+
+The read's MM tag, or undefined when its MN tag says MM was computed on a
+sequence of a different length than SEQ. Per SAMtags, MN catches a hard clip or
+trim that shifted the bases MM's deltas count, so on a mismatch every position
+MM would place is wrong.
+
+```js
+// type signature
+(feature: Feature) => string | undefined
+```
+
+[Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/modifications-utils/src/getModTag.ts)
+
 ### getModTypes
 
 The modification types an MM tag declares, from its headers alone.

package/esm/forEachModRefPos.d.ts

@@ -1,2 +1,3 @@
 import type { ModWithPositions } from './getModPositions.ts';
-export declare function forEachModRefPos(modifications: readonly ModWithPositions[], probabilities: number[] | undefined, cigarOps: ArrayLike<number>, isReverse: boolean, cb: (mod: ModWithPositions, ref: number, idx: number, prob: number) => void): void;
+import type { CigarCursor } from '@jbrowse/cigar-utils';
+export declare function forEachModRefPos(modifications: readonly ModWithPositions[], probabilities: number[] | undefined, cigarOps: ArrayLike<number>, isReverse: boolean, cb: (mod: ModWithPositions, ref: number, idx: number, prob: number) => void, from?: CigarCursor): void;

package/esm/forEachModRefPos.js

@@ -3,13 +3,14 @@ import { modProbAt } from './getModProbabilities.js';
 // Walk every modification's read-sequence positions, mapping each to its
 // reference position via the CIGAR and recovering its ML probability. The
 // ML-array offset (probStart/probStride) is precomputed per modification by
-// getModPositions, so this no longer tracks a running index by hand.
-export function forEachModRefPos(modifications, probabilities, cigarOps, isReverse, cb) {
+// getModPositions, so this no longer tracks a running index by hand. `from`
+// starts every walk at a `refWindowToRead` cursor, for positions cut to it.
+export function forEachModRefPos(modifications, probabilities, cigarOps, isReverse, cb, from) {
     for (const mod of modifications) {
         const { positions, probStart, probStride } = mod;
         getNextRefPos(cigarOps, positions, (ref, idx) => {
             const prob = modProbAt(probabilities, probStart, probStride, isReverse, idx, positions.length);
             cb(mod, ref, idx, prob);
-        });
+        }, from);
     }
 }

package/esm/getMethBins.d.ts

@@ -1,5 +1,6 @@
 import type { CytosineContext } from './cytosineContext.ts';
 import type { ModWithPositions } from './getModPositions.ts';
+import type { ReadWindow } from '@jbrowse/cigar-utils';
 export interface ParsedModData {
     modifications: ModWithPositions[];
     probabilities: number[] | undefined;
@@ -7,6 +8,8 @@ export interface ParsedModData {
     seq: string;
     fstrand: -1 | 0 | 1;
     flen: number;
+    /** the window `modifications` was cut to, and the only one binned */
+    window?: ReadWindow;
 }
 /**
  * #api
@@ -26,7 +29,7 @@ export declare function isMethylationFillType(type: string): type is "h" | "m";
  * positions, returning typed arrays for methylated/unmethylated calls. Only
  * cytosines in `context` are considered (default CpG); plants also use CHG/CHH.
  */
-export declare function getMethBins({ modifications, probabilities, cigarOps, seq, fstrand, flen }: ParsedModData, context?: CytosineContext): {
+export declare function getMethBins({ modifications, probabilities, cigarOps, seq, fstrand, flen, window, }: ParsedModData, context?: CytosineContext): {
     methBins: number[];
     hydroxyMethBins: number[];
     methProbs: number[];

package/esm/getMethBins.js

@@ -21,7 +21,7 @@ export function isMethylationFillType(type) {
  * positions, returning typed arrays for methylated/unmethylated calls. Only
  * cytosines in `context` are considered (default CpG); plants also use CHG/CHH.
  */
-export function getMethBins({ modifications, probabilities, cigarOps, seq, fstrand, flen }, context = 'CG') {
+export function getMethBins({ modifications, probabilities, cigarOps, seq, fstrand, flen, window, }, context = 'CG') {
     const isReverse = fstrand === -1;
     const methBins = [];
     const hydroxyMethBins = [];
@@ -42,7 +42,7 @@ export function getMethBins({ modifications, probabilities, cigarOps, seq, fstra
                 hydroxyMethProbs[ref] = prob;
             }
         }
-    });
+    }, window);
     // Only fill undetected sites as unmethylated when the read actually carries a
     // 5mC ('m') call. A read with only e.g. 6mA modifications never assayed
     // methylation, so inventing unmethylated cytosines for it would be wrong.
@@ -55,12 +55,14 @@ export function getMethBins({ modifications, probabilities, cigarOps, seq, fstra
     // both-strand modBAM ('C+m;G-m') has its uncalled sites in both directions.
     const fillForward = methMods.some(m => isReverse === (m.strand === '-'));
     const fillReverse = methMods.some(m => isReverse !== (m.strand === '-'));
-    // Scan the full read sequence for every cytosine in `context` and mark any not
-    // already detected from the MM tag as unmethylated (prob=0).
+    // Scan the window's read sequence for every cytosine in `context` and mark any
+    // not already detected from the MM tag as unmethylated (prob=0).
     if (fillUnmethylated) {
-        let readPos = 0;
-        let refPos = 0;
-        for (let i = 0, l = cigarOps.length; i < l; i++) {
+        const lo = Math.max(0, window?.refStart ?? 0);
+        const hi = Math.min(flen, window?.refEnd ?? flen);
+        let readPos = window?.opRead ?? 0;
+        let refPos = window?.opRef ?? 0;
+        for (let i = window?.op ?? 0, l = cigarOps.length; i < l && refPos < hi; i++) {
             const packed = cigarOps[i];
             const len = packed >>> 4;
             const op = packed & 0xf;
@@ -74,8 +76,8 @@ export function getMethBins({ modifications, probabilities, cigarOps, seq, fstra
                 for (let j = 0; j < len; j++) {
                     const rp = readPos + j;
                     const rf = refPos + j;
-                    if (rf >= 0 &&
-                        rf < flen &&
+                    if (rf >= lo &&
+                        rf < hi &&
                         !methBins[rf] &&
                         ((fillForward && matchesCytosineContext(seq, rp, false, context)) ||
                             (fillReverse && matchesCytosineContext(seq, rp, true, context)))) {

package/esm/getModPositions.d.ts

@@ -11,9 +11,18 @@ export interface ModWithPositions {
  * #api
  * Parse MM tag to extract modification positions on the read sequence.
  *
+ * Only the calls placed inside `[readStart, readEnd)` are kept, and each
+ * entry's `probStart` moves past the calls dropped ahead of them, so ML
+ * indexing is unchanged. The deltas count from the read's 5' end, which is the
+ * END of `fseq` on a reverse read: the bases between that end and the window
+ * are still counted, but only as a tally, and nothing past the far side of the
+ * window is walked.
+ *
  * @param mm - MM tag string (e.g., "C+m,2,2,1;A+a,0,3")
  * @param fseq - Read sequence
  * @param fstrand - Read strand (-1, 0, or 1)
+ * @param readStart - First read offset to keep
+ * @param readEnd - Read offset past the last one to keep
  * @returns Array of modification objects with positions
  */
-export declare function getModPositions(mm: string, fseq: string, fstrand: number): ModWithPositions[];
+export declare function getModPositions(mm: string, fseq: string, fstrand: number, readStart?: number, readEnd?: number): ModWithPositions[];

package/esm/getModPositions.js

@@ -7,19 +7,209 @@ const COMPLEMENT_CODE = {
     71: 67, // G->C
     78: 78, // N->N
 };
+const COMMA = 44;
+const encoder = new TextEncoder();
+const scratch = new Uint8Array(1 << 16);
+const scratchWords = new Uint32Array(scratch.buffer, scratch.byteOffset, scratch.byteLength / 4);
+// Occurrences of `code` in text[start, end), four characters per step over the
+// text's bytes: a byte of `word ^ pattern` is zero exactly where the character
+// matches, and the SWAR zero-byte test finds all four at once.
+function countCode(text, code, start, end) {
+    const pattern = Math.imul(code, 0x01010101);
+    let n = 0;
+    for (let from = start; from < end; from += scratch.length) {
+        const to = Math.min(end, from + scratch.length);
+        const len = to - from;
+        const { read, written } = encoder.encodeInto(text.substring(from, to), scratch);
+        if (read !== len || written !== len) {
+            for (let i = from; i < to; i++) {
+                n += +(text.charCodeAt(i) === code);
+            }
+            continue;
+        }
+        const nWords = len >> 2;
+        for (let i = 0; i < nWords; i++) {
+            const x = scratchWords[i] ^ pattern;
+            const zero = ~(((x & 0x7f7f7f7f) + 0x7f7f7f7f) | x | 0x7f7f7f7f);
+            n += Math.imul(zero >>> 7, 0x01010101) >>> 24;
+        }
+        for (let i = nWords << 2; i < len; i++) {
+            n += +(scratch[i] === code);
+        }
+    }
+    return n;
+}
+// One group's calls inside [windowStart, windowEnd), ascending, and how many
+// calls came before them in MM order. `deltas` is the group after its header,
+// `,2,2,1`.
+//
+// An MM tag may declare more calls of a base than the read has left. When that
+// happens the walk has nowhere to put them, and every emitted value still has
+// to be a valid index into the read — `getMethBins` indexes the sequence with
+// these, and the CIGAR walk requires them ascending, so a position outside the
+// read is read as a real one somewhere wrong rather than dropped. So the
+// exhausted case clamps to the nearest valid index and stays there, which on an
+// empty read is 0 for every call.
+function walkGroup(deltas, nPositions, base, fseq, isRev, windowStart, windowEnd) {
+    const seqLength = fseq.length;
+    const positions = [];
+    if (seqLength === 0) {
+        for (let i = 0; i < nPositions; i++) {
+            positions.push(0);
+        }
+        return { positions, skipped: 0 };
+    }
+    if (windowStart >= windowEnd || nPositions === 0) {
+        return { positions, skipped: 0 };
+    }
+    const isN = base === 'N';
+    const baseCode = base.charCodeAt(0);
+    // Reverse reads are walked from the back of fseq, matching the complement,
+    // rather than reverse-complementing the read.
+    const code = isRev ? (COMPLEMENT_CODE[baseCode] ?? baseCode) : baseCode;
+    // `+field` for each delta in turn, read in place rather than split out: the
+    // digits are summed as they are passed, and a field holding anything else
+    // (a sign, a space, a fraction) goes to `+` itself, so a malformed tag reads
+    // as it always has. Against `split(',')` on this same windowed walk it
+    // measured 1.24x at a 1 kb view and 1.03x over whole reads
+    // (`benches/modWindow.bench.ts`); `mmParseShape.bench.ts` had declined it
+    // at 1.06x when every read was walked end to end.
+    const deltasLength = deltas.length;
+    let cursor = 0;
+    const next = () => {
+        const from = cursor + 1;
+        let to = from;
+        let value = 0;
+        let digits = true;
+        for (; to < deltasLength; to++) {
+            const d = deltas.charCodeAt(to) - 48;
+            if (d === COMMA - 48) {
+                break;
+            }
+            if (d < 0 || d > 9) {
+                digits = false;
+            }
+            value = value * 10 + d;
+        }
+        cursor = to;
+        return digits && to - from < 16 ? value : +deltas.slice(from, to);
+    };
+    // The calls on the 5' side of the window are passed over by counting their
+    // base there once and subtracting whole deltas from the count. `carry` is
+    // what is left: occurrences the first kept call has already used up. A NaN
+    // delta fails the test and is handed to the walk, which places it as it
+    // always has.
+    const tallyStart = isRev ? windowEnd : 0;
+    const tallyEnd = isRev ? seqLength : windowStart;
+    let carry = isN
+        ? tallyEnd - tallyStart
+        : countCode(fseq, code, tallyStart, tallyEnd);
+    let first = 1;
+    let delta = next();
+    while (delta + 1 <= carry && first < nPositions) {
+        carry -= delta + 1;
+        first++;
+        delta = next();
+    }
+    if (delta + 1 <= carry) {
+        return { positions, skipped: nPositions };
+    }
+    if (isRev) {
+        let currPos = seqLength - windowEnd;
+        for (let i = first; i <= nPositions; i++) {
+            if (i > first) {
+                delta = next();
+            }
+            let at = 0;
+            if (currPos < seqLength) {
+                let remaining = delta - carry;
+                carry = 0;
+                do {
+                    if (isN || fseq.charCodeAt(seqLength - 1 - currPos) === code) {
+                        remaining--;
+                    }
+                    currPos++;
+                } while (remaining >= 0 && currPos < seqLength);
+                at = seqLength - currPos;
+            }
+            if (at < windowStart) {
+                break;
+            }
+            positions.push(at);
+        }
+        positions.reverse();
+    }
+    else {
+        // **Forward jumps, reverse steps, and the asymmetry is measured rather
+        // than assumed.** `indexOf` for a single character is a native scan, so
+        // finding the (delta+1)-th occurrence is delta+1 searches instead of one
+        // step per base — 1.560x on the sparse fixture and 1.247x on the dense
+        // one, parse phase, in `benches/mmDeltaJump.bench.ts`. `lastIndexOf` is
+        // NOT the mirror image: the same change on reverse reads measures
+        // **0.786x**.
+        const endClamp = seqLength - 1;
+        let currPos = windowStart;
+        for (let i = first; i <= nPositions; i++) {
+            if (i > first) {
+                delta = next();
+            }
+            const remaining = delta - carry;
+            carry = 0;
+            let at = -1;
+            if (isN) {
+                // 'N' matches every base, so the (delta+1)-th is delta ahead and
+                // there is nothing to search for.
+                at = currPos + remaining;
+                if (at >= seqLength) {
+                    at = -1;
+                }
+            }
+            else {
+                for (let k = 0; k <= remaining; k++) {
+                    at = fseq.indexOf(base, currPos);
+                    if (at < 0) {
+                        break;
+                    }
+                    currPos = at + 1;
+                }
+            }
+            if (at < 0) {
+                currPos = seqLength;
+                at = endClamp;
+            }
+            else {
+                currPos = at + 1;
+            }
+            if (at >= windowEnd) {
+                break;
+            }
+            positions.push(at);
+        }
+    }
+    return { positions, skipped: first - 1 };
+}
 /**
  * #api
  * Parse MM tag to extract modification positions on the read sequence.
  *
+ * Only the calls placed inside `[readStart, readEnd)` are kept, and each
+ * entry's `probStart` moves past the calls dropped ahead of them, so ML
+ * indexing is unchanged. The deltas count from the read's 5' end, which is the
+ * END of `fseq` on a reverse read: the bases between that end and the window
+ * are still counted, but only as a tally, and nothing past the far side of the
+ * window is walked.
+ *
  * @param mm - MM tag string (e.g., "C+m,2,2,1;A+a,0,3")
  * @param fseq - Read sequence
  * @param fstrand - Read strand (-1, 0, or 1)
+ * @param readStart - First read offset to keep
+ * @param readEnd - Read offset past the last one to keep
  * @returns Array of modification objects with positions
  */
-export function getModPositions(mm, fseq, fstrand) {
-    const seqLength = fseq.length;
+export function getModPositions(mm, fseq, fstrand, readStart = 0, readEnd = fseq.length) {
     const isRev = fstrand === -1;
-    const mods = mm.split(';');
+    const windowStart = Math.max(0, readStart);
+    const windowEnd = Math.min(fseq.length, readEnd);
     const result = [];
     // Running offset into the flat ML probabilities array. Each group consumes
     // (numPositions * numTypes) values, interleaved per position.
@@ -29,27 +219,26 @@ export function getModPositions(mm, fseq, fstrand) {
     // model emits `C+h?;C+m?` — two groups, one canonical base, identical delta
     // lists — so on real ONT output this drops one of every three sequence walks.
     //
-    // The key is what the walk below READS: the canonical base and the delta list
-    // (`fseq` and `fstrand` are per read, not per group). It also carries the MM
-    // strand, which the walk does not currently read — deliberately stronger than
-    // needed, so the test cannot go quietly wrong if the walk ever becomes
-    // strand-aware.
+    // The key is what the walk READS: the canonical base and the delta list
+    // (`fseq`, `fstrand` and the window are per read, not per group). It also
+    // carries the MM strand, which the walk does not currently read —
+    // deliberately stronger than needed, so the test cannot go quietly wrong if
+    // the walk ever becomes strand-aware.
     //
-    // Parallel arrays rather than a Map: a read carries one to four groups, so a
-    // linear scan of char compares beats hashing a multi-kilobyte delta string,
-    // and they are allocated on the first walk so a single-group read builds none.
+    // A list rather than a Map: a read carries one to four groups, so a linear
+    // scan of char compares beats hashing a multi-kilobyte delta string, and it
+    // is allocated on the first walk so a single-group read builds none.
     // `benches/sameBaseMerge.bench.ts` prices the whole test at inside the control
     // on every fixture where it cannot fire, including one where every compare is
-    // forced to run to its final byte and then fail.
-    let seenKeys;
-    let seenDeltas;
-    let seenPositions;
-    for (const mod of mods) {
+    // forced to run to its final byte and then fail. A group that matches is not
+    // even split.
+    let seen;
+    for (const mod of mm.split(';')) {
         if (mod === '') {
             continue;
         }
-        const split = mod.split(',');
-        const basemod = split[0];
+        const comma = mod.indexOf(',');
+        const basemod = comma < 0 ? mod : mod.slice(0, comma);
         const { base, strand, typestr, mod: skipFlag, } = parseModHeader(basemod, mod);
         const unknownSkip = skipFlag === '?';
         // typestr can be multi-char lowercase e.g. 'mh' (5mC + 5hmC at same
@@ -59,7 +248,7 @@ export function getModPositions(mm, fseq, fstrand) {
         const isSingleType = isSingleModType(typestr);
         const nTypes = isSingleType ? 1 : typestr.length;
         // ONE walk per GROUP, not per type. Every type in a combined code is called
-        // at the same positions — only probStart differs — so the walk below and the
+        // at the same positions — only probStart differs — so the walk and the
         // array it fills are shared, and the entries pushed after it point at the
         // same array. `C+mh` used to walk the read sequence twice and allocate two
         // identical arrays; `benches/modCombinedCode.bench.ts` (in the alignments
@@ -67,115 +256,30 @@ export function getModPositions(mm, fseq, fstrand) {
         // `C+mh`, and at **1.16x** even on a single-type tag, where nothing is
         // deduplicated and the win is the per-group closure this loop replaced.
         //
-        // A combined code is the RARER of the two shapes this deduplicates, though.
-        // The reuse test below is the common one — see `seenKeys`.
-        //
         // this logic based on parse_mm.pl from hts-specs
-        const splitLength = split.length;
-        const nPositions = splitLength - 1;
+        //
         // Everything after the header — `,2,2,1`. V8 slices a long string in O(1),
         // and the compare rejects on length before it reads a byte.
         const deltas = mod.slice(basemod.length);
         const key = base + strand;
-        let positions;
-        if (seenKeys !== undefined) {
-            for (let s = 0, n = seenKeys.length; s < n; s++) {
-                if (seenKeys[s] === key && seenDeltas[s] === deltas) {
-                    positions = seenPositions[s];
-                    break;
-                }
-            }
-        }
-        if (positions === undefined) {
-            const isN = base === 'N';
-            let currPos = 0;
-            // An MM tag may declare more calls of a base than the read has left. When
-            // that happens the walk has nowhere to put them, and every emitted value
-            // still has to be a valid index into the read — `getMethBins` indexes the
-            // sequence with these, and the CIGAR walk requires them ascending, so a
-            // position outside the read is read as a real one somewhere wrong rather
-            // than dropped. So the exhausted case clamps to the nearest valid index
-            // and stays there.
-            const endClamp = isRev ? 0 : Math.max(0, seqLength - 1);
-            // Pre-allocate and fill backwards on reverse strand to avoid a final
-            // reverse(). Forward stays a growing literal on purpose: filling
-            // `new Array(n)` leaves holey elements, and this array is read in the
-            // CIGAR walk's inner loop.
-            positions = isRev ? new Array(nPositions) : [];
-            let writeIndex = isRev ? nPositions - 1 : 0;
-            if (isRev) {
-                // Avoid revcom(fseq) by reading fseq from the back and complementing the
-                // expected char-code.
-                const baseCode = base.charCodeAt(0);
-                const targetCode = COMPLEMENT_CODE[baseCode] ?? baseCode;
-                for (let i = 1; i < splitLength; i++) {
-                    if (currPos >= seqLength) {
-                        positions[writeIndex--] = endClamp;
-                        continue;
-                    }
-                    let delta = +split[i];
-                    do {
-                        if (isN ||
-                            fseq.charCodeAt(seqLength - 1 - currPos) === targetCode) {
-                            delta--;
-                        }
-                        currPos++;
-                    } while (delta >= 0 && currPos < seqLength);
-                    positions[writeIndex--] = seqLength - currPos;
-                }
-            }
-            else {
-                // **Forward jumps, reverse steps, and the asymmetry is measured rather
-                // than assumed.** `indexOf` for a single character is a native scan, so
-                // finding the (delta+1)-th occurrence is delta+1 searches instead of one
-                // step per base — 1.560x on the sparse fixture and 1.247x on the dense
-                // one, parse phase, in `benches/mmDeltaJump.bench.ts`.
-                //
-                // `lastIndexOf` is NOT the mirror image: the same change on reverse
-                // reads measures **0.786x**, i.e. materially slower than stepping, so
-                // reverse keeps the loop above. Applying it to both, which is the
-                // obvious version, nets 1.054x where branching on strand nets 1.263x.
-                for (let i = 1; i < splitLength; i++) {
-                    const delta = +split[i];
-                    let at = -1;
-                    if (isN) {
-                        // 'N' matches every base, so the (delta+1)-th is delta ahead and
-                        // there is nothing to search for.
-                        at = currPos + delta;
-                        if (at >= seqLength) {
-                            at = -1;
-                        }
-                    }
-                    else {
-                        for (let k = 0; k <= delta; k++) {
-                            at = fseq.indexOf(base, currPos);
-                            if (at < 0) {
-                                break;
-                            }
-                            currPos = at + 1;
-                        }
-                    }
-                    if (at < 0) {
-                        currPos = seqLength;
-                        positions[writeIndex++] = endClamp;
-                    }
-                    else {
-                        currPos = at + 1;
-                        positions[writeIndex++] = at;
-                    }
-                }
-            }
-            if (seenKeys === undefined) {
-                seenKeys = [key];
-                seenDeltas = [deltas];
-                seenPositions = [positions];
+        let walked = seen?.find(w => w.key === key && w.deltas === deltas);
+        if (walked === undefined) {
+            const nPositions = countCode(deltas, COMMA, 0, deltas.length);
+            walked = {
+                key,
+                deltas,
+                nPositions,
+                ...walkGroup(deltas, nPositions, base, fseq, isRev, windowStart, windowEnd),
+            };
+            if (seen === undefined) {
+                seen = [walked];
             }
             else {
-                seenKeys.push(key);
-                seenDeltas.push(deltas);
-                seenPositions.push(positions);
+                seen.push(walked);
             }
         }
+        const { positions, skipped, nPositions } = walked;
+        const probStart = mlBase + skipped * nTypes;
         if (isSingleType) {
             result.push({
                 type: typestr,
@@ -183,7 +287,7 @@ export function getModPositions(mm, fseq, fstrand) {
                 strand,
                 unknownSkip,
                 positions,
-                probStart: mlBase,
+                probStart,
                 probStride: 1,
             });
         }
@@ -196,7 +300,7 @@ export function getModPositions(mm, fseq, fstrand) {
                     strand,
                     unknownSkip,
                     positions,
-                    probStart: mlBase + j,
+                    probStart: probStart + j,
                     probStride: nTypes,
                 });
             }

package/esm/getModTag.d.ts

@@ -0,0 +1,9 @@
+import type { Feature } from '@jbrowse/core/util';
+/**
+ * #api
+ * The read's MM tag, or undefined when its MN tag says MM was computed on a
+ * sequence of a different length than SEQ. Per SAMtags, MN catches a hard clip
+ * or trim that shifted the bases MM's deltas count, so on a mismatch every
+ * position MM would place is wrong.
+ */
+export declare function getModTag(feature: Feature): string | undefined;

package/esm/getModTag.js

@@ -0,0 +1,22 @@
+import { getTag, getTagAlt } from './getTagAlt.js';
+function seqLength(feature) {
+    const len = feature.get('seq_length');
+    return typeof len === 'number'
+        ? len
+        : feature.get('seq')?.length;
+}
+/**
+ * #api
+ * The read's MM tag, or undefined when its MN tag says MM was computed on a
+ * sequence of a different length than SEQ. Per SAMtags, MN catches a hard clip
+ * or trim that shifted the bases MM's deltas count, so on a mismatch every
+ * position MM would place is wrong.
+ */
+export function getModTag(feature) {
+    const mm = getTagAlt(feature, 'MM', 'Mm');
+    if (!mm) {
+        return undefined;
+    }
+    const mn = getTag(feature, 'MN');
+    return mn === undefined || Number(mn) === seqLength(feature) ? mm : undefined;
+}

package/esm/index.d.ts

@@ -6,6 +6,7 @@ export { forEachModRefPos } from './forEachModRefPos.ts';
 export { getMethBins, isMethylationFillType } from './getMethBins.ts';
 export type { ParsedModData } from './getMethBins.ts';
 export { getModPositions } from './getModPositions.ts';
+export { getModTag } from './getModTag.ts';
 export type { ModWithPositions } from './getModPositions.ts';
 export { getModTypes, isSingleModType } from './getModTypes.ts';
 export type { ModTypeHeader } from './getModTypes.ts';

package/esm/index.js

@@ -4,6 +4,7 @@ export { detectSimplexModifications } from './detectSimplexModifications.js';
 export { forEachModRefPos } from './forEachModRefPos.js';
 export { getMethBins, isMethylationFillType } from './getMethBins.js';
 export { getModPositions } from './getModPositions.js';
+export { getModTag } from './getModTag.js';
 export { getModTypes, isSingleModType } from './getModTypes.js';
 export { getModProbabilities, getModProbabilityBytes, modProbAt, } from './getModProbabilities.js';
 export { getTag, getTagAlt } from './getTagAlt.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/modifications-utils",
-  "version": "5.0.0-beta.1",
+  "version": "5.0.0-beta.10",
   "type": "module",
   "description": "Pure MM/ML base-modification tag parsers (methylation, etc.)",
   "keywords": [
@@ -25,8 +25,8 @@
     "esm"
   ],
   "dependencies": {
-    "@jbrowse/cigar-utils": "^5.0.0-beta.1",
-    "@jbrowse/core": "^5.0.0-beta.1"
+    "@jbrowse/cigar-utils": "^5.0.0-beta.10",
+    "@jbrowse/core": "^5.0.0-beta.10"
   },
   "publishConfig": {
     "access": "public"