@jbrowse/bandage-core 0.1.1

package/dist/types/layout/walkRows.d.ts

@@ -0,0 +1,25 @@
+import type { Graph } from '../types';
+export interface WalkRun {
+    start: number;
+    bp: number;
+    onReference: boolean;
+}
+export interface WalkRow {
+    name: string;
+    label: string;
+    sample: string;
+    bp: number;
+    offReferenceBp: number;
+    complete: boolean;
+    runs: WalkRun[];
+}
+export interface WalkRows {
+    origin: number;
+    unit?: number;
+    reference: WalkRow;
+    rows: WalkRow[];
+}
+export declare function walkRows(graph: Graph, region?: {
+    start: number;
+    end: number;
+}, unit?: number): WalkRows | undefined;

package/dist/types/layoutModes.d.ts

@@ -0,0 +1,153 @@
+import { anchoredLayout } from './layout/anchoredLayout';
+import { orderedLayout } from './layout/orderedLayout';
+import { sampleRowLayout } from './layout/sampleRowLayout';
+import { hasTubeMapPaths, tubeMapLayout, tubeMapReferenceLayout } from './layout/tubeMapLayout';
+import { variantMapLayout } from './layout/variantMapLayout';
+import { walkRowLayout } from './layout/walkRowLayout';
+import type { Graph, LayoutResult } from './types';
+export declare const FORCE_LAYOUT_LABEL = "Force-directed layout";
+export interface LayoutMode {
+    value: string;
+    label: string;
+    description: string;
+    run: (graph: Graph, region?: {
+        start: number;
+        end: number;
+    }, keepRows?: readonly string[]) => LayoutResult | undefined;
+    available: (graph: Graph) => boolean;
+    cutMargins: boolean;
+    drawsLocally: (graph: Graph) => boolean;
+}
+export declare const LAYOUT_MODES: readonly [{
+    readonly value: "auto";
+    readonly label: "Anchored";
+    readonly description: "x is reference bp, one row per stable rank. Needs rGFA tags or a reference path.";
+    readonly run: typeof anchoredLayout;
+    readonly cutMargins: true;
+    readonly available: (graph: Graph) => boolean;
+    readonly drawsLocally: (graph: Graph) => boolean;
+}, {
+    readonly value: "samplerows";
+    readonly label: "Sample rows";
+    readonly description: "x is reference bp, one row per contributing assembly. Needs rGFA tags or a reference path.";
+    readonly run: typeof sampleRowLayout;
+    readonly cutMargins: true;
+    readonly available: (graph: Graph) => boolean;
+    readonly drawsLocally: (graph: Graph) => boolean;
+}, {
+    readonly value: "walkrows";
+    readonly label: "Walk rows";
+    readonly description: "x is each walk's own bp: one bar per haplotype, sequence the reference also carries in blue and sequence it does not in purple, so a repeat expansion reads as bar length. Needs W or P lines.";
+    readonly run: typeof walkRowLayout;
+    readonly cutMargins: false;
+    readonly available: (graph: Graph) => boolean;
+    readonly drawsLocally: (graph: Graph) => boolean;
+}, {
+    readonly value: "ordered";
+    readonly label: "Ordered";
+    readonly description: "x is reference order, not bp: every node gets room, bubbles read as lenses. Needs rGFA tags or a reference path.";
+    readonly run: typeof orderedLayout;
+    readonly cutMargins: false;
+    readonly available: (graph: Graph) => boolean;
+    readonly drawsLocally: (graph: Graph) => boolean;
+}, {
+    readonly value: "variants";
+    readonly label: "Variant map";
+    readonly description: "The reference as a line with one typed glyph per bubble, from the bubble index or from the graph itself: SNP, indel, deletion, inversion, repeat array. Click a glyph to open the graph inside it.";
+    readonly run: typeof variantMapLayout;
+    readonly cutMargins: true;
+    readonly available: (graph: Graph) => boolean;
+    readonly drawsLocally: (graph: Graph) => boolean;
+}, {
+    readonly value: "tubemap";
+    readonly label: "Tube map";
+    readonly description: "sequenceTubeMap: every path a coloured tube through boxed nodes, columns in node order and node widths log-scaled. Needs P or W lines.";
+    readonly run: typeof tubeMapLayout;
+    readonly cutMargins: false;
+    readonly available: typeof hasTubeMapPaths;
+    readonly drawsLocally: typeof hasTubeMapPaths;
+}, {
+    readonly value: "tubemapref";
+    readonly label: "Tube map on reference";
+    readonly description: "The tube map with each column at the reference bp it covers, so the tubes line up with the tracks around them. Needs P or W lines and a reference path.";
+    readonly run: typeof tubeMapReferenceLayout;
+    readonly cutMargins: true;
+    readonly available: (graph: Graph) => boolean;
+    readonly drawsLocally: (graph: Graph) => boolean;
+}, {
+    readonly value: "force";
+    readonly label: "Force-directed layout";
+    readonly description: "OGDF FMMM, via the external Bandage engine.";
+    readonly run: () => undefined;
+    readonly cutMargins: false;
+    readonly available: () => true;
+    readonly drawsLocally: () => false;
+}];
+export type LayoutModeValue = (typeof LAYOUT_MODES)[number]['value'];
+export declare const LAYOUT_MODE_VALUES: ("auto" | "ordered" | "samplerows" | "walkrows" | "variants" | "tubemap" | "tubemapref" | "force")[];
+export declare function modeUsesLayoutEngine(value: string, graph: Graph): boolean;
+export declare function layoutModeByValue(value: string): {
+    readonly value: "auto";
+    readonly label: "Anchored";
+    readonly description: "x is reference bp, one row per stable rank. Needs rGFA tags or a reference path.";
+    readonly run: typeof anchoredLayout;
+    readonly cutMargins: true;
+    readonly available: (graph: Graph) => boolean;
+    readonly drawsLocally: (graph: Graph) => boolean;
+} | {
+    readonly value: "samplerows";
+    readonly label: "Sample rows";
+    readonly description: "x is reference bp, one row per contributing assembly. Needs rGFA tags or a reference path.";
+    readonly run: typeof sampleRowLayout;
+    readonly cutMargins: true;
+    readonly available: (graph: Graph) => boolean;
+    readonly drawsLocally: (graph: Graph) => boolean;
+} | {
+    readonly value: "walkrows";
+    readonly label: "Walk rows";
+    readonly description: "x is each walk's own bp: one bar per haplotype, sequence the reference also carries in blue and sequence it does not in purple, so a repeat expansion reads as bar length. Needs W or P lines.";
+    readonly run: typeof walkRowLayout;
+    readonly cutMargins: false;
+    readonly available: (graph: Graph) => boolean;
+    readonly drawsLocally: (graph: Graph) => boolean;
+} | {
+    readonly value: "ordered";
+    readonly label: "Ordered";
+    readonly description: "x is reference order, not bp: every node gets room, bubbles read as lenses. Needs rGFA tags or a reference path.";
+    readonly run: typeof orderedLayout;
+    readonly cutMargins: false;
+    readonly available: (graph: Graph) => boolean;
+    readonly drawsLocally: (graph: Graph) => boolean;
+} | {
+    readonly value: "variants";
+    readonly label: "Variant map";
+    readonly description: "The reference as a line with one typed glyph per bubble, from the bubble index or from the graph itself: SNP, indel, deletion, inversion, repeat array. Click a glyph to open the graph inside it.";
+    readonly run: typeof variantMapLayout;
+    readonly cutMargins: true;
+    readonly available: (graph: Graph) => boolean;
+    readonly drawsLocally: (graph: Graph) => boolean;
+} | {
+    readonly value: "tubemap";
+    readonly label: "Tube map";
+    readonly description: "sequenceTubeMap: every path a coloured tube through boxed nodes, columns in node order and node widths log-scaled. Needs P or W lines.";
+    readonly run: typeof tubeMapLayout;
+    readonly cutMargins: false;
+    readonly available: typeof hasTubeMapPaths;
+    readonly drawsLocally: typeof hasTubeMapPaths;
+} | {
+    readonly value: "tubemapref";
+    readonly label: "Tube map on reference";
+    readonly description: "The tube map with each column at the reference bp it covers, so the tubes line up with the tracks around them. Needs P or W lines and a reference path.";
+    readonly run: typeof tubeMapReferenceLayout;
+    readonly cutMargins: true;
+    readonly available: (graph: Graph) => boolean;
+    readonly drawsLocally: (graph: Graph) => boolean;
+} | {
+    readonly value: "force";
+    readonly label: "Force-directed layout";
+    readonly description: "OGDF FMMM, via the external Bandage engine.";
+    readonly run: () => undefined;
+    readonly cutMargins: false;
+    readonly available: () => true;
+    readonly drawsLocally: () => false;
+};

