@jbrowse/bandage-core 6.0.1 → 6.0.2

package/dist/chunks/chunk-LOEA5IHZ.js

@@ -0,0 +1,71 @@
+import {
+  placeOffReference
+} from "./chunk-TZFWUT2C.js";
+import {
+  parsePanSN
+} from "./chunk-RVS2QCOX.js";
+import {
+  ROW_HEIGHT_PX
+} from "./chunk-CPMHA4W5.js";
+import {
+  backboneNodes,
+  backbonePositions,
+  isOffReference,
+  referenceSpan
+} from "./chunk-FYQWPEEY.js";
+
+// src/layout/sampleRowLayout.ts
+function contributingSamples(graph, keep) {
+  const carried = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    if (isOffReference(node)) {
+      const { sample } = parsePanSN(node.stable.refName);
+      carried.set(sample, (carried.get(sample) ?? 0) + node.length);
+    }
+  }
+  const held = new Map(keep.map((sample, row) => [sample, row]));
+  return [...carried.keys()].sort(
+    (a, b) => (held.get(a) ?? Infinity) - (held.get(b) ?? Infinity) || carried.get(b) - carried.get(a) || a.localeCompare(b)
+  );
+}
+function sampleRowLayout(graph, region, keep = []) {
+  const backbone = backboneNodes(graph);
+  const samples = contributingSamples(graph, keep);
+  if (backbone.length === 0 || samples.length === 0) {
+    return void 0;
+  }
+  const span = referenceSpan(backbone, region);
+  const rowOf = new Map(samples.map((s, i) => [s, i + 1]));
+  const nodePositions = backbonePositions(backbone);
+  const spareRow = samples.length + 1;
+  const alleleDeletions = placeOffReference({
+    graph,
+    span,
+    rowY: (node) => {
+      const stable = node.stable;
+      const row = stable ? rowOf.get(parsePanSN(stable.refName).sample) : void 0;
+      return (row ?? spareRow) * ROW_HEIGHT_PX;
+    },
+    positions: nodePositions
+  });
+  const referenceSample = parsePanSN(backbone[0].stable.refName).sample;
+  const rowLabels = [
+    { label: referenceSample, y: 0 },
+    ...samples.map((sample) => ({
+      label: sample,
+      y: rowOf.get(sample) * ROW_HEIGHT_PX
+    }))
+  ];
+  return {
+    nodePositions,
+    rowLabels,
+    sampleRows: samples,
+    referenceAxis: true,
+    pixelRows: true,
+    alleleDeletions
+  };
+}
+
+export {
+  sampleRowLayout
+};

package/dist/chunks/chunk-LTUWJKHD.js

