@jbrowse/plugin-alignments 3.6.5 → 4.0.0

package/esm/MismatchParser/index.js

@@ -1,11 +1,11 @@
-import { cigarToMismatches } from './cigarToMismatches';
-import { mdToMismatches } from './mdToMismatches';
+import { cigarToMismatches } from "./cigarToMismatches.js";
+import { cigarToMismatches2 } from "./cigarToMismatches2.js";
+import { mdToMismatches } from "./mdToMismatches.js";
+import { mdToMismatches2 } from "./mdToMismatches2.js";
 const startClip = new RegExp(/(\d+)[SH]$/);
 const endClip = new RegExp(/^(\d+)([SH])/);
 export function parseCigar(s = '') {
     let currLen = '';
-    let len;
-    let op;
     const ret = [];
     for (let i = 0, l = s.length; i < l; i++) {
         const c = s[i];
@@ -13,14 +13,39 @@ export function parseCigar(s = '') {
             currLen = currLen + c;
         }
         else {
-            len = currLen;
-            op = c;
+            ret.push(currLen, c);
             currLen = '';
-            ret.push(len, op);
         }
     }
     return ret;
 }
+const CIGAR_CODE_TO_INDEX = {
+    77: 0,
+    73: 1,
+    68: 2,
+    78: 3,
+    83: 4,
+    72: 5,
+    80: 6,
+    61: 7,
+    88: 8,
+};
+export function parseCigar2(s = '') {
+    let currLen = 0;
+    const ret = [];
+    for (let i = 0, l = s.length; i < l; i++) {
+        const code = s.charCodeAt(i);
+        if (code >= 48 && code <= 57) {
+            currLen = currLen * 10 + (code - 48);
+        }
+        else {
+            const opIndex = CIGAR_CODE_TO_INDEX[code];
+            ret.push((currLen << 4) | opIndex);
+            currLen = 0;
+        }
+    }
+    return new Uint32Array(ret);
+}
 export function getMismatches(cigar, md, seq, ref, qual) {
     let mismatches = [];
     const ops = parseCigar(cigar);
@@ -32,6 +57,16 @@ export function getMismatches(cigar, md, seq, ref, qual) {
     }
     return mismatches;
 }
