@jbrowse/plugin-alignments 2.16.1 → 2.18.0

package/esm/MismatchParser/index.js

@@ -1,336 +1,22 @@
-import { revcom } from '@jbrowse/core/util';
-import { getTagAlt } from '../util';
-const mdRegex = new RegExp(/(\d+|\^[a-z]+|[a-z])/gi);
-const modificationRegex = new RegExp(/([A-Z])([-+])([^,.?]+)([.?])?/);
+import { cigarToMismatches } from './cigarToMismatches';
+import { mdToMismatches } from './mdToMismatches';
 const cigarRegex = new RegExp(/([MIDNSHPX=])/);
 const startClip = new RegExp(/(\d+)[SH]$/);
 const endClip = new RegExp(/^(\d+)([SH])/);
 export function parseCigar(cigar = '') {
     return cigar.split(cigarRegex).slice(0, -1);
 }
-export 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
- */
-export 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;
-}
 export 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));
     }
-    // now let's look for CRAM or MD mismatches
     if (md && seq) {
         mismatches = mismatches.concat(mdToMismatches(md, ops, mismatches, seq, qual));
     }
     return mismatches;
 }
-// get relative reference sequence positions for positions given relative to
-// the read sequence
-export 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;
-        }
-    }
-}
-export function getModificationProbabilities(feature) {
-    var _a;
-    const m = getTagAlt(feature, 'ML', 'Ml') || [];
-    return m
-        ? (typeof m === 'string' ? m.split(',').map(e => +e) : m).map(e => e / 255)
-        : (_a = 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));
-}
-export function getMethBins(feature) {
-    const fstart = feature.get('start');
-    const fend = feature.get('end');
-    const fstrand = feature.get('strand');
-    const flen = fend - fstart;
-    const mm = 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 };
-}
-export function getModificationPositions(mm, fseq, fstrand) {
-    const seq = fstrand === -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);
-                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,
-                positions,
-            });
-        }
-    }
-    return result;
-}
-export 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);
-    });
-}
 export function getOrientedCigar(flip, cigar) {
     if (flip) {
         const ret = [];
@@ -394,16 +80,9 @@ export function getClip(cigar, strand) {
         ? +(startClip.exec(cigar) || [])[1] || 0
         : +(endClip.exec(cigar) || [])[1] || 0;
 }
-export function getTag(f, tag) {
-    const tags = f.get('tags');
-    return tags ? tags[tag] : f.get(tag);
+export function getTag(feature, tag) {
+    return feature.get('tags')[tag];
 }
-// produces a list of "feature-like" object from parsing supplementary
-// alignments in the SA tag
-//
-// @param normalize - used specifically in the linear-read-vs-ref context, it
-// flips features around relative to the original feature. other contexts of
-// usage can keep this false
 export function featurizeSA(SA, id, strand, readName, normalize) {
     return ((SA === null || SA === void 0 ? void 0 : SA.split(';').filter(aln => !!aln).map((aln, index) => {
         const ret = aln.split(',');
@@ -434,3 +113,4 @@ export function featurizeSA(SA, id, strand, readName, normalize) {
         };
     })) || []);
 }
+export { getNextRefPos } from './getNextRefPos';

package/esm/MismatchParser/mdToMismatches.d.ts

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

package/esm/MismatchParser/mdToMismatches.js

@@ -0,0 +1,71 @@
+const mdRegex = new RegExp(/(\d+|\^[a-z]+|[a-z])/gi);
+export 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');
+    function nextRecord() {
+        mismatchRecords.push(curr);
+        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);
+    }
+    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 {
+            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/esm/ModificationParser/index.d.ts

@@ -0,0 +1,19 @@
+import type { 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/esm/ModificationParser/index.js

@@ -0,0 +1,121 @@
+import { revcom } from '@jbrowse/core/util';
+import { getNextRefPos } from '../MismatchParser';
+import { getTagAlt } from '../util';
+const modificationRegex = new RegExp(/([A-Z])([-+])([^,.?]+)([.?])?/);
+export function getModProbabilities(feature) {
+    var _a;
+    const m = getTagAlt(feature, 'ML', 'Ml') || [];
+    return m
+        ? (typeof m === 'string' ? m.split(',').map(e => +e) : m).map(e => e / 255)
+        : (_a = 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));
+}
+export function getModPositions(mm, fseq, fstrand) {
+    const seq = fstrand === -1 ? revcom(fseq) : fseq;
+    const mods = mm.split(';').filter(mod => !!mod);
+    const result = [];
+    for (const mod of mods) {
+        const [basemod, ...skips] = mod.split(',');
+        const matches = modificationRegex.exec(basemod);
+        if (!matches) {
+            throw new Error('bad format for MM tag');
+        }
+        const [, base, strand, typestr] = matches;
+        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,
+            });
+        }
+        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) {
+                        positions.unshift(pos);
+                    }
+                }
+                else {
+                    positions.push(i - 1);
+                }
+            }
+            result.push({
+                type,
+                base: base,
+                strand: strand,
+                positions,
+            });
+        }
+    }
+    return result;
+}
+export 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;
+        return typestr
+            .split(/(\d+|.)/)
+            .filter(f => !!f)
+            .map(type => ({
+            type,
+            base: base,
+            strand: strand,
+        }));
+    });
+}
+export 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 = 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 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 };
+}