@@ -0,0 +1,112 @@
+import {
+  joinCuts
+} from "./chunk-WSIFAZU7.js";
+import {
+  wellKnownSample
+} from "./chunk-RAKOB6IV.js";
+import {
+  panSNMatchesPrefix,
+  panSNSample
+} from "./chunk-BPLIXMH7.js";
+
+// src/gbzWindow.ts
+var NoReferenceSampleError = class extends Error {
+  constructor(anchor, referenceSamples) {
+    super(
+      referenceSamples.length === 0 ? `the graph names no reference sample (gbwt_reference_samples) and the anchor "${anchor}" maps to none; set referenceSample` : `the anchor "${anchor}" is none of the graph's reference samples (${referenceSamples.join(", ")}); set referenceSample or map it through assemblyNameToPanSN`
+    );
+    this.name = "NoReferenceSampleError";
+  }
+};
+var NodeLimitError = class extends Error {
+  constructor(limit, windowBp, fitsBp) {
+    super(
+      `this ${windowBp.toLocaleString()} bp window reads more than nodeLimit (${limit.toLocaleString()}) graph nodes; zoom in to about ${fitsBp.toLocaleString()} bp or raise nodeLimit`
+    );
+    this.fitsBp = fitsBp;
+    this.name = "NodeLimitError";
+    this.regionTooLarge = true;
+  }
+};
+function haplotypePrefix(name) {
+  return `${name.sample}#${name.haplotype}`;
+}
+function haplotypeWanted(name, wanted) {
+  const prefix = haplotypePrefix(name);
+  return wanted === void 0 || wanted.some((candidate) => panSNMatchesPrefix(prefix, candidate));
+}
+async function referenceSamplesOf(db) {
+  return (await db.tag("gbwt_reference_samples") ?? "").split(/\s+/).filter((sample) => sample !== "");
+}
+function aliasedSample(anchorSample, referenceSamples) {
+  const lower = anchorSample.toLowerCase();
+  const alias = wellKnownSample(anchorSample)?.toLowerCase();
+  return referenceSamples.find((s) => s === anchorSample) ?? referenceSamples.find((s) => s.toLowerCase() === lower) ?? referenceSamples.find((s) => s.toLowerCase() === alias);
+}
+function resolveReferenceSample({
+  configured,
+  anchorPrefix,
+  referenceSamples
+}) {
+  if (configured !== "") {
+    return configured;
+  }
+  const sample = aliasedSample(panSNSample(anchorPrefix), referenceSamples) ?? (referenceSamples.length === 1 ? referenceSamples[0] : void 0);
+  if (sample === void 0) {
+    throw new NoReferenceSampleError(anchorPrefix, referenceSamples);
+  }
+  return sample;
+}
+async function referencePathQuery(db, referenceSample, refName) {
+  const path = (await db.paths()).find(
+    (p) => p.isIndexed && p.name.sample === referenceSample && p.name.contig === refName
+  );
+  return path ? {
+    sample: path.name.sample,
+    contig: refName,
+    haplotype: path.name.haplotype
+  } : void 0;
+}
+function nodeLimitError(error, limit, windowBp) {
+  const isLimit = error instanceof Error && (error.name === "SubgraphLimitError" || /^Subgraph size limit of \d+ nodes exceeded/.test(error.message));
+  if (!isLimit) {
+    return void 0;
+  } else {
+    const walked = error.walkedBp;
+    const fits = typeof walked === "number" && walked > 0 ? Math.floor(walked * 0.8) : Math.floor(windowBp / 2);
+    return new NodeLimitError(limit, windowBp, Math.max(fits, 1));
+  }
+}
+var GBZ_CUT_DEFAULTS = {
+  context: 1e3,
+  snarls: "contained",
+  limit: 1e5
+};
+async function cutWindowGFA(db, query, start, end, opts) {
+  if (!query) {
+    return "";
+  }
+  const subgraphs = await db.getSubgraphs({ ...opts, path: query, start, end, haplotypes: "all" }).catch((error) => {
+    throw nodeLimitError(error, opts.limit, end - start) ?? error;
+  });
+  const paths = await db.paths();
+  return joinCuts(
+    await Promise.all(subgraphs.map((subgraph) => subgraph.toGFA())),
+    (sample, haplotype, contig, at) => paths.some(
+      ({ name }) => name.sample === sample && name.haplotype === haplotype && name.contig === contig && name.fragment === at
+    )
+  );
+}
+
+export {
+  NoReferenceSampleError,
+  NodeLimitError,
+  haplotypePrefix,
+  haplotypeWanted,
+  referenceSamplesOf,
+  resolveReferenceSample,
+  referencePathQuery,
+  nodeLimitError,
+  GBZ_CUT_DEFAULTS,
+  cutWindowGFA
+};

package/dist/chunks/chunk-LVZZH2NI.js

