@jbrowse/bandage-core 10.2.7 → 10.3.1

package/dist/chunks/{chunk-WBSWROE6.js → chunk-SFP3E4RI.js}

@@ -1,20 +1,25 @@
 import {
   alongRow,
   boxesGenes,
-  rowPitch
-} from "./chunk-EFQLEGWM.js";
+  rowPitch,
+  rowSpan
+} from "./chunk-ZJBOM73S.js";
 import {
   el
 } from "./chunk-H2H4Y3TV.js";
 import {
-  READOUT_ROOM
-} from "./chunk-L2HDM2R3.js";
+  READOUT_ROOM,
+  longestBar
+} from "./chunk-A2TJ5UX6.js";
 import {
   pathOrigin
-} from "./chunk-M6LK4GII.js";
+} from "./chunk-B5X2RLJG.js";
 import {
   LABEL_CHAR_PX
 } from "./chunk-AB35TJST.js";
+import {
+  partitionPoint
+} from "./chunk-HOAIOEI7.js";
 
 // src/layout/walkStrip.ts
 function walkStripApplies(o) {
@@ -63,7 +68,7 @@ function spansOf(graph, name) {
   const lengthOf = new Map(graph.nodes.map((n) => [n.id, n.length]));
   const origin = pathOrigin(name).name;
   const pieces = (graph.paths ?? []).filter(
-    (p) => origin === graph.referencePath ? pathOrigin(p.name).name === origin : p.name === name
+    (p) => pathOrigin(p.name).name === origin
   );
   let spans;
   if (pieces.every((p) => p.start !== void 0)) {
@@ -90,19 +95,10 @@ function segmentAt(graph, row, offset, pxPerBp) {
   }
   const at = axis.reversed ? axis.start - offset : axis.start + offset;
   const tol = 0.5 / pxPerBp;
-  const bar = axis.reversed ? { start: axis.start - row.bp, end: axis.start } : { start: axis.start, end: axis.start + row.bp };
+  const bar = rowSpan(axis, row.bp);
   const from = Math.max(at - tol, bar.start);
   const to = Math.min(at + tol, bar.end);
-  let lo = 0;
-  let hi = spans.starts.length;
-  while (lo < hi) {
-    const mid = lo + hi >> 1;
-    if (spans.ends[mid] <= from) {
-      lo = mid + 1;
-    } else {
-      hi = mid;
-    }
-  }
+  const lo = partitionPoint(spans.starts.length, (i) => spans.ends[i] <= from);
   let best;
   let bestLen = -1;
   let bestHolds = false;
@@ -126,7 +122,7 @@ function walkStripFrame(bars, o) {
     maxHeight - 2 * PAD_PX,
     MIN_ROW_PX
   );
-  const longest = Math.max(bars.reference.bp, ...bars.rows.map((r) => r.bp), 1);
+  const longest = Math.max(longestBar(bars), 1);
   const left = labelled ? labelPx : PAD_PX;
   const usable = Math.max(1, o.width - left - PAD_PX);
   const scaleX = usable / (longest * (readouts ? READOUT_ROOM : 1));

package/dist/chunks/{chunk-2CMYNW3E.js → chunk-SI3BB4DO.js}

@@ -1,7 +1,7 @@
 import {
   referenceKnots,
   warpX
-} from "./chunk-HK5Y2YWV.js";
+} from "./chunk-MYDHU2UV.js";
 
 // src/tubeMap/frame.ts
 var MIN_TUBE_Y_SCALE = 0.05;

package/dist/chunks/{chunk-DY3JCAMX.js → chunk-SOMZGDVS.js}

@@ -1,9 +1,12 @@
 import {
   ownStrand
-} from "./chunk-7SRWJLSC.js";
+} from "./chunk-UBQSRCWR.js";
+import {
+  groupBy
+} from "./chunk-BSOZW3FC.js";
 import {
   isBackbone
-} from "./chunk-FYQWPEEY.js";
+} from "./chunk-RJWPJCIB.js";
 
 // src/foldVariants.ts
 function foldVariants(graph, belowBp) {
@@ -15,7 +18,7 @@ function foldVariants(graph, belowBp) {
   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 members = groupBy(allele.keys(), (i) => allele[i]);
   const kept = new Uint8Array(nodes.length);
   const big = [];
   for (const group of members.values()) {
@@ -137,18 +140,6 @@ function alleleOf(nodes, edges, sides, index) {
   });
   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;
@@ -311,7 +302,7 @@ function mergeAlleleRuns(graph, kept, allele) {
   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];
+      const [left, right] = a.side === "e" ? [a, b] : [b, a];
       next.set(left.i, { j: right.i, out: left.side, in: right.side });
       hasPrev.add(right.i);
       internal.add(k);

package/dist/chunks/{chunk-A4PFFC4Q.js → chunk-SWCULW6S.js}

@@ -3,29 +3,38 @@ import {
   fadeAbgr,
   packAbgr
 } from "./chunk-G2FD7S3C.js";
+import {
+  REFERENCE_RAMP_LIGHTNESS,
+  REFERENCE_RAMP_SATURATION,
+  rampHueAt
+} from "./chunk-GQZVR5DW.js";
 import {
   baseEdgeCurves
-} from "./chunk-ZY2AFL4Y.js";
+} from "./chunk-WA5WNP6V.js";
 import {
   PATH_LIGHTNESS,
   PATH_SATURATION,
   nameHue,
   pathHueAt
-} from "./chunk-3XSM4OZU.js";
+} from "./chunk-3GP3KT5L.js";
 import {
   meanDepth,
   nodeWidthPx
-} from "./chunk-JBCZIBFC.js";
+} from "./chunk-CRCD3ODN.js";
 import {
   referenceMidpoints
-} from "./chunk-ES2N6V56.js";
+} from "./chunk-VX656OAZ.js";
 import {
   dashCurves,
   pathRibbonOffsets,
+  polylinePx,
   strandSides,
   translateCurves,
   yToXOf
-} from "./chunk-7SRWJLSC.js";
+} from "./chunk-UBQSRCWR.js";
+import {
+  pushTo
+} from "./chunk-BSOZW3FC.js";
 
 // src/renderer/GeometryBuilder.ts
 var EDGE_DEFAULT_COLOR = packAbgr(119, 119, 119, 217);
