@jbrowse/bandage-core 11.8.0 → 11.9.0

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

@@ -1,19 +1,13 @@
 import {
-  LANE_SMOOTHING_PX,
   THREAD_PITCH_PX,
   THREAD_PX,
-  THREAD_REACH_PX,
-  THREAD_TAPER_PX,
   bandScale,
-  bandSpans,
   bandWidthPx,
-  laneLines,
-  laneRuns,
   laneSlideAt,
+  liftLanes,
   slotCentres,
-  threadsPasses,
-  walkThreads
-} from "./chunk-7GDNDQD7.js";
+  threadsPasses
+} from "./chunk-3BDQQTXY.js";
 import {
   abgrToCssRgba,
   fadeAbgr,
@@ -26,13 +20,13 @@ import {
 } from "./chunk-GQZVR5DW.js";
 import {
   baseEdgeCurves
-} from "./chunk-VSRRIFRF.js";
+} from "./chunk-P2GJBFNA.js";
 import {
   PATH_LIGHTNESS,
   PATH_SATURATION,
   nameHue,
   pathHueAt
-} from "./chunk-JKIAHYAW.js";
+} from "./chunk-VQ353UDK.js";
 import {
   meanDepth,
   nodeWidthPx,
@@ -41,6 +35,9 @@ import {
 import {
   referenceMidpoints
 } from "./chunk-VX656OAZ.js";
+import {
+  weakMemo
+} from "./chunk-HMXCN6PG.js";
 import {
   dashSpans,
   pathRibbonOffsets,
@@ -49,7 +46,7 @@ import {
   strandSides,
   translateCurves,
   yToXOf
-} from "./chunk-735MPLUL.js";
+} from "./chunk-JJV2GT2Z.js";
 import {
   pushTo
 } from "./chunk-BSOZW3FC.js";
@@ -194,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) => {
@@ -203,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;
@@ -413,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;
     }
   }