@@ -0,0 +1,181 @@
+import {
+  baseEdgeCurves
+} from "./chunk-6YRRNX2P.js";
+import {
+  curveBounds,
+  pathRibbonOffsets
+} from "./chunk-3PLYZLYV.js";
+
+// src/util/SpatialIndex.ts
+var FALLBACK_CELL_SIZE = 50;
+function meanExtentCellSize(extentTotal, count) {
+  return count > 0 ? Math.max(1, extentTotal / count) : FALLBACK_CELL_SIZE;
+}
+function rowPitchOf(boxes) {
+  const distinct = /* @__PURE__ */ new Set();
+  let min = Infinity;
+  let max = -Infinity;
+  for (const box of boxes) {
+    distinct.add(box.minY);
+    min = Math.min(min, box.minY);
+    max = Math.max(max, box.minY);
+  }
+  return distinct.size > 1 ? (max - min) / (distinct.size - 1) : void 0;
+}
+function cellSizeFrom(boxes, extentX, extentY) {
+  const x = meanExtentCellSize(extentX, boxes.length);
+  return {
+    x,
+    y: extentY > 0 ? meanExtentCellSize(extentY, boxes.length) : rowPitchOf(boxes) ?? x
+  };
+}
+function resolveCellSize(given, boxes, extentX, extentY) {
+  return given === void 0 ? cellSizeFrom(boxes, extentX, extentY) : typeof given === "number" ? { x: given, y: given } : given;
+}
+function getOrCreateCell(cells, cx, cy) {
+  let row = cells.get(cx);
+  if (!row) {
+    row = /* @__PURE__ */ new Map();
+    cells.set(cx, row);
+  }
+  let cell = row.get(cy);
+  if (!cell) {
+    cell = [];
+    row.set(cy, cell);
+  }
+  return cell;
+}
+function addToGrid(cells, cellSize, minX, minY, maxX, maxY, entry) {
+  const cx0 = Math.floor(minX / cellSize.x);
+  const cx1 = Math.floor(maxX / cellSize.x);
+  const cy0 = Math.floor(minY / cellSize.y);
+  const cy1 = Math.floor(maxY / cellSize.y);
+  for (let cx = cx0; cx <= cx1; cx++) {
+    for (let cy = cy0; cy <= cy1; cy++) {
+      getOrCreateCell(cells, cx, cy).push(entry);
+    }
+  }
+}
+function queryGrid(cells, cellSize, x, y, radiusX, radiusY) {
+  const cx0 = Math.floor((x - radiusX) / cellSize.x);
+  const cx1 = Math.floor((x + radiusX) / cellSize.x);
+  const cy0 = Math.floor((y - radiusY) / cellSize.y);
+  const cy1 = Math.floor((y + radiusY) / cellSize.y);
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let cx = cx0; cx <= cx1; cx++) {
+    const row = cells.get(cx);
+    if (row) {
+      for (let cy = cy0; cy <= cy1; cy++) {
+        const cell = row.get(cy);
+        if (cell) {
+          for (const entry of cell) {
+            if (!seen.has(entry)) {
+              seen.add(entry);
+              results.push(entry);
+            }
+          }
+        }
+      }
+    }
+  }
+  return results;
+}
+var SpatialIndex = class {
+  constructor(nodePositions, cellSize) {
+    this.cells = /* @__PURE__ */ new Map();
+    const boxes = [];
+    let extentX = 0;
+    let extentY = 0;
+    for (const [nodeId, segments] of Object.entries(nodePositions)) {
+      for (let i = 0; i < segments.length - 1; i++) {
+        const seg = segments[i];
+        const next = segments[i + 1];
+        const minX = Math.min(seg.x, next.x);
+        const minY = Math.min(seg.y, next.y);
+        const maxX = Math.max(seg.x, next.x);
+        const maxY = Math.max(seg.y, next.y);
+        extentX += maxX - minX;
+        extentY += maxY - minY;
+        boxes.push({ entry: { nodeId, segmentIdx: i }, minX, minY, maxX, maxY });
+      }
+    }
+    this.cellSize = resolveCellSize(cellSize, boxes, extentX, extentY);
+    for (const b of boxes) {
+      addToGrid(
+        this.cells,
+        this.cellSize,
+        b.minX,
+        b.minY,
+        b.maxX,
+        b.maxY,
+        b.entry
+      );
+    }
+  }
+  query(x, y, radiusX, radiusY = radiusX) {
+    return queryGrid(this.cells, this.cellSize, x, y, radiusX, radiusY);
+  }
+};
+var EdgeSpatialIndex = class {
+  constructor(nodePositions, graph, drawPaths, axis, cellSize, deletions, version = 0, routes, stranded = false) {
+    this.cells = /* @__PURE__ */ new Map();
+    this.edgeCurves = baseEdgeCurves(
+      nodePositions,
+      graph,
+      axis,
+      deletions,
+      version,
+      routes,
+      stranded
+    );
+    const boxes = [];
+    let extentX = 0;
+    let extentY = 0;
+    for (let ei = 0; ei < graph.edges.length; ei++) {
+      const edge = graph.edges[ei];
+      const fromSegments = nodePositions[edge.from];
+      const toSegments = nodePositions[edge.to];
+      const curves = this.edgeCurves.get(ei);
+      if (fromSegments?.length && toSegments?.length && curves) {
+        let { minX, minY, maxX, maxY } = curveBounds(curves);
+        const numPaths = edge.pathIds?.length ?? 0;
+        if (drawPaths && numPaths > 0) {
+          let padX = 0;
+          let padY = 0;
+          for (const o of pathRibbonOffsets(
+            fromSegments,
+            toSegments,
+            numPaths,
+            axis
+          )) {
+            padX = Math.max(padX, Math.abs(o.x));
+            padY = Math.max(padY, Math.abs(o.y));
+          }
+          minX -= padX;
+          minY -= padY;
+          maxX += padX;
+          maxY += padY;
+        }
+        extentX += maxX - minX;
+        extentY += maxY - minY;
+        boxes.push({ ei, minX, minY, maxX, maxY });
+      }
+    }
+    this.cellSize = resolveCellSize(cellSize, boxes, extentX, extentY);
+    for (const b of boxes) {
+      addToGrid(this.cells, this.cellSize, b.minX, b.minY, b.maxX, b.maxY, b.ei);
+    }
+  }
+  getCurves(ei) {
+    return this.edgeCurves.get(ei);
+  }
+  query(x, y, radiusX, radiusY = radiusX) {
+    return queryGrid(this.cells, this.cellSize, x, y, radiusX, radiusY);
+  }
+};
+
+export {
+  SpatialIndex,
+  EdgeSpatialIndex
+};