@@ -119,7 +128,7 @@ function arrowheadFor({
   const lengthPx = walkPx[n - 1];
   const abutting = lengthPx < ABUTTING_PX;
   const inset = Math.min(nodeHalfWidth, lengthPx);
-  const fit = abutting ? Math.min(1, polylinePx(fromSegments, scale, yToX) / length) : 1;
+  const fit = abutting ? Math.min(1, polylinePx(fromSegments, scale, scale * yToX) / length) : 1;
   if (abutting ? fit < MIN_ARROW_FIT : lengthPx < MIN_LINK_HEADS * length) {
     return void 0;
   }
@@ -137,16 +146,6 @@ function arrowheadFor({
     color
   };
 }
-function polylinePx(segments, scale, yToX) {
-  let length = 0;
-  for (let i = 1; i < segments.length; i++) {
-    length += Math.hypot(
-      segments[i].x - segments[i - 1].x,
-      (segments[i].y - segments[i - 1].y) * yToX
-    );
-  }
-  return length * scale;
-}
 function leavesStart(edge, segments, first, stranded, yToX) {
   if (stranded) {
     return strandSides(edge).from === "start";
@@ -163,58 +162,28 @@ function intoDirection(last, toSegments) {
   const atStart = Math.hypot(last.x1 - first.x, last.y1 - first.y) <= Math.hypot(last.x1 - final.x, last.y1 - final.y);
   return atStart ? { from: first, to: toSegments[1] } : { from: final, to: toSegments[toSegments.length - 2] };
 }
+function normal(a, b) {
+  if (!a || !b) {
+    return void 0;
+  }
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  const len = Math.hypot(dx, dy);
+  return len > 0 ? { nx: -dy / len, ny: dx / len } : void 0;
+}
 function pointNormalsOf(rawPoints, yToX = 1) {
   const points = yToX === 1 ? rawPoints : rawPoints.map((p) => ({ x: p.x, y: p.y * yToX }));
-  const pointNormals = [];
-  for (let i = 0; i < points.length; i++) {
-    let nx = 0;
-    let ny = 0;
-    if (i === 0) {
-      const dx = points[1].x - points[0].x;
-      const dy = points[1].y - points[0].y;
-      const len = Math.hypot(dx, dy);
-      if (len > 0) {
-        nx = -dy / len;
-        ny = dx / len;
-      }
-    } else if (i === points.length - 1) {
-      const dx = points[i].x - points[i - 1].x;
-      const dy = points[i].y - points[i - 1].y;
-      const len = Math.hypot(dx, dy);
-      if (len > 0) {
-        nx = -dy / len;
-        ny = dx / len;
-      }
-    } else {
-      const dx1 = points[i].x - points[i - 1].x;
-      const dy1 = points[i].y - points[i - 1].y;
-      const len1 = Math.hypot(dx1, dy1);
-      const dx2 = points[i + 1].x - points[i].x;
-      const dy2 = points[i + 1].y - points[i].y;
-      const len2 = Math.hypot(dx2, dy2);
-      if (len1 > 0 && len2 > 0) {
-        const nx1 = -dy1 / len1;
-        const ny1 = dx1 / len1;
-        const nx2 = -dy2 / len2;
-        const ny2 = dx2 / len2;
-        nx = (nx1 + nx2) / 2;
-        ny = (ny1 + ny2) / 2;
-        const dot = nx1 * nx + ny1 * ny;
-        if (dot > 0.1) {
-          nx /= dot;
-          ny /= dot;
-        }
-      } else if (len1 > 0) {
-        nx = -dy1 / len1;
-        ny = dx1 / len1;
-      } else if (len2 > 0) {
-        nx = -dy2 / len2;
-        ny = dx2 / len2;
-      }
+  return points.map((p, i) => {
+    const before = normal(points[i - 1], p);
+    const after = normal(p, points[i + 1]);
+    if (before && after) {
+      const nx = (before.nx + after.nx) / 2;
+      const ny = (before.ny + after.ny) / 2;
+      const dot = before.nx * nx + before.ny * ny;
+      return dot > 0.1 ? { nx: nx / dot, ny: ny / dot } : { nx, ny };
     }
-    pointNormals.push({ nx, ny });
-  }
-  return pointNormals;
+    return before ?? after ?? { nx: 0, ny: 0 };
+  });
 }
 function offsetPolyline(points, normals, distance, yToX = 1) {
   return points.map((p, i) => ({
@@ -222,14 +191,6 @@ function offsetPolyline(points, normals, distance, yToX = 1) {
     y: p.y + normals[i].ny * distance / yToX
   }));
 }
-function packNorm(r, g, b, a) {
-  return packAbgr(
-    Math.round(r * 255),
-    Math.round(g * 255),
-    Math.round(b * 255),
-    Math.round(a * 255)
-  );
-}
 function hslToRgb(h, s, l) {
   const c = (1 - Math.abs(2 * l - 1)) * s;
   const x = c * (1 - Math.abs(h / 60 % 2 - 1));
@@ -258,6 +219,15 @@ function hslToRgb(h, s, l) {
   }
   return [r + m, g + m, b + m];
 }
+function packHsl(h, s, l, a = 1) {
+  const [r, g, b] = hslToRgb(h, s, l);
+  return packAbgr(
+    Math.round(r * 255),
+    Math.round(g * 255),
+    Math.round(b * 255),
+    Math.round(a * 255)
+  );
+}
 var DEPTH_GRADIENT = [
   [68, 1, 84],
   [59, 82, 139],
@@ -287,12 +257,8 @@ function sampleGradient(stops, t) {
   );
 }
 function hashColor(str, alpha) {
-  const [r, g, b] = hslToRgb(nameHue(str), PATH_SATURATION, PATH_LIGHTNESS);
-  return packNorm(r, g, b, alpha);
+  return packHsl(nameHue(str), PATH_SATURATION, PATH_LIGHTNESS, alpha);
 }
-var REFERENCE_RAMP_MAX_HUE = 300;
-var REFERENCE_RAMP_SATURATION = 0.7;
-var REFERENCE_RAMP_LIGHTNESS = 0.5;
 var REFERENCE_RAMP_ALT_RGB = [60, 65, 72];
 var REFERENCE_RAMP_ALT_COLOR = packAbgr(...REFERENCE_RAMP_ALT_RGB, 255);
 var REFERENCE_RAMP_ALT_CSS = `rgb(${REFERENCE_RAMP_ALT_RGB.join(", ")})`;
@@ -317,7 +283,7 @@ function computeReferenceRamp(graph, domain) {
     midpoints
   };
 }
-function computeColorSchemeRange(graph) {
+function computeColorSchemeRange(graph, referenceRamp) {
   let minDepth = Infinity;
   let maxDepth = -Infinity;
   let minLength = Infinity;
@@ -346,7 +312,8 @@ function computeColorSchemeRange(graph) {
     minLength,
     maxLength,
     maxRank,
-    nodeCount: graph.nodes.length
+    nodeCount: graph.nodes.length,
+    referenceRamp
   };
 }
 function getNodeColor(node, nodeIndex, colorScheme, range) {
@@ -384,20 +351,17 @@ function getNodeColor(node, nodeIndex, colorScheme, range) {
       if (node.stable !== void 0 && node.stable.rank > 0) {
         return REFERENCE_RAMP_ALT_COLOR;
       }
-      const frac = Math.max(0, Math.min(1, (mid - ramp.start) / ramp.span));
-      const [r, g, b] = hslToRgb(
-        frac * REFERENCE_RAMP_MAX_HUE,
+      return packHsl(
+        rampHueAt((mid - ramp.start) / ramp.span),
         REFERENCE_RAMP_SATURATION,
         REFERENCE_RAMP_LIGHTNESS
       );
-      return packNorm(r, g, b, 1);
     }
     case "grey":
       return packAbgr(160, 160, 160, 255);
     case "rainbow": {
       const hue = range.nodeCount > 1 ? nodeIndex / range.nodeCount * 360 : 0;
-      const [r, g, b] = hslToRgb(hue, 0.75, 0.5);
-      return packNorm(r, g, b, 1);
+      return packHsl(hue, 0.75, 0.5);
     }
     default:
       return packAbgr(52, 152, 219, 255);
@@ -447,12 +411,14 @@ function pathPaletteOf(graph) {
     const pathIndexByName = /* @__PURE__ */ new Map();
     const paths = graph.paths ?? [];
     for (let i = 0; i < paths.length; i++) {
-      const [r, g, b] = hslToRgb(
-        pathHueAt(i, paths.length),
-        PATH_SATURATION,
-        PATH_LIGHTNESS
+      pathColorByIndex.push(
+        packHsl(
+          pathHueAt(i, paths.length),
+          PATH_SATURATION,
+          PATH_LIGHTNESS,
+          0.85
+        )
       );
-      pathColorByIndex.push(packNorm(r, g, b, 0.85));
       if (!pathIndexByName.has(paths[i].name)) {
         pathIndexByName.set(paths[i].name, i);
       }
@@ -470,12 +436,7 @@ function pathSlotsOf(graph) {
     slots = /* @__PURE__ */ new Map();
     for (const [pathIdx, path] of (graph.paths ?? []).entries()) {
       for (const nodeId of new Set(path.nodeIds)) {
-        const visits = slots.get(nodeId);
-        if (visits) {
-          visits.push(pathIdx);
-        } else {
-          slots.set(nodeId, [pathIdx]);
-        }
+        pushTo(slots, nodeId, pathIdx);
       }
     }
     slotsCache.set(graph, slots);
@@ -505,6 +466,7 @@ function buildGeometry(options) {
   } = options;
   const depthNorm = nodeWidth === "depth" ? meanDepth(graph) : 0;
   const scale = axis.scaleX;
+  const worldPerScreenPx = 1 / Math.max(scale, MIN_SCALE_FOR_OFFSET);
   const yToX = yToXOf(axis);
   const sharedCurves = baseEdgeCurves(
     nodePositions,
@@ -521,7 +483,7 @@ function buildGeometry(options) {
   const arrowRuns = /* @__PURE__ */ new Map();
   const edgeCurves = [];
   const edgeCurveRuns = /* @__PURE__ */ new Map();
-  const colorRange = { ...computeColorSchemeRange(graph), referenceRamp };
+  const colorRange = computeColorSchemeRange(graph, referenceRamp);
   const nodeIndexMap = /* @__PURE__ */ new Map();
   if (colorScheme === "rainbow") {
     for (let i = 0; i < graph.nodes.length; i++) {
@@ -594,7 +556,6 @@ function buildGeometry(options) {
         nx: 0,
         ny: 0
       };
-      const worldPerScreenPx = 1 / Math.max(scale, MIN_SCALE_FOR_OFFSET);
       laneWalks.forEach((walk, lane) => {
         if (!walk.edgeIndexes.has(ei)) {
           return;
@@ -677,7 +638,6 @@ function buildGeometry(options) {
     if (drawable && lanes) {
       const laneWidth = Math.max(width / lanes.length, MIN_WALK_LANE_PX);
       const normals = pointNormalsOf(segments, yToX);
-      const worldPerScreenPx = 1 / Math.max(scale, MIN_SCALE_FOR_OFFSET);
       lanes.forEach((walk, lane) => {
         const laneColor = walk.colors.get(nodeId);
         if (laneColor === void 0) {
@@ -692,7 +652,6 @@ function buildGeometry(options) {
       });
     } else if (drawable && slots?.length && slotWidth >= MIN_PATH_STRIPE_PX) {
       const normals = pointNormalsOf(segments, yToX);
-      const worldPerScreenPx = 1 / Math.max(scale, MIN_SCALE_FOR_OFFSET);
       for (const slot of slots) {
         const offset = (slot - (pathCount - 1) / 2) * slotWidth * worldPerScreenPx;
         const stripe = pathColorByIndex[slot] ?? EDGE_PATH_FALLBACK_COLOR;
@@ -726,7 +685,6 @@ export {
   FADED_ALPHA,
   LIFT_BACKDROP_CSS,
   hslToRgb,
-  REFERENCE_RAMP_MAX_HUE,
   REFERENCE_RAMP_ALT_COLOR,
   REFERENCE_RAMP_ALT_CSS,
   computeReferenceRamp,

package/dist/chunks/{chunk-XV4P5KEQ.js → chunk-TGUFT6KK.js}

@@ -1,3 +1,7 @@
+import {
+  panSNFields
+} from "./chunk-4XWZNPQ2.js";
+
 // src/facetGrid.ts
 var FACET_GAP_PX = 8;
 var FACET_TITLE_PX = 34;
@@ -85,9 +89,8 @@ function facetCells(names, by, domain = []) {
     return wrap;
   }
   const places = names.map((name) => {
-    const [sample, haplotype, contig] = name.split("#");
-    const n = Number(haplotype);
-    return contig !== void 0 && Number.isInteger(n) && n >= 0 ? { sample, column: Math.max(0, n - 1) } : void 0;
+    const fields = panSNFields(name);
+    return fields && Number.isInteger(fields.haplotype) && fields.haplotype >= 0 ? { sample: fields.sample, column: Math.max(0, fields.haplotype - 1) } : void 0;
   });
   const rows = domainFirst(
     [...new Set(places.flatMap((p) => p ? [p.sample] : []))],

package/dist/chunks/{chunk-CM6LO6OC.js → chunk-UAFATXYA.js}

@@ -1,9 +1,12 @@
+import {
+  buildNeighbors
+} from "./chunk-VX656OAZ.js";
 import {
   ROW_HEIGHT_PX
 } from "./chunk-CPMHA4W5.js";
 import {
   isBackbone
-} from "./chunk-FYQWPEEY.js";
+} from "./chunk-RJWPJCIB.js";
 
 // src/layout/orderedLayout.ts
 var GUTTER = 12;
@@ -99,13 +102,13 @@ function placeByWalks(graph, backbone) {
   }
   return placed;
 }
-function placeBySearch(adjacent, key) {
+function placeBySearch(adjacent, key, isNode) {
   const queue = [...key.entries()].sort(([a, ka], [b, kb]) => compareKeys(ka, kb) || compare(a, b)).map(([id]) => id);
   const placed = queue.length;
   for (const id of queue) {
     const from = key.get(id);
     for (const nb of adjacent.get(id) ?? []) {
-      if (!key.has(nb)) {
+      if (isNode.has(nb) && !key.has(nb)) {
         key.set(nb, { at: from.at, side: 1, hops: from.hops + 1 });
         queue.push(nb);
       }
@@ -127,6 +130,9 @@ function placeBySearch(adjacent, key) {
       let touchesLeft = false;
       for (const nb of adjacent.get(id) ?? []) {
         const other = key.get(nb);
+        if (!other) {
+          continue;
+        }
         if (other.at === at && searched.has(nb)) {
           deadEnd &&= other.hops <= hops;
           if (!sided.has(nb)) {
@@ -149,16 +155,6 @@ function placeBySearch(adjacent, key) {
   }
 }
 function orderKeys(graph) {
-  const ids = new Set(graph.nodes.map((n) => n.id));
-  const adjacent = /* @__PURE__ */ new Map();
-  for (const e of graph.edges) {
-    if (!ids.has(e.from) || !ids.has(e.to)) {
-      continue;
-    }
-    ;
-    (adjacent.get(e.from) ?? adjacent.set(e.from, []).get(e.from)).push(e.to);
-    (adjacent.get(e.to) ?? adjacent.set(e.to, []).get(e.to)).push(e.from);
-  }
   const backbone = graph.nodes.filter(isBackbone).sort(
     (a, b) => compare(a.stable.start, b.stable.start) || compare(a.name, b.name)
   );
@@ -166,7 +162,7 @@ function orderKeys(graph) {
   placeByWalks(graph, backbone).forEach((id, rank) => {
     key.set(id, { at: rank, side: 0, hops: 0 });
   });
-  placeBySearch(adjacent, key);
+  placeBySearch(buildNeighbors(graph), key, new Set(graph.nodes.map((n) => n.id)));
   return key;
 }
 function layerGraph(graph) {

package/dist/chunks/{chunk-7SRWJLSC.js → chunk-UBQSRCWR.js}

@@ -240,17 +240,19 @@ function unscaleYOf(curves, yToX) {
   }
   return curves;
 }
+function polylinePx(points, scaleX, scaleY) {
+  let total = 0;
+  for (let i = 1; i < points.length; i++) {
+    const a = points[i - 1];
+    const b = points[i];
+    total += Math.hypot((b.x - a.x) * scaleX, (b.y - a.y) * scaleY);
+  }
+  return total;
+}
 var SELF_LOOP_MIN_PX = 12;
 var SELF_LOOP_MAX_PX = 40;
 function selfLoopReach(segments, scale) {
-  let length = 0;
-  for (let i = 1; i < segments.length; i++) {
-    length += Math.hypot(
-      segments[i].x - segments[i - 1].x,
-      segments[i].y - segments[i - 1].y
-    );
-  }
-  const nodePx = length * scale;
+  const nodePx = polylinePx(segments, scale, scale);
   const reachPx = Math.min(
     SELF_LOOP_MAX_PX,
     Math.max(SELF_LOOP_MIN_PX, nodePx / 2)
@@ -520,6 +522,7 @@ export {
   yToXOf,
   PATH_RIBBON_SPACING_PX,
   pathRibbonOffsets,
+  polylinePx,
   selfLinkOf,
   edgeJoinOf,
   computeEdgeCurves,

package/dist/chunks/{chunk-RUCH6ZFL.js → chunk-V4YML3GR.js}

@@ -1,5 +1,6 @@
 // src/renderer/svgCanvas.ts
 var n = (v) => +v.toFixed(1);
+var alpha = (v) => +v.toFixed(3);
 function paint(css) {
   const m = /^rgba?\(([^,]+),([^,]+),([^,)]+)(?:,([^)]+))?\)$/.exec(
     css.replaceAll(" ", "")
@@ -12,7 +13,7 @@ function paint(css) {
 }
 function paintAttrs(kind, css) {
   const { color, opacity } = paint(css);
-  return `${kind}="${color}"${opacity < 1 ? ` ${kind}-opacity="${n(opacity)}"` : ""}`;
+  return `${kind}="${color}"${opacity < 1 ? ` ${kind}-opacity="${alpha(opacity)}"` : ""}`;
 }
 var DOT_PX = 0.5;
 var DOT_CELL_PX = 0.25;

package/dist/chunks/{chunk-ES2N6V56.js → chunk-VX656OAZ.js}

@@ -1,22 +1,17 @@
+import {
+  pushTo
+} from "./chunk-BSOZW3FC.js";
 import {
   isBackbone
-} from "./chunk-FYQWPEEY.js";
+} from "./chunk-RJWPJCIB.js";
 
 // src/referenceSpan.ts
 var MAX_BACKBONE_HOPS = 4;
 function buildNeighbors(graph) {
   const neighbors = /* @__PURE__ */ new Map();
-  function add(from, to) {
-    const list = neighbors.get(from);
-    if (list) {
-      list.push(to);
-    } else {
-      neighbors.set(from, [to]);
-    }
-  }
   for (const edge of graph.edges) {
-    add(edge.from, edge.to);
-    add(edge.to, edge.from);
+    pushTo(neighbors, edge.from, edge.to);
+    pushTo(neighbors, edge.to, edge.from);
   }
   return neighbors;
 }

package/dist/chunks/chunk-WA5WNP6V.js

@@ -0,0 +1,37 @@
+import {
+  weakMemo
+} from "./chunk-HMXCN6PG.js";
+import {
+  edgeCurvesOf
+} from "./chunk-CGMSKIEO.js";
+
+// src/util/edgeCurves.ts
+var cache = weakMemo();
+function baseEdgeCurves(nodePositions, graph, axis, deletions, version, routes, stranded = false) {
+  return cache(
+    nodePositions,
+    [graph, axis.scaleX, axis.scaleY, deletions, routes, stranded, version],
+    () => {
+      const curves = /* @__PURE__ */ new Map();
+      for (let ei = 0; ei < graph.edges.length; ei++) {
+        const bypassed = deletions?.get(ei);
+        const edgeCurves = edgeCurvesOf(
+          nodePositions,
+          graph.edges[ei],
+          axis,
+          bypassed,
+          bypassed && routes?.[ei],
+          stranded
+        );
+        if (edgeCurves) {
+          curves.set(ei, edgeCurves);
+        }
+      }
+      return curves;
+    }
+  );
+}
+
+export {
+  baseEdgeCurves
+};