@jbrowse/plugin-alignments 3.6.5 → 4.0.0

package/esm/LinearSNPCoverageDisplay/model.js

@@ -1,38 +1,37 @@
 import { lazy } from 'react';
 import { getConf, readConfObject } from '@jbrowse/core/configuration';
 import SerializableFilterChain from '@jbrowse/core/pluggableElementTypes/renderers/util/serializableFilterChain';
-import { getContainingView } from '@jbrowse/core/util';
+import { getContainingView, getSession } from '@jbrowse/core/util';
+import { cast, getSnapshot, isAlive, types } from '@jbrowse/mobx-state-tree';
 import { linearWiggleDisplayModelFactory } from '@jbrowse/plugin-wiggle';
+import FilterListIcon from '@mui/icons-material/FilterList';
 import VisibilityIcon from '@mui/icons-material/Visibility';
-import { observable } from 'mobx';
-import { cast, getEnv, isAlive, types } from 'mobx-state-tree';
-import { getUniqueModifications } from '../shared/getUniqueModifications';
-import { createAutorun, getColorForModification } from '../util';
-const Tooltip = lazy(() => import('./components/Tooltip'));
+import { SharedModificationsMixin } from "../shared/SharedModificationsMixin.js";
+import { getUniqueModifications } from "../shared/getUniqueModifications.js";
+import { getSNPCoverageLegendItems } from "../shared/legendUtils.js";
+import { isDefaultFilterFlags } from "../shared/util.js";
+import { createAutorun } from "../util.js";
+const Tooltip = lazy(() => import("./components/Tooltip.js"));
+const FilterArcsByScoreDialog = lazy(() => import("./components/FilterArcsByScoreDialog.js"));
 const rendererTypes = new Map([['snpcoverage', 'SNPCoverageRenderer']]);
 function stateModelFactory(pluginManager, configSchema) {
     return types
-        .compose('LinearSNPCoverageDisplay', linearWiggleDisplayModelFactory(pluginManager, configSchema), types.model({
+        .compose('LinearSNPCoverageDisplay', linearWiggleDisplayModelFactory(pluginManager, configSchema), SharedModificationsMixin(), types.model({
         type: types.literal('LinearSNPCoverageDisplay'),
         showInterbaseCounts: types.maybe(types.boolean),
         showInterbaseIndicators: types.maybe(types.boolean),
         showArcs: types.maybe(types.boolean),
+        minArcScore: types.optional(types.number, 0),
         filterBySetting: types.frozen(),
         colorBySetting: types.frozen(),
         jexlFilters: types.optional(types.array(types.string), []),
-    }))
-        .volatile(() => ({
-        visibleModifications: observable.map({}),
-        modificationsReady: false,
     }))
         .views(self => ({
         get colorBy() {
-            var _a;
-            return (_a = self.colorBySetting) !== null && _a !== void 0 ? _a : getConf(self, 'colorBy');
+            return self.colorBySetting ?? getConf(self, 'colorBy');
         },
         get filterBy() {
-            var _a;
-            return (_a = self.filterBySetting) !== null && _a !== void 0 ? _a : getConf(self, 'filterBy');
+            return self.filterBySetting ?? getConf(self, 'filterBy');
         },
     }))
         .actions(self => ({
@@ -54,46 +53,56 @@ function stateModelFactory(pluginManager, configSchema) {
         setJexlFilters(filters) {
             self.jexlFilters = cast(filters);
         },
-        updateVisibleModifications(uniqueModifications) {
-            for (const modification of uniqueModifications) {
-                if (!self.visibleModifications.has(modification.type)) {
-                    self.visibleModifications.set(modification.type, {
-                        ...modification,
-                        color: getColorForModification(modification.type),
-                    });
-                }
-            }
-        },
     }))
         .views(self => {
         const { adapterProps: superAdapterProps } = self;
         return {
+            get modificationThreshold() {
+                return self.colorBy?.modifications?.threshold ?? 10;
+            },
             get rendererConfig() {
                 const configBlob = getConf(self, ['renderers', self.rendererTypeName]) || {};
                 const { showArcs, showInterbaseCounts, showInterbaseIndicators } = self;
-                return self.rendererType.configSchema.create({
+                return {
                     ...configBlob,
-                    showInterbaseCounts: showInterbaseCounts !== null && showInterbaseCounts !== void 0 ? showInterbaseCounts : configBlob.showInterbaseCounts,
-                    showInterbaseIndicators: showInterbaseIndicators !== null && showInterbaseIndicators !== void 0 ? showInterbaseIndicators : configBlob.showInterbaseIndicators,
-                    showArcs: showArcs !== null && showArcs !== void 0 ? showArcs : configBlob.showArcs,
-                }, getEnv(self));
+                    showInterbaseCounts: showInterbaseCounts ?? configBlob.showInterbaseCounts,
+                    showInterbaseIndicators: showInterbaseIndicators ?? configBlob.showInterbaseIndicators,
+                    showArcs: showArcs ?? configBlob.showArcs,
+                };
             },
             get showArcsSetting() {
-                var _a;
-                return ((_a = self.showArcs) !== null && _a !== void 0 ? _a : readConfObject(this.rendererConfig, 'showArcs'));
+                return (self.showArcs ?? readConfObject(this.rendererConfig, 'showArcs'));
+            },
+            get skipFeatures() {
+                if (!this.showArcsSetting) {
+                    return [];
+                }
+                const { minArcScore } = self;
+                const skipFeaturesMap = new Map();
+                for (const block of self.blockState.values()) {
+                    if (block.features) {
+                        for (const feature of block.features.values()) {
+                            if (feature.get('type') === 'skip' &&
+                                (feature.get('score') ?? 1) >= minArcScore) {
+                                skipFeaturesMap.set(feature.id(), feature);
+                            }
+                        }
+                    }
+                }
+                return [...skipFeaturesMap.values()];
             },
             get showInterbaseCountsSetting() {
-                var _a;
-                return ((_a = self.showInterbaseCounts) !== null && _a !== void 0 ? _a : readConfObject(this.rendererConfig, 'showInterbaseCounts'));
+                return (self.showInterbaseCounts ??
+                    readConfObject(this.rendererConfig, 'showInterbaseCounts'));
             },
             get showInterbaseIndicatorsSetting() {
-                var _a;
-                return ((_a = self.showInterbaseIndicators) !== null && _a !== void 0 ? _a : readConfObject(this.rendererConfig, 'showInterbaseIndicators'));
+                return (self.showInterbaseIndicators ??
+                    readConfObject(this.rendererConfig, 'showInterbaseIndicators'));
             },
             get autorunReady() {
                 const view = getContainingView(self);
                 return (view.initialized &&
-                    self.statsReadyAndRegionNotTooLarge &&
+                    self.featureDensityStatsReadyAndRegionNotTooLarge &&
                     !self.error);
             },
             adapterProps() {
@@ -103,14 +112,12 @@ function stateModelFactory(pluginManager, configSchema) {
                     ...superProps,
                     filters,
                     filterBy,
+                    modificationThreshold: this.modificationThreshold,
                 };
             },
         };
     })
         .actions(self => ({
-        setModificationsReady(flag) {
-            self.modificationsReady = flag;
-        },
         setShowInterbaseIndicators(arg) {
             self.showInterbaseIndicators = arg;
         },
@@ -120,6 +127,9 @@ function stateModelFactory(pluginManager, configSchema) {
         setShowArcs(arg) {
             self.showArcs = arg;
         },
+        setMinArcScore(arg) {
+            self.minArcScore = arg;
+        },
     }))
         .actions(self => ({
         afterAttach() {
@@ -131,14 +141,15 @@ function stateModelFactory(pluginManager, configSchema) {
                 const view = getContainingView(self);
                 const { staticBlocks } = view;
                 const { colorBy } = self;
-                if ((colorBy === null || colorBy === void 0 ? void 0 : colorBy.type) === 'modifications') {
-                    const vals = await getUniqueModifications({
+                if (colorBy?.type === 'modifications') {
+                    const { modifications, simplexModifications } = await getUniqueModifications({
                         model: self,
                         adapterConfig: getConf(self.parentTrack, 'adapter'),
                         blocks: staticBlocks,
                     });
                     if (isAlive(self)) {
-                        self.updateVisibleModifications(vals);
+                        self.updateVisibleModifications(modifications);
+                        self.setSimplexModifications(simplexModifications);
                         self.setModificationsReady(true);
                     }
                 }
@@ -149,29 +160,52 @@ function stateModelFactory(pluginManager, configSchema) {
         },
     }))
         .views(self => {
-        const { renderProps: superRenderProps, trackMenuItems: superTrackMenuItems, } = self;
+        const { renderProps: superRenderProps, renderingProps: superRenderingProps, renderSvg: superRenderSvg, wiggleBaseTrackMenuItems, } = self;
         return {
             renderReady() {
                 const superProps = superRenderProps();
                 return !superProps.notReady && self.modificationsReady;
             },
             renderProps() {
-                const { colorBy, visibleModifications } = self;
+                const { colorBy, visibleModifications, simplexModifications } = self;
                 return {
                     ...superRenderProps(),
                     notReady: !this.renderReady(),
                     colorBy,
                     visibleModifications: Object.fromEntries(visibleModifications.toJSON()),
+                    simplexModifications: [...simplexModifications],
+                };
+            },
+            renderingProps() {
+                return {
+                    ...superRenderingProps(),
+                    displayModel: self,
                 };
             },
+            async renderSvg(opts) {
+                const { renderSNPCoverageSvg } = await import("./components/renderSvg.js");
+                return renderSNPCoverageSvg(self, opts, superRenderSvg);
+            },
             get TooltipComponent() {
                 return Tooltip;
             },
             get adapterConfig() {
                 const subadapter = getConf(self.parentTrack, 'adapter');
+                const view = getContainingView(self);
+                const session = getSession(self);
+                const { assemblyManager } = session;
+                const assemblyName = view.assemblyNames[0];
+                const assembly = assemblyName
+                    ? assemblyManager.get(assemblyName)
+                    : undefined;
+                const sequenceAdapterConfig = assembly?.configuration?.sequence?.adapter;
+                const sequenceAdapter = sequenceAdapterConfig
+                    ? getSnapshot(sequenceAdapterConfig)
+                    : undefined;
                 return {
                     type: 'SNPCoverageAdapter',
                     subadapter,
+                    sequenceAdapter,
                 };
             },
             get rendererTypeName() {
@@ -185,32 +219,62 @@ function stateModelFactory(pluginManager, configSchema) {
             },
             trackMenuItems() {
                 return [
-                    ...superTrackMenuItems(),
-                    {
-                        label: 'Show insertion/clipping indicators',
-                        icon: VisibilityIcon,
-                        type: 'checkbox',
-                        checked: self.showInterbaseIndicatorsSetting,
-                        onClick: () => {
-                            self.setShowInterbaseIndicators(!self.showInterbaseIndicatorsSetting);
-                        },
-                    },
+                    ...wiggleBaseTrackMenuItems(),
                     {
-                        label: 'Show insertion/clipping counts',
+                        label: 'Show...',
                         icon: VisibilityIcon,
-                        type: 'checkbox',
-                        checked: self.showInterbaseCountsSetting,
-                        onClick: () => {
-                            self.setShowInterbaseCounts(!self.showInterbaseCountsSetting);
-                        },
+                        type: 'subMenu',
+                        subMenu: [
+                            {
+                                label: 'Show tooltips',
+                                type: 'checkbox',
+                                checked: self.showTooltipsEnabled,
+                                onClick: () => {
+                                    self.setShowTooltips(!self.showTooltipsEnabled);
+                                },
+                            },
+                            {
+                                label: 'Show legend',
+                                type: 'checkbox',
+                                checked: self.showLegend,
+                                onClick: () => {
+                                    self.setShowLegend(!self.showLegend);
+                                },
+                            },
+                            {
+                                label: 'Insertion/clipping indicators',
+                                type: 'checkbox',
+                                checked: self.showInterbaseIndicatorsSetting,
+                                onClick: () => {
+                                    self.setShowInterbaseIndicators(!self.showInterbaseIndicatorsSetting);
+                                },
+                            },
+                            {
+                                label: 'Insertion/clipping counts',
+                                type: 'checkbox',
+                                checked: self.showInterbaseCountsSetting,
+                                onClick: () => {
+                                    self.setShowInterbaseCounts(!self.showInterbaseCountsSetting);
+                                },
+                            },
+                            {
+                                label: 'Sashimi arcs',
+                                type: 'checkbox',
+                                checked: self.showArcsSetting,
+                                onClick: () => {
+                                    self.setShowArcs(!self.showArcsSetting);
+                                },
+                            },
+                        ],
                     },
                     {
-                        label: 'Show arcs',
-                        icon: VisibilityIcon,
-                        type: 'checkbox',
-                        checked: self.showArcsSetting,
+                        label: 'Filter arcs by score...',
+                        icon: FilterListIcon,
                         onClick: () => {
-                            self.setShowArcs(!self.showArcsSetting);
+                            getSession(self).queueDialog(handleClose => [
+                                FilterArcsByScoreDialog,
+                                { model: self, handleClose },
+                            ]);
                         },
                     },
                 ];
@@ -218,6 +282,38 @@ function stateModelFactory(pluginManager, configSchema) {
             get filters() {
                 return new SerializableFilterChain({ filters: self.jexlFilters });
             },
+            legendItems(theme) {
+                return getSNPCoverageLegendItems(self.colorBy, self.visibleModifications, theme);
+            },
+        };
+    })
+        .preProcessSnapshot(snap => {
+        if (snap) {
+            const { colorBy, colorBySetting, filterBySetting, filterBy, ...rest } = snap;
+            return {
+                ...rest,
+                filterBySetting: filterBySetting || filterBy,
+                colorBySetting: colorBySetting || colorBy,
+            };
+        }
+        return snap;
+    })
+        .postProcessSnapshot(snap => {
+        if (!snap) {
+            return snap;
+        }
+        const { showInterbaseCounts, showInterbaseIndicators, showArcs, minArcScore, filterBySetting, colorBySetting, jexlFilters, ...rest } = snap;
+        return {
+            ...rest,
+            ...(showInterbaseCounts !== undefined ? { showInterbaseCounts } : {}),
+            ...(showInterbaseIndicators !== undefined
+                ? { showInterbaseIndicators }
+                : {}),
+            ...(showArcs !== undefined ? { showArcs } : {}),
+            ...(minArcScore ? { minArcScore } : {}),
+            ...(!isDefaultFilterFlags(filterBySetting) ? { filterBySetting } : {}),
+            ...(colorBySetting !== undefined ? { colorBySetting } : {}),
+            ...(jexlFilters?.length ? { jexlFilters } : {}),
         };
     });
 }

package/esm/MismatchParser/cigarToMismatches.d.ts

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

package/esm/MismatchParser/cigarToMismatches.js

@@ -9,7 +9,8 @@ export function cigarToMismatches(ops, seq, ref, qual) {
         if (op === 'M' || op === '=' || op === 'E') {
             if (hasRefAndSeq) {
                 for (let j = 0; j < len; j++) {
-                    if (seq[soffset + j].toUpperCase() !== ref[roffset + j].toUpperCase()) {
+                    if ((seq.charCodeAt(soffset + j) | 0x20) !==
+                        (ref.charCodeAt(roffset + j) | 0x20)) {
                         mismatches.push({
                             start: roffset + j,
                             type: 'mismatch',
@@ -26,7 +27,8 @@ export function cigarToMismatches(ops, seq, ref, qual) {
             mismatches.push({
                 start: roffset,
                 type: 'insertion',
-                base: `${len}`,
+                insertlen: len,
+                insertedBases: seq?.slice(soffset, soffset + len),
                 length: 0,
             });
             soffset += len;
@@ -35,7 +37,6 @@ export function cigarToMismatches(ops, seq, ref, qual) {
             mismatches.push({
                 start: roffset,
                 type: 'deletion',
-                base: '*',
                 length: len,
             });
         }
@@ -43,13 +44,12 @@ export function cigarToMismatches(ops, seq, ref, qual) {
             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)) || [];
+            const r = seq?.slice(soffset, soffset + len) || [];
+            const q = qual?.subarray(soffset, soffset + len) || [];
             for (let j = 0; j < len; j++) {
                 mismatches.push({
                     start: roffset + j,
@@ -65,7 +65,6 @@ export function cigarToMismatches(ops, seq, ref, qual) {
             mismatches.push({
                 start: roffset,
                 type: 'hardclip',
-                base: `H${len}`,
                 cliplen: len,
                 length: 1,
             });
@@ -74,7 +73,6 @@ export function cigarToMismatches(ops, seq, ref, qual) {
             mismatches.push({
                 start: roffset,
                 type: 'softclip',
-                base: `S${len}`,
                 cliplen: len,
                 length: 1,
             });

package/esm/MismatchParser/cigarToMismatches2.d.ts

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

package/{dist/MismatchParser/cigarToMismatches.js → esm/MismatchParser/cigarToMismatches2.js}

@@ -1,18 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cigarToMismatches = cigarToMismatches;
-function cigarToMismatches(ops, seq, ref, qual) {
+import { CIGAR_D, CIGAR_EQ, CIGAR_H, CIGAR_I, CIGAR_M, CIGAR_N, CIGAR_S, CIGAR_X, } from "../PileupRenderer/renderers/cigarUtil.js";
+export function cigarToMismatches2(ops, seq, ref, qual) {
     let roffset = 0;
     let soffset = 0;
     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') {
+    for (let i = 0, l = ops.length; i < l; i++) {
+        const packed = ops[i];
+        const len = packed >> 4;
+        const op = packed & 0xf;
+        if (op === CIGAR_M || op === CIGAR_EQ) {
             if (hasRefAndSeq) {
                 for (let j = 0; j < len; j++) {
-                    if (seq[soffset + j].toUpperCase() !== ref[roffset + j].toUpperCase()) {
+                    if ((seq.charCodeAt(soffset + j) | 0x20) !==
+                        (ref.charCodeAt(roffset + j) | 0x20)) {
                         mismatches.push({
                             start: roffset + j,
                             type: 'mismatch',
@@ -24,68 +24,64 @@ function cigarToMismatches(ops, seq, ref, qual) {
                 }
             }
             soffset += len;
+            roffset += len;
         }
-        if (op === 'I') {
+        else if (op === CIGAR_I) {
             mismatches.push({
                 start: roffset,
                 type: 'insertion',
-                base: `${len}`,
+                insertlen: len,
+                insertedBases: seq?.slice(soffset, soffset + len),
                 length: 0,
             });
             soffset += len;
         }
-        else if (op === 'D') {
+        else if (op === CIGAR_D) {
             mismatches.push({
                 start: roffset,
                 type: 'deletion',
-                base: '*',
                 length: len,
             });
+            roffset += len;
         }
-        else if (op === 'N') {
+        else if (op === CIGAR_N) {
             mismatches.push({
                 start: roffset,
                 type: 'skip',
-                base: 'N',
                 length: len,
             });
+            roffset += 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)) || [];
+        else if (op === CIGAR_X) {
             for (let j = 0; j < len; j++) {
                 mismatches.push({
                     start: roffset + j,
                     type: 'mismatch',
-                    base: r[j] || 'X',
-                    qual: q[j],
+                    base: seq?.[soffset + j] || 'X',
+                    qual: qual?.[soffset + j],
                     length: 1,
                 });
             }
             soffset += len;
+            roffset += len;
         }
-        else if (op === 'H') {
+        else if (op === CIGAR_H) {
             mismatches.push({
                 start: roffset,
                 type: 'hardclip',
-                base: `H${len}`,
                 cliplen: len,
                 length: 1,
             });
         }
-        else if (op === 'S') {
+        else if (op === CIGAR_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;
 }

package/esm/MismatchParser/getNextRefPos.d.ts

@@ -1,4 +1,4 @@
-export declare function getNextRefPos(cigarOps: string[], positions: number[]): {
+export declare function getNextRefPos(cigarOps: ArrayLike<number>, positions: number[]): {
     ref: number;
     idx: number;
 }[];

package/esm/MismatchParser/getNextRefPos.js

@@ -1,27 +1,29 @@
+import { CIGAR_D, CIGAR_EQ, CIGAR_I, CIGAR_M, CIGAR_N, CIGAR_S, CIGAR_X, } from "../PileupRenderer/renderers/cigarUtil.js";
 export function getNextRefPos(cigarOps, positions) {
     let readPos = 0;
     let refPos = 0;
     let currPos = 0;
     const ret = [];
-    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) {
+    for (let i = 0, l = cigarOps.length, l2 = positions.length; i < l && currPos < l2; i++) {
+        const packed = cigarOps[i];
+        const len = packed >> 4;
+        const op = packed & 0xf;
+        if (op === CIGAR_S || op === CIGAR_I) {
+            for (let j = 0; j < len && currPos < l2; j++) {
+                if (positions[currPos] === readPos + j) {
                     currPos++;
                 }
             }
             readPos += len;
         }
-        else if (op === 'D' || op === 'N') {
+        else if (op === CIGAR_D || op === CIGAR_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) {
+        else if (op === CIGAR_M || op === CIGAR_X || op === CIGAR_EQ) {
+            for (let j = 0; j < len && currPos < l2; j++) {
+                if (positions[currPos] === readPos + j) {
                     ret.push({
-                        ref: refPos + i,
+                        ref: refPos + j,
                         idx: currPos,
                     });
                     currPos++;

package/esm/MismatchParser/index.d.ts

@@ -1,7 +1,9 @@
-import type { Mismatch } from '../shared/types';
+import type { Mismatch } from '../shared/types.ts';
 import type { Feature } from '@jbrowse/core/util';
 export declare function parseCigar(s?: string): string[];
+export declare function parseCigar2(s?: string): Uint32Array;
 export declare function getMismatches(cigar?: string, md?: string, seq?: string, ref?: string, qual?: Uint8Array): Mismatch[];
+export declare function getMismatches2(cigar?: Uint32Array, md?: string, seq?: string, ref?: string, qual?: Uint8Array): 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;
@@ -14,7 +16,7 @@ export declare function featurizeSA(SA: string | undefined, id: string, strand:
     start: number;
     end: number;
     seqLength: number;
-    clipPos: number;
+    clipLengthAtStartOfRead: number;
     CIGAR: string;
     strand: number;
     uniqueId: string;
@@ -24,4 +26,5 @@ export declare function featurizeSA(SA: string | undefined, id: string, strand:
         refName: string;
     };
 }[];
-export { getNextRefPos } from './getNextRefPos';
+export { getNextRefPos } from './getNextRefPos.ts';
+export { cigarToMismatches2 } from './cigarToMismatches2.ts';