@jbrowse/bandage-core 11.7.3 → 11.8.0

package/dist/chunks/{chunk-VACK24HF.js → chunk-735MPLUL.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,49 @@ 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, 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 translateCurves(curves, dx, dy) {
   const out = new Array(curves.length);
   for (let i = 0; i < curves.length; i++) {
@@ -555,6 +578,9 @@ export {
   curveMidpoint,
   curveBounds,
   dashCurves,
+  dashSpans,
+  slideAt,
+  slideCurves,
   translateCurves,
   ownStrand,
   strandSides,

package/dist/chunks/chunk-7GDNDQD7.js

@@ -0,0 +1,504 @@
+import {
+  slideAt
+} from "./chunk-735MPLUL.js";
+
+// src/renderer/walkLanes.ts
+var THREAD_PX = 2;
+var THREAD_GAP_PX = 1.5;
+var SLOT_GAP_PX = 4;
+var LANE_SMOOTHING_PX = 12;
+var THREAD_REACH_PX = 64;
+var THREAD_TAPER_PX = 24;
+var MAX_BAND_PX = 48;
+var PASSES_KEY = "a thread per pass through a node";
+var threadsPasses = (walks) => walks.length > 1 && walks.some((w) => w.mostPasses > 1);
+var threadsWidth = (threads) => threads * THREAD_PX + Math.max(0, threads - 1) * THREAD_GAP_PX;
+var sum = (values) => values.reduce((a, b) => a + b, 0);
+function slotLayout(spans, mostPasses, laneWidth) {
+  const widths = spans.map(
+    (m, i) => mostPasses[i] > 1 ? threadsWidth(m) : laneWidth * Math.min(1, m)
+  );
+  let seen = 0;
+  const gaps = spans.map((m) => {
+    const share = Math.min(1, m);
+    const gap = SLOT_GAP_PX * share * seen;
+    seen = Math.max(seen, share);
+    return gap;
+  });
+  return { widths, gaps, band: sum(widths) + sum(gaps) };
+}
+var THREAD_PITCH_PX = THREAD_PX + THREAD_GAP_PX;
+function slotCentres(spans, mostPasses, held = spans) {
+  const { widths, gaps, band } = slotLayout(spans, mostPasses, THREAD_PX);
+  let at = -band / 2;
+  return widths.map((width, i) => {
+    at += gaps[i];
+    const slack = mostPasses[i] > 1 ? Math.max(0, width - threadsWidth(held[i])) : 0;
+    const centre = at + slack / 2 + THREAD_PX / 2;
+    at += width;
+    return centre;
+  });
+}
+var bandWidthPx = (mostPasses) => slotLayout(mostPasses, mostPasses, THREAD_PX).band;
+var bandScale = (mostPasses) => Math.min(1, MAX_BAND_PX / (bandWidthPx(mostPasses) || 1));
+var passesKey = (walks) => bandScale(walks.map((w) => w.mostPasses)) < 1 ? `${PASSES_KEY}, thinned to fit` : PASSES_KEY;
+function laneSlideAt(start, end, along) {
+  const vector = ({ normal, offsetX: offsetX2 }) => ({
+    dx: normal.nx * offsetX2,
+    dy: normal.ny * offsetX2
+  });
+  const { dx, dy } = slideAt(vector(start), vector(end), along);
+  const offsetX = Math.hypot(dx, dy);
+  return offsetX > 0 ? { normal: { nx: dx / offsetX, ny: dy / offsetX }, offsetX } : { normal: { nx: 0, ny: 0 }, offsetX: 0 };
+}
+var gapOf = (a, b) => Math.hypot(b.x - a.x, b.y - a.y);
+function arcOf(run) {
+  const s = [0];
+  for (let i = 1; i < run.length; i++) {
+    s.push(s[i - 1] + gapOf(run[i - 1], run[i]));
+  }
+  return s;
+}
+function laneRuns(routes, nodePositions, yToX, jump) {
+  const seen = /* @__PURE__ */ new Set();
+  const owns = routes.map(
+    (route) => route.map((id) => {
+      const first = !!nodePositions[id]?.length && !seen.has(id);
+      seen.add(id);
+      return first;
+    })
+  );
+  const gap = (a, b) => Math.hypot(b.x - a.x, b.y * yToX - a.y);
+  const runs = [];
+  const owned = [];
+  let run = [];
+  let mine = [];
+  const breakRun = () => {
+    if (run.length) {
+      runs.push(run);
+      owned.push(mine);
+    }
+    run = [];
+    mine = [];
+  };
+  routes.forEach((route, r) => {
+    if (!owns[r].includes(true)) {
+      return;
+    }
+    route.forEach((id, step) => {
+      const segments = nodePositions[id];
+      if (!segments?.length) {
+        breakRun();
+        return;
+      }
+      const first = segments[0];
+      const last = segments.at(-1);
+      const prev = run.at(-1);
+      const next = nodePositions[route[step + 1] ?? ""];
+      const toNext = (p) => {
+        const at = { x: p.x, y: p.y * yToX };
+        return next?.length ? Math.min(gap(at, next[0]), gap(at, next.at(-1))) : 0;
+      };
+      const forward = prev ? gap(prev, first) <= gap(prev, last) : toNext(last) <= toNext(first);
+      if (prev && gap(prev, forward ? first : last) > jump) {
+        breakRun();
+      }
+      const middle = Math.floor(segments.length / 2);
+      for (let k = 0; k < segments.length; k++) {
+        const index = forward ? k : segments.length - 1 - k;
+        const p = segments[index];
+        run.push({
+          x: p.x,
+          y: p.y * yToX,
+          id,
+          index,
+          middle: index === middle,
+          forward
+        });
+        mine.push(owns[r][step]);
+      }
+    });
+    breakRun();
+  });
+  return { runs, owned };
+}
+function ownedWindows(s, owned, margin) {
+  const windows = [];
+  for (let i = 0; i < owned.length; i++) {
+    if (!owned[i]) {
+      continue;
+    }
+    let j = i;
+    while (j + 1 < owned.length && owned[j + 1]) {
+      j++;
+    }
+    const last = windows.at(-1);
+    const floor = last ? last[1] : 0;
+    let lo = i;
+    while (lo > floor && s[i] - s[lo - 1] <= margin) {
+      lo--;
+    }
+    let hi = j;
+    while (hi + 1 < s.length && s[hi + 1] - s[j] <= margin) {
+      hi++;
+    }
+    if (last && lo <= last[1] + 1) {
+      last[1] = hi;
+    } else {
+      windows.push([lo, hi]);
+    }
+    i = j;
+  }
+  return windows;
+}
+function smoothedNormals(run, reach) {
+  const s = arcOf(run);
+  const end = s.at(-1);
+  const pointAt = (at, j) => {
+    const a = run[j];
+    const b = run[Math.min(j + 1, run.length - 1)];
+    const span = s[Math.min(j + 1, run.length - 1)] - s[j];
+    const f = span > 0 ? (at - s[j]) / span : 0;
+    return { x: a.x + (b.x - a.x) * f, y: a.y + (b.y - a.y) * f };
+  };
+  let lo = 0;
+  let hi = 0;
+  return run.map((_, i) => {
+    const back = Math.max(0, s[i] - reach / 2);
+    const ahead = Math.min(end, s[i] + reach / 2);
+    while (lo < run.length - 1 && s[lo + 1] <= back) {
+      lo++;
+    }
+    while (hi < run.length - 1 && s[hi + 1] <= ahead) {
+      hi++;
+    }
+    const a = pointAt(back, lo);
+    const b = pointAt(ahead, hi);
+    const len = gapOf(a, b);
+    return len > 0 ? { nx: -(b.y - a.y) / len, ny: (b.x - a.x) / len } : void 0;
+  });
+}
+function cutCurls(run, close, length) {
+  const s = arcOf(run);
+  const out = run.slice();
+  const picks = [];
+  s.forEach((at, k) => {
+    const last = picks.at(-1);
+    if (last === void 0 || at - s[last] >= close / 4) {
+      picks.push(k);
+    }
+  });
+  if (picks.at(-1) !== run.length - 1) {
+    picks.push(run.length - 1);
+  }
+  let a = 0;
+  while (a < picks.length) {
+    const i = picks[a];
+    let to = -1;
+    for (let b = a + 1; b < picks.length && s[picks[b]] - s[i] <= length; b++) {
+      const j2 = picks[b];
+      if (s[j2] - s[i] > Math.PI * close && gapOf(run[i], run[j2]) <= close) {
+        to = b;
+      }
+    }
+    if (to < 0) {
+      a++;
+      continue;
+    }
+    const j = picks[to];
+    const p = run[i];
+    const q = run[j];
+    for (let k = i + 1; k < j; k++) {
+      const f = (s[k] - s[i]) / (s[j] - s[i]);
+      out[k] = {
+        ...run[k],
+        x: p.x + (q.x - p.x) * f,
+        y: p.y + (q.y - p.y) * f
+      };
+    }
+    a = to;
+  }
+  return out;
+}
+function rounded(run, half) {
+  const s = arcOf(run);
+  const end = s.at(-1);
+  const sums = [{ w: 0, x: 0, y: 0 }];
+  run.forEach((p, i) => {
+    const w = (s[Math.min(i + 1, run.length - 1)] - s[Math.max(i - 1, 0)]) / 2;
+    const last = sums[i];
+    sums.push({ w: last.w + w, x: last.x + w * p.x, y: last.y + w * p.y });
+  });
+  const firstAtOrAfter = (at) => {
+    let lo = 0;
+    let hi = s.length;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (s[mid] < at) {
+        lo = mid + 1;
+      } else {
+        hi = mid;
+      }
+    }
+    return lo;
+  };
+  return run.map((p, i) => {
+    const reach = Math.min(half, s[i], end - s[i]);
+    const lo = firstAtOrAfter(s[i] - reach);
+    const hi = firstAtOrAfter(s[i] + reach + 1e-9 * (1 + end));
+    const w = sums[hi].w - sums[lo].w;
+    return w > 0 ? {
+      x: (sums[hi].x - sums[lo].x) / w,
+      y: (sums[hi].y - sums[lo].y) / w
+    } : { x: p.x, y: p.y };
+  });
+}
+function fieldSetter(field, nodePositions) {
+  return ({ id, index }, value) => {
+    const own = field.get(id) ?? new Array(nodePositions[id].length);
+    own[index] = value;
+    field.set(id, own);
+  };
+}
+function laneLines(lanes, nodePositions, yToX, reach, band, smooth = true) {
+  const turn = Math.max(reach, 2 * band);
+  const curl = Math.PI * band;
+  const margin = smooth ? curl + band / 2 + turn / 2 : turn / 2;
+  const normals = /* @__PURE__ */ new Map();
+  const shifts = /* @__PURE__ */ new Map();
+  const setNormal = fieldSetter(normals, nodePositions);
+  const setShift = fieldSetter(shifts, nodePositions);
+  lanes.runs.forEach((run, r) => {
+    const owned = lanes.owned[r];
+    const pieces = ownedWindows(arcOf(run), owned, margin).map(([lo, hi]) => {
+      const points = run.slice(lo, hi + 1);
+      const line = smooth ? rounded(cutCurls(points, band / 2, curl), band / 2) : points;
+      return { lo, points, line, normals: smoothedNormals(line, turn) };
+    });
+    let agree = 0;
+    let along = 0;
+    for (const piece of pieces) {
+      piece.points.forEach((p, i) => {
+        const theirs = normals.get(p.id)?.[p.index];
+        const mine = piece.normals[i];
+        if (theirs && mine) {
+          agree += theirs.nx * mine.nx + theirs.ny * mine.ny;
+        }
+        along += p.forward ? 1 : -1;
+      });
+    }
+    const sign = (agree === 0 ? along : agree) < 0 ? -1 : 1;
+    for (const { lo, points, line, normals: own } of pieces) {
+      points.forEach((p, i) => {
+        if (!owned[lo + i]) {
+          return;
+        }
+        const n = own[i];
+        if (n) {
+          setNormal(p, sign > 0 ? n : { nx: -n.nx, ny: -n.ny });
+        }
+        if (smooth) {
+          setShift(p, {
+            dx: line[i].x - p.x,
+            dy: (line[i].y - p.y) / yToX
+          });
+        }
+      });
+    }
+  });
+  return { normals, shifts };
+}
+function windowed(s, v, half, sign) {
+  const out = new Array(v.length);
+  const deque = [];
+  let head = 0;
+  let next = 0;
+  for (let i = 0; i < v.length; i++) {
+    while (next < v.length && s[next] - s[i] <= half) {
+      while (deque.length > head && sign * v[deque.at(-1)] <= sign * v[next]) {
+        deque.pop();
+      }
+      deque.push(next++);
+    }
+    while (s[i] - s[deque[head]] > half) {
+      head++;
+    }
+    out[i] = v[deque[head]];
+  }
+  return out;
+}
+function windowMean(s, v, half, counted = () => true) {
+  const n = v.length;
+  const weight = s.map(
+    (_, i) => !counted(v[i]) ? 0 : n > 1 ? (s[Math.min(i + 1, n - 1)] - s[Math.max(i - 1, 0)]) / 2 : 1
+  );
+  const sumW = [0];
+  const sumWV = [0];
+  for (let i = 0; i < n; i++) {
+    sumW.push(sumW[i] + weight[i]);
+    sumWV.push(sumWV[i] + weight[i] * v[i]);
+  }
+  let lo = 0;
+  let hi = 0;
+  return v.map((value, i) => {
+    while (s[i] - s[lo] > half) {
+      lo++;
+    }
+    while (hi < n && s[hi] - s[i] <= half) {
+      hi++;
+    }
+    const w = sumW[hi] - sumW[lo];
+    return w > 0 ? (sumWV[hi] - sumWV[lo]) / w : value;
+  });
+}
+function walkThreads(route, passes, nodePositions, yToX, reach) {
+  if (![...passes.values()].some((p) => p > 1)) {
+    return { span: passes, nodeThreads: /* @__PURE__ */ new Map(), linkThreads: /* @__PURE__ */ new Map() };
+  }
+  const span = /* @__PURE__ */ new Map();
+  const visits = /* @__PURE__ */ new Map();
+  const wanted = /* @__PURE__ */ new Map();
+  const steps = [];
+  for (const piece of route) {
+    const points = [];
+    for (const id of piece) {
+      const segments = nodePositions[id];
+      const mid = segments?.[Math.floor(segments.length / 2)];
+      points.push(
+        mid ? { x: mid.x, y: mid.y * yToX } : points.at(-1) ?? { x: 0, y: 0 }
+      );
+    }
+    const s = arcOf(points);
+    const p = piece.map((id) => passes.get(id) ?? 1);
+    const most = windowed(s, p, reach / 2, 1);
+    const copy = piece.map((id) => {
+      const visit = (visits.get(id) ?? 0) + 1;
+      visits.set(id, visit);
+      return visit;
+    });
+    const full = p.map((v, i) => v === most[i]);
+    const before = [];
+    let last = -1;
+    for (let i = 0; i < piece.length; i++) {
+      last = full[i] ? i : last;
+      before.push(last);
+    }
+    const after = new Array(piece.length);
+    last = -1;
+    for (let i = piece.length - 1; i >= 0; i--) {
+      last = full[i] ? i : last;
+      after[i] = last;
+    }
+    const own = [];
+    piece.forEach((id, i) => {
+      const b = before[i];
+      const a = after[i];
+      const nearest = b < 0 ? a : a < 0 ? b : s[i] - s[b] <= s[a] - s[i] ? b : a;
+      const thread = Math.min(copy[nearest], most[i]) - 1;
+      span.set(id, Math.max(span.get(id) ?? 0, most[i]));
+      const list = wanted.get(id) ?? [];
+      list.push({ visit: copy[i], thread });
+      wanted.set(id, list);
+      own.push({ id, visit: copy[i] });
+    });
+    steps.push(own);
+  }
+  const threadOf = /* @__PURE__ */ new Map();
+  const nodeThreads = /* @__PURE__ */ new Map();
+  for (const [id, list] of wanted) {
+    const width = span.get(id);
+    const taken = /* @__PURE__ */ new Set();
+    const free = (want) => {
+      for (let d = 0; d < width; d++) {
+        for (const c of [want - d, want + d]) {
+          if (c >= 0 && c < width && !taken.has(c)) {
+            return c;
+          }
+        }
+      }
+      return want;
+    };
+    const byVisit = [];
+    for (const { visit, thread } of list) {
+      const t = free(thread);
+      taken.add(t);
+      byVisit[visit] = t;
+    }
+    threadOf.set(id, byVisit);
+    nodeThreads.set(
+      id,
+      [...taken].sort((a, b) => a - b)
+    );
+  }
+  const linkThreads = /* @__PURE__ */ new Map();
+  for (const own of steps) {
+    own.forEach((cur, i) => {
+      const prev = own[i - 1];
+      if (!prev) {
+        return;
+      }
+      const key = `${prev.id}>${cur.id}`;
+      const pair = [
+        threadOf.get(prev.id)[prev.visit],
+        threadOf.get(cur.id)[cur.visit]
+      ];
+      const list = linkThreads.get(key) ?? [];
+      if (!list.some(([a, b]) => a === pair[0] && b === pair[1])) {
+        list.push(pair);
+      }
+      linkThreads.set(key, list);
+    });
+  }
+  return { span, nodeThreads, linkThreads };
+}
+function bandSpans(lanes, spans, { reach, taper }) {
+  const out = /* @__PURE__ */ new Map();
+  lanes.runs.forEach((run, r) => {
+    const s = arcOf(run);
+    const mids = run.flatMap((p, i) => p.middle ? [i] : []);
+    const along = mids.map((i) => s[i]);
+    const owned = mids.map((i) => lanes.owned[r][i]);
+    for (const [lo, hi] of ownedWindows(along, owned, reach / 2 + taper / 2)) {
+      const at = along.slice(lo, hi + 1);
+      const ids = mids.slice(lo, hi + 1).map((i) => run[i].id);
+      const eased = spans.map((own) => {
+        const raw = ids.map((id) => own.get(id) ?? 0);
+        return raw.every((v) => v === raw[0]) ? { slot: raw, held: raw } : {
+          slot: windowMean(at, windowed(at, raw, reach / 2, 1), taper / 2),
+          held: windowMean(at, raw, taper / 2, (v) => v > 0)
+        };
+      });
+      ids.forEach((id, i) => {
+        if (owned[lo + i]) {
+          out.set(id, {
+            slot: eased.map((e) => e.slot[i]),
+            held: eased.map((e) => e.held[i])
+          });
+        }
+      });
+    }
+  });
+  return out;
+}
+
+export {
+  THREAD_PX,
+  THREAD_GAP_PX,
+  SLOT_GAP_PX,
+  LANE_SMOOTHING_PX,
+  THREAD_REACH_PX,
+  THREAD_TAPER_PX,
+  MAX_BAND_PX,
+  PASSES_KEY,
+  threadsPasses,
+  THREAD_PITCH_PX,
+  slotCentres,
+  bandWidthPx,
+  bandScale,
+  passesKey,
+  laneSlideAt,
+  laneRuns,
+  laneLines,
+  walkThreads,
+  bandSpans
+};

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

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

package/dist/chunks/{chunk-XTCIKBWM.js → chunk-AXE3RR7J.js}

@@ -1,6 +1,6 @@
 import {
   pathSteps
-} from "./chunk-63XWYNID.js";
+} from "./chunk-G4WQBRDS.js";
 import {
   pathOrigin
 } from "./chunk-3YBP46PB.js";

package/dist/chunks/{chunk-BXE3SBBN.js → chunk-C3KAPREU.js}

@@ -1,7 +1,7 @@
 import {
   walkRowRuns,
   walkRowsOf
-} from "./chunk-G7SG4XMK.js";
+} from "./chunk-LODKC7PJ.js";
 
 // src/layout/walkRows.ts
 function filterSamples(rows, samples) {

package/dist/chunks/{chunk-QJC63NFR.js → chunk-G3GLGDKV.js}

@@ -1,10 +1,10 @@
 import {
   nodesUnderBox
-} from "./chunk-LH436HS2.js";
+} from "./chunk-NHOXLUIL.js";
 import {
   graphLabels,
   rowLabelBox
-} from "./chunk-N73RA4DR.js";
+} from "./chunk-6CXLLJ2C.js";
 import {
   LABEL_CHAR_PX,
   LABEL_PAD,

package/dist/chunks/{chunk-63XWYNID.js → chunk-G4WQBRDS.js}

@@ -1,21 +1,21 @@
 import {
   stepName,
   tubeMapReads
-} from "./chunk-SDI6BVG7.js";
+} from "./chunk-J4PDHWP2.js";
 import {
   referenceWalkName
-} from "./chunk-G7SG4XMK.js";
+} from "./chunk-LODKC7PJ.js";
 import {
   pathCssColor,
   pathGreyCssColor
-} from "./chunk-GD6RUZU5.js";
+} from "./chunk-JKIAHYAW.js";
 import {
   pathOrigin
 } from "./chunk-3YBP46PB.js";
 import {
   ownStrand,
   strandSides
-} from "./chunk-VACK24HF.js";
+} from "./chunk-735MPLUL.js";
 import {
   groupBy
 } from "./chunk-BSOZW3FC.js";

