@jbrowse/bandage-core 11.8.0 → 11.10.0

package/dist/chunks/{chunk-2H3ALI6L.js → chunk-53DZE3SA.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-4KBZ7WPP.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,55 @@ 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 threadColor = (lane, nodeId, thread) => liftedWalks[lane]?.passColors.get(nodeId)?.[threads?.[lane]?.threadPasses.get(nodeId)?.[thread] ?? 0];
   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 +646,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 +707,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),
-              walk.colors.get(edge.from) ?? walk.colors.get(edge.to) ?? plainEdgeColor,
-              { walk: lane, pass, start, end }
+              thickness,
+              threadColor(lane, edge.from, pass) ?? threadColor(lane, edge.to, toPass) ?? plainEdgeColor,
+              lane,
+              pass,
+              from.normal,
+              offsetX,
+              to.normal,
+              endOffsetX
             );
           }
         }
-      });
+      }
       if (edgeCurves.length > edgeCurveStart) {
         arrowOn(baseCurves);
       }
@@ -807,34 +827,37 @@ 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) {
+          const color2 = threadColor(lane, nodeId, pass) ?? laneColor;
+          if (lanes.length === 1) {
+            nodeStrokes.push({
               points: segments,
               thickness,
-              color: laneColor,
+              color: color2,
               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: color2,
+            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-YF6T33PU.js → chunk-54C73ICS.js}

@@ -1,10 +1,11 @@
 import {
   encodedColor,
-  resolveEncoding
-} from "./chunk-N4AJV4GH.js";
+  resolveEncoding,
+  splitFamilies
+} from "./chunk-UVRCXTBY.js";
 import {
   rampFraction
-} from "./chunk-2H3ALI6L.js";
+} from "./chunk-53DZE3SA.js";
 import {
   gapParts
 } from "./chunk-LG2UK4MB.js";
@@ -54,6 +55,7 @@ function highlightOf(graph, name, { byId, edgeAt }) {
   const nodeIds = /* @__PURE__ */ new Set();
   const edgeIndexes = /* @__PURE__ */ new Set();
   const progress = /* @__PURE__ */ new Map();
+  const passProgress = /* @__PURE__ */ new Map();
   const passes = /* @__PURE__ */ new Map();
   let mostPasses = 1;
   let before = 0;
@@ -74,8 +76,15 @@ function highlightOf(graph, name, { byId, edgeAt }) {
         }
       }
       const length = lengthOf(id);
+      const at = span > 0 ? (before + length / 2) / span : 0;
       if (!progress.has(id)) {
-        progress.set(id, span > 0 ? (before + length / 2) / span : 0);
+        progress.set(id, at);
+      }
+      const seen = passProgress.get(id);
+      if (seen) {
+        seen.push(at);
+      } else {
+        passProgress.set(id, [at]);
       }
       before += length;
     });
