@jbrowse/bandage-core 10.2.7 → 10.3.1

package/dist/chunks/{chunk-VQWHMWLF.js → chunk-M5NPD55W.js}

@@ -1,11 +1,15 @@
 import {
   GBZ_CUT_DEFAULTS,
+  NoReferenceSampleError,
+  aliasedSample,
   cutWindowGFA,
   haplotypeWanted,
   referencePathQuery,
-  referenceSamplesOf,
-  resolveReferenceSample
-} from "./chunk-Q7LYHGGQ.js";
+  referenceSamplesOf
+} from "./chunk-GIHTHYXY.js";
+import {
+  panSNSample
+} from "./chunk-4XWZNPQ2.js";
 
 // src/gbzCut.ts
 import { GBZBase } from "@gmod/gbz-base";
@@ -13,6 +17,9 @@ var HPRC_GBZ = {
   db: "https://s3-us-west-2.amazonaws.com/human-pangenomics/pangenomes/freeze/release2/minigraph-cactus/v2.1/hprc-v2.1-mc-grch38/hprc-v2.1-mc-grch38.gbz.db",
   index: "https://jbrowse.org/demos/hprc/hprc-v2.1-mc-grch38.haplotype-index.f3.db"
 };
+function gbzLocations({ db, index }) {
+  return db === "hprc" ? { db: HPRC_GBZ.db, index: index ?? HPRC_GBZ.index } : { db, index };
+}
 function haplotypeIndexBeside(db) {
   const GBZ_DB = /\.gbz\.db$/i;
   return GBZ_DB.test(db) ? db.replace(GBZ_DB, ".haplotype-index.db") : void 0;
@@ -36,18 +43,14 @@ async function openGbz(db, index) {
   return { base, referenceSamples: await referenceSamplesOf(base) };
 }
 function referenceSample(ref, samples) {
-  try {
-    return resolveReferenceSample({
-      configured: "",
-      anchorPrefix: ref ?? samples[0] ?? "",
-      referenceSamples: samples
-    });
-  } catch (e) {
-    if (ref) {
-      return ref;
-    }
-    throw e;
+  if (ref) {
+    return aliasedSample(panSNSample(ref), samples) ?? ref;
+  }
+  const first = samples[0];
+  if (first === void 0) {
+    throw new NoReferenceSampleError("", samples);
   }
+  return first;
 }
 async function cutGbzRegion({ base, referenceSamples }, src, signal) {
   const region = parseRegion(src.region);
@@ -70,6 +73,7 @@ async function cutGbzRegion({ base, referenceSamples }, src, signal) {
 
 export {
   HPRC_GBZ,
+  gbzLocations,
   haplotypeIndexBeside,
   parseRegion,
   openGbz,

package/dist/chunks/chunk-MWOVW4AH.js

@@ -0,0 +1,327 @@
+import {
+  pathSteps
+} from "./chunk-FW2R7UDZ.js";
+import {
+  pathOrigin
+} from "./chunk-B5X2RLJG.js";
+import {
+  PathVisitsBuilder
+} from "./chunk-ZPZ7GNBT.js";
+import {
+  isBackbone
+} from "./chunk-RJWPJCIB.js";
+import {
+  partitionPoint
+} from "./chunk-HOAIOEI7.js";
+
+// src/tubeMap/coarsen.ts
+function readWalk(path, steps) {
+  const runs = [];
+  const open = () => ({ a: -Infinity, b: Infinity, detour: [], bp: 0 });
+  const gaps = [open()];
+  for (const { node, strand } of steps) {
+    const gap = gaps.at(-1);
+    const last = runs.at(-1);
+    if (isBackbone(node)) {
+      const start = node.stable.start;
+      const end = start + node.length;
+      const inverted = strand !== (node.stable.strand ?? "+");
+      const joins = last !== void 0 && gap.detour.length === 0;
+      if (joins && !last.inverted && !inverted && last.end === start) {
+        last.end = end;
+      } else if (joins && last.inverted && inverted && last.start === end) {
+        last.start = start;
+      } else {
+        runs.push({ start, end, inverted });
+        gaps.push(open());
+      }
+    } else {
+      gap.detour.push({ node, strand });
+      gap.bp += node.length;
+    }
+  }
+  runs.forEach((run, i) => {
+    gaps[i].b = run.start;
+    gaps[i + 1].a = run.end;
+  });
+  return { path, runs, gaps };
+}
+function isSmall(gap, sigma) {
+  return Number.isFinite(gap.a) && Number.isFinite(gap.b) && gap.b >= gap.a && Math.max(gap.b - gap.a, gap.bp) < sigma;
+}
+function strictlyInside(cuts, a, b) {
+  const i = partitionPoint(cuts.length, (j) => cuts[j] <= a);
+  return i < cuts.length && cuts[i] < b;
+}
+function referenceGaps(backbone) {
+  const cuts = /* @__PURE__ */ new Map();
+  for (let i = 1; i < backbone.length; i++) {
+    const prev = backbone[i - 1];
+    const node = backbone[i];
+    const end = prev.stable.start + prev.length;
+    if (end !== node.stable.start) {
+      cuts.set(end, "reference-gap");
+      cuts.set(node.stable.start, "reference-gap");
+    }
+  }
+  return cuts;
+}
+function findCuts(walks, sigma, cuts) {
+  const cut = (bp, cause) => {
+    if (Number.isFinite(bp) && !cuts.has(bp)) {
+      cuts.set(bp, cause);
+    }
+  };
+  for (const { runs, gaps } of walks) {
+    const first = runs[0];
+    const last = runs.at(-1);
+    if (first && last) {
+      cut(first.start, "walk-end");
+      cut(last.end, "walk-end");
+    }
+    for (const run of runs) {
+      if (run.inverted && run.end - run.start >= sigma) {
+        cut(run.start, "inversion");
+        cut(run.end, "inversion");
+      }
+    }
+    for (const gap of gaps) {
+      if (gap.b < gap.a) {
+        cut(gap.a, "backward");
+        cut(gap.b, "backward");
+      } else if (!isSmall(gap, sigma)) {
+        cut(gap.a, "variant");
+        cut(gap.b, "variant");
+      }
+    }
+  }
+  const spans = walks.flatMap(({ runs, gaps }) => [
+    ...gaps.filter((g) => isSmall(g, sigma)).map((g) => [g.a, g.b]),
+    ...runs.filter((r) => r.inverted && r.end - r.start < sigma).map((r) => [r.start, r.end])
+  ]);
+  for (let changed = true; changed; ) {
+    changed = false;
+    const sorted = [...cuts.keys()].sort((x, y) => x - y);
+    for (const [a, b] of spans) {
+      if (strictlyInside(sorted, a, b)) {
+        changed ||= !cuts.has(a) || !cuts.has(b);
+        cut(a, "overlap");
+        cut(b, "overlap");
+      }
+    }
+  }
+  return cuts;
+}
+function mergeReference(backbone, cuts) {
+  const merged = [];
+  let group = [];
+  const close = () => {
+    const first = group[0];
+    const last = group.at(-1);
+    if (first && last) {
+      const bp0 = first.stable.start;
+      const bp1 = last.stable.start + last.length;
+      const name = `${bp0}-${bp1}`;
+      merged.push({
+        node: {
+          id: `${name}+`,
+          name,
+          length: bp1 - bp0,
+          depth: 0,
+          stable: {
+            refName: first.stable.refName,
+            start: bp0,
+            rank: 0,
+            strand: "+"
+          }
+        },
+        members: group
+      });
+    }
+    group = [];
+  };
+  for (const node of backbone) {
+    if (cuts.has(node.stable.start)) {
+      close();
+    }
+    group.push(node);
+  }
+  close();
+  return merged;
+}
+function lastAtMost(items, key, x) {
+  return Math.max(0, partitionPoint(items.length, (i) => key(items[i]) <= x) - 1);
+}
+function coarsenTubeMap(graph, sigma) {
+  const backbone = graph.nodes.filter(isBackbone).sort((a, b) => a.stable.start - b.stable.start);
+  const paths = graph.paths ?? [];
+  if (backbone.length === 0 || paths.length === 0) {
+    return void 0;
+  }
+  const stepsOf = pathSteps(graph);
+  const walks = paths.map((p, i) => readWalk(p, stepsOf[i]));
+  const cuts = findCuts(walks, sigma, referenceGaps(backbone));
+  const sortedCuts = [...cuts.keys()].sort((x, y) => x - y);
+  const merged = mergeReference(backbone, cuts);
+  const mergedAt = (bp) => lastAtMost(merged, (m) => m.node.stable.start, bp);
+  const members = /* @__PURE__ */ new Map();
+  const coarseOf = /* @__PURE__ */ new Map();
+  for (const m of merged) {
+    members.set(
+      m.node.id,
+      m.members.map((n) => n.id)
+    );
+    for (const n of m.members) {
+      coarseOf.set(n.id, m.node.id);
+    }
+  }
+  const routes = /* @__PURE__ */ new Map();
+  const routeFor = (gap) => {
+    const key = `${gap.a}	${gap.b}	${gap.detour.map((s) => s.node.id + s.strand).join(",")}`;
+    let node = routes.get(key);
+    if (!node) {
+      const name = `r${routes.size}`;
+      node = {
+        id: `${name}+`,
+        name,
+        length: gap.bp,
+        depth: 0,
+        stable: {
+          refName: backbone[0].stable.refName,
+          start: Number.isFinite(gap.a) ? gap.a : gap.b,
+          rank: 1,
+          strand: "+"
+        }
+      };
+      routes.set(key, node);
+      members.set(
+        node.id,
+        gap.detour.map((s) => s.node.id)
+      );
+      for (const s of gap.detour) {
+        if (!coarseOf.has(s.node.id)) {
+          coarseOf.set(s.node.id, node.id);
+        }
+      }
+    }
+    return node;
+  };
+  const deviations = /* @__PURE__ */ new Map();
+  const coarsePaths = [];
+  const pathVisits = new PathVisitsBuilder();
+  const edges = /* @__PURE__ */ new Map();
+  const depth = /* @__PURE__ */ new Map();
+  for (const { path, runs, gaps } of walks) {
+    const steps = [];
+    const devs = [];
+    let continuing = false;
+    const append = (node, strand) => {
+      const last = steps.at(-1);
+      if (!(continuing && last?.node === node && last.strand === strand)) {
+        steps.push({ node, strand });
+      }
+      continuing = true;
+    };
+    const structural = (gap) => {
+      continuing = false;
+      if (gap.detour.length > 0) {
+        append(routeFor(gap), "+");
+        continuing = false;
+      }
+    };
+    const fold = (gap) => {
+      if (gap.bp > 0 || gap.b > gap.a) {
+        devs.push({ start: gap.a, end: gap.b, bp: gap.bp });
+      }
+      const home = merged[mergedAt(gap.b > gap.a ? gap.a : gap.a - 1)];
+      for (const s of gap.detour) {
+        if (!coarseOf.has(s.node.id)) {
+          coarseOf.set(s.node.id, home.node.id);
+          members.get(home.node.id).push(s.node.id);
+        }
+      }
+    };
+    runs.forEach((run, i) => {
+      const gap = gaps[i];
+      if (isSmall(gap, sigma) && !strictlyInside(sortedCuts, gap.a, gap.b)) {
+        fold(gap);
+      } else {
+        structural(gap);
+      }
+      const i0 = mergedAt(run.start);
+      const i1 = mergedAt(run.end - 1);
+      const small = run.end - run.start < sigma;
+      if (run.inverted && !small) {
+        continuing = false;
+        for (let j = i1; j >= i0; j--) {
+          append(merged[j].node, "-");
+        }
+        continuing = false;
+      } else {
+        if (run.inverted) {
+          devs.push({
+            start: run.start,
+            end: run.end,
+            bp: run.end - run.start,
+            inverted: true
+          });
+        }
+        for (let j = i0; j <= i1; j++) {
+          append(merged[j].node, "+");
+        }
+      }
+    });
+    structural(gaps.at(-1));
+    const visitName = pathOrigin(path.name).name;
+    let pos = 0;
+    steps.forEach(({ node, strand }, i) => {
+      depth.set(node.id, (depth.get(node.id) ?? 0) + 1);
+      pathVisits.add(
+        node.name,
+        visitName,
+        path.sample ?? visitName,
+        pos,
+        strand === "-"
+      );
+      pos += node.length;
+      const next = steps[i + 1];
+      if (next) {
+        const key = `${node.id}${strand}	${next.node.id}${next.strand}`;
+        const edge = edges.get(key);
+        if (edge) {
+          edge.pathIds.push(path.name);
+        } else {
+          edges.set(key, {
+            from: node.id,
+            to: next.node.id,
+            fromStrand: strand,
+            toStrand: next.strand,
+            pathIds: [path.name]
+          });
+        }
+      }
+    });
+    coarsePaths.push({ ...path, nodeIds: steps.map((s) => s.node.id) });
+    deviations.set(path.name, devs);
+  }
+  const nodes = [...merged.map((m) => m.node), ...routes.values()].filter((n) => depth.has(n.id)).map((n) => ({ ...n, depth: depth.get(n.id) }));
+  return {
+    graph: {
+      ...graph,
+      nodes,
+      edges: [...edges.values()],
+      paths: coarsePaths,
+      pathVisits: pathVisits.build(),
+      reads: void 0
+    },
+    members,
+    coarseOf,
+    deviations,
+    cuts
+  };
+}
+
+export {
+  lastAtMost,
+  coarsenTubeMap
+};

package/dist/chunks/{chunk-HK5Y2YWV.js → chunk-MYDHU2UV.js}

@@ -1,3 +1,7 @@
+import {
+  partitionPoint
+} from "./chunk-HOAIOEI7.js";
+
 // src/tubeMap/warp.ts
 var MAX_GAP_PX = 24;
 var MAX_GAP_SHARE = 0.5;
@@ -55,17 +59,8 @@ function warpX(knots, tx) {
   if (tx >= last.tx) {
     return last.sx + (tx - last.tx);
   }
-  let lo = 0;
-  let hi = n - 1;
-  while (hi - lo > 1) {
-    const mid = lo + hi >> 1;
-    if (knots[mid].tx <= tx) {
-      lo = mid;
-    } else {
-      hi = mid;
-    }
-  }
-  const a = knots[lo];
+  const hi = 1 + partitionPoint(n - 2, (i) => knots[i + 1].tx <= tx);
+  const a = knots[hi - 1];
   const b = knots[hi];
   const span = b.tx - a.tx;
   return span > 0 ? a.sx + (tx - a.tx) / span * (b.sx - a.sx) : a.sx;

package/dist/chunks/{chunk-TZFWUT2C.js → chunk-MYLAJDKB.js}

@@ -1,9 +1,9 @@
 import {
   projectAlleles
-} from "./chunk-RVS2QCOX.js";
+} from "./chunk-3GLG3ZLE.js";
 import {
   buildNeighbors
-} from "./chunk-ES2N6V56.js";
+} from "./chunk-VX656OAZ.js";
 
 // src/layout/placeOffReference.ts
 var MIN_DELETION_BP = 1;

package/dist/chunks/{chunk-AR4BUBMU.js → chunk-NZTYV3JL.js}

@@ -4,10 +4,10 @@ import {
 import {
   pathOrigin,
   surveyPaths
-} from "./chunk-M6LK4GII.js";
+} from "./chunk-B5X2RLJG.js";
 
 // src/gfa/gfaConverter.ts
-function surveySegments(gfaGraph) {
+function surveySegments(gfaGraph, pathSteps) {
   const canonical = /* @__PURE__ */ new Map();
   const traversals = /* @__PURE__ */ new Map();
   function claim(id, strand) {
@@ -26,36 +26,35 @@ function surveySegments(gfaGraph) {
     claim(link.source, link.strand1 === "-" ? "-" : "+");
     claim(link.target, link.strand2 === "-" ? "-" : "+");
   }
-  for (const gfaPath of gfaGraph.paths) {
-    for (const segment of gfaPath.path.split(",")) {
-      traverse(segment.slice(0, -1), segment.endsWith("-") ? "-" : "+");
+  for (const { steps } of pathSteps) {
+    for (const step of steps) {
+      traverse(step.id, step.strand);
     }
   }
   for (const walk of gfaGraph.walks) {
-    for (const seg of walk.segments) {
-      traverse(seg.id, seg.strand === "-" ? "-" : "+");
+    for (const step of walk.segments) {
+      traverse(step.id, step.strand);
     }
   }
   return { canonical, traversals };
 }
 var walkStart = (w) => w.start === -1 ? 0 : w.start;
-var stranded = (s) => s.strand === "+" || s.strand === "-";
-function anchorablePaths(gfaGraph) {
+function stepsOfPath(p) {
+  return {
+    ...pathOrigin(p.name),
+    steps: p.path.split(",").map((segment) => ({
+      id: segment.slice(0, -1),
+      strand: segment.endsWith("-") ? "-" : "+"
+    }))
+  };
+}
+function anchorablePaths(gfaGraph, pathSteps) {
   return [
-    ...gfaGraph.paths.map((p) => ({
-      ...pathOrigin(p.name),
-      steps: p.path.split(",").map((segment) => ({
-        id: segment.slice(0, -1),
-        strand: segment.endsWith("-") ? "-" : "+"
-      }))
-    })),
+    ...pathSteps,
     ...gfaGraph.walks.map((w) => ({
       name: `${w.sample}#${w.haplotype}#${w.contig}`,
       start: walkStart(w),
-      steps: w.segments.every(stranded) ? w.segments : w.segments.map((s) => ({
-        id: s.id,
-        strand: s.strand === "-" ? "-" : "+"
-      }))
+      steps: w.segments
     }))
   ];
 }
@@ -85,7 +84,8 @@ function makeNode(gfaNode, strand, depth) {
 function convertGFAToGraph(gfaGraph, name = "Imported GFA") {
   const nodes = [];
   const edges = [];
-  const { canonical, traversals } = surveySegments(gfaGraph);
+  const pathSteps = gfaGraph.paths.map(stepsOfPath);
+  const { canonical, traversals } = surveySegments(gfaGraph, pathSteps);
   const nodeIds = /* @__PURE__ */ new Map();
   const nodeId = (segmentId) => {
     let id = nodeIds.get(segmentId);
@@ -95,12 +95,12 @@ function convertGFAToGraph(gfaGraph, name = "Imported GFA") {
     }
     return id;
   };
-  const declared = /* @__PURE__ */ new Set();
+  const lengths = /* @__PURE__ */ new Map();
   for (const gfaNode of gfaGraph.nodes) {
-    if (declared.has(gfaNode.id)) {
+    if (lengths.has(gfaNode.id)) {
       continue;
     }
-    declared.add(gfaNode.id);
+    lengths.set(gfaNode.id, gfaNode.length);
     const depth = statedDepth(gfaNode) ?? Math.max(traversals.get(gfaNode.id) ?? 1, 1);
     nodes.push(makeNode(gfaNode, canonical.get(gfaNode.id) ?? "+", depth));
   }
@@ -137,15 +137,12 @@ function convertGFAToGraph(gfaGraph, name = "Imported GFA") {
       pairPaths(nodeIds2[i], nodeIds2[i + 1])?.add(name2);
     }
   }
-  for (const gfaPath of gfaGraph.paths) {
-    const nodeIds2 = gfaPath.path.split(",").map((segment) => nodeId(segment.slice(0, -1)));
-    paths.push({
-      name: gfaPath.name,
-      nodeIds: nodeIds2,
-      start: pathOrigin(gfaPath.name).start
-    });
-    recordPathEdges(nodeIds2, gfaPath.name);
-  }
+  gfaGraph.paths.forEach(({ name: name2 }, i) => {
+    const { start, steps } = pathSteps[i];
+    const nodeIds2 = steps.map((step) => nodeId(step.id));
+    paths.push({ name: name2, nodeIds: nodeIds2, start });
+    recordPathEdges(nodeIds2, name2);
+  });
   for (const walk of gfaGraph.walks) {
     const nodeIds2 = walk.segments.map((seg) => nodeId(seg.id));
     const name2 = `${walk.sample}#${walk.haplotype}#${walk.contig}`;
@@ -165,8 +162,10 @@ function convertGFAToGraph(gfaGraph, name = "Imported GFA") {
       edge.pathIds = [...pathIds];
     }
   });
-  const lengths = new Map(gfaGraph.nodes.map((n) => [n.id, n.length]));
-  const anchoring = gfaGraph.paths.length > 0 || gfaGraph.walks.length > 0 ? surveyPaths(anchorablePaths(gfaGraph), (id) => lengths.get(id) ?? 0) : void 0;
+  const anchoring = gfaGraph.paths.length > 0 || gfaGraph.walks.length > 0 ? surveyPaths(
+    anchorablePaths(gfaGraph, pathSteps),
+    (id) => lengths.get(id) ?? 0
+  ) : void 0;
   return {
     name,
     nodes,

package/dist/chunks/{chunk-4HWM3FNK.js → chunk-OMUPUB4J.js}

@@ -1,12 +1,15 @@
 import {
   EdgeSpatialIndex,
   SpatialIndex
-} from "./chunk-KBEP7VYK.js";
+} from "./chunk-3VCKBSML.js";
+import {
+  weakMemo
+} from "./chunk-HMXCN6PG.js";
 import {
   pathRibbonOffsets,
   translateCurves,
   yToXOf
-} from "./chunk-7SRWJLSC.js";
+} from "./chunk-UBQSRCWR.js";
 
 // src/util/hitDetection.ts
 function distanceToSegment(px, py, x1, y1, x2, y2) {
@@ -19,40 +22,26 @@ function distanceToSegment(px, py, x1, y1, x2, y2) {
   const t = Math.max(0, Math.min(1, ((px - x1) * dx + (py - y1) * dy) / lenSq));
   return Math.hypot(px - (x1 + t * dx), py - (y1 + t * dy));
 }
-function distanceToCubicBezier(px, py, x1, y1, cx1, cy1, cx2, cy2, x2, y2) {
+function distanceToCubicBezier(px, py, c) {
   let minDist = Infinity;
   const samples = 20;
-  let lastX = x1;
-  let lastY = y1;
+  let lastX = c.x0;
+  let lastY = c.y0;
   for (let i = 1; i <= samples; i++) {
     const t = i / samples;
     const u = 1 - t;
-    const bx = u * u * u * x1 + 3 * u * u * t * cx1 + 3 * u * t * t * cx2 + t * t * t * x2;
-    const by = u * u * u * y1 + 3 * u * u * t * cy1 + 3 * u * t * t * cy2 + t * t * t * y2;
+    const bx = u * u * u * c.x0 + 3 * u * u * t * c.cx0 + 3 * u * t * t * c.cx1 + t * t * t * c.x1;
+    const by = u * u * u * c.y0 + 3 * u * u * t * c.cy0 + 3 * u * t * t * c.cy1 + t * t * t * c.y1;
     minDist = Math.min(minDist, distanceToSegment(px, py, lastX, lastY, bx, by));
     lastX = bx;
     lastY = by;
   }
   return minDist;
 }
-function distanceToBezierCurve(px, py, c) {
-  return distanceToCubicBezier(
-    px,
-    py,
-    c.x0,
-    c.y0,
-    c.cx0,
-    c.cy0,
-    c.cx1,
-    c.cy1,
-    c.x1,
-    c.y1
-  );
-}
 function distanceToEdgeCurves(px, py, curves, yToX = 1) {
   let minDist = Infinity;
   for (const c of curves) {
-    const d = distanceToBezierCurve(
+    const d = distanceToCubicBezier(
       px,
       py,
       yToX === 1 ? c : {
@@ -72,45 +61,39 @@ function distanceToEdgeCurves(px, py, curves, yToX = 1) {
   }
   return minDist;
 }
-var nodeCache = /* @__PURE__ */ new WeakMap();
+var nodeCache = weakMemo();
 function getSpatialIndex(nodePositions, version) {
-  const cached = nodeCache.get(nodePositions);
-  if (cached?.version === version) {
-    return cached.index;
-  }
-  const index = new SpatialIndex(nodePositions);
-  nodeCache.set(nodePositions, { version, index });
-  return index;
+  return nodeCache(
+    nodePositions,
+    [version],
+    () => new SpatialIndex(nodePositions)
+  );
 }
-var edgeCache = /* @__PURE__ */ new WeakMap();
+var edgeCache = weakMemo();
 function getEdgeSpatialIndex(nodePositions, graph, drawPaths, axis, version, deletions, routes, stranded = false) {
-  const cached = edgeCache.get(nodePositions);
-  if (cached?.graph === graph && cached.drawPaths === drawPaths && cached.scaleX === axis.scaleX && cached.scaleY === axis.scaleY && cached.version === version && cached.deletions === deletions && cached.routes === routes && cached.stranded === stranded) {
-    return cached.index;
-  }
-  const index = new EdgeSpatialIndex(
+  return edgeCache(
     nodePositions,
-    graph,
-    drawPaths,
-    axis,
-    void 0,
-    deletions,
-    version,
-    routes,
-    stranded
+    [
+      graph,
+      drawPaths,
+      axis.scaleX,
+      axis.scaleY,
+      version,
+      deletions,
+      routes,
+      stranded
+    ],
+    () => new EdgeSpatialIndex(
+      nodePositions,
+      graph,
+      drawPaths,
+      axis,
+      deletions,
+      version,
+      routes,
+      stranded
+    )
   );
-  edgeCache.set(nodePositions, {
-    graph,
-    drawPaths,
-    scaleX: axis.scaleX,
-    scaleY: axis.scaleY,
-    version,
-    index,
-    deletions,
-    routes,
-    stranded
-  });
-  return index;
 }
 var MIN_NODE_REACH_PX = 5;
 function findHoveredNode(nodePositions, graphX, graphY, axis, version = 0, ink) {