@jbrowse/bandage-core 9.0.0 → 9.2.0

package/dist/bubbles/bubbleHalos.js

@@ -1,11 +1,15 @@
 import {
-  bubbleHalos
-} from "../chunks/chunk-ISEI2FH3.js";
-import "../chunks/chunk-WOO7QYKB.js";
-import "../chunks/chunk-MFKORG3F.js";
+  WHOLE_FRACTION,
+  bubbleHalos,
+  coversGraph
+} from "../chunks/chunk-2AWUWGAD.js";
+import "../chunks/chunk-XKWD2RY3.js";
+import "../chunks/chunk-FX4RDMDN.js";
 import "../chunks/chunk-2CVHXFK7.js";
 import "../chunks/chunk-CPMHA4W5.js";
 import "../chunks/chunk-FYQWPEEY.js";
 export {
-  bubbleHalos
+  WHOLE_FRACTION,
+  bubbleHalos,
+  coversGraph
 };

package/dist/bubbles/bubbleLine.js

@@ -1,13 +1,15 @@
 import {
   SATURATED_PATH_COUNT,
   bubbleDescription,
+  bubbleKey,
   bubbleLabel,
   parseBubbleLine,
   sameBubble
-} from "../chunks/chunk-MFKORG3F.js";
+} from "../chunks/chunk-FX4RDMDN.js";
 export {
   SATURATED_PATH_COUNT,
   bubbleDescription,
+  bubbleKey,
   bubbleLabel,
   parseBubbleLine,
   sameBubble

package/dist/bubbles/bubblesFromGraph.js

@@ -1,10 +1,14 @@
 import {
-  bubblesFromGraph
-} from "../chunks/chunk-4S47XRYA.js";
-import "../chunks/chunk-MFKORG3F.js";
+  bubblesFromGraph,
+  walkIndexOf,
+  walkRoutes
+} from "../chunks/chunk-GOZYKNQ2.js";
+import "../chunks/chunk-FX4RDMDN.js";
 import "../chunks/chunk-HNQPEMYE.js";
 import "../chunks/chunk-CPMHA4W5.js";
 import "../chunks/chunk-FYQWPEEY.js";
 export {
-  bubblesFromGraph
+  bubblesFromGraph,
+  walkIndexOf,
+  walkRoutes
 };

package/dist/bubbles/classifyBubble.js

@@ -4,8 +4,8 @@ import {
   bubbleSegmentIds,
   classifyBubble,
   formatBp
-} from "../chunks/chunk-WOO7QYKB.js";
-import "../chunks/chunk-MFKORG3F.js";
+} from "../chunks/chunk-XKWD2RY3.js";
+import "../chunks/chunk-FX4RDMDN.js";
 export {
   BUBBLE_KIND_COLORS,
   BUBBLE_KIND_NAMES,

package/dist/bubbles/superbubbles.js

@@ -0,0 +1,21 @@
+import {
+  MAX_SUPERBUBBLES,
+  graphBubbles,
+  superbubblesFromGraph
+} from "../chunks/chunk-ZDJDM77V.js";
+import "../chunks/chunk-VHW7FDHU.js";
+import "../chunks/chunk-2AWUWGAD.js";
+import "../chunks/chunk-XKWD2RY3.js";
+import "../chunks/chunk-GOZYKNQ2.js";
+import "../chunks/chunk-FX4RDMDN.js";
+import "../chunks/chunk-HNQPEMYE.js";
+import "../chunks/chunk-ST2IBUAN.js";
+import "../chunks/chunk-BPLIXMH7.js";
+import "../chunks/chunk-2CVHXFK7.js";
+import "../chunks/chunk-CPMHA4W5.js";
+import "../chunks/chunk-FYQWPEEY.js";
+export {
+  MAX_SUPERBUBBLES,
+  graphBubbles,
+  superbubblesFromGraph
+};

package/dist/chunks/{chunk-ISEI2FH3.js → chunk-2AWUWGAD.js}

@@ -2,7 +2,7 @@ import {
   bubbleSegmentIds,
   classifyBubble,
   formatBp
-} from "./chunk-WOO7QYKB.js";
+} from "./chunk-XKWD2RY3.js";
 import {
   svgPath
 } from "./chunk-2CVHXFK7.js";