package/dist/types/loadBandage.d.ts

@@ -0,0 +1,3 @@
+export type { BandageModule } from './bandage/bandage-layout.js';
+import type { BandageModule } from './bandage/bandage-layout.js';
+export default function loadBandage(): Promise<BandageModule>;

package/dist/types/nodeWidths.d.ts

@@ -0,0 +1,18 @@
+import type { Graph, GraphNode } from './types';
+import type { NodeInk } from './util/hitDetection';
+export declare const NODE_WIDTHS: readonly [{
+    readonly value: "depth";
+    readonly label: "By depth";
+    readonly description: "Thicker the more paths carry a node, on the square root of its depth against the mean. A graph with one depth everywhere draws uniform.";
+}, {
+    readonly value: "uniform";
+    readonly label: "Uniform";
+    readonly description: "Every node the same thickness.";
+}];
+export type NodeWidth = (typeof NODE_WIDTHS)[number]['value'];
+export declare const NODE_WIDTH_VALUES: ("uniform" | "depth")[];
+export declare function meanDepth(graph: Graph): number;
+export declare function depthWidthFactor(node: GraphNode, mean: number): number;
+export declare function nodeWidthPx(node: GraphNode, contigThickness: number, nodeWidth: NodeWidth, mean: number): number;
+export declare function maxNodeWidthPx(contigThickness: number, nodeWidth: NodeWidth): number;
+export declare function nodeInk(graph: Graph | undefined, nodeById: ReadonlyMap<string, GraphNode> | undefined, contigThickness: number, nodeWidth: NodeWidth): NodeInk;