@@ -112,6 +121,7 @@ function highlightOf(graph, name, { byId, edgeAt }) {
     nodeIds,
     edgeIndexes,
     progress,
+    passProgress,
     passes,
     mostPasses,
     route: pieces.map((piece) => piece.nodeIds),
@@ -124,12 +134,17 @@ function highlightOf(graph, name, { byId, edgeAt }) {
 }
 function laneColors(byId, walk, encoding, ramp) {
   const colors = /* @__PURE__ */ new Map();
-  for (const [id, progress] of walk.progress) {
+  const passColors = /* @__PURE__ */ new Map();
+  for (const [id, progress] of walk.passProgress) {
     const node = byId.get(id);
-    const t = encoding.field === "progress" ? progress : ramp && node ? rampFraction(node, ramp) : void 0;
-    colors.set(id, encodedColor(encoding, t));
+    const atNode = ramp && node ? rampFraction(node, ramp) : void 0;
+    const each = progress.map(
+      (t) => encodedColor(encoding, encoding.field === "progress" ? t : atNode)
+    );
+    colors.set(id, each[0]);
+    passColors.set(id, each);
   }
-  return colors;
+  return { colors, passColors };
 }
 function reversedNodes(graph, byId, walk) {
   const reversed = /* @__PURE__ */ new Set();
@@ -167,18 +182,23 @@ function walkLift(graph, layers, ramp) {
     return void 0;
   }
   let picked = 0;
-  const walks = lifted.map(({ walk, layer }) => {
-    const encoding = resolveEncoding(
-      layer,
-      walk.reference,
-      walk.reference ? 0 : picked++,
-      lifted.length === 1
-    );
+  const encodings = splitFamilies(
+    lifted.map(
+      ({ walk, layer }) => resolveEncoding(
+        layer,
+        walk.reference,
+        walk.reference ? 0 : picked++,
+        lifted.length === 1
+      )
+    )
+  );
+  const walks = lifted.map(({ walk }, i) => {
+    const encoding = encodings[i];
     const { reversed, bp } = reversedNodes(graph, index.byId, walk);
     return {
       ...walk,
       encoding,
-      colors: laneColors(index.byId, walk, encoding, ramp),
+      ...laneColors(index.byId, walk, encoding, ramp),
       reversed,
       reversedBp: bp
     };
@@ -200,7 +220,7 @@ function facetLifts(graph, lift, layers, ramp) {
         {
           ...walk,
           encoding,
-          colors: laneColors(byId, walk, encoding, ramp)
+          ...laneColors(byId, walk, encoding, ramp)
         }
       ],
       ramp

package/dist/chunks/{chunk-U6JPSXJ3.js → chunk-55DRWHBF.js}

@@ -3,30 +3,30 @@ import {
 } from "./chunk-CO6RGQAD.js";
 import {
   layoutModeByValue
-} from "./chunk-3XYLEK4H.js";
+} from "./chunk-ARXDNQLF.js";
 import {
   parseRegion
 } from "./chunk-FNDNSDKW.js";
 import {
   genePins
-} from "./chunk-X5ULFAMM.js";
+} from "./chunk-HEYIAMTC.js";
 import {
   version
-} from "./chunk-L2RQV23D.js";
+} from "./chunk-2NCZ5YYN.js";
 import {
   axisScaleOf
-} from "./chunk-2RCKHCF7.js";
+} from "./chunk-3DHGSHC3.js";
 import {
   figureScene
-} from "./chunk-R3NPBUKT.js";
+} from "./chunk-YQAZNH37.js";
 import {
   encodingStops
-} from "./chunk-N4AJV4GH.js";
+} from "./chunk-UVRCXTBY.js";
 import {
   laneSlideAt,
   passesKey,
   threadsPasses
-} from "./chunk-7GDNDQD7.js";
+} from "./chunk-4KBZ7WPP.js";
 import {
   abgrAlpha,
   abgrBlue,
@@ -35,13 +35,13 @@ import {
 } from "./chunk-G2FD7S3C.js";
 import {
   FIGURE_DEFAULTS
-} from "./chunk-6MD4VS2F.js";
+} from "./chunk-2MXFG3W7.js";
 import {
   engineSettingsOf,
   fitTransform,
   forceLayout,
   loadGraph
-} from "./chunk-S3ICPPXC.js";
+} from "./chunk-JVT3XTKN.js";
 import {
   referenceVisitStarts
 } from "./chunk-3YBP46PB.js";

package/dist/chunks/{chunk-4OVIUCSB.js → chunk-77O67GIB.js}

@@ -3,7 +3,7 @@ import {
   boxesGenes,
   rowPitch,
   rowSpan
-} from "./chunk-LA6JHEVV.js";
+} from "./chunk-ALOF5SOT.js";
 import {
   el
 } from "./chunk-H2H4Y3TV.js";

package/dist/chunks/{chunk-7PEYA3NA.js → chunk-7YSIP3O2.js}

@@ -1,10 +1,10 @@
 import {
   baseEdgeCurves
-} from "./chunk-VSRRIFRF.js";
+} from "./chunk-P2GJBFNA.js";
 import {
   curveBounds,
   pathRibbonOffsets
-} from "./chunk-735MPLUL.js";
+} from "./chunk-JJV2GT2Z.js";
 
 // src/util/SpatialIndex.ts
 var FALLBACK_CELL_SIZE = 50;