@jbrowse/bandage-core 6.0.1 → 6.0.3

package/dist/index.js

@@ -1,1437 +1,292 @@
+import {
+  wheelZoomFactor
+} from "./chunks/chunk-TDQLINVI.js";
+import {
+  tubeMapFrame,
+  tubeMapNodeAt
+} from "./chunks/chunk-VZQ4FKLR.js";
+import {
+  drawTubeMapGenes,
+  tubeMapGenes
+} from "./chunks/chunk-CTSBC2O6.js";
+import {
+  tubeMapNodeColors
+} from "./chunks/chunk-EPZORFTI.js";
+import {
+  referenceKnots,
+  warpX
+} from "./chunks/chunk-KQFOCDFY.js";
+import {
+  drawTubeMapRuler,
+  referenceBoxes,
+  rulerBoxes,
+  tubeX
+} from "./chunks/chunk-CS3E4ETM.js";
+import {
+  connectorAt,
+  drawTubeMapConnectors,
+  referenceNodes,
+  tubeMapConnectors
+} from "./chunks/chunk-GQ2AOHU4.js";
+import {
+  drawTubeMap,
+  tubeMapPicture
+} from "./chunks/chunk-CR7EGAFE.js";
+import "./chunks/chunk-EJ5OZTCK.js";
+import {
+  bubbleHalos
+} from "./chunks/chunk-ISEI2FH3.js";
+import {
+  bubblesFromGraph
+} from "./chunks/chunk-4S47XRYA.js";
+import {
+  BUBBLE_KIND_COLORS,
+  BUBBLE_KIND_NAMES,
+  bubbleSegmentIds,
+  classifyBubble
+} from "./chunks/chunk-WOO7QYKB.js";
+import "./chunks/chunk-MFKORG3F.js";
+import {
+  bubbleSubgraph
+} from "./chunks/chunk-VHW7FDHU.js";
+import {
+  genesFromBed,
+  genesFromGff3Lines,
+  genesFromText,
+  mergeOverlappingByName
+} from "./chunks/chunk-BXEPA4KS.js";
+import {
+  REFERENCE_STRIP_ZONE_PX,
+  drawReferenceStrip,
+  referenceStripBlocks,
+  stripBlockAt
+} from "./chunks/chunk-EK4HGYO7.js";
+import {
+  FORCE_LAYOUT_LABEL,
+  LAYOUT_MODES,
+  layoutModeByValue,
+  modeUsesLayoutEngine
+} from "./chunks/chunk-T43W7NKK.js";
+import "./chunks/chunk-R6ZUK4Y3.js";
+import "./chunks/chunk-TEDQJPMI.js";
+import "./chunks/chunk-LOEA5IHZ.js";
+import "./chunks/chunk-L3O7AWLI.js";
+import "./chunks/chunk-TZFWUT2C.js";
+import "./chunks/chunk-HNQPEMYE.js";
+import "./chunks/chunk-C44YRP5F.js";
+import "./chunks/chunk-RVS2QCOX.js";
+import {
+  loadBandage
+} from "./chunks/chunk-7XHHVYG7.js";
+import {
+  figureSvg
+} from "./chunks/chunk-5XQDMQXU.js";
+import {
+  svgCanvas
+} from "./chunks/chunk-47DYCZOK.js";
+import {
+  LABELLED_ROW_PX,
+  WALK_STRIP_CEILING_PX,
+  segmentAt,
+  stripGeneGaps,
+  stripMarks,
+  stripRowAt,
+  walkMarksTree,
+  walkStripFrame,
+  walkStripLabelsTree
+} from "./chunks/chunk-ROF2R3RF.js";
 import {
   BAR_PX,
-  BUBBLE_SPREADS,
-  COLOR_SCHEMES,
-  Canvas2DRenderer,
   DISAGREES,
-  EXON_COLOR,
-  FACET_GAP_PX,
-  FACET_PAD_PX,
-  FACET_TITLE_PX,
-  FIT_PADDING,
-  FORCE_LAYOUT_LABEL,
   GAP_PX,
   GENE_INK,
-  HALO_FACTOR,
-  HPRC_GBZ,
-  LABELLED_ROW_PX,
-  LABEL_CHAR_PX,
-  LABEL_PAD,
-  LABEL_PX,
-  LAYOUT_MODES,
-  LEGEND_INSET_PX,
-  LIFT_BACKDROP_CSS,
-  NODE_WIDTHS,
   OFF_REFERENCE,
   ON_REFERENCE,
   OUTSIDE_CUT,
-  RAMP_GRADIENT_CSS,
-  REFERENCE_RAMP_MAX_HUE,
-  ROW_HEIGHT_PX,
-  WALK_FIELDS,
-  WALK_SCHEMES,
-  WALK_STRIP_CEILING_PX,
-  WELL_KNOWN_SAMPLES,
   alongRow,
-  assemblyWalk,
-  axisScaleOf,
-  backboneAssembly,
-  buildGeometry,
-  clampZoom,
   coalesceRuns,
-  computeColorSchemeRange,
-  computeReferenceRamp,
+  genesOnRow,
+  placeRowGenes,
+  readoutPlacement,
+  rowGeneBoxes,
+  rowSpan,
+  runPaint,
+  unitTicks,
+  walkRowReadout,
+  walkRowsKey,
+  walkRowsKeyTree,
+  walkRowsTree
+} from "./chunks/chunk-6SXMCK6I.js";
+import {
+  Canvas2DRenderer
+} from "./chunks/chunk-D3M7SBKL.js";
+import {
+  genePins
+} from "./chunks/chunk-BUBZ32IC.js";
+import {
+  EXON_COLOR,
+  exonOutlineTree,
+  exonStretches
+} from "./chunks/chunk-3S3YVOJ7.js";
+import {
+  version
+} from "./chunks/chunk-LLJUG2H7.js";
+import {
+  axisScaleOf,
   contains,
-  cutGbzRegion,
-  cutWindowGFA,
-  deletionEdges,
-  drawingBounds,
-  el,
+  padded,
+  screenToLayout,
+  viewportOf,
+  zoomAbout
+} from "./chunks/chunk-MQJUG2D2.js";
+import {
+  facetLifts,
+  walkHighlight,
+  walkLift
+} from "./chunks/chunk-GGQRADFS.js";
+import {
+  WALK_FIELDS,
+  WALK_SCHEMES,
   encodingStops,
   encodingSwatchCss,
+  resolveEncoding,
+  schemeCss
+} from "./chunks/chunk-WFX3MAKA.js";
+import {
+  rangeText,
+  walkKey,
+  walkPosition
+} from "./chunks/chunk-GOY6REMT.js";
+import {
+  FIT_PADDING,
+  clampZoom,
+  drawingBounds,
   engineKey,
   engineRequest,
-  exonOutlineTree,
-  exonStretches,
-  facetCells,
-  facetGrid,
-  facetLifts,
-  facetSettingOf,
-  featuresOnBackbone,
-  figureSvg,
-  filterSamples,
-  findHoveredEdge,
-  findHoveredNode,
   fitTransform,
   forceLayout,
-  formatBp,
-  geneCoverageNote,
-  genePins,
-  genesFromBed,
-  genesFromGff3Lines,
-  genesFromText,
-  genesOnRow,
-  getNodeColor,
-  graphBackbone,
-  haplotypeWanted,
-  isBackbone,
   layoutExtent,
-  layoutLabels,
-  layoutModeByValue,
-  loadBandage,
-  loadGraph,
+  loadGraph
+} from "./chunks/chunk-IO2PCPZI.js";
+import "./chunks/chunk-PUG7LXDF.js";
+import "./chunks/chunk-IGVV37VI.js";
+import "./chunks/chunk-72N5DJHZ.js";
+import "./chunks/chunk-QYBZZI5H.js";
+import "./chunks/chunk-CDLPYR5O.js";
+import "./chunks/chunk-MI35EUIE.js";
+import {
+  RAMP_GRADIENT_CSS,
+  rampHue,
+  rampHueCss,
+  rampStops
+} from "./chunks/chunk-CJ2EE4AF.js";
+import {
+  REFERENCE_RAMP_MAX_HUE,
+  buildGeometry,
+  computeReferenceRamp
+} from "./chunks/chunk-PCZ4PTYC.js";
+import "./chunks/chunk-MNUSQCLG.js";
+import {
+  HALO_FACTOR,
+  LEGEND_INSET_PX,
+  geneCoverageNote,
+  layoutLabels
+} from "./chunks/chunk-DKOB2OPC.js";
+import {
+  findHoveredEdge,
+  findHoveredNode
+} from "./chunks/chunk-YMSSF2RK.js";
+import "./chunks/chunk-MREQ7GIA.js";
+import "./chunks/chunk-Y3IOTZJA.js";
+import {
+  walkRowsExtent
+} from "./chunks/chunk-EZPBJPK6.js";
+import {
+  filterSamples,
+  walkRows
+} from "./chunks/chunk-SZNZ2T6D.js";
+import {
+  pathColorsLegible,
+  pathLegend
+} from "./chunks/chunk-X5L37W4J.js";
+import "./chunks/chunk-ST2IBUAN.js";
+import "./chunks/chunk-ES2N6V56.js";
+import {
+  formatBp
+} from "./chunks/chunk-N62KBLFC.js";
+import {
+  LABEL_CHAR_PX,
+  LABEL_PAD,
+  LABEL_PX
+} from "./chunks/chunk-AB35TJST.js";
+import "./chunks/chunk-TAMCZHLW.js";
+import {
+  NODE_WIDTHS,
   maxNodeWidthPx,
   meanDepth,
-  mergeOverlappingByName,
-  modeUsesLayoutEngine,
   nodeInk,
-  nodeWidthPx,
+  nodeWidthPx
+} from "./chunks/chunk-PBENCR5L.js";
+import {
+  BUBBLE_SPREADS
+} from "./chunks/chunk-UVBGRJQX.js";
+import "./chunks/chunk-6JEWNXCQ.js";
+import {
+  COLOR_SCHEMES,
+  resolveColorScheme
+} from "./chunks/chunk-JKJWSY4V.js";
+import {
+  deletionEdges
+} from "./chunks/chunk-4EMPBO7S.js";
+import "./chunks/chunk-2CVHXFK7.js";
+import {
+  ROW_HEIGHT_PX
+} from "./chunks/chunk-CPMHA4W5.js";
+import {
+  el,
+  serializeEl
+} from "./chunks/chunk-NNODIW4U.js";
+import {
+  FACET_GAP_PX,
+  FACET_PAD_PX,
+  FACET_TITLE_PX,
+  facetCells,
+  facetGrid,
+  facetSettingOf
+} from "./chunks/chunk-6SBUFFTB.js";
+import {
+  HPRC_GBZ,
+  cutGbzRegion,
   openGbz,
-  padded,
-  panSNContig,
-  panSNHaplotype,
-  panSNSample,
-  parseRegion,
-  pathColorsLegible,
-  pathLegend,
-  placeRowGenes,
-  rampHue,
-  rampHueCss,
-  rampStops,
-  rangeText,
-  readoutPlacement,
-  refNameBinding,
-  referenceLabel,
-  referenceOrder,
+  parseRegion
+} from "./chunks/chunk-73RSLGZT.js";
+import {
+  cutWindowGFA,
+  haplotypeWanted,
   referencePathQuery,
   referenceSamplesOf,
-  resolveColorScheme,
-  resolveEncoding,
-  resolveReferenceSample,
-  rowGeneBoxes,
-  rowSpan,
-  runPaint,
-  schemeCss,
-  screenToLayout,
-  segmentAt,
-  serializeEl,
-  stripGeneGaps,
-  stripMarks,
-  stripRowAt,
-  svgCanvas,
-  svgPath,
-  trimOrigins,
-  unitTicks,
-  version,
-  viewportOf,
-  walkHighlight,
-  walkKey,
-  walkLift,
-  walkMarksTree,
-  walkPosition,
-  walkRowReadout,
-  walkRows,
-  walkRowsExtent,
-  walkRowsKey,
-  walkRowsKeyTree,
-  walkRowsTree,
-  walkStripFrame,
-  walkStripLabelsTree,
-  wellKnownSample,
-  zoomAbout
-} from "./chunks/chunk-EXSFRX2F.js";
+  resolveReferenceSample
+} from "./chunks/chunk-LTUWJKHD.js";
+import "./chunks/chunk-WSIFAZU7.js";
+import {
+  WELL_KNOWN_SAMPLES,
+  assemblyWalk,
+  backboneAssembly,
+  featuresOnBackbone,
+  graphBackbone,
+  refNameBinding,
+  referenceLabel,
+  wellKnownSample
+} from "./chunks/chunk-RAKOB6IV.js";
+import {
+  panSNContig,
+  panSNHaplotype,
+  panSNSample
+} from "./chunks/chunk-BPLIXMH7.js";
+import "./chunks/chunk-FYQWPEEY.js";
 
 // src/index.ts
 import { getDpr } from "@jbrowse/render-core/canvas2dUtils";