@@ -12,6 +12,9 @@ import {
 
 // src/bubbles/bubbleHalos.ts
 var WHOLE_FRACTION = 0.9;
+function coversGraph(members, nodes) {
+  return members + 2 >= nodes || members >= WHOLE_FRACTION * nodes;
+}
 var NAMED_WALKS = 2;
 var MIN_CHIPPED_BP = 1e3;
 function bubbleHalos(graph, bubbles, positions, walkLabel = (name) => name, repeats = []) {
@@ -24,13 +27,14 @@ function bubbleHalos(graph, bubbles, positions, walkLabel = (name) => name, repe
     let minY = Infinity;
     const nodeIds = [];
     const ends = [];
-    for (const name of bubbleSegmentIds(bubble)) {
+    const names = bubbleSegmentIds(bubble);
+    for (const [i, name] of names.entries()) {
       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)) {
+      if (bubble.key ? i === 0 || i === names.length - 1 : isBackbone(node) && (node.stable.start < bubble.start || node.stable.start >= bubble.end)) {
         ends.push(line[Math.floor(line.length / 2)]);
         continue;
       }
@@ -90,7 +94,7 @@ function bubbleHalos(graph, bubbles, positions, walkLabel = (name) => name, repe
       labelAt,
       members: nodeIds.length,
       nodeIds,
-      whole: nodeIds.length >= WHOLE_FRACTION * graph.nodes.length,
+      whole: coversGraph(nodeIds.length, graph.nodes.length),
       routes
     });
   }
@@ -104,5 +108,7 @@ function routeText(route, walkLabel) {
 }
 
 export {
+  WHOLE_FRACTION,
+  coversGraph,
   bubbleHalos
 };

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

@@ -69,7 +69,10 @@ function drawTubeMapConnectors(ctx, connectors, bottom, {
   ctx.strokeStyle = `rgba(${ink},0.35)`;
   ctx.lineWidth = 0.5;
   ctx.stroke();
-  const lit = connectors.find((c) => c.node === highlightNode);
+  drawLitConnector(ctx, connectors, bottom, highlightNode);
+}
+function drawLitConnector(ctx, connectors, bottom, node) {
+  const lit = bottom > 0 && node ? connectors.find((c) => c.node === node) : void 0;
   if (lit) {
     ctx.beginPath();
     band(ctx, lit, bottom);
@@ -86,5 +89,6 @@ function drawTubeMapConnectors(ctx, connectors, bottom, {
 export {
   tubeMapConnectors,
   connectorAt,
-  drawTubeMapConnectors
+  drawTubeMapConnectors,
+  drawLitConnector
 };

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

@@ -192,24 +192,40 @@ function drawTubeMap(ctx, picture, frame) {
   }
   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));
+  ctx.lineWidth = outlineWidth(frame);
   for (const node of picture.nodes) {
-    if (visible(node)) {
-      const lit = node.name === frame.highlightNode;
+    if (visible(node) && 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;
+      const tint = frame.nodeColors?.get(node.name);
+      ctx.fillStyle = tint ?? fill;
+      ctx.strokeStyle = stroke;
       ctx.globalAlpha = tint ? NODE_TINT_ALPHA : 1;
       ctx.fill();
-      ctx.globalAlpha = lit ? 1 : outlineAlpha(x(node.x1) - x(node.x0));
+      ctx.globalAlpha = outlineAlpha(x(node.x1) - x(node.x0));
       ctx.stroke();
       ctx.globalAlpha = 1;
     }
   }
+  drawTubeMapHighlight(ctx, picture, frame);
   drawMismatches(ctx, picture.mismatches, frame);
 }
+function outlineWidth(frame) {
+  return 2 * Math.max(0.25, Math.min(1, frame.yScale));
+}
+function drawTubeMapHighlight(ctx, picture, frame) {
+  const node = frame.highlightNode ? picture.nodes.find((n) => n.name === frame.highlightNode) : void 0;
+  if (node) {
+    ctx.beginPath();
+    trace(ctx, node.commands, frame.x, frame.y);
+    ctx.globalAlpha = 1;
+    ctx.lineWidth = outlineWidth(frame);
+    ctx.fillStyle = "rgba(255,192,203,0.5)";
+    ctx.strokeStyle = "#ff0000";
+    ctx.fill();
+    ctx.stroke();
+  }
+}
 var MISMATCH_FONT_PX = 12;
 var MIN_MISMATCH_FONT_PX = 6;
 function mismatchesLegible(yScale) {
@@ -273,6 +289,7 @@ export {
   trackColors,
   tubeMapPicture,
   drawTubeMap,
+  drawTubeMapHighlight,
   mismatchesLegible,
   mismatchOnScreen,
   tubeMapTrackAt,

package/dist/chunks/{chunk-FFFQNQUI.js → chunk-A4MYLGKG.js}

@@ -1,7 +1,7 @@
 import {
   computeColorSchemeRange,
   getNodeColor
-} from "./chunk-HBEKUQO4.js";
+} from "./chunk-BR25DGIJ.js";
 import {
   abgrToCssRgba
 } from "./chunk-G2FD7S3C.js";

package/dist/chunks/chunk-B4645SM2.js

@@ -0,0 +1,358 @@
+import {
+  ownStrand
+} from "./chunk-2CVHXFK7.js";
+import {
+  isBackbone
+} from "./chunk-FYQWPEEY.js";
+
+// src/foldVariants.ts
+function foldVariants(graph, belowBp) {
+  if (!(belowBp > 0) || graph.paths?.length || !graph.nodes.some((node) => isBackbone(node))) {
+    return graph;
+  }
+  const { nodes, edges } = graph;
+  const index = new Map(nodes.map((node, i) => [node.id, i]));
+  const sides = edges.map(forwardSides);
+  const links = linksAt(nodes.length, edges, sides, index);
+  const allele = alleleOf(nodes, edges, sides, index);
+  const members = groupBy(allele);
+  const kept = new Uint8Array(nodes.length);
+  const big = [];
+  for (const group of members.values()) {
+    if (alleleContent(group, nodes, links, allele) >= belowBp) {
+      for (const i of group) {
+        kept[i] = 1;
+      }
+      if (!isBackbone(nodes[group[0]])) {
+        big.push(group);
+      }
+    }
+  }
+  const { dist, pred } = distancesFromBackbone(nodes, links);
+  for (const group of big) {
+    for (const [i, side] of alleleEnds(group, nodes, links, allele)) {
+      let next = nearestOutside(i, side, links, allele, dist, nodes);
+      while (next !== void 0 && !kept[next]) {
+        kept[next] = 1;
+        next = isBackbone(nodes[next]) ? void 0 : pred[next];
+      }
+    }
+  }
+  const keptEdges = edges.filter((edge, k) => {
+    const a = index.get(edge.from);
+    const b = index.get(edge.to);
+    if (a === void 0 || b === void 0) {
+      return false;
+    }
+    const skip = skipped(nodes[a], sides[k].from, nodes[b], sides[k].to);
+    return kept[a] && kept[b] && !(skip > 0 && skip < belowBp);
+  });
+  return mergeAlleleRuns({ ...graph, edges: keptEdges }, kept, allele);
+}
+function forwardSides(edge) {
+  return {
+    from: (edge.fromStrand ?? ownStrand(edge.from)) === "+" ? "e" : "s",
+    to: (edge.toStrand ?? ownStrand(edge.to)) === "+" ? "s" : "e"
+  };
+}
+function linksAt(count, edges, sides, index) {
+  const links = Array.from({ length: count }, () => []);
+  edges.forEach((edge, k) => {
+    const a = index.get(edge.from);
+    const b = index.get(edge.to);
+    if (a !== void 0 && b !== void 0) {
+      links[a].push({ other: b, side: sides[k].from });
+      links[b].push({ other: a, side: sides[k].to });
+    }
+  });
+  return links;
+}
+function onOneSequence(a, b) {
+  const sa = a.stable;
+  const sb = b.stable;
+  return sa && sb?.refName === sa.refName && sb.rank === sa.rank ? [sa, sb] : void 0;
+}
+function continues(a, aSide, b, bSide) {
+  const pair = onOneSequence(a, b);
+  if (!pair || aSide === bSide) {
+    return false;
+  }
+  const [sa, sb] = pair;
+  return sa.start + a.length === sb.start || sb.start + b.length === sa.start;
+}
+function skipped(a, aSide, b, bSide) {
+  const pair = onOneSequence(a, b);
+  if (!pair || continues(a, aSide, b, bSide)) {
+    return 0;
+  }
+  const [sa, sb] = pair;
+  return Math.max(
+    sb.start - (sa.start + a.length),
+    sa.start - (sb.start + b.length)
+  );
+}
+function alleleOf(nodes, edges, sides, index) {
+  const parent = nodes.map((_, i) => i);
+  const find = (i) => {
+    while (parent[i] !== i) {
+      parent[i] = parent[parent[i]];
+      i = parent[i];
+    }
+    return i;
+  };
+  edges.forEach((edge, k) => {
+    const a = index.get(edge.from);
+    const b = index.get(edge.to);
+    if (a !== void 0 && b !== void 0 && continues(nodes[a], sides[k].from, nodes[b], sides[k].to)) {
+      parent[find(a)] = find(b);
+    }
+  });
+  return nodes.map((_, i) => find(i));
+}
+function groupBy(allele) {
+  const groups = /* @__PURE__ */ new Map();
+  allele.forEach((root, i) => {
+    const group = groups.get(root);
+    if (group) {
+      group.push(i);
+    } else {
+      groups.set(root, [i]);
+    }
+  });
+  return groups;
+}
+function alleleContent(group, nodes, links, allele) {
+  if (isBackbone(nodes[group[0]])) {
+    return Infinity;
+  }
+  let length = 0;
+  let refName;
+  let lo = Infinity;
+  let hi = -Infinity;
+  let oneSequence = true;
+  for (const i of group) {
+    length += nodes[i].length;
+    for (const { other } of links[i]) {
+      const node = nodes[other];
+      if (allele[other] !== allele[i] && isBackbone(node)) {
+        refName ??= node.stable.refName;
+        oneSequence &&= node.stable.refName === refName;
+        lo = Math.min(lo, node.stable.start + node.length);
+        hi = Math.max(hi, node.stable.start);
+      }
+    }
+  }
+  return oneSequence && hi > lo ? Math.max(length, hi - lo) : length;
+}
+function alleleEnds(group, nodes, links, allele) {
+  const start = (i) => nodes[i].stable?.start ?? 0;
+  const end = (i) => start(i) + nodes[i].length;
+  let first = group[0];
+  let last = group[0];
+  for (const i of group) {
+    if (start(i) < start(first)) {
+      first = i;
+    }
+    if (end(i) > end(last)) {
+      last = i;
+    }
+  }
+  const ends = [];
+  for (const i of /* @__PURE__ */ new Set([first, last])) {
+    for (const side of ["s", "e"]) {
+      if (!links[i].some(
+        (link) => link.side === side && allele[link.other] === allele[i]
+      )) {
+        ends.push([i, side]);
+      }
+    }
+  }
+  return ends;
+}
+function nearestOutside(i, side, links, allele, dist, nodes) {
+  let best;
+  for (const link of links[i]) {
+    const j = link.other;
+    if (link.side === side && allele[j] !== allele[i] && Number.isFinite(dist[j]) && (best === void 0 || dist[j] < dist[best] || dist[j] === dist[best] && nodes[j].id < nodes[best].id)) {
+      best = j;
+    }
+  }
+  return best;
+}
+function distancesFromBackbone(nodes, links) {
+  const dist = new Float64Array(nodes.length).fill(Infinity);
+  const pred = new Int32Array(nodes.length).fill(-1);
+  const heap = new MinHeap(
+    ([da, a], [db, b]) => da - db || cmp(nodes[a].id, nodes[b].id)
+  );
+  nodes.forEach((node, i) => {
+    if (isBackbone(node)) {
+      dist[i] = 0;
+      heap.push([0, i]);
+    }
+  });
+  for (let top = heap.pop(); top !== void 0; top = heap.pop()) {
+    const [d0, i] = top;
+    if (d0 > dist[i]) {
+      continue;
+    }
+    for (const { other } of links[i]) {
+      if (isBackbone(nodes[other])) {
+        continue;
+      }
+      const d = d0 + nodes[other].length;
+      if (d < dist[other]) {
+        dist[other] = d;
+        pred[other] = i;
+        heap.push([d, other]);
+      } else if (d === dist[other] && cmp(nodes[i].id, nodes[pred[other]].id) < 0) {
+        pred[other] = i;
+      }
+    }
+  }
+  return { dist, pred: Array.from(pred, (p) => p < 0 ? void 0 : p) };
+}
+function cmp(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+var MinHeap = class {
+  constructor(order) {
+    this.order = order;
+    this.items = [];
+  }
+  push(item) {
+    const { items } = this;
+    items.push(item);
+    let i = items.length - 1;
+    while (i > 0) {
+      const up = i - 1 >> 1;
+      if (this.order(items[i], items[up]) >= 0) {
+        break;
+      }
+      ;
+      [items[i], items[up]] = [items[up], items[i]];
+      i = up;
+    }
+  }
+  pop() {
+    const { items } = this;
+    const top = items[0];
+    const last = items.pop();
+    if (items.length > 0 && last !== void 0) {
+      items[0] = last;
+      let i = 0;
+      for (; ; ) {
+        const l = 2 * i + 1;
+        const r = l + 1;
+        let m = i;
+        if (l < items.length && this.order(items[l], items[m]) < 0) {
+          m = l;
+        }
+        if (r < items.length && this.order(items[r], items[m]) < 0) {
+          m = r;
+        }
+        if (m === i) {
+          break;
+        }
+        ;
+        [items[i], items[m]] = [items[m], items[i]];
+        i = m;
+      }
+    }
+    return top;
+  }
+};
+function mergeAlleleRuns(graph, kept, allele) {
+  const { nodes, edges } = graph;
+  const index = new Map(nodes.map((node, i) => [node.id, i]));
+  const sides = edges.map(forwardSides);
+  const ends = edges.map((edge, k) => [
+    { i: index.get(edge.from), side: sides[k].from },
+    { i: index.get(edge.to), side: sides[k].to }
+  ]);
+  const degree = /* @__PURE__ */ new Map();
+  const sideKey = (i, side) => `${i}${side}`;
+  for (const pair of ends) {
+    for (const { i, side } of pair) {
+      degree.set(sideKey(i, side), (degree.get(sideKey(i, side)) ?? 0) + 1);
+    }
+  }
+  const next = /* @__PURE__ */ new Map();
+  const hasPrev = /* @__PURE__ */ new Set();
+  const internal = /* @__PURE__ */ new Set();
+  ends.forEach(([a, b], k) => {
+    if (a.i !== b.i && allele[a.i] === allele[b.i] && continues(nodes[a.i], a.side, nodes[b.i], b.side) && degree.get(sideKey(a.i, a.side)) === 1 && degree.get(sideKey(b.i, b.side)) === 1) {
+      const [left, right] = nodes[a.i].stable.start < nodes[b.i].stable.start ? [a, b] : [b, a];
+      next.set(left.i, { j: right.i, out: left.side, in: right.side });
+      hasPrev.add(right.i);
+      internal.add(k);
+    }
+  });
+  const headOf = nodes.map((_, i) => i);
+  const outer = /* @__PURE__ */ new Map();
+  const merged = /* @__PURE__ */ new Map();
+  nodes.forEach((_, i) => {
+    if (!kept[i] || hasPrev.has(i) || !next.has(i)) {
+      return;
+    }
+    const run = [i];
+    let into = flip(next.get(i).out);
+    outer.set(sideKey(i, into), "s");
+    for (let step = next.get(i); step; step = next.get(step.j)) {
+      run.push(step.j);
+      into = step.in;
+    }
+    outer.set(sideKey(run.at(-1), flip(into)), "e");
+    for (const j of run) {
+      headOf[j] = i;
+    }
+    merged.set(i, mergedNode(run.map((j) => nodes[j])));
+  });
+  const endpoint = ({ i, side }) => ({
+    id: nodes[headOf[i]].id,
+    side: headOf[i] === i && !merged.has(i) ? side : outer.get(sideKey(i, side))
+  });
+  return {
+    ...graph,
+    nodes: nodes.flatMap(
+      (node, i) => !kept[i] || headOf[i] !== i ? [] : [merged.get(i) ?? node]
+    ),
+    edges: edges.flatMap((edge, k) => {
+      if (internal.has(k)) {
+        return [];
+      }
+      const [a, b] = ends[k];
+      if (!merged.has(headOf[a.i]) && !merged.has(headOf[b.i])) {
+        return [edge];
+      }
+      const from = endpoint(a);
+      const to = endpoint(b);
+      return [
+        {
+          ...edge,
+          from: from.id,
+          to: to.id,
+          fromStrand: from.side === "e" ? "+" : "-",
+          toStrand: to.side === "s" ? "+" : "-"
+        }
+      ];
+    })
+  };
+}
+function flip(side) {
+  return side === "s" ? "e" : "s";
+}
+function mergedNode(run) {
+  const { samples: firstSamples, ...first } = run[0];
+  const length = run.reduce((sum, node) => sum + node.length, 0);
+  const depth = length > 0 ? run.reduce((sum, node) => sum + node.depth * node.length, 0) / length : first.depth;
+  const samples = run.every((node) => node.samples) ? run.reduce(
+    (common, node) => common.filter((s) => node.samples.includes(s)),
+    firstSamples
+  ) : void 0;
+  return samples ? { ...first, length, depth, samples } : { ...first, length, depth };
+}
+
+export {
+  foldVariants
+};

package/dist/chunks/chunk-B4YH42OP.js

@@ -0,0 +1,24 @@
+// src/gfa/writeRgfa.ts
+function writeRgfa(graph) {
+  const nameOf = new Map(graph.nodes.map((n) => [n.id, n.name]));
+  return [
+    "H	VN:Z:1.0",
+    ...graph.nodes.map(segmentLine),
+    ...graph.edges.map(
+      (e) => `L	${nameOf.get(e.from)}	${e.fromStrand ?? "+"}	${nameOf.get(e.to)}	${e.toStrand ?? "+"}	0M`
+    ),
+    ""
+  ].join("\n");
+}
+function segmentLine(node) {
+  const { stable } = node;
+  if (!stable) {
+    throw new Error(`segment ${node.name} has no stable coordinate to file`);
+  }
+  const samples = node.samples?.length ? `	SM:Z:${node.samples.join(",")}` : "";
+  return `S	${node.name}	*	LN:i:${node.length}	SN:Z:${stable.refName}	SO:i:${stable.start}	SR:i:${stable.rank}${samples}`;
+}
+
+export {
+  writeRgfa
+};

package/dist/chunks/{chunk-6VBDMZBZ.js → chunk-BLRJ6IGK.js}

@@ -1,6 +1,6 @@
 import {
   ENGINE_DEFAULTS
-} from "./chunk-5OIVTEF7.js";
+} from "./chunk-ZGRYFUXE.js";
 
 // src/figureSettings.ts
 var FIGURE_DEFAULTS = {

package/dist/chunks/{chunk-SKKYLBRA.js → chunk-BV64PQ2C.js}

@@ -1,7 +1,7 @@
 import {
   engineKey,
   forceLayout
-} from "./chunk-5OIVTEF7.js";
+} from "./chunk-ZGRYFUXE.js";
 
 // src/layout/forceCache.ts
 var DEFAULT_SIZE = 4;

package/dist/chunks/{chunk-W253V6RR.js → chunk-CVYDR2OP.js}

@@ -2,7 +2,7 @@ import {
   LIFT_BACKDROP_CSS,
   computeColorSchemeRange,
   getNodeColor
-} from "./chunk-HBEKUQO4.js";
+} from "./chunk-BR25DGIJ.js";
 import {
   abgrToCssRgba
 } from "./chunk-G2FD7S3C.js";

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

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

package/dist/chunks/{chunk-MFKORG3F.js → chunk-FX4RDMDN.js}

@@ -19,7 +19,10 @@ function parseBubbleLine(line) {
   };
 }
 function sameBubble(a, b) {
-  return a.refName === b.refName && a.start === b.start && a.end === b.end;
+  return a.key !== void 0 || b.key !== void 0 ? a.key === b.key : a.refName === b.refName && a.start === b.start && a.end === b.end;
+}
+function bubbleKey(b) {
+  return b.key ?? `${b.refName}:${b.start}-${b.end}`;
 }
 function bubbleLabel(bubble) {
   const { shortestAlleleLength: min, longestAlleleLength: max } = bubble;
@@ -38,6 +41,7 @@ function bubbleDescription(bubble) {
 export {
   parseBubbleLine,
   sameBubble,
+  bubbleKey,
   bubbleLabel,
   SATURATED_PATH_COUNT,
   bubbleDescription

package/dist/chunks/{chunk-MIW3HYPE.js → chunk-GFRPX6M2.js}

@@ -3,10 +3,10 @@ import {
   RAMP_GRADIENT_STOPS,
   rampHueCss,
   rampStops
-} from "./chunk-6ZNQJ5ZD.js";
+} from "./chunk-OXTR3BVF.js";
 import {
   REFERENCE_RAMP_ALT_CSS
-} from "./chunk-HBEKUQO4.js";
+} from "./chunk-BR25DGIJ.js";
 import {
   LABEL_CHAR_PX
 } from "./chunk-AB35TJST.js";