@@ -465,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,
@@ -520,53 +541,26 @@ function buildGeometry(options) {
   const threaded = threadsPasses(liftedWalks);
   const lanePasses = liftedWalks.map((w) => w.mostPasses);
   const thinned = threaded ? bandScale(lanePasses) : 1;
-  const runs = liftedWalks.length > 1 ? laneRuns(
-    liftedWalks.flatMap((w) => w.route),
-    nodePositions,
-    yToX,
-    LANE_SMOOTHING_PX * worldPerScreenPx
-  ) : void 0;
-  const lines = runs ? laneLines(
-    runs,
-    nodePositions,
-    yToX,
-    LANE_SMOOTHING_PX * worldPerScreenPx,
-    bandWidthPx(lanePasses) * thinned * worldPerScreenPx,
-    threaded
-  ) : void 0;
-  const threads = threaded ? liftedWalks.map(
-    (w) => walkThreads(
-      w.route,
-      w.passes,
-      nodePositions,
-      yToX,
-      THREAD_REACH_PX * worldPerScreenPx
-    )
-  ) : void 0;
-  const spanField = runs && threads ? bandSpans(
-    runs,
-    threads.map((t) => t.span),
-    {
-      reach: THREAD_REACH_PX * worldPerScreenPx,
-      taper: THREAD_TAPER_PX * worldPerScreenPx
-    }
+  const fields = highlight && liftedWalks.length > 1 ? lanesCache(
+    highlight,
+    [nodePositions, version, axis.scaleX, axis.scaleY],
+    () => liftLanes(liftedWalks, nodePositions, yToX, worldPerScreenPx)
   ) : void 0;
-  const edgeKeys = new Set(
-    threads ? graph.edges.map((e) => `${e.from}>${e.to}`) : []
-  );
+  const lines = fields?.lines;
+  const threads = fields?.threads;
+  const spanField = fields?.spans;
+  const plainCentres = threaded ? slotCentres(lanePasses, lanePasses) : [];
   const centresByNode = /* @__PURE__ */ new Map();
-  const laneOffset = (nodeId, laneWidth, lane, pass) => {
-    if (!threaded) {
-      return (lane - (liftedWalks.length - 1) / 2) * laneWidth;
-    }
+  const centresOf = (nodeId) => {
     let centres = centresByNode.get(nodeId);
     if (!centres) {
       const spans = spanField?.get(nodeId);
-      centres = slotCentres(spans?.slot ?? lanePasses, lanePasses, spans?.held);
+      centres = spans ? slotCentres(spans.slot, lanePasses, spans.held) : plainCentres;
       centresByNode.set(nodeId, centres);
     }
-    return (centres[lane] + pass * THREAD_PITCH_PX) * thinned;
+    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) => {
@@ -579,7 +573,54 @@ function buildGeometry(options) {
     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 };
@@ -604,37 +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 stroke = (curves, thickness, color, lane) => {
-      const push = (pieces, from = 0, to = 1) => {
-        if (!lane) {
-          edgeCurves.push({ curves: pieces, thickness, color });
-          return;
-        }
-        const start = from === 0 ? lane.start : laneSlideAt(lane.start, lane.end, from);
-        const end = to === 1 ? lane.end : laneSlideAt(lane.start, lane.end, to);
+    const dashesOf = (curves) => dashSpans(curves, DELETION_DASH_PX / scale, yToX, viewportBounds);
+    const stroke = (curves, thickness, color) => {
+      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: pieces,
+          curves,
           thickness,
           color,
-          walk: lane.walk,
-          pass: lane.pass,
-          normal: start.normal,
-          offsetX: start.offsetX,
-          endNormal: end.normal,
-          endOffsetX: end.offsetX
+          walk,
+          pass,
+          normal: normal2,
+          offsetX,
+          endNormal,
+          endOffsetX
         });
-      };
-      if (!isDeletion) {
-        push(curves);
         return;
       }
-      for (const dash of dashSpans(
-        curves,
-        DELETION_DASH_PX / scale,
-        yToX,
-        viewportBounds
-      )) {
-        push(dash.curves, dash.startAlong, dash.endAlong);
+      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) => {
@@ -655,89 +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 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,
-            laneWalks.length
-          );
-          laneWidths.set(id, width);
-        }
-        return width;
-      };
-      const endOf = (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 from = endOf(
+      const from = laneEndOf(
         edge.from,
         fromSegments,
         leavesStart(edge, fromSegments, baseCurves[0], stranded, yToX)
       );
       const last = baseCurves.at(-1);
-      const to = threaded ? endOf(
+      const to = threaded ? laneEndOf(
         edge.to,
         toSegments,
         nearerStart({ x: last.x1, y: last.y1 }, toSegments, yToX)
       ) : from;
-      const slideOf = (end, offsetX) => ({
-        dx: end.shift.dx + end.normal.nx * offsetX,
-        dy: end.shift.dy + end.normal.ny * offsetX / yToX
-      });
-      const aheadKey = threads ? `${edge.from}>${edge.to}` : "";
-      const backKey = threads ? `${edge.to}>${edge.from}` : "";
-      const pairsOf = (lane) => {
-        const own = threads?.[lane]?.linkThreads;
-        if (!own?.size) {
-          return FIRST_THREADS;
-        }
-        const ahead = own.get(aheadKey);
-        const back = edgeKeys.has(backKey) ? void 0 : own.get(backKey);
-        if (!back) {
-          return ahead ?? FIRST_THREADS;
-        }
-        const turned = back.map(([a, b]) => [b, a]);
-        return ahead ? [...ahead, ...turned] : turned;
-      };
       const single = laneWalks.length === 1;
-      laneWalks.forEach((walk, lane) => {
+      const thickness = laneHalfWidth(from.laneWidth);
+      for (let lane = 0; lane < laneWalks.length; lane++) {
+        const walk = laneWalks[lane];
         if (!walk.edgeIndexes.has(ei)) {
-          return;
+          continue;
         }
-        for (const [pass, toPass] of pairsOf(lane)) {
+        for (const [pass, toPass] of threadPairs(lane, edge.from, edge.to)) {
           const offsetX = single ? 0 : laneOffset(from.id, from.laneWidth, lane, pass) * worldPerScreenPx;
-          const start = { normal: from.normal, offsetX };
-          const end = threaded ? {
-            normal: to.normal,
-            offsetX: laneOffset(to.id, to.laneWidth, lane, toPass) * worldPerScreenPx
-          } : start;
+          const endOffsetX = threaded ? laneOffset(to.id, to.laneWidth, lane, toPass) * worldPerScreenPx : offsetX;
           const curves = threaded ? slideCurves(
             baseCurves,
-            slideOf(from, start.offsetX),
-            slideOf(to, end.offsetX)
+            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)) {
-            stroke(
+            laneStroke(
               curves,
-              laneHalfWidth(from.laneWidth),
+              thickness,
               walk.colors.get(edge.from) ?? walk.colors.get(edge.to) ?? plainEdgeColor,
-              { walk: lane, pass, start, end }
+              lane,
+              pass,
+              from.normal,
+              offsetX,
+              to.normal,
+              endOffsetX
             );
           }
         }
-      });
+      }
       if (edgeCurves.length > edgeCurveStart) {
         arrowOn(baseCurves);
       }
@@ -807,34 +826,36 @@ function buildGeometry(options) {
       const laneWidth = walkLaneWidthPx(width, lanes.length);
       const normals = lanes.length > 1 ? laneNormalsOf(nodeId, segments) : [];
       const points = lanes.length > 1 ? lanePointsOf(nodeId, segments) : segments;
-      lanes.forEach((walk, lane) => {
-        const laneColor = walk.colors.get(nodeId);
+      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 onThreads = threads?.[lane]?.nodeThreads.get(nodeId) ?? ONE_PASS;
-        const thickness = laneHalfWidth(laneWidth);
-        onThreads.forEach((pass) => {
-          const offsetX = lanes.length === 1 ? 0 : laneOffset(nodeId, laneWidth, lane, pass) * worldPerScreenPx;
-          nodeStrokes.push(
-            lanes.length === 1 ? {
+        for (const pass of onThreads) {
+          if (lanes.length === 1) {
+            nodeStrokes.push({
               points: segments,
               thickness,
               color: laneColor,
               walk: lane,
               pass
-            } : {
-              points: offsetPolyline(points, normals, offsetX, yToX),
-              thickness,
-              color: laneColor,
-              walk: lane,
-              pass,
-              normals,
-              offsetX
-            }
-          );
-        });
-      });
+            });
+            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-ZKIH2USC.js → chunk-GYJMPVOU.js}

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

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

@@ -1,9 +1,9 @@
 import {
   polylineSlice
-} from "./chunk-YIWN32ZX.js";
+} from "./chunk-HNNP5QUN.js";
 import {
   svgPath
-} from "./chunk-735MPLUL.js";
+} from "./chunk-JJV2GT2Z.js";
 import {
   firstNodeAtOrAfter,
   isAnchored

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

@@ -6,7 +6,7 @@ import {
 } from "./chunk-MYDHU2UV.js";
 import {
   readColor
-} from "./chunk-J4PDHWP2.js";
+} from "./chunk-KKHXMJEE.js";
 import {
   referenceWalkName
 } from "./chunk-LODKC7PJ.js";

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

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

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

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

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

@@ -4,27 +4,27 @@ import {
 import {
   facetLifts,
   walkLift
-} from "./chunk-YF6T33PU.js";
+} from "./chunk-ZWBQ4RRK.js";
 import {
   buildGeometry,
   computeReferenceRamp
-} from "./chunk-2H3ALI6L.js";
+} from "./chunk-GDZQFELP.js";
 import {
   walkKey
-} from "./chunk-SDDMV2MM.js";
+} from "./chunk-IZKM4NY7.js";
 import {
   walkRowsExtent
 } from "./chunk-VCUOYVLC.js";
 import {
   pathLegend,
   walkLabelsOf
-} from "./chunk-JKIAHYAW.js";
+} from "./chunk-VQ353UDK.js";
 import {
   FIGURE_DEFAULTS
-} from "./chunk-6MD4VS2F.js";
+} from "./chunk-2MXFG3W7.js";
 import {
   drawingBounds
-} from "./chunk-S3ICPPXC.js";
+} from "./chunk-JVT3XTKN.js";
 import {
   referenceLabel
 } from "./chunk-5ORP7EFJ.js";
@@ -34,7 +34,7 @@ import {
 import {
   deletionDrawing,
   deletionEdges
-} from "./chunk-3CXZUC2Y.js";
+} from "./chunk-3GORESBG.js";
 import {
   facetCells,
   facetSettingOf

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

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

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

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

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

@@ -1,6 +1,6 @@
 import {
   coversGraph
-} from "./chunk-4YPCUVMC.js";
+} from "./chunk-SZYFZNCO.js";
 import {
   bubblesFromGraph,
   derivedBubble,
@@ -10,13 +10,13 @@ import {
 } from "./chunk-RFG42VIO.js";
 import {
   bubbleSegmentIds
-} from "./chunk-OIOAK7BS.js";
+} from "./chunk-NWEVR2OQ.js";
 import {
   bubbleSubgraph
 } from "./chunk-MHZTTLBU.js";
 import {
   strandSides
-} from "./chunk-735MPLUL.js";
+} from "./chunk-JJV2GT2Z.js";
 import {
   pushTo
 } from "./chunk-BSOZW3FC.js";

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

@@ -150,21 +150,29 @@ var slideAt = (from, to, along) => ({
   dx: from.dx + (to.dx - from.dx) * along,
   dy: from.dy + (to.dy - from.dy) * along
 });
-function slideCurves(curves, from, to) {
-  return curves.map((c, i) => {
-    const a = slideAt(from, to, i / curves.length);
-    const b = slideAt(from, to, (i + 1) / curves.length);
-    return {
-      x0: c.x0 + a.dx,
-      y0: c.y0 + a.dy,
-      cx0: c.cx0 + a.dx,
-      cy0: c.cy0 + a.dy,
-      cx1: c.cx1 + b.dx,
-      cy1: c.cy1 + b.dy,
-      x1: c.x1 + b.dx,
-      y1: c.y1 + b.dy
+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);