-
-// src/util/wheelZoom.ts
-var ZOOM_PER_NOTCH = 1.1;
-var NOTCH_PX = 100;
-var LINE_PX = 40;
-var PAGE_PX = 800;
-var PINCH_GAIN = 10;
-var MAX_NOTCHES_PER_EVENT = 2;
-function wheelZoomFactor(e) {
-  const px = e.deltaY * (e.deltaMode === 1 ? LINE_PX : e.deltaMode === 2 ? PAGE_PX : 1);
-  const notches = (e.ctrlKey ? PINCH_GAIN : 1) * px / NOTCH_PX;
-  return ZOOM_PER_NOTCH ** -Math.max(-MAX_NOTCHES_PER_EVENT, Math.min(MAX_NOTCHES_PER_EVENT, notches));
-}
-
-// src/referenceStrip.ts
-import { abgrToCssRgba } from "@jbrowse/core/util/colorBits";
-var REFERENCE_STRIP_PX = 12;
-var REFERENCE_STRIP_ZONE_PX = REFERENCE_STRIP_PX + 8;
-var OVERHANG_PX = 8;
-var OVERHANG_CAP_PX = OVERHANG_PX + 3;
-var MIN_STAGGER_PX = 12;
-function referenceStripBlocks(graph, {
-  colorScheme,
-  referenceRamp,
-  walks
-}) {
-  const range = { ...computeColorSchemeRange(graph), referenceRamp };
-  const out = [];
-  graph.nodes.forEach((node, index) => {
-    if (isBackbone(node)) {
-      const colors = walks ? walks.map((w) => {
-        const lane = w.colors.get(node.id);
-        return lane === void 0 ? LIFT_BACKDROP_CSS : abgrToCssRgba(lane);
-      }) : [abgrToCssRgba(getNodeColor(node, index, colorScheme, range))];
-      out.push({
-        node: node.id,
-        bp0: node.stable.start,
-        bp1: node.stable.start + node.length,
-        colors,
-        faded: colors.includes(LIFT_BACKDROP_CSS)
-      });
-    }
-  });
-  return out.sort((a, b) => a.bp0 - b.bp0);
-}
-function span(frame, bp0, bp1) {
-  const a = bp0 * frame.scale + frame.translateX;
-  const b = bp1 * frame.scale + frame.translateX;
-  return a < b ? [a, b] : [b, a];
-}
-var HIT_SLOP_PX = 2;
-function stripOverhang(blocks, frame, width) {
-  const a = -frame.translateX / frame.scale;
-  const b = (width - frame.translateX) / frame.scale;
-  const lo = Math.min(a, b);
-  const hi = Math.max(a, b);
-  let below = 0;
-  let above = 0;
-  for (const block of blocks) {
-    below += Math.max(0, Math.min(block.bp1, lo) - block.bp0);
-    above += Math.max(0, block.bp1 - Math.max(block.bp0, hi));
-  }
-  return frame.scale >= 0 ? { left: Math.round(below), right: Math.round(above) } : { left: Math.round(above), right: Math.round(below) };
-}
-function stripBlockAt(blocks, frame, sx, sy) {
-  if (sy < 0 || sy > REFERENCE_STRIP_PX + HIT_SLOP_PX) {
-    return void 0;
-  }
-  let hit;
-  let best = HIT_SLOP_PX;
-  for (const b of blocks) {
-    const [x0, x1] = span(frame, b.bp0, b.bp1);
-    const dist = Math.max(0, x0 - sx, sx - x1);
-    if (dist <= best) {
-      best = dist;
-      hit = b.node;
-    }
-  }
-  return hit;
-}
-function stripPixels(blocks, frame, width, dpr) {
-  const placed = blocks.map((b) => {
-    const [x0, x1] = span(frame, b.bp0, b.bp1);
-    const px0 = Math.round(x0 * dpr);
-    return {
-      colors: b.colors,
-      x0,
-      px0,
-      px1: Math.max(Math.round(x1 * dpr), px0 + 1)
-    };
-  }).filter((b) => b.px1 > 0 && b.px0 < width * dpr).sort((a, b) => a.x0 - b.x0);
-  const out = [];
-  let claimed = -Infinity;
-  const tierEnds = [-Infinity, -Infinity];
-  for (const { colors, px0, px1 } of placed) {
-    const start = Math.max(px0, claimed);
-    if (px1 > start) {
-      const tier = tierEnds[0] < start ? 0 : 1;
-      tierEnds[tier] = px1;
-      out.push({ colors, x0: start / dpr, x1: px1 / dpr, tier });
-      claimed = px1;
-    }
-  }
-  const covered = out.length > 0 ? out.at(-1).x1 - out[0].x0 : 0;
-  return covered >= out.length * MIN_STAGGER_PX ? out : out.map(({ tier: _, ...b }) => b);
-}
-function drawOverhang(ctx, edgeX, inward, ink) {
-  const capX = inward > 0 ? edgeX : edgeX - OVERHANG_CAP_PX;
-  ctx.clearRect(capX, 0, OVERHANG_CAP_PX, REFERENCE_STRIP_PX);
-  const tipX = edgeX + inward;
-  const baseX = tipX + inward * OVERHANG_PX;
-  ctx.beginPath();
-  ctx.moveTo(tipX, REFERENCE_STRIP_PX / 2);
-  ctx.lineTo(baseX, 0);
-  ctx.lineTo(baseX, REFERENCE_STRIP_PX);
-  ctx.closePath();
-  ctx.fillStyle = ink;
-  ctx.fill();
-}
-function rowEdge(row, rows, dpr) {
-  return Math.round(row * REFERENCE_STRIP_PX * dpr / rows) / dpr;
-}
-function drawReferenceStrip(ctx, blocks, frame, {
-  width,
-  lit,
-  darkMode,
-  dpr = 1
-}) {
-  const ink = darkMode ? "#ffffff" : "#18181c";
-  ctx.clearRect(0, 0, width, REFERENCE_STRIP_ZONE_PX);
-  for (const b of stripPixels(blocks, frame, width, dpr)) {
-    const { tier } = b;
-    const staggered = tier !== void 0 && b.colors.length === 1;
-    const rows = staggered ? 2 : b.colors.length;
-    b.colors.forEach((color, i) => {
-      const row = staggered ? tier : i;
-      const y0 = rowEdge(row, rows, dpr);
-      ctx.fillStyle = color;
-      ctx.fillRect(b.x0, y0, b.x1 - b.x0, rowEdge(row + 1, rows, dpr) - y0);
-    });
-  }
-  const overhang = stripOverhang(blocks, frame, width);
-  if (overhang.left > 0) {
-    drawOverhang(ctx, 0, 1, ink);
-  }
-  if (overhang.right > 0) {
-    drawOverhang(ctx, width, -1, ink);
-  }
-  if (lit) {
-    const [x0, x1] = span(frame, lit.start, lit.end);
-    const w = Math.max(x1 - x0, 3);
-    const left = (x0 + x1) / 2 - w / 2;
-    ctx.strokeStyle = ink;
-    ctx.lineWidth = 1.5;
-    ctx.strokeRect(left, 0.75, w, REFERENCE_STRIP_PX - 1.5);
-    if (lit.anchor) {
-      ctx.beginPath();
-      ctx.moveTo(left + w / 2, REFERENCE_STRIP_PX);
-      ctx.lineTo(lit.anchor.x, lit.anchor.y);
-      ctx.lineWidth = 1;
-      ctx.stroke();
-    }
-  }
-}
-
-// src/tubeMap/draw.ts
-import { curvePaths, nodeOutlinePath } from "@gmod/tubemap-core";
-
-// src/tubeMap/mismatches.ts
-import { forward, getXCoordinateOfBaseWithinNode } from "@gmod/tubemap-core";
-function readMismatches(read, layout) {
-  const marks = [];
-  const entries = read.sequenceNew ?? [];
-  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;
-    if (node && y !== void 0) {
-      const base = { readId: read.id, y, height: read.width, nodeY: node.y };
-      const at = (pos) => getXCoordinateOfBaseWithinNode(node, pos);
-      for (const mm of entry.mismatches) {
-        const x0 = at(mm.pos);
-        if (x0 !== null) {
-          if (mm.type === "insertion") {
-            const softClip = i === 0 && mm.pos === read.firstNodeOffset || i === entries.length - 1 && mm.pos === read.finalNodeCoverLength;
-            marks.push({
-              ...base,
-              kind: "insertion",
-              x: x0,
-              seq: mm.seq,
-              softClip
-            });
-          } 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 });
-            }
-          } else if (mm.type === "substitution" && mm.seq !== void 0) {
-            const x1 = at(mm.pos + mm.seq.length);
-            if (x1 !== null) {
-              marks.push({ ...base, kind: "substitution", x0, x1, seq: mm.seq });
-            }
-          }
-        }
-      }
-    }
-  });
-  return marks;
-}
-function tubeMapMismatches(layout) {
-  return layout.reads.flatMap((read) => readMismatches(read, layout));
-}
-
-// src/tubeMap/draw.ts
-function parsePath(d) {
-  const tokens = d.trim().split(/[\s,]+/);
-  const commands = [];
-  let i = 0;
-  const num = () => Number(tokens[i++]);
-  while (i < tokens.length) {
-    const op = tokens[i++];
-    if (op === "M" || op === "L") {
-      commands.push({ op, x: num(), y: num() });
-    } else if (op === "H") {
-      commands.push({ op, x: num() });
-    } else if (op === "V") {
-      commands.push({ op, y: num() });
-    } else if (op === "Q") {
-      commands.push({ op, x1: num(), y1: num(), x: num(), y: num() });
-    } else if (op === "C") {
-      commands.push({
-        op,
-        x1: num(),
-        y1: num(),
-        x2: num(),
-        y2: num(),
-        x: num(),
-        y: num()
-      });
-    } else if (op === "Z") {
-      commands.push({ op });
-    }
-  }
-  return commands;
-}
-function extentOf(commands) {
-  let x0 = Infinity;
-  let x1 = -Infinity;
-  for (const c of commands) {
-    if ("x" in c) {
-      x0 = Math.min(x0, c.x);
-      x1 = Math.max(x1, c.x);
-    }
-    if ("x1" in c) {
-      x0 = Math.min(x0, c.x1);
-      x1 = Math.max(x1, c.x1);
-    }
-  }
-  return { x0, x1 };
-}
-function shapeOf(d, color, alpha, track) {
-  const commands = parsePath(d);
-  return { commands, color, track, alpha, ...extentOf(commands) };
-}
-function layerOf(layout, type) {
-  const { shapes } = layout;
-  const trackOf = (s) => type === "haplotype" ? s.id : void 0;
-  const rects = [...shapes.rectangles, ...shapes.verticalRectangles].filter((r) => r.type === type).map((r) => ({
-    color: r.color,
-    track: trackOf(r),
-    alpha: r.alpha ?? 1,
-    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, c.color, c.alpha ?? 1, trackOf(c))
-  );
-  const corners = shapes.corners.filter((c) => c.type === type).map((c) => shapeOf(c.path, c.color, 1, trackOf(c)));
-  return { rects, shapes: [...curves, ...corners] };
-}
-function tubeMapPicture(layout) {
-  const nodes = [];
-  layout.nodes.forEach((node) => {
-    if (node.order >= 0) {
-      const commands = parsePath(nodeOutlinePath(node));
-      nodes.push({ name: node.name, commands, ...extentOf(commands) });
-    }
-  });
-  return {
-    bounds: layout.bounds,
-    layers: [layerOf(layout, "haplotype"), layerOf(layout, "read")],
-    nodes,
-    mismatches: tubeMapMismatches(layout).filter(
-      (m) => m.kind !== "insertion" || !m.softClip
-    )
-  };
-}
-function trace(ctx, commands, x, y) {
-  let cx = 0;
-  let cy = 0;
-  for (const c of commands) {
-    switch (c.op) {
-      case "M":
-        cx = c.x;
-        cy = c.y;
-        ctx.moveTo(x(cx), y(cy));
-        break;
-      case "L":
-        cx = c.x;
-        cy = c.y;
-        ctx.lineTo(x(cx), y(cy));
-        break;
-      case "H":
-        cx = c.x;
-        ctx.lineTo(x(cx), y(cy));
-        break;
-      case "V":
-        cy = c.y;
-        ctx.lineTo(x(cx), y(cy));
-        break;
-      case "Q":
-        cx = c.x;
-        cy = c.y;
-        ctx.quadraticCurveTo(x(c.x1), y(c.y1), x(cx), y(cy));
-        break;
-      case "C":
-        cx = c.x;
-        cy = c.y;
-        ctx.bezierCurveTo(x(c.x1), y(c.y1), x(c.x2), y(c.y2), x(cx), y(cy));
-        break;
-      case "Z":
-        ctx.closePath();
-        break;
-    }
-  }
-}
-function fillByColor(ctx, items, visible, colorOf, addTo) {
-  const byColor = /* @__PURE__ */ new Map();
-  for (const item of items) {
-    if (visible(item)) {
-      const key = `${colorOf(item)}|${item.alpha}`;
-      const list = byColor.get(key);
-      if (list) {
-        list.push(item);
-      } else {
-        byColor.set(key, [item]);
-      }
-    }
-  }
-  for (const list of byColor.values()) {
-    ctx.fillStyle = colorOf(list[0]);
-    ctx.globalAlpha = list[0].alpha;
-    ctx.beginPath();
-    for (const item of list) {
-      addTo(item);
-    }
-    ctx.fill();
-  }
-  ctx.globalAlpha = 1;
-}
-var FULL_OUTLINE_PX = 12;
-var MIN_OUTLINE_ALPHA = 0.15;
-function outlineAlpha(screenWidth) {
-  return Math.max(MIN_OUTLINE_ALPHA, Math.min(1, screenWidth / FULL_OUTLINE_PX));
-}
-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;
-  for (const layer of picture.layers) {
-    fillByColor(ctx, layer.rects, visible, colorOf, (r) => {
-      const left = x(r.x0);
-      const top = y(r.y0);
-      ctx.rect(left, top, x(r.x1) - left, y(r.y1) - top);
-    });
-    fillByColor(ctx, layer.shapes, visible, colorOf, (s) => {
-      trace(ctx, s.commands, x, y);
-    });
-  }
-  const stroke = frame.darkMode ? "#d0d0d0" : "#000000";
-  const fill = frame.darkMode ? "rgba(40,40,40,0.4)" : "rgba(255,255,255,0.4)";
-  ctx.lineWidth = 2 * Math.max(0.25, Math.min(1, frame.yScale));
-  for (const node of picture.nodes) {
-    if (visible(node)) {
-      const lit = node.name === frame.highlightNode;
-      ctx.beginPath();
-      trace(ctx, node.commands, x, y);
-      const tint = lit ? void 0 : frame.nodeColors?.get(node.name);
-      ctx.fillStyle = lit ? "rgba(255,192,203,0.5)" : tint ?? fill;
-      ctx.strokeStyle = lit ? "#ff0000" : stroke;
-      ctx.globalAlpha = tint ? NODE_TINT_ALPHA : 1;
-      ctx.fill();
-      ctx.globalAlpha = lit ? 1 : outlineAlpha(x(node.x1) - x(node.x0));
-      ctx.stroke();
-      ctx.globalAlpha = 1;
-    }
-  }
-  drawMismatches(ctx, picture.mismatches, frame);
-}
-var MISMATCH_FONT_PX = 12;
-var MIN_MISMATCH_FONT_PX = 6;
-function mismatchesLegible(yScale) {
-  return MISMATCH_FONT_PX * yScale >= MIN_MISMATCH_FONT_PX;
-}
-function mismatchOnScreen(m, { x, width }) {
-  const [x0, x1] = m.kind === "insertion" ? [m.x, m.x] : [m.x0, m.x1];
-  return x(x1) >= 0 && x(x0) <= width;
-}
-function drawMismatches(ctx, marks, frame) {
-  const { x, y, yScale, darkMode } = frame;
-  if (!mismatchesLegible(yScale) || marks.length === 0) {
-    return;
-  }
-  const fontPx = MISMATCH_FONT_PX * yScale;
-  ctx.fillStyle = "grey";
-  ctx.beginPath();
-  for (const m of marks) {
-    if (m.kind === "deletion" && mismatchOnScreen(m, frame)) {
-      const left = x(m.x0);
-      const top = y(m.y);
-      ctx.rect(left, top, x(m.x1) - left, y(m.y + m.height) - top);
-    }
-  }
-  ctx.fill();
-  ctx.font = `${fontPx}px monospace`;
-  ctx.textBaseline = "alphabetic";
-  ctx.fillStyle = darkMode ? "#ffffff" : "#000000";
-  for (const m of marks) {
-    if (!mismatchOnScreen(m, frame)) {
-      continue;
-    }
-    if (m.kind === "substitution") {
-      ctx.fillText(m.seq, x(m.x0) + 1, y(m.y + m.height));
-    } else if (m.kind === "insertion") {
-      ctx.fillText("*", x(m.x) - 3, y(m.y + m.height));
-    }
-  }
-}
-
-// src/tubeMap/nodeColors.ts
-import { abgrToCssRgba as abgrToCssRgba2 } from "@jbrowse/core/util/colorBits";
-function tubeMapNodeColors(graph, colorScheme, referenceRamp) {
-  if (colorScheme === "uniform" || colorScheme === "grey") {
-    return void 0;
-  }
-  const range = { ...computeColorSchemeRange(graph), referenceRamp };
-  return new Map(
-    graph.nodes.map((node, index) => [
-      node.id,
-      abgrToCssRgba2(getNodeColor(node, index, colorScheme, range))
-    ])
-  );
-}
-
-// src/tubeMap/warp.ts
-var MAX_GAP_PX = 24;
-var isReal = (c) => c.bp1 > c.bp0;
-function referenceKnots(columns, bpToScreen) {
-  const real = columns.filter(isReal);
-  if (real.length === 0) {
-    const first = columns[0];
-    return first ? [{ tx: first.x0, sx: bpToScreen(first.bp0) }] : [];
-  }
-  const screen = real.map((c) => ({
-    c,
-    s0: bpToScreen(c.bp0),
-    s1: bpToScreen(c.bp1),
-    trimLeft: 0,
-    trimRight: 0
-  }));
-  for (let i = 0; i + 1 < screen.length; i++) {
-    const left = screen[i];
-    const right = screen[i + 1];
-    const demand = Math.min(right.c.x0 - left.c.x1, MAX_GAP_PX);
-    const short = demand - (right.s0 - left.s1);
-    if (short > 0) {
-      const capLeft = (left.s1 - left.s0) / 2;
-      const capRight = (right.s1 - right.s0) / 2;
-      let fromLeft = Math.min(short / 2, capLeft);
-      const fromRight = Math.min(short - fromLeft, capRight);
-      fromLeft = Math.min(short - fromRight, capLeft);
-      left.trimRight = fromLeft;
-      right.trimLeft = fromRight;
-    }
-  }
-  const knots = [];
-  for (const { c, s0, s1, trimLeft, trimRight } of screen) {
-    knots.push(
-      { tx: c.x0, sx: s0 + trimLeft },
-      { tx: c.x1, sx: s1 - trimRight }
-    );
-  }
-  return knots;
-}
-function warpX(knots, tx) {
-  const n = knots.length;
-  if (n === 0) {
-    return tx;
-  }
-  const first = knots[0];
-  const last = knots[n - 1];
-  if (tx <= first.tx) {
-    return first.sx + (tx - first.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 b = knots[hi];
-  const span2 = b.tx - a.tx;
-  return span2 > 0 ? a.sx + (tx - a.tx) / span2 * (b.sx - a.sx) : a.sx;
-}
-
-// src/tubeMap/frame.ts
-var MIN_TUBE_Y_SCALE = 0.05;
-var NODE_BOX_PAD = 9;
-function squeeze(drawing, usableHeight) {
-  const { minY, maxY } = drawing.layout.bounds;
-  const h = maxY - minY;
-  return drawing.columns && h > 0 ? Math.max(MIN_TUBE_Y_SCALE, Math.min(1, usableHeight / h)) : 1;
-}
-function tubeMapFrame(drawing, view) {
-  const { scaleX, translateX, translateY } = view;
-  const yScale = view.scaleY * squeeze(drawing, view.usableHeight);
-  const y = (ty) => (ty - drawing.yOffset) * yScale + translateY;
-  const { columns } = drawing;
-  if (columns) {
-    const knots = referenceKnots(columns, (bp) => bp * scaleX + translateX);
-    return { x: (tx) => warpX(knots, tx), y, yScale };
-  }
-  return { x: (tx) => tx * scaleX + translateX, y, yScale };
-}
-function tubeMapNodeAt(drawing, { x, y }, sx, sy) {
-  let hit = null;
-  drawing.layout.nodes.forEach((node) => {
-    if (node.order >= 0 && x(node.x - NODE_BOX_PAD) <= sx && sx <= x(node.x + node.pixelWidth + NODE_BOX_PAD) && y(node.y - NODE_BOX_PAD) <= sy && sy <= y(node.y + node.contentHeight + NODE_BOX_PAD)) {
-      hit = node.name;
-    }
-  });
-  return hit;
-}
-
-// src/tubeMap/axis.ts
-function referenceBoxes(graph, layout) {
-  const nodeById = new Map(graph.nodes.map((n) => [n.id, n]));
-  const byRefName = /* @__PURE__ */ new Map();
-  layout.nodes.forEach((node) => {
-    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({
-        bp0: start,
-        bp1: start + node.sequenceLength,
-        x0: node.x,
-        x1: node.x + node.pixelWidth
-      });
-    }
-  });
-  for (const boxes of byRefName.values()) {
-    boxes.sort((a, b) => a.bp0 - b.bp0);
-  }
-  return byRefName;
-}
-function tubeX(boxes, bp, isEnd = false) {
-  let lo = 0;
-  let hi = boxes.length - 1;
-  while (lo < hi) {
-    const mid = lo + hi >> 1;
-    const bp1 = boxes[mid].bp1;
-    if (isEnd ? bp1 < bp : bp1 <= bp) {
-      lo = mid + 1;
-    } else {
-      hi = mid;
-    }
-  }
-  const box = boxes[lo];
-  if (bp <= box.bp0) {
-    return box.x0;
-  }
-  const span2 = box.bp1 - box.bp0;
-  return span2 > 0 ? box.x0 + (Math.min(bp, box.bp1) - box.bp0) / span2 * (box.x1 - box.x0) : box.x0;
-}
-function tubeSpan(boxes, start, end) {
-  const a = tubeX(boxes, start);
-  const b = tubeX(boxes, end, true);
-  return { x0: Math.min(a, b), x1: Math.max(a, b) };
-}
-function rulerBoxes(byRefName) {
-  let best;
-  for (const boxes of byRefName.values()) {
-    if (!best || boxes.length > best.length) {
-      best = boxes;
-    }
-  }
-  return best;
-}
-var TICK_PX = 5;
-var LABEL_GAP_PX = 10;
-var TARGET_TICK_PX = 110;
-var MIN_BRACKET_PX = 3;
-function rulerInk(darkMode) {
-  return darkMode ? "#b0b0b8" : "#55555c";
-}
-function niceStep(raw) {
-  const pow = 10 ** Math.floor(Math.log10(raw));
-  const m = raw / pow;
-  return (m <= 1 ? 1 : m <= 2 ? 2 : m <= 5 ? 5 : 10) * pow;
-}
-function placeLabels(candidates) {
-  const placed = [];
-  for (const a of candidates) {
-    if (placed.every(
-      (b) => Math.abs(a.at - b.at) >= (a.width + b.width) / 2 + LABEL_GAP_PX
-    )) {
-      placed.push(a);
-    }
-  }
-  return placed.map(({ text, at }) => ({ text, at }));
-}
-function scaleMarks(boxes, x, width, measure) {
-  const first = boxes[0];
-  const last = boxes.at(-1);
-  if (!first || !last) {
-    return void 0;
-  }
-  const from = x(first.x0);
-  const to = x(last.x1);
-  const bpSpan = last.bp1 - first.bp0;
-  if (to <= from || bpSpan <= 0) {
-    return void 0;
-  }
-  const step = niceStep(bpSpan / (to - from) * TARGET_TICK_PX);
-  const ticks = [];
-  const positions = [];
-  for (let bp = Math.ceil(first.bp0 / step) * step; bp <= last.bp1; bp += step) {
-    const sx = Math.round(x(tubeX(boxes, bp))) + 0.5;
-    if (sx >= 0 && sx <= width) {
-      ticks.push(sx);
-      const text = bp.toLocaleString("en-US");
-      positions.push({ text, at: sx, width: measure(text) });
-    }
-  }
-  return {
-    spans: [{ x0: from, x1: to }],
-    ticks,
-    labels: placeLabels(positions)
-  };
-}
-function boxMarks(boxes, x, width, measure) {
-  const shown = boxes.map((box) => ({ box, s0: x(box.x0), s1: x(box.x1) })).filter(({ s0, s1 }) => s1 >= 0 && s0 <= width);
-  const first = shown[0];
-  const last = shown.at(-1);
-  if (!first || !last) {
-    return void 0;
-  }
-  const label = (text, at) => ({
-    text,
-    at,
-    width: measure(text)
-  });
-  const position = (bp, at) => label(bp.toLocaleString("en-US"), at);
-  const spans = [];
-  const ticks = [];
-  const lengths = [];
-  const boundaries = [];
-  for (const { box, s0, s1 } of shown) {
-    spans.push({ x0: s0, x1: s1 });
-    ticks.push(Math.round(s0) + 0.5);
-    if (s1 - s0 >= MIN_BRACKET_PX) {
-      ticks.push(Math.round(s1) + 0.5);
-    }
-    const length = label(formatBp(box.bp1 - box.bp0), (s0 + s1) / 2);
-    if (length.width <= s1 - s0) {
-      lengths.push(length);
-    }
-    if (box !== first.box) {
-      boundaries.push(position(box.bp0, s0));
-    }
-  }
-  const ends = [
-    position(first.box.bp0, first.s0),
-    position(last.box.bp1, last.s1)
-  ];
-  return {
-    spans,
-    ticks,
-    labels: placeLabels([...ends, ...lengths, ...boundaries])
-  };
-}
-function rulerMarks(boxes, x, width, measure, referenceAxis = false) {
-  return (referenceAxis ? scaleMarks : boxMarks)(boxes, x, width, measure);
-}
-function drawTubeMapRuler(ctx, boxes, frame, top, referenceAxis = false) {
-  const { x, width, darkMode } = frame;
-  ctx.font = "10px sans-serif";
-  const marks = rulerMarks(
-    boxes,
-    x,
-    width,
-    (text) => ctx.measureText(text).width,
-    referenceAxis
-  );
-  if (!marks) {
-    return;
-  }
-  const ink = rulerInk(darkMode);
-  const y = top + 0.5;
-  ctx.strokeStyle = ink;
-  ctx.fillStyle = ink;
-  ctx.lineWidth = 1;
-  ctx.textAlign = "center";
-  ctx.textBaseline = "top";
-  ctx.beginPath();
-  for (const { x0, x1 } of marks.spans) {
-    ctx.moveTo(Math.max(0, x0), y);
-    ctx.lineTo(Math.min(width, x1), y);
-  }
-  for (const sx of marks.ticks) {
-    ctx.moveTo(sx, top);
-    ctx.lineTo(sx, top + TICK_PX);
-  }
-  ctx.stroke();
-  for (const { text, at } of marks.labels) {
-    ctx.fillText(text, at, top + TICK_PX + 2);
-  }
-}
-
-// src/tubeMap/genes.ts
-function tubeMapGenes(byRefName, genes) {
-  const out = [];
-  for (const gene of genes) {
-    const boxes = byRefName.get(gene.refName);
-    const first = boxes?.[0];
-    const last = boxes?.at(-1);
-    if (!boxes || !first || !last) {
-      continue;
-    }
-    const start = Math.max(gene.start, first.bp0);
-    const end = Math.min(gene.end, last.bp1);
-    if (end <= start) {
-      continue;
-    }
-    out.push({
-      gene,
-      ...tubeSpan(boxes, start, end),
-      exons: gene.exons.filter((e) => e.end > start && e.start < end).map(
-        (e) => tubeSpan(boxes, Math.max(e.start, start), Math.min(e.end, end))
-      )
-    });
-  }
-  return out;
-}
-var GENE_ROW_PX = 22;
-var EXON_PX = 8;
-var NAME_FONT = "11px sans-serif";
-var NAME_GAP_PX = 8;
-function drawTubeMapGenes(ctx, genes, frame, bottom, top = 0) {
-  const { x, width, darkMode } = frame;
-  const rows = Math.max(1, Math.floor((bottom - top) / GENE_ROW_PX));
-  const rowEnds = [];
-  const ink = darkMode ? "#e0e0e6" : "#1c1c22";
-  ctx.font = NAME_FONT;
-  ctx.textAlign = "center";
-  ctx.textBaseline = "alphabetic";
-  ctx.fillStyle = ink;
-  ctx.strokeStyle = ink;
-  ctx.lineWidth = 1;
-  const placed = genes.map((g) => ({ g, s0: x(g.x0), s1: x(g.x1) })).filter(({ s0, s1 }) => s1 >= 0 && s0 <= width).sort((a, b) => a.s0 - b.s0);
-  for (const { g, s0, s1 } of placed) {
-    const arrow = g.gene.strand > 0 ? " \u2192" : g.gene.strand < 0 ? "\u2190 " : "";
-    const label = g.gene.strand < 0 ? `${arrow}${g.gene.name}` : `${g.gene.name}${arrow}`;
-    const mid = (Math.max(s0, 0) + Math.min(s1, width)) / 2;
-    const half = ctx.measureText(label).width / 2;
-    const left = Math.min(s0, mid - half);
-    const right = Math.max(s1, mid + half);
-    let row = rowEnds.findIndex((end) => end + NAME_GAP_PX <= left);
-    if (row === -1) {
-      row = Math.min(rowEnds.length, rows - 1);
-    }
-    rowEnds[row] = Math.max(rowEnds[row] ?? -Infinity, right);
-    const glyphY = bottom - row * GENE_ROW_PX - EXON_PX / 2;
-    ctx.beginPath();
-    ctx.moveTo(s0, glyphY + 0.5);
-    ctx.lineTo(s1, glyphY + 0.5);
-    ctx.stroke();
-    for (const e of g.exons) {
-      const e0 = x(e.x0);
-      ctx.fillRect(e0, glyphY - EXON_PX / 2, Math.max(1, x(e.x1) - e0), EXON_PX);
-    }
-    ctx.fillText(label, mid, glyphY - EXON_PX / 2 - 2);
-  }
-}
-
-// 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) {
-  const out = [];
-  for (const n of nodes) {
-    const bottom0 = tubeToScreen(n.x0);
-    const bottom1 = tubeToScreen(n.x1);
-    if (bottom1 >= 0 && bottom0 <= width) {
-      out.push({
-        node: n.node,
-        top0: bpToScreen(n.bp0),
-        top1: bpToScreen(n.bp1),
-        bottom0,
-        bottom1
-      });
-    }
-  }
-  return out;
-}
-var HIT_SLOP_PX2 = 3;
-function connectorAt(connectors, zoneBottom, sx, sy) {
-  if (zoneBottom <= 0 || sy < 0 || sy > zoneBottom) {
-    return void 0;
-  }
-  const t = sy / zoneBottom;
-  let hit;
-  let best = HIT_SLOP_PX2;
-  for (const c of connectors) {
-    const a = c.top0 + (c.bottom0 - c.top0) * t;
-    const b = c.top1 + (c.bottom1 - c.top1) * t;
-    const dist = Math.max(0, Math.min(a, b) - sx, sx - Math.max(a, b));
-    if (dist < best) {
-      best = dist;
-      hit = c.node;
-    }
-  }
-  return hit;
-}
-function band(ctx, c, bottom) {
-  ctx.moveTo(c.top0, 0);
-  ctx.lineTo(c.top1, 0);
-  ctx.lineTo(c.bottom1, bottom);
-  ctx.lineTo(c.bottom0, bottom);
-  ctx.closePath();
-}
-function sides(ctx, c, bottom) {
-  ctx.moveTo(c.top0, 0);
-  ctx.lineTo(c.bottom0, bottom);
-  ctx.moveTo(c.top1, 0);
-  ctx.lineTo(c.bottom1, bottom);
-}
-function drawTubeMapConnectors(ctx, connectors, bottom, {
-  highlightNode,
-  darkMode
-}) {
-  if (bottom <= 0 || connectors.length === 0) {
-    return;
-  }
-  const ink = darkMode ? "255,255,255" : "0,0,0";
-  ctx.beginPath();
-  for (const c of connectors) {
-    band(ctx, c, bottom);
-  }
-  ctx.fillStyle = `rgba(${ink},0.07)`;
-  ctx.fill();
-  ctx.beginPath();
-  for (const c of connectors) {
-    sides(ctx, c, bottom);
-  }
-  ctx.strokeStyle = `rgba(${ink},0.35)`;
-  ctx.lineWidth = 0.5;
-  ctx.stroke();
-  const lit = connectors.find((c) => c.node === highlightNode);
-  if (lit) {
-    ctx.beginPath();
-    band(ctx, lit, bottom);
-    ctx.fillStyle = "rgba(255,192,203,0.5)";
-    ctx.fill();
-    ctx.beginPath();
-    sides(ctx, lit, bottom);
-    ctx.strokeStyle = "#ff0000";
-    ctx.lineWidth = 1;
-    ctx.stroke();
-  }
-}
-
-// src/bubbles/bubbleLine.ts
-var SATURATED_PATH_COUNT = 2147483647;
-
-// src/bubbles/bubblesFromGraph.ts
-function bubblesFromGraph(graph) {
-  if (!graph.nodes.some(isBackbone)) {
-    return [];
-  }
-  const byId = new Map(graph.nodes.map((n) => [n.id, n]));
-  const order = referenceOrder(graph);
-  const indexOf = new Map(order.map((id, i) => [id, i]));
-  const reach = new Int32Array(order.length + 1);
-  const succ = /* @__PURE__ */ new Map();
-  const linked = /* @__PURE__ */ new Set();
-  for (const e of graph.edges) {
-    const a = indexOf.get(e.from);
-    const b = indexOf.get(e.to);
-    if (a === void 0 || b === void 0 || a === b) {
-      continue;
-    }
-    linked.add(`${e.from}>${e.to}`).add(`${e.to}>${e.from}`);
-    const [lo, hi] = a < b ? [a, b] : [b, a];
-    reach[lo + 1]++;
-    reach[hi]--;
-    const [from, to] = a < b ? [e.from, e.to] : [e.to, e.from];
-    (succ.get(from) ?? succ.set(from, /* @__PURE__ */ new Set()).get(from)).add(to);
-  }
-  for (let i = 1; i < reach.length; i++) {
-    reach[i] += reach[i - 1];
-  }
-  const backbone = graph.nodes.filter(isBackbone).sort((a, b) => a.stable.start - b.stable.start);
-  const ends = /* @__PURE__ */ new Set([backbone[0].id, backbone.at(-1).id]);
-  const boundaries = backbone.map((node) => [node, indexOf.get(node.id)]).filter(([node, i]) => ends.has(node.id) || reach[i] === 0).sort(([a, ia], [b, ib]) => ia - ib || a.stable.start - b.stable.start);
-  const walkIndex = graph.paths?.map((p) => {
-    const at = /* @__PURE__ */ new Map();
-    p.nodeIds.forEach((id, i) => {
-      if (!at.has(id)) {
-        at.set(id, i);
-      }
-    });
-    return at;
-  });
-  const bubbles = [];
-  for (let i = 0; i + 1 < boundaries.length; i++) {
-    const [start, i0] = boundaries[i];
-    const [end, i1] = boundaries[i + 1];
-    const interior = order.slice(i0 + 1, i1);
-    if (interior.length === 0) {
-      continue;
-    }
-    const best = /* @__PURE__ */ new Map([[start.id, { min: 0, max: 0, n: 1 }]]);
-    for (const id of [start.id, ...interior]) {
-      const cur = best.get(id);
-      if (!cur) {
-        continue;
-      }
-      for (const t of succ.get(id) ?? []) {
-        const ti = indexOf.get(t);
-        if (ti > i1) {
-          continue;
-        }
-        const add = t === end.id ? 0 : byId.get(t).length;
-        const prev = best.get(t);
-        best.set(t, {
-          min: Math.min(prev?.min ?? Infinity, cur.min + add),
-          max: Math.max(prev?.max ?? -Infinity, cur.max + add),
-          n: Math.min(SATURATED_PATH_COUNT, cur.n + (prev?.n ?? 0))
-        });
-      }
-    }
-    const walked = walkIndex && walkRoutes(graph, byId, walkIndex, start.id, end.id);
-    const crossed = walked?.n ? walked : void 0;
-    const routes2 = crossed ?? best.get(end.id) ?? { min: 0, max: 0, n: 0 };
-    const walksLeave = walked !== void 0 && walked.left > 0;
-    const refStart = start.stable.start + start.length;
-    const refEnd = end.stable.start;
-    const chain = [
-      start.id,
-      ...interior.filter((id) => isBackbone(byId.get(id))),
-      end.id
-    ];
-    const chainBroken = chain.some(
-      (id, k) => k > 0 && !linked.has(`${chain[k - 1]}>${id}`)
-    );
-    const partial = chainBroken || walksLeave;
-    const fallback = chainBroken && !crossed;
-    bubbles.push({
-      refName: start.stable.refName,
-      start: refStart,
-      end: refEnd,
-      segmentCount: interior.length + 2,
-      pathCount: routes2.n,
-      // a real inversion test needs each walk's direction relative to the
-      // reference; the first visit's strand is just whichever path anchored the
-      // node
-      inversion: false,
-      shortestAlleleLength: fallback ? refEnd - refStart : routes2.min,
-      longestAlleleLength: fallback ? refEnd - refStart : routes2.max,
-      segments: [start, ...interior.map((id) => byId.get(id)), end].map((n) => n.name).join(","),
-      shortestAllele: void 0,
-      longestAllele: void 0,
-      partial,
-      routes: crossed?.routes
-    });
-  }
-  return bubbles;
-}
-function walkRoutes(graph, byId, walkIndex, startId, endId) {
-  const seen = /* @__PURE__ */ new Map();
-  let min = Infinity;
-  let max = -Infinity;
-  let left = 0;
-  graph.paths.forEach((p, k) => {
-    const i0 = walkIndex[k].get(startId);
-    const i1 = walkIndex[k].get(endId);
-    if (i0 === void 0 || i1 === void 0) {
-      if (i0 !== void 0 || i1 !== void 0) {
-        left++;
-      }
-      return;
-    }
-    const steps = p.nodeIds.slice(Math.min(i0, i1) + 1, Math.max(i0, i1));
-    if (i1 < i0) {
-      steps.reverse();
-    }
-    let bp = 0;
-    for (const id of steps) {
-      bp += byId.get(id)?.length ?? 0;
-    }
-    const key = steps.join(",");
-    const route = seen.get(key) ?? { steps, bp, walks: [] };
-    route.walks.push(p.name);
-    seen.set(key, route);
-    min = Math.min(min, bp);
-    max = Math.max(max, bp);
-  });
-  return seen.size || left ? { min, max, n: seen.size, left, routes: [...seen.values()] } : void 0;
-}
-
-// src/bubbles/classifyBubble.ts
-var REPEAT_GROWTH = 10;
-function coveringRepeat(b, repeats) {
-  const span2 = b.end - b.start;
-  const growth = b.longestAlleleLength - b.shortestAlleleLength;
-  return repeats.find(
-    (r) => growth <= REPEAT_GROWTH * (r.end - r.start) && (span2 === 0 ? r.start <= b.start && b.start <= r.end : Math.min(b.end, r.end) - Math.max(b.start, r.start) >= span2 / 2)
-  );
-}
-var SUPERBUBBLE_SEGMENTS = 40;
-function formatBp2(bp) {
-  if (bp >= 1e4) {
-    return `${(bp / 1e3).toFixed(0)} kb`;
-  }
-  if (bp >= 1e3) {
-    return `${(bp / 1e3).toFixed(1)} kb`;
-  }
-  return `${bp} bp`;
-}
-function formatBpRange(shortest, longest) {
-  const low = formatBp2(shortest);
-  const high = formatBp2(longest);
-  const unit = high.slice(high.indexOf(" "));
-  return low.endsWith(unit) ? `${low.slice(0, -unit.length)}\u2013${high}` : `${low}\u2013${high}`;
-}
-function routes(count) {
-  if (count >= SATURATED_PATH_COUNT) {
-    return "\u22652.1B routes";
-  }
-  if (count >= 1e5) {
-    return `${(count / 1e3).toFixed(0)}k routes`;
-  }
-  return `${count} routes`;
-}
-function classifyBubble(b, repeats = []) {
-  const c = classifyShape(b, repeats);
-  return b.partial ? { ...c, label: `${c.label}, partial` } : c;
-}
-function classifyShape(b, repeats) {
-  const refSpan = b.end - b.start;
-  const {
-    shortestAlleleLength: shortest,
-    longestAlleleLength: longest,
-    pathCount,
-    segmentCount,
-    inversion
-  } = b;
-  const range = formatBpRange(shortest, longest);
-  if (segmentCount >= SUPERBUBBLE_SEGMENTS) {
-    return {
-      kind: "superbubble",
-      label: `${range} superbubble, ${segmentCount} segments, ${routes(pathCount)}${inversion ? ", inv" : ""}`
-    };
-  }
-  if (inversion) {
-    return { kind: "inversion", label: `${formatBp2(longest)} inv` };
-  }
-  const repeat = longest !== shortest ? coveringRepeat(b, repeats) : void 0;
-  if (repeat) {
-    const name = repeat.name ? ` (${repeat.name})` : "";
-    return {
-      kind: "repeat",
-      label: `${range} repeat array${name}, ${routes(pathCount)}`
-    };
-  }
-  const alleles = pathCount > 2 ? `, ${pathCount} alleles` : "";
-  if (shortest === longest && shortest === refSpan) {
-    return refSpan <= 1 ? { kind: "snp", label: "SNP" } : { kind: "substitution", label: `${formatBp2(refSpan)} sub` };
-  }
-  if (refSpan === 0 || shortest === refSpan) {
-    return {
-      kind: "insertion",
-      label: `\u2264${formatBp2(longest - refSpan)} ins${alleles}`
-    };
-  }
-  if (longest === refSpan) {
-    return {
-      kind: "deletion",
-      label: `${formatBp2(refSpan - shortest)} del${alleles}`
-    };
-  }
-  return {
-    kind: "complex",
-    label: `${formatBp2(refSpan)} ref \u2192 ${range}, ${pathCount} alleles`
-  };
-}
-var BUBBLE_KIND_COLORS = {
-  snp: "#5b6b7a",
-  substitution: "#5b6b7a",
-  insertion: "#2f8fd6",
-  deletion: "#c94040",
-  inversion: "#e07b00",
-  repeat: "#8e3fbf",
-  superbubble: "#8e3fbf",
-  complex: "#8e3fbf"
-};
-var BUBBLE_KIND_NAMES = {
-  snp: "SNP",
-  substitution: "substitution",
-  insertion: "insertion",
-  deletion: "deletion",
-  inversion: "inversion",
-  repeat: "repeat array",
-  superbubble: "superbubble",
-  complex: "site"
-};
-function bubbleSegmentIds(b) {
-  return b.segments.split(",").filter(Boolean);
-}
-
-// src/bubbles/bubbleHalos.ts
-var WHOLE_FRACTION = 0.9;
-var NAMED_WALKS = 2;
-var MIN_CHIPPED_BP = 1e3;
-function bubbleHalos(graph, bubbles, positions, walkLabel = (name) => name, repeats = []) {
-  const byName = new Map(graph.nodes.map((n) => [n.name, n]));
-  const halos = [];
-  for (const bubble of bubbles) {
-    const parts = [];
-    let minX = Infinity;
-    let maxX = -Infinity;
-    let minY = Infinity;
-    const nodeIds = [];
-    const ends = [];
-    for (const name of bubbleSegmentIds(bubble)) {
-      const node = byName.get(name);
-      const line = node && positions[node.id];
-      if (!node || !line?.length) {
-        continue;
-      }
-      if (isBackbone(node) && (node.stable.start < bubble.start || node.stable.start >= bubble.end)) {
-        ends.push(line[Math.floor(line.length / 2)]);
-        continue;
-      }
-      nodeIds.push(node.id);
-      parts.push(svgPath(line.length === 1 ? [line[0], line[0]] : line));
-      for (const p of line) {
-        minX = Math.min(minX, p.x);
-        maxX = Math.max(maxX, p.x);
-        minY = Math.min(minY, p.y);
-      }
-    }
-    if (nodeIds.length === 0) {
-      continue;
-    }
-    const labelAt = { x: (minX + maxX) / 2, y: minY };
-    const anchor = ends.length ? {
-      x: ends.reduce((s, p) => s + p.x, 0) / ends.length,
-      y: ends.reduce((s, p) => s + p.y, 0) / ends.length
-    } : labelAt;
-    const sharing = /* @__PURE__ */ new Map();
-    for (const route of bubble.routes ?? []) {
-      for (const id of new Set(route.steps)) {
-        sharing.set(id, (sharing.get(id) ?? 0) + 1);
-      }
-    }
-    const routes2 = [];
-    for (const route of bubble.routes ?? []) {
-      if (bubble.longestAlleleLength < MIN_CHIPPED_BP) {
-        break;
-      }
-      if (route.steps.length === 0) {
-        continue;
-      }
-      const rarest = Math.min(...route.steps.map((id) => sharing.get(id)));
-      let at;
-      let far = -1;
-      for (const id of route.steps) {
-        if (sharing.get(id) !== rarest) {
-          continue;
-        }
-        for (const p of positions[id] ?? []) {
-          const d = Math.hypot(p.x - anchor.x, p.y - anchor.y);
-          if (d > far) {
-            far = d;
-            at = p;
-          }
-        }
-      }
-      if (at) {
-        routes2.push({ route, at, text: routeText(route, walkLabel) });
-      }
-    }
-    halos.push({
-      bubble,
-      ...classifyBubble(bubble, repeats),
-      path: parts.join(""),
-      labelAt,
-      members: nodeIds.length,
-      nodeIds,
-      whole: nodeIds.length >= WHOLE_FRACTION * graph.nodes.length,
-      routes: routes2
-    });
-  }
-  return halos;
-}
-function routeText(route, walkLabel) {
-  const names = [...new Set(route.walks.map(walkLabel))].sort();
-  const shown = names.slice(0, NAMED_WALKS).join(", ");
-  const more = names.length > NAMED_WALKS ? ` +${names.length - NAMED_WALKS}` : "";
-  return `${shown}${more} \xB7 ${formatBp2(route.bp)}`;
-}
-
-// src/bubbles/popBubble.ts
-function bubbleSubgraph(graph, segmentIds) {
-  const keep = new Set(segmentIds);
-  const nodes = graph.nodes.filter((n) => keep.has(n.name));
-  const ids = new Set(nodes.map((n) => n.id));
-  const lengthOf = new Map(graph.nodes.map((n) => [n.id, n.length]));
-  const kept = /* @__PURE__ */ new Map();
-  const paths = graph.paths?.flatMap((p) => {
-    const first = p.nodeIds.findIndex((id) => ids.has(id));
-    if (first < 0) {
-      return [];
-    }
-    const nodeIds = p.nodeIds.filter((id) => ids.has(id));
-    kept.set(p.name, { first, nodeIds });
-    const before = p.nodeIds.slice(0, first).reduce((sum, id) => sum + (lengthOf.get(id) ?? 0), 0);
-    return [
-      {
-        ...p,
-        nodeIds,
-        ...p.start === void 0 ? {} : { start: p.start + before }
-      }
-    ];
-  });
-  return {
-    name: graph.name,
-    nodes,
-    edges: graph.edges.filter((e) => ids.has(e.from) && ids.has(e.to)),
-    ...paths?.length ? { paths } : {},
-    anchorPaths: trimOrigins(graph, kept),
-    pathVisits: graph.pathVisits,
-    anchoredBy: graph.anchoredBy,
-    referencePath: graph.referencePath
-  };
-}
 export {
   BUBBLE_KIND_COLORS,
   BUBBLE_KIND_NAMES,