package/dist/chunks/{chunk-SDI6BVG7.js → chunk-J4PDHWP2.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-5OJZV6YT.js";
 import {
   ownStrand
-} from "./chunk-VACK24HF.js";
+} from "./chunk-735MPLUL.js";
 
 // src/tubeMap/reads.ts
 function stepName(node, strand) {

package/dist/chunks/{chunk-GD6RUZU5.js → chunk-JKIAHYAW.js}

@@ -1,6 +1,6 @@
 import {
   groupDigits
-} from "./chunk-N73RA4DR.js";
+} from "./chunk-6CXLLJ2C.js";
 import {
   pathOrigin
 } from "./chunk-3YBP46PB.js";
@@ -52,18 +52,24 @@ function pathLegend(paths, colors) {
       firstOf.set(path.name, i);
     }
   });
-  const entries = [...firstOf].map(([name, i]) => ({ name, i }));
+  const entries = [...firstOf].map(([name2, i]) => ({ name: name2, i }));
   const named = entries.map((e) => labelTiers(e.name));
-  const candidates = [0, 1, 2].flatMap((t) => [
-    entries.map((_, k) => named[k][t]),
-    entries.map((e, k) => offsetTiers(e.name, named[k])[t])
-  ]);
+  const name = (t) => entries.map((_, k) => named[k][t]);
+  const offset = (t) => entries.map((e, k) => offsetTiers(e.name, named[k])[t]);
+  const candidates = [
+    name(0),
+    name(1),
+    offset(0),
+    name(2),
+    offset(1),
+    offset(2)
+  ];
   const distinct = candidates.find(
     (labels2) => new Set(labels2).size === entries.length
   );
   const labels = distinct ?? candidates.at(-1);
-  return entries.map(({ name, i }, k) => ({
-    name,
+  return entries.map(({ name: name2, i }, k) => ({
+    name: name2,
     label: labels[k],
     color: colors?.[i] ?? pathCssColor(i, paths.length)
   }));