@jbrowse/bandage-core 11.7.3 → 11.9.0

package/dist/chunks/{chunk-VXKL2ZLR.js → chunk-GDZQFELP.js}

@@ -1,3 +1,13 @@
+import {
+  THREAD_PITCH_PX,
+  THREAD_PX,
+  bandScale,
+  bandWidthPx,
+  laneSlideAt,
+  liftLanes,
+  slotCentres,
+  threadsPasses
+} from "./chunk-3BDQQTXY.js";
 import {
   abgrToCssRgba,
   fadeAbgr,
@@ -10,13 +20,13 @@ import {
 } from "./chunk-GQZVR5DW.js";
 import {
   baseEdgeCurves
-} from "./chunk-33KUO34R.js";
+} from "./chunk-P2GJBFNA.js";
 import {
   PATH_LIGHTNESS,
   PATH_SATURATION,
   nameHue,
   pathHueAt
-} from "./chunk-GD6RUZU5.js";
+} from "./chunk-VQ353UDK.js";
 import {
   meanDepth,
   nodeWidthPx,
@@ -26,13 +36,17 @@ import {
   referenceMidpoints
 } from "./chunk-VX656OAZ.js";
 import {
-  dashCurves,
+  weakMemo
+} from "./chunk-HMXCN6PG.js";
+import {
+  dashSpans,
   pathRibbonOffsets,
   polylinePx,
+  slideCurves,
   strandSides,
   translateCurves,
   yToXOf
-} from "./chunk-VACK24HF.js";
+} from "./chunk-JJV2GT2Z.js";
 import {
   pushTo
 } from "./chunk-BSOZW3FC.js";
@@ -149,13 +163,16 @@ function arrowheadFor({
     color
   };
 }
