@jbrowse/bandage-core 8.2.0 → 9.0.0

package/dist/chunks/{chunk-3FXPFVKJ.js → chunk-AMS3MAFP.js}

@@ -1,5 +1,5 @@
 // src/version.ts
-var version = "8.2.0";
+var version = "9.0.0";
 
 export {
   version

package/dist/chunks/{chunk-DRA7733Q.js → chunk-BPRXQ2SS.js}

@@ -6,17 +6,22 @@ import {
 } from "./chunk-FYQWPEEY.js";
 
 // src/tubeMap/axis.ts
-function referenceBoxes(graph, layout) {
+function referenceBoxes({
+  graph,
+  layout
+}) {
   const nodeById = new Map(graph.nodes.map((n) => [n.id, n]));
   const byRefName = /* @__PURE__ */ new Map();
-  layout.nodes.forEach((node) => {
+  layout.nodes.forEach((node, index) => {
     const graphNode = nodeById.get(node.name);
     if (node.order >= 0 && graphNode && isBackbone(graphNode)) {
       const { refName, start } = graphNode.stable;
       const boxes = byRefName.get(refName) ?? byRefName.set(refName, []).get(refName);
       boxes.push({
+        name: node.name,
+        index,
         bp0: start,
-        bp1: start + node.sequenceLength,
+        bp1: start + graphNode.length,
         x0: node.x,
         x1: node.x + node.pixelWidth
       });

package/dist/chunks/{chunk-TEDQJPMI.js → chunk-CWFNEKST.js}

@@ -30,16 +30,30 @@ function mismatchesByStep(record, lengths) {
     return byStep;
   }
   const starts = stepStarts(lengths, record.pathLength);
+  const known = starts.flatMap((start, s) => start === void 0 ? [] : [s]);
+  const startOf = (k) => starts[known[k]];
+  const endOf = (k) => startOf(k) + lengths[known[k]];
+  let first = 0;
   const stepAt = (pos2, atEnd = false) => {
-    for (let s = 0; s < starts.length; s++) {
-      const start = starts[s];
-      const length = lengths[s];
-      if (start !== void 0 && length !== void 0 && start <= pos2 && (pos2 < start + length || atEnd && pos2 === start + length)) {
-        return { s, local: pos2 - start, room: start + length - pos2 };
+    while (first < known.length && endOf(first) < pos2) {
+      first++;
+    }
+    for (let k = first; k < known.length && startOf(k) <= pos2; k++) {
+      const end = endOf(k);
+      if (pos2 < end || atEnd && pos2 === end) {
+        return { s: known[k], local: pos2 - startOf(k), room: end - pos2 };
       }
     }
     return void 0;
   };
+  const unplacedFrom = (pos2) => {
+    for (let k = first; k < known.length; k++) {
+      if (startOf(k) > pos2) {
+        return startOf(k) - pos2;
+      }
+    }
+    return Infinity;
+  };
   const add = (s, mismatch) => {
     const list = byStep[s];
     const last = list.at(-1);
@@ -68,7 +82,7 @@ function mismatchesByStep(record, lengths) {
       let left = op.length;
       while (left > 0) {
         const at = stepAt(pos);
-        const take = at ? Math.min(left, at.room) : left;
+        const take = Math.min(left, at ? at.room : unplacedFrom(pos));
         if (at) {
           add(at.s, { type: "deletion", pos: at.local, length: take });
         }
@@ -106,7 +120,8 @@ function tubeMapReads(graph, records, firstId) {
         })),
         firstNodeOffset: first === 0 ? record.pathStart : 0,
         finalNodeCoverLength: last === record.path.length - 1 ? lastLength - (record.pathLength - record.pathEnd) : lastLength,
-        mapping_quality: record.mappingQuality === 255 ? 0 : record.mappingQuality,
+        // 255 is GAF's missing MAPQ
+        mapping_quality: record.mappingQuality === 255 ? void 0 : record.mappingQuality,
         is_secondary: record.secondary,
         is_reverse: record.strand === "-"
       });

package/dist/chunks/chunk-INJ2UVOT.js

@@ -0,0 +1,370 @@
+import {
+  canonicalStrand,
+  stepName,
+  tubeMapReads
+} from "./chunk-CWFNEKST.js";
+import {
+  pathCssColor,
+  pathGreyCssColor
+} from "./chunk-7GBL7SJY.js";
+import {
+  pathOrigin
+} from "./chunk-ST2IBUAN.js";
+import {
+  ownStrand,
+  strandSides
+} from "./chunk-2CVHXFK7.js";
+import {
+  isBackbone
+} from "./chunk-FYQWPEEY.js";
+
+// src/layout/tubeMapLayout.ts
+import { forward, isReverse, layoutTubeMap } from "@jbrowse/tubemap-core";
+function pathSteps(graph) {
+  const nodeById = new Map(graph.nodes.map((n) => [n.id, n]));
+  const strands = /* @__PURE__ */ new Map();
+  for (const [segment, visits] of graph.pathVisits ?? []) {
+    for (const visit of visits) {
+      const key = `${visit.path}	${segment}`;
+      const list = strands.get(key);
+      if (list) {
+        list.push(visit.strand);
+      } else {
+        strands.set(key, [visit.strand]);
+      }
+    }
+  }
+  const seen = /* @__PURE__ */ new Map();
+  return (graph.paths ?? []).map((path) => {
+    const walk = pathOrigin(path.name).name;
+    return path.nodeIds.flatMap((id) => {
+      const node = nodeById.get(id);
+      if (!node) {
+        return [];
+      }
+      const key = `${walk}	${node.name}`;
+      const k = seen.get(key) ?? 0;
+      seen.set(key, k + 1);
+      return [{ node, strand: strands.get(key)?.[k] ?? canonicalStrand(node) }];
+    });
+  });
+}
+function tubeMapTracks(graph) {
+  const steps = pathSteps(graph);
+  const tracks = (graph.paths ?? []).flatMap((path, index) => {
+    const sequence = steps[index].map((s) => stepName(s.node, s.strand));
+    return sequence.length > 0 ? [
+      {
+        id: index,
+        name: path.name,
+        sequence,
+        sourceTrackID: 0,
+        type: "haplotype"
+      }
+    ] : [];
+  });
+  const reference = tracks.findIndex(
+    (t) => pathOrigin(t.name).name === graph.referencePath
+  );
+  if (reference > 0) {
+    tracks.unshift(...tracks.splice(reference, 1));
+  }
+  return tracks;
+}
+function tubeMapNodes(graph) {
+  return graph.nodes.map((n) => ({
+    name: n.id,
+    seq: "",
+    sequenceLength: Math.max(1, n.length)
+  }));
+}
+function hasTubeMapPaths(graph) {
+  return (graph.paths?.length ?? 0) > 0;
+}
+var STACK_PX = 600;
+var MIN_TUBE_PX = 3;
+var MAX_TUBE_PX = 15;
+function tubeWidth(trackCount) {
+  return Math.max(
+    MIN_TUBE_PX,
+    Math.min(MAX_TUBE_PX, Math.floor(STACK_PX / Math.max(1, trackCount)))
+  );
+}
+function straightened(first) {
+  const flipped = /* @__PURE__ */ new Set();
+  const forwards = /* @__PURE__ */ new Set();
+  for (const step of first?.sequence ?? []) {
+    if (!isReverse(step)) {
+      forwards.add(step);
+    } else if (!forwards.has(forward(step))) {
+      flipped.add(forward(step));
+    }
+  }
+  return flipped;
+}
+function mergedRuns(graph, layout, walks) {
+  const flipped = straightened(walks[0]);
+  const before = /* @__PURE__ */ new Map();
+  for (const { sequence, is_secondary } of walks) {
+    if (!is_secondary) {
+      sequence.forEach((step, i) => {
+        const id = forward(step);
+        const against = isReverse(step) !== flipped.has(id);
+        const neighbour = against ? sequence[i + 1] : sequence[i - 1];
+        if (!layout.nodeMap.has(id) && neighbour !== void 0) {
+          before.set(id, forward(neighbour));
+        }
+      });
+    }
+  }
+  const lengthOf = new Map(graph.nodes.map((n) => [n.id, Math.max(1, n.length)]));
+  const after = new Map([...before].map(([node, prev]) => [prev, node]));
+  const members = /* @__PURE__ */ new Map();
+  for (const head of after.keys()) {
+    const index = layout.nodeMap.get(head);
+    if (index !== void 0) {
+      const run = [head];
+      for (let n = after.get(head); n !== void 0; n = after.get(n)) {
+        run.push(n);
+      }
+      const bp = run.reduce((sum, id) => sum + (lengthOf.get(id) ?? 0), 0);
+      if (bp === layout.nodes[index].sequenceLength) {
+        members.set(head, run);
+      }
+    }
+  }
+  return { members, flipped };
+}
+var opposite = { start: "end", end: "start" };
+var otherStrand = { "+": "-", "-": "+" };
+function boxGraph(graph, { members, flipped }) {
+  if (members.size === 0) {
+    return graph;
+  }
+  const nodeById = new Map(graph.nodes.map((n) => [n.id, n]));
+  const boxOf = /* @__PURE__ */ new Map();
+  const inner = /* @__PURE__ */ new Set();
+  const drawn = (id, side) => flipped.has(id) ? opposite[side] : side;
+  for (const [box, run] of members) {
+    run.forEach((id, i) => {
+      boxOf.set(id, box);
+      const next = run[i + 1];
+      if (next !== void 0) {
+        inner.add(`${id}:${drawn(id, "end")}	${next}:${drawn(next, "start")}`);
+      }
+    });
+  }
+  const absorbed = new Set(
+    [...boxOf].filter(([id, box]) => id !== box).map(([id]) => id)
+  );
+  const nodes = graph.nodes.flatMap((node) => {
+    const run = members.get(node.id);
+    if (!run) {
+      return absorbed.has(node.id) ? [] : [node];
+    }
+    const parts = run.map((id) => nodeById.get(id));
+    const starts = parts.flatMap((p) => p.stable ? [p.stable.start] : []);
+    return [
+      {
+        ...node,
+        length: parts.reduce((sum, p) => sum + p.length, 0),
+        stable: node.stable && { ...node.stable, start: Math.min(...starts) }
+      }
+    ];
+  });
+  const leaving = (id, box, side) => drawn(box, drawn(id, side)) === "end" ? ownStrand(box) : otherStrand[ownStrand(box)];
+  const edges = graph.edges.flatMap((edge) => {
+    const sides = strandSides(edge);
+    const from = `${edge.from}:${sides.from}`;
+    const to = `${edge.to}:${sides.to}`;
+    if (inner.has(`${from}	${to}`) || inner.has(`${to}	${from}`)) {
+      return [];
+    }
+    const fromBox = boxOf.get(edge.from);
+    const toBox = boxOf.get(edge.to);
+    return [
+      {
+        ...edge,
+        ...fromBox === void 0 ? {} : {
+          from: fromBox,
+          fromStrand: leaving(edge.from, fromBox, sides.from)
+        },
+        ...toBox === void 0 ? {} : {
+          to: toBox,
+          toStrand: otherStrand[leaving(edge.to, toBox, sides.to)]
+        }
+      }
+    ];
+  });
+  const absorbedNames = new Set(
+    [...absorbed].map((id) => nodeById.get(id)?.name ?? id)
+  );
+  return {
+    ...graph,
+    nodes,
+    edges,
+    paths: graph.paths?.map((path) => ({
+      ...path,
+      nodeIds: path.nodeIds.filter((id) => !absorbed.has(id))
+    })),
+    pathVisits: graph.pathVisits && new Map(
+      [...graph.pathVisits].filter(([name]) => !absorbedNames.has(name))
+    )
+  };
+}
+function runTubeMap(graph) {
+  const paths = graph.paths ?? [];
+  const tracks = tubeMapTracks(graph);
+  const reads = graph.reads ? tubeMapReads(graph, graph.reads, paths.length) : [];
+  const tubeColor = reads.length > 0 ? pathGreyCssColor : pathCssColor;
+  const pathColors = paths.map((_, i) => tubeColor(i, paths.length));
+  const layout = layoutTubeMap(tubeMapNodes(graph), tracks, reads, {
+    nodeWidthOption: "compressed",
+    trackWidth: tubeWidth(tracks.length)
+  });
+  if (!layout) {
+    return void 0;
+  }
+  const runs = mergedRuns(graph, layout, [...tracks, ...reads]);
+  return {
+    layout,
+    pathColors,
+    members: runs.members,
+    graph: boxGraph(graph, runs)
+  };
+}
+function drawnNodes(layout) {
+  const nodes = [];
+  layout.nodes.forEach((node) => {
+    if (node.order >= 0) {
+      nodes.push(node);
+    }
+  });
+  return nodes;
+}
+function centreline(node, yOffset, x0, x1) {
+  const y = node.y + node.contentHeight / 2 - yOffset;
+  return [
+    { x: x0, y },
+    { x: x1, y }
+  ];
+}
+function extentOf(layout, yOffset) {
+  return {
+    minY: layout.bounds.minY - yOffset,
+    maxY: layout.bounds.maxY - yOffset
+  };
+}
+function tubeMapLayout(graph) {
+  const run = hasTubeMapPaths(graph) ? runTubeMap(graph) : void 0;
+  if (!run) {
+    return void 0;
+  }
+  const { layout, ...drawing } = run;
+  const yOffset = layout.bounds.minY;
+  const nodePositions = {};
+  for (const node of drawnNodes(layout)) {
+    nodePositions[node.name] = centreline(
+      node,
+      yOffset,
+      node.x,
+      node.x + node.pixelWidth
+    );
+  }
+  const { minY, maxY } = extentOf(layout, yOffset);
+  return {
+    nodePositions,
+    tubeMap: { layout, yOffset, ...drawing },
+    extent: {
+      minX: layout.bounds.minX,
+      maxX: layout.bounds.maxX,
+      minY,
+      maxY
+    }
+  };
+}
+function tubeMapColumns(graph, layout) {
+  const nodeById = new Map(graph.nodes.map((n) => [n.id, n]));
+  const byOrder = /* @__PURE__ */ new Map();
+  for (const node of drawnNodes(layout)) {
+    const list = byOrder.get(node.order);
+    if (list) {
+      list.push(node);
+    } else {
+      byOrder.set(node.order, [node]);
+    }
+  }
+  const columns = [];
+  let end = -Infinity;
+  for (const order of [...byOrder.keys()].sort((a, b) => a - b)) {
+    const nodes = byOrder.get(order);
+    let bp0 = Infinity;
+    let bp1 = -Infinity;
+    for (const node of nodes) {
+      const graphNode = nodeById.get(node.name);
+      if (graphNode && isBackbone(graphNode)) {
+        bp0 = Math.min(bp0, graphNode.stable.start);
+        bp1 = Math.max(bp1, graphNode.stable.start + graphNode.length);
+      }
+    }
+    if (bp0 === Infinity) {
+      bp0 = bp1 = end;
+    }
+    if (bp0 < end) {
+      bp0 = end;
+      bp1 = Math.max(end, bp1);
+    }
+    end = Math.max(end, bp1);
+    columns.push({
+      order,
+      x0: Math.min(...nodes.map((n) => n.x)),
+      x1: Math.max(...nodes.map((n) => n.x + n.pixelWidth)),
+      bp0,
+      bp1
+    });
+  }
+  const first = columns.find((c) => c.bp0 !== -Infinity);
+  for (const column of columns) {
+    if (column.bp0 === -Infinity) {
+      column.bp0 = column.bp1 = first?.bp0 ?? 0;
+    }
+  }
+  return columns;
+}
+function hasTubeMapBackbone(graph) {
+  return hasTubeMapPaths(graph) && graph.nodes.some(isBackbone);
+}
+function tubeMapReferenceLayout(graph) {
+  const run = hasTubeMapBackbone(graph) ? runTubeMap(graph) : void 0;
+  if (!run) {
+    return void 0;
+  }
+  const { layout, ...drawing } = run;
+  const columns = tubeMapColumns(drawing.graph, layout);
+  const byOrder = new Map(columns.map((c) => [c.order, c]));
+  const yOffset = layout.bounds.minY;
+  const nodePositions = {};
+  for (const node of drawnNodes(layout)) {
+    const column = byOrder.get(node.order);
+    nodePositions[node.name] = centreline(node, yOffset, column.bp0, column.bp1);
+  }
+  return {
+    nodePositions,
+    tubeMap: { layout, yOffset, columns, ...drawing },
+    referenceAxis: true,
+    pixelRows: true,
+    extent: extentOf(layout, yOffset)
+  };
+}
+
+export {
+  pathSteps,
+  tubeMapTracks,
+  hasTubeMapPaths,
+  tubeWidth,
+  mergedRuns,
+  boxGraph,
+  tubeMapLayout,
+  hasTubeMapBackbone,
+  tubeMapReferenceLayout
+};

package/dist/chunks/{chunk-KCRL5JB2.js → chunk-LLP3FXPM.js}

@@ -1,9 +1,9 @@
 import {
   tubeMapMismatches
-} from "./chunk-733L2TS6.js";
+} from "./chunk-XXT2JCAC.js";
 import {
   readColor
-} from "./chunk-TEDQJPMI.js";
+} from "./chunk-CWFNEKST.js";
 
 // src/tubeMap/draw.ts
 import { curvePaths, nodeOutlinePath } from "@jbrowse/tubemap-core";
@@ -53,9 +53,9 @@ function extentOf(commands) {
   }
   return { x0, x1 };
 }
-function shapeOf(d, color, track) {
+function shapeOf(d, color, id, haplotype) {
   const commands = parsePath(d);
-  return { commands, color, track, ...extentOf(commands) };
+  return { commands, color, id, haplotype, ...extentOf(commands) };
 }
 function trackColors(layout, pathColors) {
   return new Map(
@@ -67,20 +67,21 @@ function trackColors(layout, pathColors) {
 }
 function layerOf(layout, type, colors) {
   const { shapes } = layout;
+  const haplotype = type === "haplotype";
   const colorOf = (s) => colors.get(s.id);
-  const trackOf = (s) => type === "haplotype" ? s.id : void 0;
   const rects = [...shapes.rectangles, ...shapes.verticalRectangles].filter((r) => r.type === type).map((r) => ({
     color: colorOf(r),
-    track: trackOf(r),
+    id: r.id,
+    haplotype,
     x0: r.xStart,
     x1: r.xEnd + 1,
     y0: r.yStart,
     y1: r.yEnd + 1
   }));
   const curves = curvePaths(shapes.curves, type).map(
-    (c) => shapeOf(c.path, colorOf(c), trackOf(c))
+    (c) => shapeOf(c.path, colorOf(c), c.id, haplotype)
   );
-  const corners = shapes.corners.filter((c) => c.type === type).map((c) => shapeOf(c.path, colorOf(c), trackOf(c)));
+  const corners = shapes.corners.filter((c) => c.type === type).map((c) => shapeOf(c.path, colorOf(c), c.id, haplotype));
   return { rects, shapes: [...curves, ...corners] };
 }
 function tubeMapPicture({
@@ -177,7 +178,7 @@ var NODE_TINT_ALPHA = 0.55;
 function drawTubeMap(ctx, picture, frame) {
   const { x, y, width } = frame;
   const visible = (item) => x(item.x1) >= 0 && x(item.x0) <= width;
-  const colorOf = (item) => item.track !== void 0 && frame.tubeColors?.[item.track] || item.color;
+  const colorOf = (item) => item.haplotype && frame.tubeColors?.[item.id] || item.color;
   ctx.globalAlpha = 1;
   for (const layer of picture.layers) {
     fillByColor(ctx, layer.rects, visible, colorOf, (r) => {
@@ -235,6 +236,7 @@ function drawMismatches(ctx, marks, frame) {
   }
   ctx.fill();
   ctx.font = `${fontPx}px monospace`;
+  ctx.textAlign = "left";
   ctx.textBaseline = "alphabetic";
   ctx.fillStyle = darkMode ? "#ffffff" : "#000000";
   for (const m of marks) {
@@ -248,6 +250,23 @@ function drawMismatches(ctx, marks, frame) {
     }
   }
 }
+function tubeMapTrackAt(picture, { x, y }, sx, sy) {
+  for (let l = picture.layers.length - 1; l >= 0; l--) {
+    for (const r of picture.layers[l].rects) {
+      if (x(r.x0) <= sx && sx <= x(r.x1) && y(r.y0) <= sy && sy <= y(r.y1)) {
+        return r.id;
+      }
+    }
+  }
+  return void 0;
+}
+var INSERTION_SLOP_PX = 4;
+function tubeMapMismatchAt(picture, frame, sx, sy) {
+  const { x, y, yScale } = frame;
+  return mismatchesLegible(yScale) ? picture.mismatches.find(
+    (m) => y(m.y) <= sy && sy <= y(m.y + m.height) && (m.kind === "insertion" ? Math.abs(x(m.x) - sx) <= INSERTION_SLOP_PX : x(m.x0) <= sx && sx <= x(m.x1))
+  ) : void 0;
+}
 
 export {
   parsePath,
@@ -255,5 +274,7 @@ export {
   tubeMapPicture,
   drawTubeMap,
   mismatchesLegible,
-  mismatchOnScreen
+  mismatchOnScreen,
+  tubeMapTrackAt,
+  tubeMapMismatchAt
 };

package/dist/chunks/{chunk-DE4UFDUZ.js → chunk-TLQ7F2ZT.js}

@@ -42,7 +42,7 @@ import {
 } from "./chunk-HBEKUQO4.js";
 import {
   version
-} from "./chunk-3FXPFVKJ.js";
+} from "./chunk-AMS3MAFP.js";
 import {
   axisScaleOf
 } from "./chunk-TL4B342F.js";

package/dist/chunks/{chunk-OWFPAIJI.js → chunk-WEDZ76AK.js}

@@ -1,6 +1,6 @@
 import {
   tubeSpan
-} from "./chunk-DRA7733Q.js";
+} from "./chunk-BPRXQ2SS.js";
 
 // src/tubeMap/genes.ts
 function tubeMapGenes(byRefName, genes) {

package/dist/chunks/{chunk-CF62U3QS.js → chunk-WNUZP3WQ.js}

@@ -1,8 +1,9 @@
 import {
+  hasTubeMapBackbone,
   hasTubeMapPaths,
   tubeMapLayout,
   tubeMapReferenceLayout
-} from "./chunk-W2I4DOL4.js";
+} from "./chunk-INJ2UVOT.js";
 import {
   sampleRowLayout
 } from "./chunk-LOEA5IHZ.js";
@@ -24,7 +25,6 @@ import {
 var FORCE_LAYOUT_LABEL = "Force-directed layout";
 var hasBackbone = (graph) => graph.nodes.some(isBackbone);
 var hasWalks = (graph) => hasBackbone(graph) && (graph.paths?.length ?? 0) > 1;
-var hasTubeMapBackbone = (graph) => hasBackbone(graph) && hasTubeMapPaths(graph);
 var hasAlleles = (graph) => hasBackbone(graph) && graph.nodes.some(isOffReference);
 var LAYOUT_MODES = [
   {

package/dist/chunks/{chunk-733L2TS6.js → chunk-XXT2JCAC.js}

@@ -3,16 +3,13 @@ import { forward, getXCoordinateOfBaseWithinNode } from "@jbrowse/tubemap-core";
 function readMismatches(read, layout) {
   const marks = [];
   const entries = read.sequenceNew ?? [];
+  const visits = read.path.filter((segment) => segment.node !== null);
   entries.forEach((entry, i) => {
     const nodeIndex = layout.nodeMap.get(forward(entry.nodeName));
     const node = nodeIndex === void 0 ? void 0 : layout.nodes[nodeIndex];
-    let pathIndex = i;
-    while (pathIndex < read.path.length && read.path[pathIndex].node !== nodeIndex) {
-      pathIndex += 1;
-    }
-    const y = read.path[pathIndex]?.y;
+    const y = visits[i]?.y;
     if (node && y !== void 0) {
-      const base = { readId: read.id, y, height: read.width, nodeY: node.y };
+      const base = { readId: read.id, y, height: read.width };
       const at = (pos) => getXCoordinateOfBaseWithinNode(node, pos);
       for (const mm of entry.mismatches) {
         const x0 = at(mm.pos);
@@ -29,7 +26,13 @@ function readMismatches(read, layout) {
           } else if (mm.type === "deletion" && mm.length !== void 0) {
             const x1 = at(mm.pos + mm.length);
             if (x1 !== null) {
-              marks.push({ ...base, kind: "deletion", x0, x1 });
+              marks.push({
+                ...base,
+                kind: "deletion",
+                x0,
+                x1,
+                length: mm.length
+              });
             }
           } else if (mm.type === "substitution" && mm.seq !== void 0) {
             const x1 = at(mm.pos + mm.seq.length);

package/dist/chunks/{chunk-GQ2AOHU4.js → chunk-YOYLCLIG.js}

@@ -1,35 +1,14 @@
-import {
-  isBackbone
-} from "./chunk-FYQWPEEY.js";
-
 // src/tubeMap/connectors.ts
-function referenceNodes(graph, layout) {
-  const nodeById = new Map(graph.nodes.map((n) => [n.id, n]));
-  const out = [];
-  layout.nodes.forEach((node) => {
-    const graphNode = nodeById.get(node.name);
-    if (node.order >= 0 && graphNode && isBackbone(graphNode)) {
-      out.push({
-        node: node.name,
-        bp0: graphNode.stable.start,
-        bp1: graphNode.stable.start + node.sequenceLength,
-        x0: node.x,
-        x1: node.x + node.pixelWidth
-      });
-    }
-  });
-  return out;
-}
-function tubeMapConnectors(nodes, bpToScreen, tubeToScreen, width) {
+function tubeMapConnectors(boxes, bpToScreen, tubeToScreen, width) {
   const out = [];
-  for (const n of nodes) {
-    const bottom0 = tubeToScreen(n.x0);
-    const bottom1 = tubeToScreen(n.x1);
+  for (const box of boxes) {
+    const bottom0 = tubeToScreen(box.x0);
+    const bottom1 = tubeToScreen(box.x1);
     if (bottom1 >= 0 && bottom0 <= width) {
       out.push({
-        node: n.node,
-        top0: bpToScreen(n.bp0),
-        top1: bpToScreen(n.bp1),
+        node: box.name,
+        top0: bpToScreen(box.bp0),
+        top1: bpToScreen(box.bp1),
         bottom0,
         bottom1
       });
@@ -105,7 +84,6 @@ function drawTubeMapConnectors(ctx, connectors, bottom, {
 }
 
 export {
-  referenceNodes,
   tubeMapConnectors,
   connectorAt,
   drawTubeMapConnectors