+export function getMismatches2(cigar, md, seq, ref, qual) {
+    let mismatches = [];
+    if (cigar && cigar.length > 0) {
+        mismatches = mismatches.concat(cigarToMismatches2(cigar, seq, ref, qual));
+    }
+    if (md && seq && cigar) {
+        mismatches = mismatches.concat(mdToMismatches2(md, cigar, mismatches, seq, qual));
+    }
+    return mismatches;
+}
 export function getOrientedCigar(flip, cigar) {
     if (flip) {
         const ret = [];
@@ -99,7 +134,9 @@ export function getTag(feature, tag) {
     return feature.get('tags')[tag];
 }
 export function featurizeSA(SA, id, strand, readName, normalize) {
-    return ((SA === null || SA === void 0 ? void 0 : SA.split(';').filter(aln => !!aln).map((aln, index) => {
+    return (SA?.split(';')
+        .filter(aln => !!aln)
+        .map((aln, index) => {
         const ret = aln.split(',');
         const saRef = ret[0];
         const saStart = ret[1];
@@ -116,7 +153,7 @@ export function featurizeSA(SA, id, strand, readName, normalize) {
             start: saRealStart,
             end: saRealStart + saLengthOnRef,
             seqLength: saLength,
-            clipPos: saClipPos,
+            clipLengthAtStartOfRead: saClipPos,
             CIGAR: saCigar,
             strand: (normalize ? strand : 1) * saStrandNormalized,
             uniqueId: `${id}_SA${index}`,
@@ -126,6 +163,7 @@ export function featurizeSA(SA, id, strand, readName, normalize) {
                 refName: readName,
             },
         };
-    })) || []);
+    }) || []);
 }
-export { getNextRefPos } from './getNextRefPos';
+export { getNextRefPos } from "./getNextRefPos.js";
+export { cigarToMismatches2 } from "./cigarToMismatches2.js";

package/esm/MismatchParser/mdToMismatches.d.ts

@@ -1,2 +1,2 @@
-import type { Mismatch } from '../shared/types';
+import type { Mismatch } from '../shared/types.ts';
 export declare function mdToMismatches(mdstring: string, ops: string[], cigarMismatches: Mismatch[], seq: string, qual?: Uint8Array): Mismatch[];

package/esm/MismatchParser/mdToMismatches.js

@@ -1,70 +1,104 @@
-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' };
+    const mismatchRecords = [];
+    const opsLength = ops.length;
+    const seqLength = seq.length;
+    const hasQual = qual !== undefined;
+    const cigarLength = cigarMismatches.length;
+    let hasSkips = false;
+    for (let k = 0; k < cigarLength; k++) {
+        if (cigarMismatches[k].type === 'skip') {
+            hasSkips = true;
+            break;
+        }
+    }
+    let currStart = 0;
     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;
+    let i = 0;
+    const len = mdstring.length;
+    while (i < len) {
+        const char = mdstring.charCodeAt(i);
+        if (char >= 48 && char <= 57) {
+            let num = 0;
+            while (i < len) {
+                const c = mdstring.charCodeAt(i);
+                if (c >= 48 && c <= 57) {
+                    num = num * 10 + (c - 48);
+                    i++;
+                }
+                else {
+                    break;
+                }
             }
+            currStart += num;
         }
-        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 if (char === 94) {
+            i++;
+            let delLen = 0;
+            while (i < len) {
+                const c = mdstring.charCodeAt(i);
+                if (c >= 65 && c <= 90) {
+                    delLen++;
+                    i++;
+                }
+                else {
+                    break;
+                }
+            }
+            currStart += delLen;
         }
-        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;
+        else if (char >= 65 && char <= 90) {
+            const letter = mdstring[i];
+            i++;
+            if (hasSkips) {
+                while (lastSkipPos < cigarLength) {
+                    const mismatch = cigarMismatches[lastSkipPos];
+                    if (mismatch.type === 'skip' && currStart >= mismatch.start) {
+                        currStart += mismatch.length;
                         lastSkipPos++;
                     }
-                    else {
+                    else if (mismatch.type === 'skip') {
                         break;
                     }
+                    else {
+                        lastSkipPos++;
+                    }
                 }
-                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();
             }
+            let templateOffset = lastTemplateOffset;
+            let refOffset = lastRefOffset;
+            for (let j = lastCigar; j < opsLength && refOffset <= currStart; j += 2, lastCigar = j) {
+                const len = +ops[j];
+                const op = ops[j + 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;
+            const s = templateOffset - (refOffset - currStart);
+            const base = s < seqLength ? seq[s] : 'X';
+            mismatchRecords.push({
+                start: currStart,
+                base,
+                qual: hasQual ? qual[s] : undefined,
+                altbase: letter,
+                length: 1,
+                type: 'mismatch',
+            });
+            currStart++;
+        }
+        else {
+            i++;
         }
     }
     return mismatchRecords;

package/esm/MismatchParser/mdToMismatches2.d.ts

@@ -0,0 +1,2 @@
+import type { Mismatch } from '../shared/types.ts';
+export declare function mdToMismatches2(mdstring: string, ops: Uint32Array | undefined, cigarMismatches: Mismatch[], seq: string, qual?: Uint8Array): Mismatch[];

package/esm/MismatchParser/mdToMismatches2.js

@@ -0,0 +1,96 @@
+import { CIGAR_D, CIGAR_H, CIGAR_I, CIGAR_N, CIGAR_P, CIGAR_S, } from "../PileupRenderer/renderers/cigarUtil.js";
+export function mdToMismatches2(mdstring, ops, cigarMismatches, seq, qual) {
+    if (!ops) {
+        return [];
+    }
+    const mismatchRecords = [];
+    const opsLength = ops.length;
+    const seqLength = seq.length;
+    const hasQual = qual !== undefined;
+    const cigarLength = cigarMismatches.length;
+    let hasSkips = false;
+    for (let k = 0; k < cigarLength; k++) {
+        if (cigarMismatches[k].type === 'skip') {
+            hasSkips = true;
+            break;
+        }
+    }
+    let currStart = 0;
+    let lastCigar = 0;
+    let lastTemplateOffset = 0;
+    let lastRefOffset = 0;
+    let lastSkipPos = 0;
+    let i = 0;
+    const len = mdstring.length;
+    while (i < len) {
+        const char = mdstring.charCodeAt(i);
+        if (char >= 48 && char <= 57) {
+            let num = 0;
+            while (i < len) {
+                const c = mdstring.charCodeAt(i);
+                if (c >= 48 && c <= 57) {
+                    num = num * 10 + (c - 48);
+                    i++;
+                }
+                else {
+                    break;
+                }
+            }
+            currStart += num;
+        }
+        else if (char === 94) {
+            i++;
+            while (i < len && mdstring.charCodeAt(i) >= 65) {
+                i++;
+                currStart++;
+            }
+        }
+        else if (char >= 65) {
+            const letter = mdstring[i];
+            i++;
+            if (hasSkips && cigarLength > 0) {
+                for (let k = lastSkipPos; k < cigarLength; k++) {
+                    const mismatch = cigarMismatches[k];
+                    if (mismatch.type === 'skip' && currStart >= mismatch.start) {
+                        currStart += mismatch.length;
+                        lastSkipPos = k;
+                    }
+                }
+            }
+            let templateOffset = lastTemplateOffset;
+            let refOffset = lastRefOffset;
+            for (let j = lastCigar; j < opsLength && refOffset <= currStart; j++, lastCigar = j) {
+                const packed = ops[j];
+                const len = packed >> 4;
+                const op = packed & 0xf;
+                if (op === CIGAR_S || op === CIGAR_I) {
+                    templateOffset += len;
+                }
+                else if (op === CIGAR_D || op === CIGAR_P || op === CIGAR_N) {
+                    refOffset += len;
+                }
+                else if (op !== CIGAR_H) {
+                    templateOffset += len;
+                    refOffset += len;
+                }
+            }
+            lastTemplateOffset = templateOffset;
+            lastRefOffset = refOffset;
+            const s = templateOffset - (refOffset - currStart);
+            const base = s < seqLength ? seq[s] : 'X';
+            mismatchRecords.push({
+                start: currStart,
+                base,
+                qual: hasQual ? qual[s] : undefined,
+                altbase: letter,
+                length: 1,
+                type: 'mismatch',
+            });
+            currStart++;
+        }
+        else {
+            i++;
+        }
+    }
+    return mismatchRecords;
+}

package/esm/ModificationParser/detectSimplexModifications.d.ts

@@ -0,0 +1,4 @@
+import type { ModificationType } from '../shared/types.ts';
+type ModificationTypeList = readonly ModificationType[];
+export declare function detectSimplexModifications(modifications: ModificationTypeList): ReadonlySet<string>;
+export {};

package/esm/ModificationParser/detectSimplexModifications.js

@@ -0,0 +1,17 @@
+export function detectSimplexModifications(modifications) {
+    const minusStrandMods = new Set();
+    const simplexModifications = new Set();
+    for (const modification of modifications) {
+        const mod = modification;
+        if (mod.strand === '-') {
+            minusStrandMods.add(mod.type);
+        }
+    }
+    for (const modification of modifications) {
+        const mod = modification;
+        if (mod.strand === '+' && !minusStrandMods.has(mod.type)) {
+            simplexModifications.add(mod.type);
+        }
+    }
+    return simplexModifications;
+}

package/esm/ModificationParser/getMethBins.d.ts

@@ -1,5 +1,5 @@
 import type { Feature } from '@jbrowse/core/util';
-export declare function getMethBins(feature: Feature, cigarOps: string[]): {
+export declare function getMethBins(feature: Feature, cigarOps: ArrayLike<number>): {
     methBins: number[];
     hydroxyMethBins: number[];
     methProbs: number[];

package/esm/ModificationParser/getMethBins.js

@@ -1,7 +1,7 @@
-import { getNextRefPos } from '../MismatchParser';
-import { getModPositions } from './getModPositions';
-import { getModProbabilities } from './getModProbabilities';
-import { getTagAlt } from '../util';
+import { getModPositions } from "./getModPositions.js";
+import { getModProbabilities } from "./getModProbabilities.js";
+import { getNextRefPos } from "../MismatchParser/index.js";
+import { getTagAlt } from "../util.js";
 export function getMethBins(feature, cigarOps) {
     const fstart = feature.get('start');
     const fend = feature.get('end');
@@ -24,7 +24,7 @@ export function getMethBins(feature, cigarOps) {
                 }
                 const isReverseStrand = fstrand === -1;
                 const idx2 = probIndex + (isReverseStrand ? positions.length - 1 - idx : idx);
-                const prob = (probabilities === null || probabilities === void 0 ? void 0 : probabilities[idx2]) || 0;
+                const prob = probabilities?.[idx2] || 0;
                 if (type === 'm') {
                     methBins[ref] = 1;
                     methProbs[ref] = prob;

package/esm/ModificationParser/getModPositions.d.ts

@@ -1,6 +1,6 @@
 export declare function getModPositions(mm: string, fseq: string, fstrand: number): {
     type: string;
-    positions: number[];
     base: string;
     strand: string;
+    positions: any[];
 }[];

package/esm/ModificationParser/getModPositions.js

@@ -1,7 +1,8 @@
 import { revcom } from '@jbrowse/core/util';
-import { modificationRegex } from './consts';
+import { modificationRegex } from "./consts.js";
 export function getModPositions(mm, fseq, fstrand) {
     const seq = fstrand === -1 ? revcom(fseq) : fseq;
+    const seqLength = seq.length;
     const mods = mm.split(';');
     const result = [];
     for (const mod of mods) {
@@ -16,44 +17,40 @@ export function getModPositions(mm, fseq, fstrand) {
         }
         const [, base, strand, typestr] = matches;
         const types = typestr.split(/(\d+|.)/);
-        if (strand === '-') {
-            console.warn('unsupported negative strand modifications');
-            result.push({
-                type: 'unsupported',
-                positions: [],
-                base: base,
-                strand: strand,
-            });
-        }
         for (const type of types) {
             if (type === '') {
                 continue;
             }
+            const splitLength = split.length;
             let currPos = 0;
-            const positions = [];
-            for (let i = 1, l = split.length; i < l; i++) {
+            const positions = fstrand === -1 ? new Array(splitLength - 1) : [];
+            let writeIndex = fstrand === -1 ? splitLength - 2 : 0;
+            for (let i = 1; i < splitLength; i++) {
                 let delta = +split[i];
                 do {
                     if (base === 'N' || base === seq[currPos]) {
                         delta--;
                     }
                     currPos++;
-                } while (delta >= 0 && currPos < seq.length);
+                } while (delta >= 0 && currPos < seqLength);
                 if (fstrand === -1) {
-                    const pos = seq.length - currPos;
+                    const pos = seqLength - currPos;
                     if (pos >= 0) {
-                        positions.unshift(pos);
+                        positions[writeIndex--] = pos;
+                    }
+                    else {
                     }
                 }
                 else {
-                    positions.push(currPos - 1);
+                    positions[writeIndex++] = currPos - 1;
                 }
             }
+            const validPositions = fstrand === -1 ? positions.slice(writeIndex + 1) : positions;
             result.push({
                 type,
                 base: base,
                 strand: strand,
-                positions,
+                positions: validPositions,
             });
         }
     }

package/esm/ModificationParser/getModProbabilities.js

@@ -1,4 +1,4 @@
-import { getTagAlt } from '../util';
+import { getTagAlt } from "../util.js";
 export function getModProbabilities(feature) {
     const m = getTagAlt(feature, 'ML', 'Ml') || [];
     if (m) {

package/esm/ModificationParser/getModTypes.js

@@ -1,4 +1,4 @@
-import { modificationRegex } from './consts';
+import { modificationRegex } from "./consts.js";
 export function getModTypes(mm) {
     const result = [];
     const mods = mm.split(';');

package/esm/PileupRPC/base.js

@@ -2,9 +2,8 @@ import RpcMethodType from '@jbrowse/core/pluggableElementTypes/RpcMethodType';
 import { renameRegionsIfNeeded } from '@jbrowse/core/util';
 export default class PileupBaseRPC extends RpcMethodType {
     async serializeArguments(args, rpcDriver) {
-        var _a;
         const { rootModel } = this.pluginManager;
-        const assemblyManager = (_a = rootModel === null || rootModel === void 0 ? void 0 : rootModel.session) === null || _a === void 0 ? void 0 : _a.assemblyManager;
+        const assemblyManager = rootModel?.session?.assemblyManager;
         if (!assemblyManager) {
             throw new Error('no assembly manager available');
         }

package/esm/PileupRPC/index.js

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

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

@@ -1,4 +1,4 @@
-import PileupBaseRPC from '../base';
+import PileupBaseRPC from '../base.ts';
 import type { Region } from '@jbrowse/core/util';
 export default class PileupGetGlobalValueForTag extends PileupBaseRPC {
     name: string;

package/esm/PileupRPC/methods/GetGlobalValueForTag.js

@@ -1,12 +1,9 @@
 import { getAdapter } from '@jbrowse/core/data_adapters/dataAdapterCache';
 import { firstValueFrom } from 'rxjs';
 import { toArray } from 'rxjs/operators';
-import PileupBaseRPC from '../base';
+import PileupBaseRPC from "../base.js";
 export default class PileupGetGlobalValueForTag extends PileupBaseRPC {
-    constructor() {
-        super(...arguments);
-        this.name = 'PileupGetGlobalValueForTag';
-    }
+    name = 'PileupGetGlobalValueForTag';
     async execute(args, rpcDriver) {
         const deserializedArgs = await this.deserializeArguments(args, rpcDriver);
         const { adapterConfig, sessionId, regions, tag } = deserializedArgs;
@@ -15,7 +12,7 @@ export default class PileupGetGlobalValueForTag extends PileupBaseRPC {
         const featuresArray = await firstValueFrom(features.pipe(toArray()));
         return [
             ...new Set(featuresArray
-                .map(feature => { var _a; return (_a = feature.get('tags')) === null || _a === void 0 ? void 0 : _a[tag]; })
+                .map(feature => feature.get('tags')?.[tag])
                 .filter(f => f !== undefined)
                 .map(f => `${f}`)),
         ];

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

@@ -1,5 +1,5 @@
-import PileupBaseRPC from '../base';
-import type { ModificationType } from '../../shared/types';
+import PileupBaseRPC from '../base.ts';
+import type { ModificationType } from '../../shared/types.ts';
 import type { Region } from '@jbrowse/core/util';
 export default class PileupGetVisibleModifications extends PileupBaseRPC {
     name: string;
@@ -10,5 +10,8 @@ export default class PileupGetVisibleModifications extends PileupBaseRPC {
         regions: Region[];
         sessionId: string;
         tag: string;
-    }, rpcDriver: string): Promise<ModificationType[]>;
+    }, rpcDriver: string): Promise<{
+        modifications: ModificationType[];
+        simplexModifications: string[];
+    }>;
 }

package/esm/PileupRPC/methods/GetVisibleModifications.js

@@ -1,14 +1,12 @@
 import { getAdapter } from '@jbrowse/core/data_adapters/dataAdapterCache';
 import { firstValueFrom } from 'rxjs';
 import { toArray } from 'rxjs/operators';
-import { getModTypes } from '../../ModificationParser/getModTypes';
-import { getTagAlt } from '../../util';
-import PileupBaseRPC from '../base';
+import { detectSimplexModifications } from "../../ModificationParser/detectSimplexModifications.js";
+import { getModTypes } from "../../ModificationParser/getModTypes.js";
+import { getTagAlt } from "../../util.js";
+import PileupBaseRPC from "../base.js";
 export default class PileupGetVisibleModifications extends PileupBaseRPC {
-    constructor() {
-        super(...arguments);
-        this.name = 'PileupGetVisibleModifications';
-    }
+    name = 'PileupGetVisibleModifications';
     async execute(args, rpcDriver) {
         const deserializeArguments = await this.deserializeArguments(args, rpcDriver);
         const { adapterConfig, sessionId, regions } = deserializeArguments;
@@ -20,11 +18,23 @@ export default class PileupGetVisibleModifications extends PileupBaseRPC {
         for (const feat of featuresArray) {
             const mmTag = getTagAlt(feat, 'MM', 'Mm');
             for (const mod of getModTypes(typeof mmTag === 'string' ? mmTag : '')) {
-                if (!uniqueModifications.has(mod.type)) {
-                    uniqueModifications.set(mod.type, mod);
+                const key = `${mod.base}${mod.strand}${mod.type}`;
+                if (!uniqueModifications.has(key)) {
+                    uniqueModifications.set(key, mod);
                 }
             }
         }
-        return [...uniqueModifications.values()];
+        const modifications = [...uniqueModifications.values()];
+        const simplexModifications = detectSimplexModifications(modifications);
+        const modificationsForDisplay = new Map();
+        for (const mod of modifications) {
+            if (!modificationsForDisplay.has(mod.type)) {
+                modificationsForDisplay.set(mod.type, mod);
+            }
+        }
+        return {
+            modifications: [...modificationsForDisplay.values()],
+            simplexModifications: [...simplexModifications],
+        };
     }
 }

package/esm/PileupRPC/rpcMethods.d.ts

@@ -1,3 +1,2 @@
-export { default as PileupGetReducedFeatures } from './methods/GetReducedFeatures';
-export { default as PileupGetVisibleModifications } from './methods/GetVisibleModifications';
-export { default as PileupGetGlobalValueForTag } from './methods/GetGlobalValueForTag';
+export { default as PileupGetVisibleModifications } from './methods/GetVisibleModifications.ts';
+export { default as PileupGetGlobalValueForTag } from './methods/GetGlobalValueForTag.ts';

package/esm/PileupRPC/rpcMethods.js

@@ -1,3 +1,2 @@
-export { default as PileupGetReducedFeatures } from './methods/GetReducedFeatures';
-export { default as PileupGetVisibleModifications } from './methods/GetVisibleModifications';
-export { default as PileupGetGlobalValueForTag } from './methods/GetGlobalValueForTag';
+export { default as PileupGetVisibleModifications } from "./methods/GetVisibleModifications.js";
+export { default as PileupGetGlobalValueForTag } from "./methods/GetGlobalValueForTag.js";