package/dist/chunks/chunk-MFKORG3F.js

@@ -0,0 +1,44 @@
+// src/bubbles/bubbleLine.ts
+function sequence(field) {
+  return field === void 0 || field === "*" ? void 0 : field;
+}
+function parseBubbleLine(line) {
+  const cols = line.split("	");
+  return {
+    refName: cols[0],
+    start: +cols[1],
+    end: +cols[2],
+    segmentCount: +cols[3],
+    pathCount: +cols[4],
+    inversion: cols[5] === "1",
+    shortestAlleleLength: +cols[6],
+    longestAlleleLength: +cols[7],
+    segments: cols[11],
+    shortestAllele: sequence(cols[12]),
+    longestAllele: sequence(cols[13])
+  };
+}
+function sameBubble(a, b) {
+  return a.refName === b.refName && a.start === b.start && a.end === b.end;
+}
+function bubbleLabel(bubble) {
+  const { shortestAlleleLength: min, longestAlleleLength: max } = bubble;
+  return min === max ? `${max.toLocaleString()} bp` : `${min.toLocaleString()}-${max.toLocaleString()} bp`;
+}
+var SATURATED_PATH_COUNT = 2147483647;
+function bubbleDescription(bubble) {
+  const { pathCount, segmentCount, inversion } = bubble;
+  return [
+    `${segmentCount} segments`,
+    pathCount === SATURATED_PATH_COUNT ? "more paths than gfatools counts" : `up to ${pathCount.toLocaleString()} paths`,
+    ...inversion ? ["inversion"] : []
+  ].join(", ");
+}
+
+export {
+  parseBubbleLine,
+  sameBubble,
+  bubbleLabel,
+  SATURATED_PATH_COUNT,
+  bubbleDescription
+};

package/dist/chunks/chunk-MHGHYHTL.js