package/esm/PileupRPC/base.d.ts

@@ -1,8 +1,8 @@
 import RpcMethodType from '@jbrowse/core/pluggableElementTypes/RpcMethodType';
-import { RenderArgs } from '@jbrowse/core/rpc/coreRpcMethods';
+import type { RenderArgs } from '@jbrowse/core/rpc/coreRpcMethods';
 export default abstract class PileupBaseRPC extends RpcMethodType {
     serializeArguments(args: RenderArgs & {
-        signal?: AbortSignal;
+        stopToken?: string;
         statusCallback?: (arg: string) => void;
     }, rpcDriver: string): Promise<Record<string, unknown>>;
 }

package/esm/PileupRPC/base.js

@@ -1,6 +1,5 @@
 import RpcMethodType from '@jbrowse/core/pluggableElementTypes/RpcMethodType';
 import { renameRegionsIfNeeded } from '@jbrowse/core/util';
-// specialized get features to return limited data about alignments
 export default class PileupBaseRPC extends RpcMethodType {
     async serializeArguments(args, rpcDriver) {
         var _a;

package/esm/PileupRPC/index.d.ts

@@ -1,2 +1,2 @@
-import PluginManager from '@jbrowse/core/PluginManager';
+import type PluginManager from '@jbrowse/core/PluginManager';
 export default function PileupRPCMethodsF(pm: PluginManager): void;

package/esm/PileupRPC/index.js

@@ -1,4 +1,4 @@
-import { PileupGetGlobalValueForTag, PileupGetVisibleModifications, PileupGetReducedFeatures, } from './rpcMethods';
+import { PileupGetGlobalValueForTag, PileupGetReducedFeatures, PileupGetVisibleModifications, } from './rpcMethods';
 export default function PileupRPCMethodsF(pm) {
     pm.addRpcMethod(() => new PileupGetGlobalValueForTag(pm));
     pm.addRpcMethod(() => new PileupGetVisibleModifications(pm));

package/esm/PileupRPC/methods/GetGlobalValueForTag.d.ts

@@ -1,11 +1,10 @@
-import { Region } from '@jbrowse/core/util';
-import { RemoteAbortSignal } from '@jbrowse/core/rpc/remoteAbortSignals';
 import PileupBaseRPC from '../base';
+import type { Region } from '@jbrowse/core/util';
 export default class PileupGetGlobalValueForTag extends PileupBaseRPC {
     name: string;
     execute(args: {
         adapterConfig: Record<string, unknown>;
-        signal?: RemoteAbortSignal;
+        stopToken?: string;
         headers?: Record<string, string>;
         regions: Region[];
         sessionId: string;

package/esm/PileupRPC/methods/GetGlobalValueForTag.js

@@ -1,9 +1,7 @@
 import { getAdapter } from '@jbrowse/core/data_adapters/dataAdapterCache';
-import { toArray } from 'rxjs/operators';
 import { firstValueFrom } from 'rxjs';
-// locals
+import { toArray } from 'rxjs/operators';
 import PileupBaseRPC from '../base';
-import { getTag } from '../../util';
 export default class PileupGetGlobalValueForTag extends PileupBaseRPC {
     constructor() {
         super(...arguments);
@@ -16,7 +14,7 @@ export default class PileupGetGlobalValueForTag extends PileupBaseRPC {
         const featuresArray = await firstValueFrom(features.pipe(toArray()));
         return [
             ...new Set(featuresArray
-                .map(feature => getTag(feature, tag))
+                .map(feature => { var _a; return (_a = feature.get('tags')) === null || _a === void 0 ? void 0 : _a[tag]; })
                 .filter(f => f !== undefined)
                 .map(f => `${f}`)),
         ];

package/esm/PileupRPC/methods/GetReducedFeatures.d.ts

@@ -1,11 +1,10 @@
-import { Region } from '@jbrowse/core/util';
-import { RemoteAbortSignal } from '@jbrowse/core/rpc/remoteAbortSignals';
 import PileupBaseRPC from '../base';
+import type { Region } from '@jbrowse/core/util';
 export default class PileupGetReducedFeatures extends PileupBaseRPC {
     name: string;
     execute(args: {
         adapterConfig: Record<string, unknown>;
-        signal?: RemoteAbortSignal;
+        stopToken?: string;
         headers?: Record<string, string>;
         regions: Region[];
         sessionId: string;
@@ -23,7 +22,7 @@ export default class PileupGetReducedFeatures extends PileupBaseRPC {
             pair_orientation: any;
             next_ref: any;
             next_pos: any;
-            clipPos: any;
+            clipPos: number;
             SA: any;
         }[][];
         stats: {