package/dist/types/overlayLabels.d.ts

@@ -0,0 +1,29 @@
+export interface Box {
+    x0: number;
+    x1: number;
+    y0: number;
+    y1: number;
+}
+export declare const LABEL_PX = 11;
+export declare const LABEL_CHAR_PX = 6.2;
+export declare const LABEL_PAD = 4;
+export interface LabelCandidate<T> {
+    item: T;
+    x: number;
+    y: number;
+    text: string;
+    stack?: number;
+}
+export interface PlacedLabel<T> extends LabelCandidate<T> {
+    w: number;
+}
+export type TakeBox = (box: Box) => boolean;
+export declare function labelWidth(text: string): number;
+export declare function overlaps(a: Box, b: Box): boolean;
+interface Frame {
+    width: number;
+    height: number;
+}
+export declare function occupancy(frame: Frame, reserved?: Box[]): TakeBox;
+export declare function placeLabels<T>(candidates: LabelCandidate<T>[], frame: Frame, take: TakeBox): PlacedLabel<T>[];
+export {};

package/dist/types/pansn.d.ts

@@ -0,0 +1,8 @@
+import type { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
+export declare function panSNSample(refName: string): string;
+export declare function panSNHaplotype(refName: string): string | undefined;
+export declare function panSNContig(refName: string): string;
+export declare function panSNMatchesPrefix(refName: string, prefix: string | undefined): boolean;
+export declare function resolvePanSNPrefix(adapter: BaseFeatureDataAdapter, name: string): string;
+export declare function resolvePanSNPrefix(adapter: BaseFeatureDataAdapter, name: string | undefined): string | undefined;
+export declare function assemblyByPanSNPrefix(adapter: BaseFeatureDataAdapter): Record<string, string>;

package/dist/types/pathAnchoring.d.ts

@@ -0,0 +1,20 @@
+import type { Graph, PathOrigin, PathVisit } from './types';
+export declare function pathOrigin(pathName: string): {
+    name: string;
+    start: number;
+};
+export interface PathSteps {
+    name: string;
+    start: number;
+    steps: {
+        id: string;
+        strand: '+' | '-';
+    }[];
+}
+export declare function surveyPaths(paths: PathSteps[], lengthOf: (segmentId: string) => number): {
+    anchorPaths: PathOrigin[];
+    pathVisits: Map<string, PathVisit[]>;
+};
+export declare function chooseReferencePath(anchorPaths: PathOrigin[], preferred: string | undefined): PathOrigin | undefined;
+export declare function anchorFromPaths(graph: Graph, preferred: string | undefined): Graph;
+export declare function anchorGraph(graph: Graph, preferred: string | undefined): Graph;

package/dist/types/pathColors.d.ts

@@ -0,0 +1,14 @@
+import type { GraphPath } from './types';
+export declare function nameHue(name: string): number;
+export declare function pathHueAt(index: number, count: number): number;
+export declare const PATH_SATURATION = 0.7;
+export declare const PATH_LIGHTNESS = 0.5;
+export declare const MAX_PATH_COLORS = 16;
+export declare function pathColorsLegible(pathCount: number): boolean;
+export declare function pathCssColor(index: number, count: number): string;
+export interface PathLegendEntry {
+    name: string;
+    label: string;
+    color: string;
+}
+export declare function pathLegend(paths: GraphPath[]): PathLegendEntry[];

package/dist/types/pipeline.d.ts

@@ -0,0 +1,79 @@
+import type { BubbleSpread } from './bubbleSpreads';
+import type { LayoutScaling } from './layout/drawnScale';
+import type { LayoutNode } from './layout/referenceSeeds';
+import type { Graph, LayoutResult, NodeSegment } from './types';
+export interface Bounds {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}
+export declare function loadGraph(text: string, name: string, opts?: {
+    referencePath?: string;
+    maxNodes?: number;
+}): Graph;
+export interface EngineRequest {
+    graph: {
+        nodes: LayoutNode[];
+        edges: Graph['edges'];
+    };
+    options: Record<string, unknown>;
+}
+export type LayoutEngine = (request: EngineRequest) => Promise<{
+    result: LayoutResult;
+    duration: number;
+}>;
+export interface EngineSettings {
+    quality: number;
+    linearLayout: boolean;
+    bubbleSpread: BubbleSpread;
+}
+export declare function engineRequest(graph: Graph, scaling: LayoutScaling, settings: EngineSettings): EngineRequest;
+export declare function engineKey(graph: Graph, settings: EngineSettings): string;
+export declare function forceLayout(graph: Graph, settings: EngineSettings, engine: LayoutEngine): Promise<{
+    result: {
+        nodePositions: Record<string, NodeSegment[]>;
+        rowLabels?: import("./types").RowLabel[];
+        sampleRows?: string[];
+        alleleDeletions?: import("./types").AlleleDeletion[];
+        referenceAxis?: boolean;
+        pixelRows?: boolean;
+        extent?: {
+            minX?: number;
+            minY?: number;
+            maxX?: number;
+            maxY?: number;
+        };
+        tubeMap?: import(".").TubeMapDrawing;
+    };
+    duration: number;
+}>;
+export declare function layoutExtent(nodePositions: Record<string, NodeSegment[]>): Bounds;
+export declare const FIT_PADDING = 40;
+export declare function clampZoom(zoom: number): number;
+export declare function fittedTranslateY(bounds: {
+    minY: number;
+    h: number;
+}, usableHeight: number, yScale: number): number;
+export declare function fitTransform(bounds: {
+    minX: number;
+    minY: number;
+    w: number;
+    h: number;
+}, paneWidth: number, paneHeight: number, pixelRows: boolean): {
+    scale: number;
+    translateX: number;
+    translateY: number;
+} | undefined;
+export declare function drawingBounds(layout: LayoutResult, opts?: {
+    region?: {
+        start: number;
+        end: number;
+    };
+    extent?: LayoutResult['extent'];
+}): {
+    minX: number;
+    minY: number;
+    w: number;
+    h: number;
+};

package/dist/types/referenceSpan.d.ts

@@ -0,0 +1,12 @@
+import type { Graph, GraphNode } from './types';
+export interface ReferenceSpan {
+    start: number;
+    end: number;
+}
+export declare function buildNeighbors(graph: Graph): Map<string, string[]>;
+export declare function nodeReferenceSpan({ nodeId, nodeById, neighbors, }: {
+    nodeId: string;
+    nodeById: Map<string, GraphNode>;
+    neighbors: Map<string, string[]>;
+}): ReferenceSpan | undefined;
+export declare function referenceMidpoints(graph: Graph): Map<string, number>;

package/dist/types/renderer/Canvas2DRenderer.d.ts

@@ -0,0 +1,32 @@
+import { Canvas2DRenderingBackendBase } from '@jbrowse/render-core/renderingBackendBase';
+import type { Arrowhead, RenderBatch, Renderer, TransformUniform } from './types';
+export declare class Canvas2DRenderer extends Canvas2DRenderingBackendBase implements Renderer {
+    private transform;
+    private batch;
+    private nodeHighlights;
+    private highlightedEdge;
+    private highlightFactor;
+    resize(width: number, height: number): void;
+    uploadGeometry(batch: RenderBatch): void;
+    setNodeHighlights(factors: ReadonlyMap<string, number>): void;
+    setEdgeHighlight(edgeIndex: number | null, factor: number): void;
+    updateTransform(transform: TransformUniform): void;
+    render(clearColor: [number, number, number, number]): void;
+    private renderEdges;
+    private renderNodes;
+    private renderArrows;
+    dispose(): void;
+}
+export declare function arrowheadOutline(a: Arrowhead, t: TransformUniform): readonly [{
+    readonly x: number;
+    readonly y: number;
+}, {
+    readonly x: number;
+    readonly y: number;
+}, {
+    readonly x: number;
+    readonly y: number;
+}, {
+    readonly x: number;
+    readonly y: number;
+}];

package/dist/types/renderer/GeometryBuilder.d.ts

@@ -0,0 +1,63 @@
+import type { ResolvedColorScheme } from '../colorSchemes';
+import type { NodeWidth } from '../nodeWidths';
+import type { Graph, GraphNode, NodeSegment } from '../types';
+import type { WalkHighlight } from '../walkHighlight';
+import type { RenderBatch } from './types';
+import type { AxisScale, BezierCurve } from '../util/geometry';
+export interface BuildOptions {
+    nodePositions: Record<string, NodeSegment[]>;
+    graph: Graph;
+    nodeById: Map<string, GraphNode>;
+    colorScheme: ResolvedColorScheme;
+    contigThickness: number;
+    connectorThickness: number;
+    drawPaths: boolean;
+    nodeWidth?: NodeWidth;
+    highlight?: WalkHighlight;
+    axis: AxisScale;
+    linearLayout?: boolean;
+    viewportBounds?: {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    };
+    referenceRamp?: ReferenceRamp;
+    deletions?: Map<number, string[]>;
+    hiddenEdges?: ReadonlySet<number>;
+    version?: number;
+}
+export declare function hslToRgb(h: number, s: number, l: number): [number, number, number];
+export declare const REFERENCE_RAMP_MAX_HUE = 300;
+export interface ReferenceRamp {
+    start: number;
+    span: number;
+    midpoints: Map<string, number>;
+}
+export interface ColorSchemeRange {
+    minDepth: number;
+    maxDepth: number;
+    minLength: number;
+    maxLength: number;
+    maxRank: number;
+    nodeCount: number;
+    referenceRamp?: ReferenceRamp;
+}
+export declare function computeReferenceRamp(graph: Graph, domain: {
+    start: number;
+    end: number;
+} | undefined): ReferenceRamp;
+export declare function computeColorSchemeRange(graph: Graph): {
+    minDepth: number;
+    maxDepth: number;
+    minLength: number;
+    maxLength: number;
+    maxRank: number;
+    nodeCount: number;
+};
+export declare function getNodeColor(node: GraphNode, nodeIndex: number, colorScheme: ResolvedColorScheme, range: ColorSchemeRange): number;
+export declare function endTangent(c: BezierCurve, yToX?: number, into?: {
+    from: NodeSegment;
+    to: NodeSegment;
+}): number;
+export declare function buildGeometry(options: BuildOptions): RenderBatch;

package/dist/types/renderer/colorBits.d.ts

@@ -0,0 +1,2 @@
+export declare function fadeAbgr(c: number, alpha: number): number;
+export declare function brightenAbgr(c: number, factor: number): number;

package/dist/types/renderer/types.d.ts

@@ -0,0 +1,50 @@
+import type { BezierCurve } from '../util/geometry';
+export interface EdgeCurveBatch {
+    curves: BezierCurve[];
+    thickness: number;
+    color: number;
+}
+export interface NodeStroke {
+    points: {
+        x: number;
+        y: number;
+    }[];
+    thickness: number;
+    color: number;
+}
+export interface Arrowhead {
+    x: number;
+    y: number;
+    angle: number;
+    length: number;
+    halfWidth: number;
+    color: number;
+}
+export interface Run {
+    start: number;
+    count: number;
+}
+export interface RenderBatch {
+    nodeStrokes: NodeStroke[];
+    nodeStrokeRuns: Map<string, Run>;
+    arrows: Arrowhead[];
+    arrowRuns: Map<number, Run>;
+    edgeCurves: EdgeCurveBatch[];
+    edgeCurveRuns: Map<number, Run>;
+}
+export interface TransformUniform {
+    scaleX: number;
+    scaleY: number;
+    translateX: number;
+    translateY: number;
+    dpr: number;
+}
+export interface Renderer {
+    resize(width: number, height: number): void;
+    uploadGeometry(batch: RenderBatch): void;
+    setNodeHighlights(factors: ReadonlyMap<string, number>): void;
+    setEdgeHighlight(edgeIndex: number | null, factor: number): void;
+    updateTransform(transform: TransformUniform): void;
+    render(clearColor: [number, number, number, number]): void;
+    dispose(): void;
+}

package/dist/types/tubeMap/draw.d.ts

@@ -0,0 +1,66 @@
+import type { TubeMapTransform } from './frame';
+import type { TubeMapMismatch } from './mismatches';
+import type { TubeMapLayout } from '@gmod/tubemap-core';
+type Command = {
+    op: 'M' | 'L';
+    x: number;
+    y: number;
+} | {
+    op: 'Q';
+    x1: number;
+    y1: number;
+    x: number;
+    y: number;
+} | {
+    op: 'C';
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    x: number;
+    y: number;
+} | {
+    op: 'H';
+    x: number;
+} | {
+    op: 'V';
+    y: number;
+} | {
+    op: 'Z';
+};
+export declare function parsePath(d: string): Command[];
+interface Filled {
+    color: string;
+    alpha: number;
+    x0: number;
+    x1: number;
+}
+interface Rect extends Filled {
+    y0: number;
+    y1: number;
+}
+interface Shape extends Filled {
+    commands: Command[];
+}
+interface Layer {
+    rects: Rect[];
+    shapes: Shape[];
+}
+export interface TubeMapPicture {
+    layers: Layer[];
+    nodes: {
+        name: string;
+        commands: Command[];
+        x0: number;
+        x1: number;
+    }[];
+    mismatches: TubeMapMismatch[];
+}
+export declare function tubeMapPicture(layout: TubeMapLayout): TubeMapPicture;
+export interface TubeMapFrame extends TubeMapTransform {
+    width: number;
+    highlightNode?: string | null;
+    darkMode?: boolean;
+}
+export declare function drawTubeMap(ctx: CanvasRenderingContext2D, picture: TubeMapPicture, frame: TubeMapFrame): void;
+export {};

package/dist/types/tubeMap/frame.d.ts

@@ -0,0 +1,15 @@
+import type { TubeMapDrawing } from '../layout/tubeMapLayout';
+export interface TubeMapView {
+    scaleX: number;
+    translateX: number;
+    scaleY: number;
+    translateY: number;
+    usableHeight: number;
+}
+export interface TubeMapTransform {
+    x: (tx: number) => number;
+    y: (ty: number) => number;
+    yScale: number;
+}
+export declare function tubeMapFrame(drawing: TubeMapDrawing, view: TubeMapView): TubeMapTransform;
+export declare function tubeMapNodeAt(drawing: TubeMapDrawing, { x, y }: TubeMapTransform, sx: number, sy: number): null;

package/dist/types/tubeMap/mismatches.d.ts

@@ -0,0 +1,24 @@
+import type { TubeMapLayout } from '@gmod/tubemap-core';
+interface MarkBase {
+    readId: number;
+    y: number;
+    height: number;
+    nodeY: number;
+}
+export type TubeMapMismatch = (MarkBase & {
+    kind: 'insertion';
+    x: number;
+    seq?: string;
+    softClip: boolean;
+}) | (MarkBase & {
+    kind: 'deletion';
+    x0: number;
+    x1: number;
+}) | (MarkBase & {
+    kind: 'substitution';
+    x0: number;
+    x1: number;
+    seq: string;
+});
+export declare function tubeMapMismatches(layout: TubeMapLayout): TubeMapMismatch[];
+export {};

package/dist/types/tubeMap/reads.d.ts

@@ -0,0 +1,10 @@
+import type { GafRecord } from '../gaf/parseGaf';
+import type { Graph, GraphNode } from '../types';
+import type { InputTrack } from '@gmod/tubemap-core';
+export declare function canonicalStrand(node: GraphNode): "+" | "-";
+export declare function stepName(node: GraphNode, strand: '+' | '-'): string;
+export declare function tubeMapReads(graph: Graph, records: readonly GafRecord[], firstId: number): InputTrack[];
+export declare function readColor(read: {
+    id: number;
+    is_reverse?: boolean;
+}): string;

package/dist/types/tubeMap/warp.d.ts

@@ -0,0 +1,7 @@
+import type { TubeMapColumn } from '../layout/tubeMapLayout';
+export interface Knot {
+    tx: number;
+    sx: number;
+}
+export declare function referenceKnots(columns: readonly TubeMapColumn[], bpToScreen: (bp: number) => number): Knot[];
+export declare function warpX(knots: readonly Knot[], tx: number): number;