@@ -0,0 +1,205 @@
+import {
+  alongRow,
+  boxesGenes
+} from "./chunk-QCYM44UL.js";
+import {
+  pathOrigin
+} from "./chunk-ST2IBUAN.js";
+import {
+  LABEL_CHAR_PX
+} from "./chunk-AB35TJST.js";
+import {
+  ROW_HEIGHT_PX
+} from "./chunk-CPMHA4W5.js";
+import {
+  el
+} from "./chunk-NNODIW4U.js";
+
+// src/layout/walkStrip.ts
+var PAD_PX = 6;
+var WALK_STRIP_CEILING_PX = 260;
+var LABEL_FONT_PX = 11;
+var MIN_ROW_PX = 3;
+var LABELLED_ROW_PX = 12;
+var READOUT_ROOM = 1.3;
+var MARK_INK = "#111";
+var TICK_PX = 3;
+function stripMarks(graph, rows, node) {
+  const visits = graph.pathVisits?.get(node.name) ?? [];
+  const marks = [];
+  for (const row of rows) {
+    const axis = row.axis;
+    if (!axis) {
+      continue;
+    }
+    const path = pathOrigin(row.name).name;
+    for (const v of visits) {
+      if (v.path !== path) {
+        continue;
+      }
+      const { start, end } = alongRow(axis, v.start, v.start + node.length);
+      if (end > 0 && start < row.bp) {
+        marks.push({ row: row.name, start, bp: end - start });
+      }
+    }
+  }
+  return marks;
+}
+var spanCache = /* @__PURE__ */ new WeakMap();
+function spansOf(graph, name) {
+  let byName = spanCache.get(graph);
+  if (!byName) {
+    byName = /* @__PURE__ */ new Map();
+    spanCache.set(graph, byName);
+  }
+  if (byName.has(name)) {
+    return byName.get(name);
+  }
+  const lengthOf = new Map(graph.nodes.map((n) => [n.id, n.length]));
+  const pieces = (graph.paths ?? []).filter((p) => p.name === name);
+  let spans;
+  if (pieces.every((p) => p.start !== void 0)) {
+    spans = { ids: [], starts: [], ends: [] };
+    for (const piece of [...pieces].sort((a, b) => a.start - b.start)) {
+      let pos = piece.start;
+      for (const id of piece.nodeIds) {
+        const len = lengthOf.get(id) ?? 0;
+        spans.ids.push(id);
+        spans.starts.push(pos);
+        spans.ends.push(pos + len);
+        pos += len;
+      }
+    }
+  }
+  byName.set(name, spans);
+  return spans;
+}
+function segmentAt(graph, row, offset, pxPerBp) {
+  const axis = row.axis;
+  const spans = axis && spansOf(graph, row.name);
+  if (!axis || !spans || offset < 0 || offset > row.bp) {
+    return void 0;
+  }
+  const at = axis.reversed ? axis.start - offset : axis.start + offset;
+  const tol = 0.5 / pxPerBp;
+  const bar = axis.reversed ? { start: axis.start - row.bp, end: axis.start } : { start: axis.start, end: axis.start + row.bp };
+  const from = Math.max(at - tol, bar.start);
+  const to = Math.min(at + tol, bar.end);
+  let lo = 0;
+  let hi = spans.starts.length;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    if (spans.ends[mid] <= from) {
+      lo = mid + 1;
+    } else {
+      hi = mid;
+    }
+  }
+  let best;
+  let bestLen = -1;
+  let bestHolds = false;
+  for (let i = lo; i < spans.starts.length && spans.starts[i] < to; i++) {
+    const len = spans.ends[i] - spans.starts[i];
+    const holds = spans.starts[i] <= at && at < spans.ends[i];
+    if (len > bestLen || len === bestLen && holds && !bestHolds) {
+      bestLen = len;
+      best = spans.ids[i];
+      bestHolds = holds;
+    }
+  }
+  return best;
+}
+function walkStripFrame(bars, o) {
+  const maxHeight = o.maxHeight ?? WALK_STRIP_CEILING_PX;
+  const labelPx = o.labelPx ?? Math.max(...[bars.reference, ...bars.rows].map((r) => r.label.length)) * LABEL_CHAR_PX + 16;
+  const count = bars.rows.length + 1;
+  const rowPx = Math.max(
+    MIN_ROW_PX,
+    Math.min(ROW_HEIGHT_PX, Math.floor((maxHeight - 2 * PAD_PX) / count))
+  );
+  const labelled = rowPx >= LABELLED_ROW_PX;
+  const readouts = rowPx >= 14;
+  const barPx = Math.max(2, Math.round(rowPx * 0.6));
+  const longest = Math.max(bars.reference.bp, ...bars.rows.map((r) => r.bp), 1);
+  const left = labelled ? labelPx : PAD_PX;
+  const usable = Math.max(1, o.width - left - PAD_PX);
+  const scaleX = usable / (longest * (readouts ? READOUT_ROOM : 1));
+  return {
+    scaleX,
+    scaleY: 1,
+    translateX: left - bars.origin * scaleX,
+    translateY: PAD_PX + rowPx / 2,
+    width: o.width,
+    height: count * rowPx + 2 * PAD_PX,
+    rowPx,
+    barPx,
+    readouts,
+    labelled,
+    boxesGenes: boxesGenes(rowPx, barPx)
+  };
+}
+function stripRowAt(bars, frame, x, y) {
+  const i = Math.round((y - frame.translateY) / frame.rowPx);
+  const row = [bars.reference, ...bars.rows][i];
+  const offset = (x - frame.translateX) / frame.scaleX - bars.origin;
+  return row && i >= 0 && offset >= 0 && offset <= row.bp ? { index: i, row, offset } : void 0;
+}
+function walkMarksTree(bars, frame, marks) {
+  const index = new Map(
+    [bars.reference, ...bars.rows].map((row, i) => [row.name, i])
+  );
+  const X = (offset) => (bars.origin + offset) * frame.scaleX + frame.translateX;
+  return el(
+    "g",
+    { "data-testid": "graph-walk-marks" },
+    ...marks.flatMap((m) => {
+      const i = index.get(m.row);
+      if (i === void 0) {
+        return [];
+      }
+      const y = i * frame.rowPx + frame.translateY;
+      const x = X(m.start);
+      const w = Math.max(2, m.bp * frame.scaleX);
+      const tick = (top) => el("rect", { x, y: top, width: w, height: TICK_PX, fill: MARK_INK });
+      return [
+        tick(y - frame.barPx / 2 - TICK_PX - 1),
+        tick(y + frame.barPx / 2 + 1)
+      ];
+    })
+  );
+}
+function walkStripLabelsTree(bars, frame, bold = /* @__PURE__ */ new Set()) {
+  return el(
+    "g",
+    { "font-family": "sans-serif", "font-size": LABEL_FONT_PX, fill: "#333" },
+    ...(frame.labelled ? [bars.reference, ...bars.rows] : []).map(
+      (row, i) => el(
+        "text",
+        {
+          x: 6,
+          y: i * frame.rowPx + frame.translateY + 4,
+          "font-weight": bold.has(row.name) ? 600 : void 0
+        },
+        row.label
+      )
+    )
+  );
+}
+function stripGeneGaps(frame, rowGenes, gaps) {
+  if (!rowGenes?.size) {
+    return void 0;
+  }
+  return frame.boxesGenes ? gaps : { untracked: 0, unread: 0, ...gaps, crowded: true };
+}
+
+export {
+  WALK_STRIP_CEILING_PX,
+  LABELLED_ROW_PX,
+  stripMarks,
+  segmentAt,
+  walkStripFrame,
+  stripRowAt,
+  walkMarksTree,
+  walkStripLabelsTree,
+  stripGeneGaps
+};