-function leavesStart(edge, segments, first, stranded, yToX) {
-  if (stranded) {
-    return strandSides(edge).from === "start";
-  }
-  const gap = (p) => Math.hypot(p.x - first.x0, (p.y - first.y0) * yToX);
+var FIRST_THREADS = [[0, 0]];
+var ONE_PASS = [0];
+var NO_SHIFT = { dx: 0, dy: 0 };
+function nearerStart(at, segments, yToX) {
+  const gap = (p) => Math.hypot(p.x - at.x, (p.y - at.y) * yToX);
   return gap(segments[0]) < gap(segments.at(-1));
 }
+function leavesStart(edge, segments, first, stranded, yToX) {
+  return stranded ? strandSides(edge).from === "start" : nearerStart({ x: first.x0, y: first.y0 }, segments, yToX);
+}
 function intoDirection(last, toSegments) {
   if (toSegments.length < 2) {
     return void 0;
@@ -174,6 +191,8 @@ function normal(a, b) {
   const len = Math.hypot(dx, dy);
   return len > 0 ? { nx: -dy / len, ny: dx / len } : void 0;
 }
+var MITRE_LIMIT = 0.1;
+var LONGEST_NORMAL = 1 / Math.sqrt(MITRE_LIMIT);
 function pointNormalsOf(rawPoints, yToX = 1) {
   const points = yToX === 1 ? rawPoints : rawPoints.map((p) => ({ x: p.x, y: p.y * yToX }));
   return points.map((p, i) => {
@@ -183,16 +202,20 @@ function pointNormalsOf(rawPoints, yToX = 1) {
       const nx = (before.nx + after.nx) / 2;
       const ny = (before.ny + after.ny) / 2;
       const dot = before.nx * nx + before.ny * ny;
-      return dot > 0.1 ? { nx: nx / dot, ny: ny / dot } : { nx, ny };
+      return dot > MITRE_LIMIT ? { nx: nx / dot, ny: ny / dot } : { nx, ny };
     }
     return before ?? after ?? { nx: 0, ny: 0 };
   });
 }
 function offsetPolyline(points, normals, distance, yToX = 1) {
-  return points.map((p, i) => ({
-    x: p.x + normals[i].nx * distance,
-    y: p.y + normals[i].ny * distance / yToX
-  }));
+  const out = new Array(points.length);
+  for (let i = 0; i < points.length; i++) {
+    out[i] = {
+      x: points[i].x + normals[i].nx * distance,
+      y: points[i].y + normals[i].ny * distance / yToX
+    };
+  }
+  return out;
 }
 function hslToRgb(h, s, l) {
   const c = (1 - Math.abs(2 * l - 1)) * s;
@@ -393,13 +416,13 @@ function isPolylineInBounds(segments, bounds) {
   }
   return hit;
 }
-function isBezierInBounds(curves, bounds) {
+function isBezierInBounds(curves, bounds, growX = 0, growY = 0) {
   for (const c of curves) {
     const cMinX = Math.min(c.x0, c.cx0, c.cx1, c.x1);
     const cMaxX = Math.max(c.x0, c.cx0, c.cx1, c.x1);
     const cMinY = Math.min(c.y0, c.cy0, c.cy1, c.y1);
     const cMaxY = Math.max(c.y0, c.cy0, c.cy1, c.y1);
-    if (cMaxX >= bounds.minX && cMinX <= bounds.maxX && cMaxY >= bounds.minY && cMinY <= bounds.maxY) {
+    if (cMaxX >= bounds.minX - growX && cMinX <= bounds.maxX + growX && cMaxY >= bounds.minY - growY && cMinY <= bounds.maxY + growY) {
       return true;
     }
   }
@@ -445,6 +468,24 @@ function pathSlotsOf(graph) {
   }
   return slots;
 }
+var lanesCache = weakMemo();
+var linksCache = /* @__PURE__ */ new WeakMap();
+function linksOf(graph) {
+  let links = linksCache.get(graph);
+  if (!links) {
+    links = /* @__PURE__ */ new Map();
+    for (const { from, to } of graph.edges) {
+      let out = links.get(from);
+      if (!out) {
+        out = /* @__PURE__ */ new Set();
+        links.set(from, out);
+      }
+      out.add(to);
+    }
+    linksCache.set(graph, links);
+  }
+  return links;
+}
 function buildGeometry(options) {
   const {
     nodePositions,
@@ -496,6 +537,94 @@ function buildGeometry(options) {
   const { pathColorByIndex, pathIndexByName } = pathPaletteOf(graph);
   const pathColorByName = (name) => pathColorByIndex[pathIndexByName.get(name) ?? -1] ?? EDGE_PATH_FALLBACK_COLOR;
   const nodePathSlots = drawPaths && pathCount > 1 ? pathSlotsOf(graph) : NO_SLOTS;
+  const liftedWalks = highlight?.walks ?? [];
+  const threaded = threadsPasses(liftedWalks);
+  const lanePasses = liftedWalks.map((w) => w.mostPasses);
+  const thinned = threaded ? bandScale(lanePasses) : 1;
+  const fields = highlight && liftedWalks.length > 1 ? lanesCache(
+    highlight,
+    [nodePositions, version, axis.scaleX, axis.scaleY],
+    () => liftLanes(liftedWalks, nodePositions, yToX, worldPerScreenPx)
+  ) : void 0;
+  const lines = fields?.lines;
+  const threads = fields?.threads;
+  const spanField = fields?.spans;
+  const plainCentres = threaded ? slotCentres(lanePasses, lanePasses) : [];
+  const centresByNode = /* @__PURE__ */ new Map();
+  const centresOf = (nodeId) => {
+    let centres = centresByNode.get(nodeId);
+    if (!centres) {
+      const spans = spanField?.get(nodeId);
+      centres = spans ? slotCentres(spans.slot, lanePasses, spans.held) : plainCentres;
+      centresByNode.set(nodeId, centres);
+    }
+    return centres;
+  };
+  const laneOffset = (nodeId, laneWidth, lane, pass) => threaded ? (centresOf(nodeId)[lane] + pass * THREAD_PITCH_PX) * thinned : (lane - (liftedWalks.length - 1) / 2) * laneWidth;
+  const laneHalfWidth = (laneWidth) => threaded ? THREAD_PX / 2 * thinned : laneWidth / 2;
+  const laneNormals = /* @__PURE__ */ new Map();
+  const laneNormalsOf = (nodeId, segments) => {
+    let normals = laneNormals.get(nodeId);
+    if (!normals) {
+      const smoothed = lines?.normals.get(nodeId);
+      normals = smoothed ? pointNormalsOf(segments, yToX).map((n, i) => smoothed[i] ?? n) : pointNormalsOf(segments, yToX);
+      laneNormals.set(nodeId, normals);
+    }
+    return normals;
+  };
+  const laneWidths = /* @__PURE__ */ new Map();
+  const laneWidthOf = (id) => {
+    let width = laneWidths.get(id);
+    if (width === void 0) {
+      const node = nodeById.get(id);
+      width = walkLaneWidthPx(
+        node ? nodeWidthPx(node, contigThickness, nodeWidth, depthNorm) : contigThickness,
+        liftedWalks.length
+      );
+      laneWidths.set(id, width);
+    }
+    return width;
+  };
+  const laneShiftOf = (nodeId, index) => lines?.shifts.get(nodeId)?.[index] ?? NO_SHIFT;
+  const laneEndOf = (id, segments, atStart) => {
+    const at = atStart ? 0 : segments.length - 1;
+    return {
+      id,
+      laneWidth: laneWidthOf(id),
+      normal: laneNormalsOf(id, segments)[at] ?? { nx: 0, ny: 0 },
+      shift: laneShiftOf(id, at)
+    };
+  };
+  const lanesMayShow = (curves, fromId) => {
+    if (!viewportBounds) {
+      return true;
+    }
+    const offset = threaded ? bandWidthPx(lanePasses) * thinned : (liftedWalks.length - 1) / 2 * laneWidthOf(fromId);
+    const reach = LONGEST_NORMAL * offset * worldPerScreenPx;
+    return isBezierInBounds(
+      curves,
+      viewportBounds,
+      reach + (fields?.furthestShift.dx ?? 0),
+      reach / yToX + (fields?.furthestShift.dy ?? 0)
+    );
+  };
+  const threadPairs = (lane, from, to) => {
+    const own = threads?.[lane]?.linkThreads;
+    if (!own?.size) {
+      return FIRST_THREADS;
+    }
+    const ahead = own.get(from)?.get(to);
+    const back = linksOf(graph).get(to)?.has(from) ? void 0 : own.get(to)?.get(from);
+    if (!back) {
+      return ahead ?? FIRST_THREADS;
+    }
+    const turned = back.map(([a, b]) => [b, a]);
+    return ahead ? [...ahead, ...turned] : turned;
+  };
+  const lanePointsOf = (nodeId, segments) => lines?.shifts.has(nodeId) ? segments.map((p, i) => {
+    const { dx, dy } = laneShiftOf(nodeId, i);
+    return { ...p, x: p.x + dx, y: p.y + dy };
+  }) : segments;
   const showArrows = scale > (linearLayout ? 1 : MIN_ARROW_SCALE);
   for (let ei = 0; ei < graph.edges.length; ei++) {
     const edge = graph.edges[ei];
@@ -516,18 +645,47 @@ function buildGeometry(options) {
     const toNode = nodeById.get(edge.to);
     const intoHalfWidth = (toNode ? nodeWidthPx(toNode, contigThickness, nodeWidth, depthNorm) : contigThickness) / 2;
     const inView = (curves) => !viewportBounds || isBezierInBounds(curves, viewportBounds);
+    const dashesOf = (curves) => dashSpans(curves, DELETION_DASH_PX / scale, yToX, viewportBounds);
     const stroke = (curves, thickness, color) => {
-      if (isDeletion) {
-        for (const dash of dashCurves(
-          curves,
-          DELETION_DASH_PX / scale,
-          yToX,
-          viewportBounds
-        )) {
-          edgeCurves.push({ curves: dash, thickness, color });
-        }
-      } else {
+      if (!isDeletion) {
         edgeCurves.push({ curves, thickness, color });
+        return;
+      }
+      for (const dash of dashesOf(curves)) {
+        edgeCurves.push({ curves: dash.curves, thickness, color });
+      }
+    };
+    const laneStroke = (curves, thickness, color, walk, pass, normal2, offsetX, endNormal, endOffsetX) => {
+      if (!isDeletion) {
+        edgeCurves.push({
+          curves,
+          thickness,
+          color,
+          walk,
+          pass,
+          normal: normal2,
+          offsetX,
+          endNormal,
+          endOffsetX
+        });
+        return;
+      }
+      const start = { normal: normal2, offsetX };
+      const end = { normal: endNormal, offsetX: endOffsetX };
+      for (const dash of dashesOf(curves)) {
+        const a = dash.startAlong === 0 ? start : laneSlideAt(start, end, dash.startAlong);
+        const b = dash.endAlong === 1 ? end : laneSlideAt(start, end, dash.endAlong);
+        edgeCurves.push({
+          curves: dash.curves,
+          thickness,
+          color,
+          walk,
+          pass,
+          normal: a.normal,
+          offsetX: a.offsetX,
+          endNormal: b.normal,
+          endOffsetX: b.offsetX
+        });
       }
     };
     const arrowOn = (curves) => {
@@ -548,35 +706,57 @@ function buildGeometry(options) {
     const edgeCurveStart = edgeCurves.length;
     const arrowStart = arrows.length;
     const laneWalks = highlight?.walks.length && onWalk && !ribbons ? highlight.walks : void 0;
+    if (laneWalks && !lanesMayShow(baseCurves, edge.from)) {
+      continue;
+    }
     if (laneWalks) {
-      const fromNode = nodeById.get(edge.from);
-      const width = fromNode ? nodeWidthPx(fromNode, contigThickness, nodeWidth, depthNorm) : contigThickness;
-      const laneWidth = walkLaneWidthPx(width, laneWalks.length);
-      const normals = pointNormalsOf(fromSegments, yToX);
-      const { nx, ny } = (leavesStart(
-        edge,
+      const from = laneEndOf(
+        edge.from,
         fromSegments,
-        baseCurves[0],
-        stranded,
-        yToX
-      ) ? normals[0] : normals.at(-1)) ?? {
-        nx: 0,
-        ny: 0
-      };
-      laneWalks.forEach((walk, lane) => {
+        leavesStart(edge, fromSegments, baseCurves[0], stranded, yToX)
+      );
+      const last = baseCurves.at(-1);
+      const to = threaded ? laneEndOf(
+        edge.to,
+        toSegments,
+        nearerStart({ x: last.x1, y: last.y1 }, toSegments, yToX)
+      ) : from;
+      const single = laneWalks.length === 1;
+      const thickness = laneHalfWidth(from.laneWidth);
+      for (let lane = 0; lane < laneWalks.length; lane++) {
+        const walk = laneWalks[lane];
         if (!walk.edgeIndexes.has(ei)) {
-          return;
+          continue;
         }
-        const offset = (lane - (laneWalks.length - 1) / 2) * laneWidth * worldPerScreenPx;
-        const curves = offset === 0 ? baseCurves : translateCurves(baseCurves, nx * offset, ny * offset / yToX);
-        if (inView(curves)) {
-          stroke(
-            curves,
-            laneWidth / 2,
-            walk.colors.get(edge.from) ?? walk.colors.get(edge.to) ?? plainEdgeColor
+        for (const [pass, toPass] of threadPairs(lane, edge.from, edge.to)) {
+          const offsetX = single ? 0 : laneOffset(from.id, from.laneWidth, lane, pass) * worldPerScreenPx;
+          const endOffsetX = threaded ? laneOffset(to.id, to.laneWidth, lane, toPass) * worldPerScreenPx : offsetX;
+          const curves = threaded ? slideCurves(
+            baseCurves,
+            from.shift.dx + from.normal.nx * offsetX,
+            from.shift.dy + from.normal.ny * offsetX / yToX,
+            to.shift.dx + to.normal.nx * endOffsetX,
+            to.shift.dy + to.normal.ny * endOffsetX / yToX
+          ) : offsetX === 0 ? baseCurves : translateCurves(
+            baseCurves,
+            from.normal.nx * offsetX,
+            from.normal.ny * offsetX / yToX
           );
+          if (inView(curves)) {
+            laneStroke(
+              curves,
+              thickness,
+              walk.colors.get(edge.from) ?? walk.colors.get(edge.to) ?? plainEdgeColor,
+              lane,
+              pass,
+              from.normal,
+              offsetX,
+              to.normal,
+              endOffsetX
+            );
+          }
         }
-      });
+      }
       if (edgeCurves.length > edgeCurveStart) {
         arrowOn(baseCurves);
       }
@@ -644,19 +824,38 @@ function buildGeometry(options) {
     const lanes = highlight?.walks.length && !faded && !slots?.length ? highlight.walks : void 0;
     if (drawable && lanes) {
       const laneWidth = walkLaneWidthPx(width, lanes.length);
-      const normals = pointNormalsOf(segments, yToX);
-      lanes.forEach((walk, lane) => {
-        const laneColor = walk.colors.get(nodeId);
+      const normals = lanes.length > 1 ? laneNormalsOf(nodeId, segments) : [];
+      const points = lanes.length > 1 ? lanePointsOf(nodeId, segments) : segments;
+      const thickness = laneHalfWidth(laneWidth);
+      for (let lane = 0; lane < lanes.length; lane++) {
+        const laneColor = lanes[lane].colors.get(nodeId);
         if (laneColor === void 0) {
-          return;
+          continue;
         }
-        const offset = (lane - (lanes.length - 1) / 2) * laneWidth * worldPerScreenPx;
-        nodeStrokes.push({
-          points: lanes.length === 1 ? segments : offsetPolyline(segments, normals, offset, yToX),
-          thickness: laneWidth / 2,
-          color: laneColor
-        });
-      });
+        const onThreads = threads?.[lane]?.nodeThreads.get(nodeId) ?? ONE_PASS;
+        for (const pass of onThreads) {
+          if (lanes.length === 1) {
+            nodeStrokes.push({
+              points: segments,
+              thickness,
+              color: laneColor,
+              walk: lane,
+              pass
+            });
+            continue;
+          }
+          const offsetX = laneOffset(nodeId, laneWidth, lane, pass) * worldPerScreenPx;
+          nodeStrokes.push({
+            points: offsetPolyline(points, normals, offsetX, yToX),
+            thickness,
+            color: laneColor,
+            walk: lane,
+            pass,
+            normals,
+            offsetX
+          });
+        }
+      }
     } else if (drawable && slots?.length && slotWidth >= MIN_PATH_STRIPE_PX) {
       const normals = pointNormalsOf(segments, yToX);
       for (const slot of slots) {

package/dist/chunks/{chunk-2T3V6Z3M.js → chunk-GYJMPVOU.js}

@@ -1,7 +1,7 @@
 import {
   computeColorSchemeRange,
   getNodeColor
-} from "./chunk-VXKL2ZLR.js";
+} from "./chunk-GDZQFELP.js";
 import {
   abgrToCssRgba
 } from "./chunk-G2FD7S3C.js";

package/dist/chunks/{chunk-BFUS3ENH.js → chunk-HEYIAMTC.js}

@@ -1,9 +1,9 @@
 import {
   polylineSlice
-} from "./chunk-2VMKQKVO.js";
+} from "./chunk-HNNP5QUN.js";
 import {
   svgPath
-} from "./chunk-VACK24HF.js";
+} from "./chunk-JJV2GT2Z.js";
 import {
   firstNodeAtOrAfter,
   isAnchored

package/dist/chunks/{chunk-HMEAGAGC.js → chunk-HIN56TLA.js}

@@ -6,10 +6,10 @@ import {
 } from "./chunk-MYDHU2UV.js";
 import {
   readColor
-} from "./chunk-SDI6BVG7.js";
+} from "./chunk-KKHXMJEE.js";
 import {
   referenceWalkName
-} from "./chunk-G7SG4XMK.js";
+} from "./chunk-LODKC7PJ.js";
 import {
   pathOrigin
 } from "./chunk-3YBP46PB.js";

package/dist/chunks/{chunk-2VMKQKVO.js → chunk-HNNP5QUN.js}

@@ -1,7 +1,7 @@
 import {
   ownStrand,
   strandSides
-} from "./chunk-VACK24HF.js";
+} from "./chunk-JJV2GT2Z.js";
 import {
   pushTo
 } from "./chunk-BSOZW3FC.js";

package/dist/chunks/{chunk-W5YRBEWQ.js → chunk-I53QYITQ.js}

@@ -1,6 +1,6 @@
 import {
   formatBp
-} from "./chunk-N73RA4DR.js";
+} from "./chunk-AURNOR27.js";
 import {
   pushTo
 } from "./chunk-BSOZW3FC.js";

package/dist/chunks/{chunk-UTDMFVC7.js → chunk-I5CHAYDZ.js}

@@ -4,27 +4,27 @@ import {
 import {
   facetLifts,
   walkLift
-} from "./chunk-Z4HXW6ZH.js";
+} from "./chunk-ZWBQ4RRK.js";
 import {
   buildGeometry,
   computeReferenceRamp
-} from "./chunk-VXKL2ZLR.js";
+} from "./chunk-GDZQFELP.js";
 import {
   walkKey
-} from "./chunk-SG7VQB4F.js";
+} from "./chunk-IZKM4NY7.js";
 import {
   walkRowsExtent
-} from "./chunk-SENPGW4O.js";
+} from "./chunk-VCUOYVLC.js";
 import {
   pathLegend,
   walkLabelsOf
-} from "./chunk-GD6RUZU5.js";
+} from "./chunk-VQ353UDK.js";
 import {
   FIGURE_DEFAULTS
-} from "./chunk-4SN7R4UF.js";
+} from "./chunk-2MXFG3W7.js";
 import {
   drawingBounds
-} from "./chunk-XKPXOIWD.js";
+} from "./chunk-JVT3XTKN.js";
 import {
   referenceLabel
 } from "./chunk-5ORP7EFJ.js";
@@ -34,7 +34,7 @@ import {
 import {
   deletionDrawing,
   deletionEdges
-} from "./chunk-P276TWPM.js";
+} from "./chunk-3GORESBG.js";
 import {
   facetCells,
   facetSettingOf

package/dist/chunks/{chunk-EPOPGV5G.js → chunk-IXLT3JJX.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-H2H4Y3TV.js";
 import {
   REFERENCE_RAMP_ALT_CSS
-} from "./chunk-VXKL2ZLR.js";
+} from "./chunk-GDZQFELP.js";
 import {
   RAMP_GRADIENT_CSS,
   RAMP_GRADIENT_STOPS,

package/dist/chunks/{chunk-SG7VQB4F.js → chunk-IZKM4NY7.js}

@@ -5,7 +5,7 @@ import {
 import {
   formatBp,
   groupDigits
-} from "./chunk-N73RA4DR.js";
+} from "./chunk-AURNOR27.js";
 
 // src/walkKey.ts
 function rangeText(contig, start, end) {

package/dist/chunks/{chunk-KMLATBNT.js → chunk-J7RNXBXA.js}

@@ -1,6 +1,6 @@
 import {
   coversGraph
-} from "./chunk-BLDUBB7X.js";
+} from "./chunk-SZYFZNCO.js";
 import {
   bubblesFromGraph,
   derivedBubble,
@@ -10,13 +10,13 @@ import {
 } from "./chunk-RFG42VIO.js";
 import {
   bubbleSegmentIds
-} from "./chunk-AWJJSA7D.js";
+} from "./chunk-NWEVR2OQ.js";
 import {
   bubbleSubgraph
 } from "./chunk-MHZTTLBU.js";
 import {
   strandSides
-} from "./chunk-VACK24HF.js";
+} from "./chunk-JJV2GT2Z.js";
 import {
   pushTo
 } from "./chunk-BSOZW3FC.js";

package/dist/chunks/{chunk-VACK24HF.js → chunk-JJV2GT2Z.js}

@@ -97,7 +97,8 @@ function visibleStretches(curves, lengths, bounds, yToX) {
   });
   return stretches;
 }
-function dashCurves(curves, dashWorld, yToX = 1, bounds) {
+var dashCurves = (curves, dashWorld, yToX = 1, bounds) => dashSpans(curves, dashWorld, yToX, bounds).map((d) => d.curves);
+function dashSpans(curves, dashWorld, yToX = 1, bounds) {
   const lengths = curves.map(
     (c) => Math.hypot(c.cx0 - c.x0, (c.cy0 - c.y0) * yToX) + Math.hypot(c.cx1 - c.cx0, (c.cy1 - c.cy0) * yToX) + Math.hypot(c.x1 - c.cx1, (c.y1 - c.cy1) * yToX)
   );
@@ -122,27 +123,57 @@ function dashCurves(curves, dashWorld, yToX = 1, bounds) {
       }
     }
     const dash = [];
+    const along = [];
     let start = 0;
     curves.forEach((c, k) => {
       const length = lengths[k];
       const end = start + length;
       if (length > 0 && end > from && start < to) {
-        dash.push(
-          subCurve(
-            c,
-            Math.max(0, (from - start) / length),
-            Math.min(1, (to - start) / length)
-          )
-        );
+        const t0 = Math.max(0, (from - start) / length);
+        const t1 = Math.min(1, (to - start) / length);
+        dash.push(subCurve(c, t0, t1));
+        along.push((k + t0) / curves.length, (k + t1) / curves.length);
       }
       start = end;
     });
     if (dash.length) {
-      out.push(dash);
+      out.push({
+        curves: dash,
+        startAlong: along[0],
+        endAlong: along.at(-1)
+      });
     }
   }
   return out;
 }
+var slideAt = (from, to, along) => ({
+  dx: from.dx + (to.dx - from.dx) * along,
+  dy: from.dy + (to.dy - from.dy) * along
+});
+function slideCurves(curves, fromDx, fromDy, toDx, toDy) {
+  const n = curves.length;
+  const out = new Array(n);
+  for (let i = 0; i < n; i++) {
+    const c = curves[i];
+    const a = i / n;
+    const b = (i + 1) / n;
+    const adx = fromDx + (toDx - fromDx) * a;
+    const ady = fromDy + (toDy - fromDy) * a;
+    const bdx = fromDx + (toDx - fromDx) * b;
+    const bdy = fromDy + (toDy - fromDy) * b;
+    out[i] = {
+      x0: c.x0 + adx,
+      y0: c.y0 + ady,
+      cx0: c.cx0 + adx,
+      cy0: c.cy0 + ady,
+      cx1: c.cx1 + bdx,
+      cy1: c.cy1 + bdy,
+      x1: c.x1 + bdx,
+      y1: c.y1 + bdy
+    };
+  }
+  return out;
+}
 function translateCurves(curves, dx, dy) {
   const out = new Array(curves.length);
   for (let i = 0; i < curves.length; i++) {
@@ -555,6 +586,9 @@ export {
   curveMidpoint,
   curveBounds,
   dashCurves,
+  dashSpans,
+  slideAt,
+  slideCurves,
   translateCurves,
   ownStrand,
   strandSides,

package/dist/chunks/{chunk-PKGPSTRW.js → chunk-JO2T77NW.js}

@@ -3,14 +3,14 @@ import {
   boxesGenes,
   rowPitch,
   rowSpan
-} from "./chunk-EPOPGV5G.js";
+} from "./chunk-IXLT3JJX.js";
 import {
   el
 } from "./chunk-H2H4Y3TV.js";
 import {
   READOUT_ROOM,
   longestBar
-} from "./chunk-SENPGW4O.js";
+} from "./chunk-VCUOYVLC.js";
 import {
   LABEL_CHAR_PX
 } from "./chunk-AB35TJST.js";