@jbrowse/bandage-core 10.2.6 → 10.3.0

package/dist/types/bubbles/bubblesFromGraph.d.ts

@@ -9,7 +9,9 @@ export declare function relax<K>(best: Map<K, Routes>, to: K, cur: Routes, add:
 export declare function bubblesFromGraph(graph: Graph): MinigraphBubble[];
 export type WalkIndex = Map<string, Int32Array>;
 export declare function walkIndexOf(graph: Graph, ids: Iterable<string>): WalkIndex | undefined;
-export declare function walkRoutes(graph: Graph, byId: Map<string, GraphNode>, walkIndex: WalkIndex, startId: string, endId: string): (Routes & {
-    left: number;
-    routes: BubbleRoute[];
-}) | undefined;
+export interface WalkedRoutes extends Routes {
+    routes?: BubbleRoute[];
+    walksLeave: boolean;
+}
+export declare function walkRoutes(graph: Graph, byId: Map<string, GraphNode>, walkIndex: WalkIndex | undefined, startId: string, endId: string, fallback: () => Routes): WalkedRoutes;
+export declare function derivedBubble(place: Pick<MinigraphBubble, 'refName' | 'start' | 'end'>, segments: readonly GraphNode[], { min, max, n, routes }: WalkedRoutes, partial: boolean): MinigraphBubble;

package/dist/types/bubbles/classifyBubble.d.ts

@@ -1,6 +1,6 @@
 import type { MinigraphBubble } from './bubbleLine.js';
 export type BubbleKind = 'snp' | 'substitution' | 'insertion' | 'deletion' | 'inversion' | 'repeat' | 'superbubble' | 'complex';
-export interface BubbleClass {
+interface BubbleClass {
     kind: BubbleKind;
     label: string;
 }
@@ -13,3 +13,4 @@ export declare function classifyBubble(b: MinigraphBubble, repeats?: readonly Re
 export declare const BUBBLE_KIND_COLORS: Record<BubbleKind, string>;
 export declare const BUBBLE_KIND_NAMES: Record<BubbleKind, string>;
 export declare function bubbleSegmentIds(b: MinigraphBubble): string[];
+export {};

package/dist/types/deletionEdges.d.ts

@@ -12,14 +12,6 @@ export interface DeletionEdge {
     bp: number;
     bypassed: string[];
 }
-export declare function bypassedPoints(nodePositions: Record<string, {
-    x: number;
-    y: number;
-}[]>, bypassed: string[]): {
-    x: number;
-    y: number;
-}[];
-export declare function deletionArcCurves(nodePositions: Record<string, NodeSegment[]>, deletion: DeletionEdge, axis: AxisScale, route?: NodeSegment[], stranded?: boolean): import("./util/geometry.js").BezierCurve[] | undefined;
 export declare function edgeCurvesOf(nodePositions: Record<string, NodeSegment[]>, edge: GraphEdge, axis: AxisScale, bypassed: string[] | undefined, route: NodeSegment[] | undefined, stranded: boolean): import("./util/geometry.js").BezierCurve[] | undefined;
 export declare function deletionEdges(graph: Graph): DeletionEdge[];
 export declare function closableDeletions(graph: Graph, deletions: DeletionEdge[]): Set<number>;

package/dist/types/figureScene.d.ts

@@ -1,7 +1,7 @@
 import type { FigureOptions } from './figure.js';
 import type { Graph, LayoutResult } from './types.js';
 import type { AxisScale } from './util/geometry.js';
-import type { WalkLift } from './walkHighlight.js';
+import type { LiftedWalk, WalkLift } from './walkHighlight.js';
 export type FigureSceneOptions = Pick<FigureOptions, 'walks' | 'facet' | 'colorScheme' | 'nodeWidth' | 'showDeletionEdges' | 'linearLayout' | 'contigThickness' | 'connectorThickness' | 'region' | 'referenceName' | 'colorDomain' | 'fitToDrawing' | 'walkRows' | 'walkRowPitch'>;
 export declare function figureScene(graph: Graph, layout: LayoutResult, o: FigureSceneOptions): {
     bounds: {
@@ -17,14 +17,24 @@ export declare function figureScene(graph: Graph, layout: LayoutResult, o: Figur
     layers: import("./walkEncoding.js").WalkLayer[];
     lift: WalkLift | undefined;
     facet: import("./facetGrid.js").FacetSetting;
-    panels: WalkLift[] | undefined;
+    facets: {
+        panels: WalkLift[];
+        place: {
+            columns: undefined;
+            count: number;
+            cells: number[];
+        } | {
+            columns: number;
+            count: number;
+            cells: number[];
+        };
+    } | undefined;
     labelOf: (name: string) => string;
     referenceName: string | undefined;
-    reference: {
-        name: string | undefined;
-        start: number;
-        end: number;
-    } | undefined;
+    keyText: (walk: LiftedWalk) => {
+        note: string;
+        scale: string | undefined;
+    };
     contigThickness: number;
     nodeWidth: "depth" | "uniform";
     geometry: (highlight: WalkLift | undefined, axis: AxisScale) => import("./renderer/types.js").RenderBatch;

package/dist/types/figureSettings.d.ts

@@ -2,6 +2,8 @@ import type { ColorScheme } from './colorSchemes.js';
 import type { NodeWidth } from './nodeWidths.js';
 import type { EngineSettings } from './pipeline.js';
 export interface FigureSettings extends Partial<EngineSettings> {
+    width?: number;
+    height?: number;
     colorScheme?: ColorScheme;
     nodeWidth?: NodeWidth;
     contigThickness?: number;

package/dist/types/gbzCut.d.ts

@@ -13,6 +13,10 @@ export declare const HPRC_GBZ: {
     db: string;
     index: string;
 };
+export declare function gbzLocations({ db, index }: Pick<GbzSource, 'db' | 'index'>): {
+    db: string;
+    index: string | undefined;
+};
 export declare function haplotypeIndexBeside(db: string): string | undefined;
 export declare function parseRegion(text: string): {
     refName: string;

package/dist/types/gbzWindow.d.ts

@@ -13,6 +13,7 @@ export declare class NodeLimitError extends Error {
 export declare function haplotypePrefix(name: Pick<PathName, 'sample' | 'haplotype'>): string;
 export declare function haplotypeWanted(name: PathName, wanted: string[] | undefined): boolean;
 export declare function referenceSamplesOf(db: GBZBase): Promise<string[]>;
+export declare function aliasedSample(anchorSample: string, referenceSamples: string[]): string | undefined;
 export declare function resolveReferenceSample({ configured, anchorPrefix, referenceSamples, }: {
     configured: string;
     anchorPrefix: string;

package/dist/types/gfa/graphTables.d.ts

@@ -36,6 +36,8 @@ export interface GraphTables {
  */
 export declare function graphFromTables({ nodes: n, links: l, walks: w }: GraphTables, name?: string): Graph;
 /**
- * The tables as GFA text: S lines in table order, then L lines, then W lines
+ * The tables as GFA text: S lines in table order, then L lines, then a W
+ * line per walk, or a P line for a walk whose name has fewer than three PanSN
+ * parts
  */
 export declare function graphTablesGFA({ nodes, links, walks }: GraphTables): string;

package/dist/types/gfa-core/gfaParser.d.ts

@@ -26,7 +26,7 @@ export interface GFAPath {
 }
 export interface GFAWalkSegment {
     id: string;
-    strand: string;
+    strand: '+' | '-';
 }
 export interface GFAWalk {
     sample: string;

package/dist/types/graphLabels.d.ts

@@ -44,7 +44,8 @@ export declare function sizeLabelCandidates({ nodePositions, nodeLengths, deleti
 };
 export declare function nodeLabelBudget(width: number, height: number): number;
 export declare function placeSizeLabels(candidates: SizeLabelCandidate[], take: TakeBox, budget?: number): GraphLabel[];
-export declare function graphLabels({ reserved, ...args }: SizeLabelArgs & {
+export declare function graphLabels({ reserved, take, ...args }: SizeLabelArgs & {
     reserved?: Box[];
+    take?: TakeBox;
 }): GraphLabel[];
 export {};

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

@@ -13,13 +13,11 @@ export interface DrawnLengthLaw {
     effect: number;
 }
 export declare const PROPORTIONAL_LENGTH: DrawnLengthLaw;
-export declare function isProportional(law: DrawnLengthLaw): boolean;
 export declare function drawnLengthFor(graph: Graph, law: DrawnLengthLaw): (bp: number) => number;
 export interface NodeLengthSpread {
     law: DrawnLengthLaw;
     minNodeLength: number;
 }
-export declare const PROPORTIONAL_SPREAD: NodeLengthSpread;
 export interface LayoutScaling {
     nodes: GraphNode[];
     opts: BandageScaleOpts;

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

@@ -4,9 +4,10 @@ export type LayoutNode = GraphNode & {
     x?: number;
     y?: number;
 };
-export interface Seed {
+interface Seed {
     x: number;
     y: number;
 }
 export declare function referenceSeeds(graph: Graph, scaling: LayoutScaling): Map<string, Seed>;
 export declare function seededNodes(graph: Graph, scaling: LayoutScaling): LayoutNode[];
+export {};

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

@@ -24,13 +24,6 @@ export interface PathStep {
 export declare function pathSteps(graph: Graph): PathStep[][];
 export declare function tubeMapTracks(graph: Graph): InputTrack[];
 export declare function hasTubeMapPaths(graph: Graph): boolean;
-export declare function tubeWidth(trackCount: number): number;
-export interface MergedRuns {
-    members: Map<string, string[]>;
-    flipped: Set<string>;
-}
-export declare function mergedRuns(graph: Graph, layout: TubeMapLayout, walks: readonly InputTrack[]): MergedRuns;
-export declare function boxGraph(graph: Graph, { members, flipped }: MergedRuns): Graph;
 export declare function tubeMapLayout(graph: Graph): LayoutResult | undefined;
 export declare function hasTubeMapBackbone(graph: Graph): boolean;
 export declare function tubeMapReferenceLayout(graph: Graph): LayoutResult | undefined;

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

@@ -8,7 +8,6 @@ export declare const GENE_INK = "#1c1c22";
 export declare const BAR_PX = 12;
 export declare const GAP_PX = 4;
 export declare const LABELLED_ROW_PX = 12;
-export declare function kb(bp: number): string;
 export interface ReadoutCall {
     bp: number;
     spanningReads?: number;

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

@@ -2,6 +2,7 @@ import type { RowPitch } from './walkRowDraw.js';
 import type { WalkRows } from './walkRows.js';
 import type { Graph, LayoutResult, RowLabel } from '../types.js';
 export declare const READOUT_ROOM = 1.3;
+export declare function longestBar(walks: WalkRows): number;
 export declare function walkRowsExtent(walks: WalkRows, pitch?: Pick<RowPitch, 'rowPx' | 'readouts'>): {
     maxX: number;
     maxY: number;

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

@@ -39,6 +39,7 @@ export declare function filterSamples<R extends {
     sample: string;
     label: string;
 }>(rows: R[], samples: string[] | undefined): R[];
+export declare function referenceWalkName(graph: Pick<Graph, 'nodes' | 'paths' | 'referencePath'>): string | undefined;
 export declare function walkRows(graph: Graph, region?: {
     start: number;
     end: number;

package/dist/types/nodeWidths.d.ts

@@ -11,7 +11,6 @@ export declare const NODE_WIDTHS: readonly [{
 }];
 export type NodeWidth = (typeof NODE_WIDTHS)[number]['value'];
 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/pansn.d.ts

@@ -5,6 +5,15 @@ export declare function panSNSample(refName: string): string;
 export declare function isGenericSample(sample: string): boolean;
 export declare function panSNHaplotype(refName: string): string | undefined;
 export declare function panSNContig(refName: string): string;
+export declare function panSNFields(name: string): {
+    sample: string;
+    haplotype: number;
+    contig: string;
+} | undefined;
+export declare function parsePanSN(refName: string): {
+    sample: string;
+    haplotype: number | undefined;
+};
 export declare function panSNMatchesPrefix(refName: string, prefix: string | undefined): boolean;
 export declare function resolvePanSNPrefix(adapter: ConfAdapter, name: string): string;
 export declare function resolvePanSNPrefix(adapter: ConfAdapter, name: string | undefined): string | undefined;

package/dist/types/pathVisits.d.ts

@@ -42,6 +42,12 @@ export declare class PathVisits {
     entries(): Generator<[string, PathVisit[]]>;
     [Symbol.iterator](): Generator<[string, PathVisit[]], any, any>;
 }
+export declare class Column<T extends Int32Array | Float64Array | Uint8Array> {
+    data: T;
+    length: number;
+    constructor(data: T);
+    push(value: number): void;
+}
 /**
  * Visits added in any order, grouped by segment on `build`, each segment's
  * keeping the order they were added in

package/dist/types/referenceRampCss.d.ts

@@ -1,4 +1,8 @@
+export declare const REFERENCE_RAMP_MAX_HUE = 300;
+export declare const REFERENCE_RAMP_SATURATION = 0.7;
+export declare const REFERENCE_RAMP_LIGHTNESS = 0.5;
 export declare function rampHueCss(hue: number): string;
+export declare function rampHueAt(frac: number): number;
 export declare function rampHue(bp: number, domain: {
     start: number;
     end: number;

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

@@ -16,6 +16,7 @@ export declare class Canvas2DRenderer implements Renderer {
     setNodeHighlights(factors: ReadonlyMap<string, number>): void;
     setEdgeHighlight(edgeIndex: number | null, factor: number): void;
     updateTransform(transform: TransformUniform): void;
+    private fitted;
     render(clearColor: [number, number, number, number]): void;
     renderHighlights(): void;
     private edgeRun;

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

@@ -34,7 +34,7 @@ export interface BuildOptions {
     version?: number;
 }
 export declare function hslToRgb(h: number, s: number, l: number): [number, number, number];
-export declare const REFERENCE_RAMP_MAX_HUE = 300;
+export { REFERENCE_RAMP_MAX_HUE } from '../referenceRampCss.js';
 export declare const REFERENCE_RAMP_ALT_COLOR: number;
 export declare const REFERENCE_RAMP_ALT_CSS: string;
 export interface ReferenceRamp {
@@ -55,13 +55,14 @@ export declare function computeReferenceRamp(graph: Graph, domain: {
     start: number;
     end: number;
 } | undefined): ReferenceRamp;
-export declare function computeColorSchemeRange(graph: Graph): {
+export declare function computeColorSchemeRange(graph: Graph, referenceRamp?: ReferenceRamp): {
     minDepth: number;
     maxDepth: number;
     minLength: number;
     maxLength: number;
     maxRank: number;
     nodeCount: number;
+    referenceRamp: ReferenceRamp | undefined;
 };
 export declare function getNodeColor(node: GraphNode, nodeIndex: number, colorScheme: ResolvedColorScheme, range: ColorSchemeRange): number;
 export declare function endTangent(c: BezierCurve, yToX?: number, into?: {

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

@@ -13,13 +13,14 @@ export interface ReferenceBox extends Box {
 export declare function referenceBoxes({ graph, layout, }: Pick<TubeMapDrawing, 'graph' | 'layout'>): Map<string, ReferenceBox[]>;
 export type ReferenceBoxes = ReturnType<typeof referenceBoxes>;
 export declare function tubeX(boxes: readonly Box[], bp: number, isEnd?: boolean): number;
+export declare function boxX(box: Box, bp: number): number;
 export declare function tubeSpan(boxes: readonly Box[], start: number, end: number): {
     x0: number;
     x1: number;
 };
 export declare function rulerBoxes(byRefName: ReferenceBoxes): Box[] | undefined;
 export declare function rulerInk(darkMode?: boolean): "#b0b0b8" | "#55555c";
-export interface RulerMarks {
+interface RulerMarks {
     spans: {
         x0: number;
         x1: number;
@@ -32,3 +33,4 @@ export interface RulerMarks {
 }
 export declare function rulerMarks(boxes: readonly Box[], x: (tx: number) => number, width: number, measure: (text: string) => number, referenceAxis?: boolean): RulerMarks | undefined;
 export declare function drawTubeMapRuler(ctx: CanvasRenderingContext2D, boxes: readonly Box[], frame: TubeMapFrame, top: number, referenceAxis?: boolean): void;
+export {};

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

@@ -5,7 +5,7 @@ export interface Deviation {
     bp: number;
     inverted?: true;
 }
-export type CutCause = 'variant' | 'backward' | 'inversion' | 'walk-end' | 'overlap' | 'reference-gap';
+type CutCause = 'variant' | 'backward' | 'inversion' | 'walk-end' | 'overlap' | 'reference-gap';
 export interface Coarsened {
     graph: Graph;
     members: Map<string, string[]>;
@@ -13,4 +13,6 @@ export interface Coarsened {
     deviations: Map<string, Deviation[]>;
     cuts: Map<number, CutCause>;
 }
+export declare function lastAtMost<T>(items: readonly T[], key: (item: T) => number, x: number): number;
 export declare function coarsenTubeMap(graph: Graph, sigma: number): Coarsened | undefined;
+export {};

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

@@ -1,7 +1,7 @@
 import type { Deviation } from './coarsen.js';
 import type { TubeMapFrame } from './draw.js';
 import type { TubeMapDrawing } from '../layout/tubeMapLayout.js';
-export interface DeviationMark {
+interface DeviationMark {
     x0: number;
     x1: number;
     y: number;
@@ -10,3 +10,4 @@ export interface DeviationMark {
 export declare function deviationMarks(drawing: Pick<TubeMapDrawing, 'graph' | 'layout'>, deviations: Map<string, Deviation[]>): DeviationMark[];
 export declare function deviationInk(darkMode?: boolean): "rgba(255,255,255,0.9)" | "rgba(0,0,0,0.8)";
 export declare function drawDeviationMarks(ctx: CanvasRenderingContext2D, marks: readonly DeviationMark[], { x, y, width, darkMode }: TubeMapFrame): void;
+export {};

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

@@ -8,7 +8,6 @@ export type TubeMapMismatch = (MarkBase & {
     kind: 'insertion';
     x: number;
     seq?: string;
-    softClip: boolean;
 }) | (MarkBase & {
     kind: 'deletion';
     x0: number;

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

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

package/dist/types/util/SpatialIndex.d.ts

@@ -19,7 +19,7 @@ export declare class EdgeSpatialIndex {
     private cellSize;
     private cells;
     private edgeCurves;
-    constructor(nodePositions: Record<string, NodeSegment[]>, graph: Graph, drawPaths: boolean, axis: AxisScale, cellSize?: number | CellSize, deletions?: Map<number, string[]>, version?: number, routes?: DeletionRoutes, stranded?: boolean);
+    constructor(nodePositions: Record<string, NodeSegment[]>, graph: Graph, drawPaths: boolean, axis: AxisScale, deletions?: Map<number, string[]>, version?: number, routes?: DeletionRoutes, stranded?: boolean);
     getCurves(ei: number): import("./geometry.js").BezierCurve[] | undefined;
     query(x: number, y: number, radiusX: number, radiusY?: number): number[];
 }

package/dist/types/util/geometry.d.ts

@@ -46,6 +46,10 @@ export declare function pathRibbonOffsets(fromSegments: NodeSegment[], toSegment
     x: number;
     y: number;
 }[];
+export declare function polylinePx(points: {
+    x: number;
+    y: number;
+}[], scaleX: number, scaleY: number): number;
 export type SelfLink = boolean | Side;
 export declare function selfLinkOf(edge: GraphEdge): SelfLink;
 export type EdgeJoin = SelfLink | EdgeSides;

package/dist/types/util/groups.d.ts

@@ -0,0 +1,3 @@
+export declare function pushTo<K, V>(map: Map<K, V[]>, key: K, value: V): void;
+export declare function addTo<K, V>(map: Map<K, Set<V>>, key: K, value: V): void;
+export declare function groupBy<T, K>(items: Iterable<T>, keyOf: (item: T) => K): Map<K, T[]>;

package/dist/types/util/hitDetection.d.ts

@@ -1,9 +1,9 @@
 import type { DeletionRoutes } from '../layout/deletionRoutes.js';
 import type { Box } from '../overlayLabels.js';
 import type { Graph, NodeSegment } from '../types.js';
-import type { AxisScale } from './geometry.js';
+import type { AxisScale, BezierCurve } from './geometry.js';
 export declare function distanceToSegment(px: number, py: number, x1: number, y1: number, x2: number, y2: number): number;
-export declare function distanceToCubicBezier(px: number, py: number, x1: number, y1: number, cx1: number, cy1: number, cx2: number, cy2: number, x2: number, y2: number): number;
+export declare function distanceToCubicBezier(px: number, py: number, c: BezierCurve): number;
 export interface NodeInk {
     halfWidthPx: (nodeId: string) => number;
     maxHalfWidthPx: number;

package/dist/types/util/partitionPoint.d.ts

@@ -0,0 +1 @@
+export declare function partitionPoint(n: number, pred: (i: number) => boolean): number;

package/dist/types/util/weakMemo.d.ts

@@ -0,0 +1 @@
+export declare function weakMemo<K extends object, V>(): (key: K, deps: readonly unknown[], compute: () => V) => V;

package/dist/types/version.d.ts

@@ -1 +1 @@
-export declare const version = "10.2.6";
+export declare const version = "10.3.0";

package/dist/util/SpatialIndex.js

@@ -1,12 +1,15 @@
 import {
   EdgeSpatialIndex,
   SpatialIndex
-} from "../chunks/chunk-KBEP7VYK.js";
-import "../chunks/chunk-ZY2AFL4Y.js";
-import "../chunks/chunk-24WITXQY.js";
-import "../chunks/chunk-7SRWJLSC.js";
+} from "../chunks/chunk-3VCKBSML.js";
+import "../chunks/chunk-WA5WNP6V.js";
+import "../chunks/chunk-HMXCN6PG.js";
+import "../chunks/chunk-CGMSKIEO.js";
+import "../chunks/chunk-UBQSRCWR.js";
 import "../chunks/chunk-CPMHA4W5.js";
-import "../chunks/chunk-FYQWPEEY.js";
+import "../chunks/chunk-BSOZW3FC.js";
+import "../chunks/chunk-RJWPJCIB.js";
+import "../chunks/chunk-HOAIOEI7.js";
 export {
   EdgeSpatialIndex,
   SpatialIndex

package/dist/util/edgeCurves.js

@@ -1,10 +1,13 @@
 import {
   baseEdgeCurves
-} from "../chunks/chunk-ZY2AFL4Y.js";
-import "../chunks/chunk-24WITXQY.js";
-import "../chunks/chunk-7SRWJLSC.js";
+} from "../chunks/chunk-WA5WNP6V.js";
+import "../chunks/chunk-HMXCN6PG.js";
+import "../chunks/chunk-CGMSKIEO.js";
+import "../chunks/chunk-UBQSRCWR.js";
 import "../chunks/chunk-CPMHA4W5.js";
-import "../chunks/chunk-FYQWPEEY.js";
+import "../chunks/chunk-BSOZW3FC.js";
+import "../chunks/chunk-RJWPJCIB.js";
+import "../chunks/chunk-HOAIOEI7.js";
 export {
   baseEdgeCurves
 };

package/dist/util/geometry.js

@@ -9,6 +9,7 @@ import {
   edgeJoinOf,
   ownStrand,
   pathRibbonOffsets,
+  polylinePx,
   projectLine,
   routedEdgeCurves,
   selfLinkOf,
@@ -16,7 +17,7 @@ import {
   svgPath,
   translateCurves,
   yToXOf
-} from "../chunks/chunk-7SRWJLSC.js";
+} from "../chunks/chunk-UBQSRCWR.js";
 import "../chunks/chunk-CPMHA4W5.js";
 export {
   PATH_RIBBON_SPACING_PX,
@@ -29,6 +30,7 @@ export {
   edgeJoinOf,
   ownStrand,
   pathRibbonOffsets,
+  polylinePx,
   projectLine,
   routedEdgeCurves,
   selfLinkOf,

package/dist/util/groups.js

@@ -0,0 +1,10 @@
+import {
+  addTo,
+  groupBy,
+  pushTo
+} from "../chunks/chunk-BSOZW3FC.js";
+export {
+  addTo,
+  groupBy,
+  pushTo
+};

package/dist/util/hitDetection.js

@@ -4,13 +4,16 @@ import {
   findHoveredEdge,
   findHoveredNode,
   nodesUnderBox
-} from "../chunks/chunk-4HWM3FNK.js";
-import "../chunks/chunk-KBEP7VYK.js";
-import "../chunks/chunk-ZY2AFL4Y.js";
-import "../chunks/chunk-24WITXQY.js";
-import "../chunks/chunk-7SRWJLSC.js";
+} from "../chunks/chunk-OMUPUB4J.js";
+import "../chunks/chunk-3VCKBSML.js";
+import "../chunks/chunk-WA5WNP6V.js";
+import "../chunks/chunk-HMXCN6PG.js";
+import "../chunks/chunk-CGMSKIEO.js";
+import "../chunks/chunk-UBQSRCWR.js";
 import "../chunks/chunk-CPMHA4W5.js";
-import "../chunks/chunk-FYQWPEEY.js";
+import "../chunks/chunk-BSOZW3FC.js";
+import "../chunks/chunk-RJWPJCIB.js";
+import "../chunks/chunk-HOAIOEI7.js";
 export {
   distanceToCubicBezier,
   distanceToSegment,

package/dist/util/partitionPoint.js

@@ -0,0 +1,6 @@
+import {
+  partitionPoint
+} from "../chunks/chunk-HOAIOEI7.js";
+export {
+  partitionPoint
+};

package/dist/util/weakMemo.js

@@ -0,0 +1,6 @@
+import {
+  weakMemo
+} from "../chunks/chunk-HMXCN6PG.js";
+export {
+  weakMemo
+};

package/dist/version.js

@@ -1,6 +1,6 @@
 import {
   version
-} from "./chunks/chunk-YYMW5XOF.js";
+} from "./chunks/chunk-PTQPTDZH.js";
 export {
   version
 };

package/dist/viewport.js

@@ -5,28 +5,30 @@ import {
   screenToLayout,
   viewportOf,
   zoomAbout
-} from "./chunks/chunk-BS4UZ44I.js";
-import "./chunks/chunk-2QLLQJ72.js";
-import "./chunks/chunk-PUG7LXDF.js";
-import "./chunks/chunk-IGVV37VI.js";
+} from "./chunks/chunk-WONB6LMC.js";
+import "./chunks/chunk-KWHWNOTY.js";
+import "./chunks/chunk-3PZSBNLI.js";
+import "./chunks/chunk-CKUVEHSS.js";
 import "./chunks/chunk-OPPVSPEF.js";
 import "./chunks/chunk-VPE4AYP7.js";
-import "./chunks/chunk-AR4BUBMU.js";
+import "./chunks/chunk-RWKP7UO4.js";
 import "./chunks/chunk-QYBZZI5H.js";
 import "./chunks/chunk-5I3K4R2G.js";
-import "./chunks/chunk-PSMKPSO4.js";
-import "./chunks/chunk-M6LK4GII.js";
-import "./chunks/chunk-RAEABQNW.js";
-import "./chunks/chunk-ES2N6V56.js";
-import "./chunks/chunk-G45YY72K.js";
-import "./chunks/chunk-BPLIXMH7.js";
-import "./chunks/chunk-N73TI3VG.js";
-import "./chunks/chunk-UVBGRJQX.js";
-import "./chunks/chunk-6JEWNXCQ.js";
-import "./chunks/chunk-24WITXQY.js";
-import "./chunks/chunk-7SRWJLSC.js";
+import "./chunks/chunk-DBLV7PGG.js";
+import "./chunks/chunk-LGJBB5BP.js";
+import "./chunks/chunk-VX656OAZ.js";
+import "./chunks/chunk-Z6XZWPXK.js";
+import "./chunks/chunk-ZPZ7GNBT.js";
+import "./chunks/chunk-BZFOFC4D.js";
+import "./chunks/chunk-HKYXWZQS.js";
+import "./chunks/chunk-34BOZKIE.js";
+import "./chunks/chunk-CGMSKIEO.js";
+import "./chunks/chunk-UBQSRCWR.js";
 import "./chunks/chunk-CPMHA4W5.js";
-import "./chunks/chunk-FYQWPEEY.js";
+import "./chunks/chunk-BSOZW3FC.js";
+import "./chunks/chunk-RJWPJCIB.js";
+import "./chunks/chunk-HOAIOEI7.js";
+import "./chunks/chunk-4XWZNPQ2.js";
 export {
   axisScaleOf,
   contains,