package/dist/chunks/chunk-MI35EUIE.js

@@ -0,0 +1,76 @@
+// src/layout/deletionRoutes.ts
+var ROUTE_ID = "\0deletion:";
+var ROUTE_FRACTION = 0.5;
+function withDeletionRoutes(graph, deletions) {
+  const routes = new Map(
+    deletions.map((d) => [d.edgeIndex, `${ROUTE_ID}${d.edgeIndex}`])
+  );
+  const edges = [];
+  graph.edges.forEach((edge, ei) => {
+    const id = routes.get(ei);
+    if (id === void 0) {
+      edges.push(edge);
+    } else {
+      const { fromStrand, toStrand } = edge;
+      edges.push(
+        { from: edge.from, to: id, ...fromStrand ? { fromStrand } : {} },
+        { from: id, to: edge.to, ...toStrand ? { toStrand } : {} }
+      );
+    }
+  });
+  return {
+    graph: {
+      ...graph,
+      nodes: [
+        ...graph.nodes,
+        ...[...routes.values()].map((id) => ({
+          id,
+          name: id,
+          length: 0,
+          depth: 0
+        }))
+      ],
+      edges
+    },
+    routes,
+    ids: new Set(routes.values())
+  };
+}
+function routeNodes(graph, deletions, routes, drawnOf, opts) {
+  const lengths = new Map(graph.nodes.map((n) => [n.id, n.length]));
+  return deletions.map((d) => {
+    const skipped = d.bypassed.reduce(
+      (sum, id2) => sum + (lengths.get(id2) ?? 0),
+      0
+    );
+    const drawn = Math.max(
+      opts.minimumNodeLength,
+      drawnOf(skipped) * ROUTE_FRACTION
+    );
+    const id = routes.get(d.edgeIndex);
+    return {
+      id,
+      name: id,
+      length: Math.round(drawn * 1e6 / opts.nodeLengthPerMegabase),
+      depth: 0
+    };
+  });
+}
+function takeRoutes(positions, routes) {
+  const nodePositions = { ...positions };
+  const deletionRoutes = {};
+  for (const [edgeIndex, id] of routes) {
+    const route = nodePositions[id];
+    delete nodePositions[id];
+    if (route?.length) {
+      deletionRoutes[edgeIndex] = route;
+    }
+  }
+  return { nodePositions, deletionRoutes };
+}
+
+export {
+  withDeletionRoutes,
+  routeNodes,
+  takeRoutes
+};