@jbrowse/bandage-core 7.0.0 → 7.2.0

package/dist/chunks/{chunk-7PWMTUAK.js → chunk-QMJ4J5PT.js}

@@ -1,3 +1,6 @@
+import {
+  Canvas2DRenderer
+} from "./chunk-CH3DLBUT.js";
 import {
   svgCanvas
 } from "./chunk-47DYCZOK.js";
@@ -5,15 +8,12 @@ import {
   stripGeneGaps,
   walkStripFrame,
   walkStripLabelsTree
-} from "./chunk-MZ7QQRUJ.js";
+} from "./chunk-KREASK3Z.js";
 import {
   walkRowsKey,
   walkRowsKeyTree,
   walkRowsTree
-} from "./chunk-JFNPL4UT.js";
-import {
-  Canvas2DRenderer
-} from "./chunk-CH3DLBUT.js";
+} from "./chunk-UGD6ZMOF.js";
 import {
   EXON_COLOR,
   exonOutlineTree,
@@ -24,10 +24,10 @@ import {
 } from "./chunk-BUBZ32IC.js";
 import {
   version
-} from "./chunk-EOSVRILX.js";
+} from "./chunk-S73EYTZA.js";
 import {
   axisScaleOf
-} from "./chunk-AWCMVPVP.js";
+} from "./chunk-Y7UR3MDE.js";
 import {
   facetLifts,
   walkLift
@@ -43,7 +43,7 @@ import {
   FIT_PADDING,
   drawingBounds,
   fitTransform
-} from "./chunk-6UFS3EWI.js";
+} from "./chunk-EPWYRSHH.js";
 import {
   buildGeometry,
   computeReferenceRamp
@@ -59,7 +59,7 @@ import {
 } from "./chunk-FP4H7SFT.js";
 import {
   walkRowsExtent
-} from "./chunk-EZPBJPK6.js";
+} from "./chunk-3JANT2SW.js";
 import {
   pathLegend
 } from "./chunk-E7FWQQHP.js";
@@ -154,7 +154,7 @@ function figureSvg(graph, layout, o = {}) {
   const rows = o.walkRows;
   const bounds = drawingBounds(layout, {
     region: o.fitToDrawing ? void 0 : region,
-    extent: rows && layout.extent ? walkRowsExtent(rows) : void 0
+    extent: rows && layout.extent ? walkRowsExtent(rows, o.walkRowPitch) : void 0
   });
   const pixelRows = layout.pixelRows ?? false;
   const nodeById = new Map(graph.nodes.map((node) => [node.id, node]));
@@ -226,7 +226,7 @@ function figureSvg(graph, layout, o = {}) {
         serializeEl(
           walkRowsTree(
             rows,
-            { ...t, width: w, height: h },
+            { ...t, width: w, height: h, ...o.walkRowPitch },
             {
               ramp: rampInterval,
               rowGenes: o.rowGenes
@@ -235,9 +235,10 @@ function figureSvg(graph, layout, o = {}) {
         )
       );
     }
-    const rowLabels = rows ? [rows.reference, ...rows.rows].map((r, i) => ({
+    const pitch = o.walkRowPitch;
+    const rowLabels = rows ? pitch && !pitch.labelled ? [] : [rows.reference, ...rows.rows].map((r, i) => ({
       label: r.label,
-      y: i * ROW_HEIGHT_PX
+      y: i * (pitch?.rowPx ?? ROW_HEIGHT_PX)
     })) : layout.rowLabels ?? [];
     for (const { label, y } of rowLabels) {
       const sy = y * t.scaleY + t.translateY;

package/dist/chunks/{chunk-EOSVRILX.js → chunk-S73EYTZA.js}

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

package/dist/chunks/{chunk-JFNPL4UT.js → chunk-UGD6ZMOF.js}

@@ -24,6 +24,9 @@ var OUTSIDE_CUT = "#bdbdbd";
 var GENE_INK = "#1c1c22";
 var BAR_PX = 12;
 var GAP_PX = 4;
+var LABELLED_ROW_PX = 12;
+var READOUT_ROW_PX = 14;
+var MIN_TILED_BAR_PX = 6;
 var MIN_TILE_PX = 3;
 function kb(bp) {
   return `${(bp / 1e3).toFixed(bp < 1e4 ? 1 : 0)} kb`;
@@ -209,6 +212,9 @@ function walkRowsKey(bars, o = {}) {
 var CALL_TICK = "#111";
 var UNBACKED_TICK = "#9e9e9e";
 var DISAGREES = "#c62828";
+function callTickInk(call) {
+  return call.agrees === false ? DISAGREES : call.spanningReads === 0 ? UNBACKED_TICK : CALL_TICK;
+}
 function walkRowsKeyTree(entries, x, y, idPrefix = "walk-key") {
   let at = 0;
   const parts = entries.flatMap((e, i) => {
@@ -262,6 +268,19 @@ function walkRowsKeyTree(entries, x, y, idPrefix = "walk-key") {
     )
   };
 }
+function rowPitch(count, room, minRowPx = 0) {
+  const fit = room / Math.max(1, count);
+  const rowPx = Math.max(
+    minRowPx,
+    Math.min(ROW_HEIGHT_PX, fit >= 1 ? Math.floor(fit) : fit)
+  );
+  return {
+    rowPx,
+    barPx: rowPx <= 3 ? rowPx : Math.max(3, Math.round(rowPx * 0.6)),
+    labelled: rowPx >= LABELLED_ROW_PX,
+    readouts: rowPx >= READOUT_ROW_PX
+  };
+}
 function coalesceRuns(runs, pxPerBp) {
   const minBp = 1 / pxPerBp;
   const out = [];
@@ -358,6 +377,7 @@ function walkRowsTree(bars, frame, o = {}) {
   const X = (bp) => bp * frame.scaleX + frame.translateX;
   const rowPx = frame.rowPx ?? ROW_HEIGHT_PX;
   const barPx = frame.barPx ?? BAR_PX;
+  const overhang = Math.min(3, Math.max(0, (rowPx - barPx) / 2));
   const Y = (row) => row * rowPx * frame.scaleY + frame.translateY;
   const { origin, unit, reference, rows } = bars;
   const along = (offset) => X(origin + offset);
@@ -392,7 +412,7 @@ function walkRowsTree(bars, frame, o = {}) {
         rect
       ] : [rect];
     });
-    const ticks = unit ? unitTicks(row.bp, unit, frame.scaleX).map(
+    const ticks = unit && barPx >= MIN_TILED_BAR_PX ? unitTicks(row.bp, unit, frame.scaleX).map(
       (k) => el("line", {
         x1: along(k),
         x2: along(k),
@@ -425,10 +445,10 @@ function walkRowsTree(bars, frame, o = {}) {
       call && el("rect", {
         "data-testid": "graph-walk-call",
         x: along(call.bp) - 1,
-        y: y - barPx / 2 - 3,
+        y: y - barPx / 2 - overhang,
         width: 2,
-        height: barPx + 6,
-        fill: call.spanningReads === 0 ? UNBACKED_TICK : CALL_TICK
+        height: barPx + 2 * overhang,
+        fill: callTickInk(call)
       }),
       readouts && el(
         "text",
@@ -457,6 +477,7 @@ export {
   GENE_INK,
   BAR_PX,
   GAP_PX,
+  LABELLED_ROW_PX,
   kb,
   walkRowReadout,
   readoutPlacement,
@@ -469,8 +490,12 @@ export {
   boxesGenes,
   rowGeneBoxes,
   walkRowsKey,
+  CALL_TICK,
+  UNBACKED_TICK,
   DISAGREES,
+  callTickInk,
   walkRowsKeyTree,
+  rowPitch,
   coalesceRuns,
   walkRowsTree
 };

package/dist/chunks/{chunk-O4TGF4WS.js → chunk-UNOE2NDN.js}

@@ -1,21 +1,11 @@
+import {
+  stressPlacement
+} from "./chunk-LYJ4US66.js";
 import {
   isBackbone
 } from "./chunk-FYQWPEEY.js";
 
 // src/layout/stressEngine.ts
-var LAYOUT_ENGINES = [
-  {
-    value: "fmmm",
-    label: "Bandage (FMMM)",
-    description: "Bandage's force-directed layout: OGDF's fast multipole multilevel method, compiled to wasm."
-  },
-  {
-    value: "stress",
-    label: "Stress (experimental)",
-    description: "Stress layout by stochastic gradient descent in plain JS: distances along the graph become distances on the page, so the reference reads straight and a repeat loop reads as a ring."
-  }
-];
-var LAYOUT_ENGINE_VALUES = LAYOUT_ENGINES.map((e) => e.value);
 var QUALITY = [
   { walks: 2, iterations: 15 },
   { walks: 4, iterations: 30 },
@@ -24,11 +14,12 @@ var QUALITY = [
   { walks: 16, iterations: 120 }
 ];
 var UNTANGLE_PASSES = 20;
-var UNTANGLE_RADIUS = 15;
+var UNTANGLE_LINKS = 3;
 var UNTANGLE_PUSH = 0.3;
 var SMOOTH_PASSES = 2;
 var MAX_HOPS = 200;
 var EPS = 0.1;
+var WARM = 0.5;
 function flipped(strand, name) {
   const own = name.at(-1);
   return (strand === "+" || strand === "-") && (own === "+" || own === "-") && strand !== own;
@@ -137,12 +128,36 @@ function chains(request) {
     off,
     nb,
     wt,
-    n
+    n,
+    link
   };
 }
+function components(c) {
+  const { n, off, nb } = c;
+  const comp = new Int32Array(n).fill(-1);
+  const members = [];
+  for (let s = 0; s < n; s++) {
+    if (comp[s] >= 0) {
+      continue;
+    }
+    const queue = [s];
+    comp[s] = members.length;
+    for (const u of queue) {
+      for (let e = off[u]; e < off[u + 1]; e++) {
+        const v = nb[e];
+        if (comp[v] < 0) {
+          comp[v] = members.length;
+          queue.push(v);
+        }
+      }
+    }
+    members.push(queue);
+  }
+  return { comp, members };
+}
 function stressLayout(request, opts = {}) {
   const c = chains(request);
-  const { n, off, nb, wt, seedX, seedY, backbone, first, count, per } = c;
+  const { n, off, nb, wt, seedX, seedY, backbone, first, count, per, link } = c;
   const o = request.options;
   const quality = QUALITY[Math.max(0, Math.min(4, num(opts.quality ?? o.quality, 2)))];
   const gap = num(opts.componentSeparation ?? o.componentSeparation, 15);
@@ -153,6 +168,7 @@ function stressLayout(request, opts = {}) {
   if (n === 0) {
     return { nodePositions };
   }
+  const { comp, members } = components(c);
   let dmin = Infinity;
   let total = 0;
   for (let e = 0; e < nb.length; e++) {
@@ -167,9 +183,13 @@ function stressLayout(request, opts = {}) {
       break;
     }
   }
+  const placed = anySeed ? stressPlacement(c) : void 0;
   const side = Math.sqrt(n) * 20;
   for (let i = 0; i < n; i++) {
-    if (anySeed && !Number.isNaN(seedX[i])) {
+    if (placed && !Number.isNaN(placed.X[i])) {
+      X[i] = placed.X[i];
+      Y[i] = placed.Y[i];
+    } else if (anySeed && !Number.isNaN(seedX[i])) {
       X[i] = seedX[i] + rand() - 0.5;
       Y[i] = seedY[i] + rand() - 0.5;
     } else {
@@ -177,15 +197,18 @@ function stressLayout(request, opts = {}) {
       Y[i] = rand() * side;
     }
   }
-  const refIdx = [];
-  for (let i = 0; i < n; i++) {
-    if (backbone[i] && !Number.isNaN(seedX[i])) {
-      refIdx.push(i);
+  const refIdx = members.map(
+    (points) => Int32Array.from(
+      points.filter((i) => backbone[i] && !Number.isNaN(seedX[i])).sort((a, b) => seedX[a] - seedX[b])
+    )
+  );
+  const refX = refIdx.map((idx) => Float64Array.from(idx, (i) => seedX[i]));
+  let span = 0;
+  for (const xs of refX) {
+    if (xs.length) {
+      span = Math.max(span, xs[xs.length - 1] - xs[0]);
     }
   }
-  refIdx.sort((a, b) => seedX[a] - seedX[b]);
-  const refX = Float64Array.from(refIdx, (i) => seedX[i]);
-  const span = refIdx.length ? refX[refX.length - 1] - refX[0] : 0;
   const dmax = Math.max(span, total / 4, dmin * 10);
   const etaMax = dmax * dmax;
   const etaMin = EPS * dmin * dmin;
@@ -209,6 +232,7 @@ function stressLayout(request, opts = {}) {
     X[j] = X[j] + rx;
     Y[j] = Y[j] + ry;
   };
+  let walked = 0;
   const walk = (i, length) => {
     let chain = c.chainOf[i];
     let idx = c.indexOf[i];
@@ -219,48 +243,57 @@ function stressLayout(request, opts = {}) {
       const step = per[chain];
       const toEnd = (dir > 0 ? points - 1 - idx : idx) * step;
       if (remaining <= toEnd) {
-        return first[chain] + idx + dir * Math.round(remaining / step);
+        const steps = Math.round(remaining / step);
+        walked = length - remaining + steps * step;
+        return first[chain] + idx + dir * steps;
       }
       remaining -= toEnd;
       const out = c.links[chain][dir > 0 ? 1 : 0];
       if (out.length === 0) {
+        walked = length - remaining;
         return first[chain] + (dir > 0 ? points - 1 : 0);
       }
       const [next, enterSide] = out[Math.floor(rand() * out.length)];
-      remaining -= num(o.edgeLength, 1);
+      remaining -= link;
       chain = next;
       dir = enterSide === 0 ? 1 : -1;
       idx = enterSide === 0 ? 0 : count[next] - 1;
       if (remaining <= 0) {
+        walked = length - remaining;
         return first[chain] + idx;
       }
     }
     return -1;
   };
-  const refPartner = (i) => {
-    const length = Math.exp(logMin + rand() * (logMax - logMin)) * (rand() < 0.5 ? -1 : 1);
-    const target = seedX[i] + length;
+  const referenceTerm = (i, eta) => {
+    const idx = refIdx[comp[i]];
+    if (!backbone[i] || idx.length < 2 || Number.isNaN(seedX[i])) {
+      return;
+    }
+    const xs = refX[comp[i]];
+    const target = seedX[i] + Math.exp(logMin + rand() * (logMax - logMin)) * (rand() < 0.5 ? -1 : 1);
     let lo = 0;
-    let hi = refX.length;
+    let hi = xs.length;
     while (lo < hi) {
       const mid = lo + hi >> 1;
-      if (refX[mid] < target) {
+      if (xs[mid] < target) {
         lo = mid + 1;
       } else {
         hi = mid;
       }
     }
-    return refIdx[Math.min(lo, refIdx.length - 1)];
-  };
-  const referenceTerm = (i, eta) => {
-    if (!backbone[i] || refIdx.length < 2 || Number.isNaN(seedX[i])) {
+    const j = idx[Math.min(lo, idx.length - 1)];
+    const d = seedX[j] - seedX[i];
+    if (j === i || d === 0) {
       return;
     }
-    const j = refPartner(i);
-    const d = Math.abs(seedX[i] - seedX[j]);
-    if (j !== i && d > 0) {
-      move(i, j, d, eta);
+    let mu = eta / (d * d);
+    if (mu > 1) {
+      mu = 1;
     }
+    const r = mu * (X[j] - X[i] - d) / 2;
+    X[i] = X[i] + r;
+    X[j] = X[j] - r;
   };
   const adjacentTerms = (i, eta) => {
     for (let e = off[i]; e < off[i + 1]; e++) {
@@ -274,7 +307,8 @@ function stressLayout(request, opts = {}) {
   for (let i = 0; i < n; i++) {
     order[i] = i;
   }
-  for (let t = 0; t < iterations; t++) {
+  const warm = anySeed ? Math.floor(WARM * iterations) : 0;
+  for (let t = warm; t < iterations; t++) {
     const eta = etaMax * Math.exp(-lambda * t);
     for (let k = n - 1; k > 0; k--) {
       const r = Math.floor(rand() * (k + 1));
@@ -288,15 +322,15 @@ function stressLayout(request, opts = {}) {
       for (let w = 0; w < walks; w++) {
         const length = Math.exp(logMin + rand() * (logMax - logMin));
         const j = walk(i, length);
-        if (j >= 0 && j !== i) {
-          move(i, j, length, eta);
+        if (j >= 0 && j !== i && walked > 0) {
+          move(i, j, walked, eta);
         }
       }
       referenceTerm(i, eta);
     }
   }
-  const cell = UNTANGLE_RADIUS;
-  const key = (x, y) => Math.floor(x / cell) * 73856093 ^ Math.floor(y / cell) * 19349663;
+  const radius = UNTANGLE_LINKS * link;
+  const key = (x, y) => Math.floor(x / radius) * 73856093 ^ Math.floor(y / radius) * 19349663;
   for (let u = 0; u < UNTANGLE_PASSES; u++) {
     const grid = /* @__PURE__ */ new Map();
     for (let i = 0; i < n; i++) {
@@ -309,8 +343,8 @@ function stressLayout(request, opts = {}) {
       }
     }
     for (let i = 0; i < n; i++) {
-      const cx = Math.floor(X[i] / cell);
-      const cy = Math.floor(Y[i] / cell);
+      const cx = Math.floor(X[i] / radius);
+      const cy = Math.floor(Y[i] / radius);
       for (let gx = cx - 1; gx <= cx + 1; gx++) {
         for (let gy = cy - 1; gy <= cy + 1; gy++) {
           const list = grid.get(gx * 73856093 ^ gy * 19349663);
@@ -334,18 +368,18 @@ function stressLayout(request, opts = {}) {
             const dx = X[i] - X[j];
             const dy = Y[i] - Y[j];
             const mag = Math.sqrt(dx * dx + dy * dy);
-            if (mag >= UNTANGLE_RADIUS) {
+            if (mag >= radius) {
               continue;
             }
             let rx;
             let ry;
             if (mag > 1e-6) {
-              const r = UNTANGLE_PUSH * (UNTANGLE_RADIUS - mag) / (2 * mag);
+              const r = UNTANGLE_PUSH * (radius - mag) / (2 * mag);
               rx = r * dx;
               ry = r * dy;
             } else {
-              rx = UNTANGLE_PUSH * UNTANGLE_RADIUS * (rand() - 0.5);
-              ry = UNTANGLE_PUSH * UNTANGLE_RADIUS * (rand() - 0.5);
+              rx = UNTANGLE_PUSH * radius * (rand() - 0.5);
+              ry = UNTANGLE_PUSH * radius * (rand() - 0.5);
             }
             X[i] = X[i] + rx;
             Y[i] = Y[i] + ry;
@@ -374,28 +408,9 @@ function stressLayout(request, opts = {}) {
         Y[a + i] = 0.5 * ys[i] + 0.25 * (ys[i - 1] + ys[i + 1]);
       }
     }
-    let length = 0;
-    let cx = 0;
-    let cy = 0;
-    for (let i = 0; i < m; i++) {
-      cx += X[a + i];
-      cy += Y[a + i];
-      if (i > 0) {
-        length += Math.hypot(
-          X[a + i] - X[a + i - 1],
-          Y[a + i] - Y[a + i - 1]
-        );
-      }
-    }
-    cx /= m;
-    cy /= m;
-    const scale = length > 0 ? per[k] * (m - 1) / length : 1;
-    for (let i = 0; i < m; i++) {
-      X[a + i] = cx + (X[a + i] - cx) * scale;
-      Y[a + i] = cy + (Y[a + i] - cy) * scale;
-    }
+    respace(X, Y, a, m, per[k]);
   }
-  packComponents(c, X, Y, anySeed, gap);
+  packComponents(comp, members, X, Y, anySeed, gap);
   for (let k = 0; k < c.ids.length; k++) {
     const points = [];
     for (let i = 0; i < count[k]; i++) {
@@ -405,99 +420,110 @@ function stressLayout(request, opts = {}) {
   }
   return { nodePositions };
 }
-function packComponents(c, X, Y, anySeed, gap) {
-  const { n, off, nb } = c;
-  const comp = new Int32Array(n).fill(-1);
-  let components = 0;
-  for (let s = 0; s < n; s++) {
-    if (comp[s] >= 0) {
-      continue;
+function respace(X, Y, a, m, per) {
+  const arc = new Float64Array(m);
+  for (let i = 1; i < m; i++) {
+    arc[i] = arc[i - 1] + Math.hypot(X[a + i] - X[a + i - 1], Y[a + i] - Y[a + i - 1]);
+  }
+  if (!arc[m - 1]) {
+    return;
+  }
+  const loss = per * (m - 1) - arc[m - 1];
+  if (loss > 0) {
+    extend(X, Y, a, a + 1, loss / 2);
+    extend(X, Y, a + m - 1, a + m - 2, loss / 2);
+    for (let i = 1; i < m; i++) {
+      arc[i] = arc[i - 1] + Math.hypot(X[a + i] - X[a + i - 1], Y[a + i] - Y[a + i - 1]);
     }
-    const queue = [s];
-    comp[s] = components;
-    for (const u of queue) {
-      for (let e = off[u]; e < off[u + 1]; e++) {
-        const v = nb[e];
-        if (comp[v] < 0) {
-          comp[v] = components;
-          queue.push(v);
-        }
-      }
+  }
+  const total = arc[m - 1];
+  const xs = X.slice(a, a + m);
+  const ys = Y.slice(a, a + m);
+  let seg = 1;
+  for (let i = 1; i + 1 < m; i++) {
+    const s = total * i / (m - 1);
+    while (seg < m - 1 && arc[seg] < s) {
+      seg++;
     }
-    components++;
+    const span = arc[seg] - arc[seg - 1];
+    const t = span > 0 ? (s - arc[seg - 1]) / span : 0;
+    X[a + i] = xs[seg - 1] + (xs[seg] - xs[seg - 1]) * t;
+    Y[a + i] = ys[seg - 1] + (ys[seg] - ys[seg - 1]) * t;
   }
+}
+function extend(X, Y, end, next, by) {
+  const dx = X[end] - X[next];
+  const dy = Y[end] - Y[next];
+  const mag = Math.hypot(dx, dy);
+  if (mag > 0) {
+    X[end] = X[end] + dx / mag * by;
+    Y[end] = Y[end] + dy / mag * by;
+  }
+}
+function packComponents(comp, members, X, Y, anySeed, gap) {
   if (!anySeed) {
-    for (let k = 0; k < components; k++) {
-      rotateToPrincipalAxis(X, Y, comp, k);
+    for (const points of members) {
+      rotateToPrincipalAxis(X, Y, points);
     }
   }
-  if (components < 2) {
+  if (members.length < 2) {
     return;
   }
-  const minX = new Float64Array(components).fill(Infinity);
-  const minY = new Float64Array(components).fill(Infinity);
-  const maxY = new Float64Array(components).fill(-Infinity);
-  for (let i = 0; i < n; i++) {
+  const minX = new Float64Array(members.length).fill(Infinity);
+  const minY = new Float64Array(members.length).fill(Infinity);
+  const maxY = new Float64Array(members.length).fill(-Infinity);
+  for (let i = 0; i < X.length; i++) {
     const k = comp[i];
     minX[k] = Math.min(minX[k], X[i]);
     minY[k] = Math.min(minY[k], Y[i]);
     maxY[k] = Math.max(maxY[k], Y[i]);
   }
-  const shift = new Float64Array(components);
+  const shift = new Float64Array(members.length);
   let y = 0;
-  for (let k = 0; k < components; k++) {
+  for (let k = 0; k < members.length; k++) {
     shift[k] = y - minY[k];
     y += maxY[k] - minY[k] + gap;
   }
-  for (let i = 0; i < n; i++) {
+  for (let i = 0; i < X.length; i++) {
     const k = comp[i];
     X[i] = X[i] - minX[k];
     Y[i] = Y[i] + shift[k];
   }
 }
-function rotateToPrincipalAxis(X, Y, comp, k) {
-  let m = 0;
+function rotateToPrincipalAxis(X, Y, points) {
+  if (points.length < 3) {
+    return;
+  }
   let cx = 0;
   let cy = 0;
-  for (let i = 0; i < X.length; i++) {
-    if (comp[i] === k) {
-      cx += X[i];
-      cy += Y[i];
-      m++;
-    }
-  }
-  if (m < 3) {
-    return;
+  for (const i of points) {
+    cx += X[i];
+    cy += Y[i];
   }
-  cx /= m;
-  cy /= m;
+  cx /= points.length;
+  cy /= points.length;
   let sxx = 0;
   let syy = 0;
   let sxy = 0;
-  for (let i = 0; i < X.length; i++) {
-    if (comp[i] === k) {
-      const dx = X[i] - cx;
-      const dy = Y[i] - cy;
-      sxx += dx * dx;
-      syy += dy * dy;
-      sxy += dx * dy;
-    }
+  for (const i of points) {
+    const dx = X[i] - cx;
+    const dy = Y[i] - cy;
+    sxx += dx * dx;
+    syy += dy * dy;
+    sxy += dx * dy;
   }
   const angle = -0.5 * Math.atan2(2 * sxy, sxx - syy);
   const cos = Math.cos(angle);
   const sin = Math.sin(angle);
-  for (let i = 0; i < X.length; i++) {
-    if (comp[i] === k) {
-      const dx = X[i] - cx;
-      const dy = Y[i] - cy;
-      X[i] = cx + cos * dx - sin * dy;
-      Y[i] = cy + sin * dx + cos * dy;
-    }
+  for (const i of points) {
+    const dx = X[i] - cx;
+    const dy = Y[i] - cy;
+    X[i] = cx + cos * dx - sin * dy;
+    Y[i] = cy + sin * dx + cos * dy;
   }
 }
 
 export {
-  LAYOUT_ENGINES,
-  LAYOUT_ENGINE_VALUES,
+  chains,
   stressLayout
 };

package/dist/chunks/{chunk-AWCMVPVP.js → chunk-Y7UR3MDE.js}

@@ -1,6 +1,6 @@
 import {
   clampZoom
-} from "./chunk-6UFS3EWI.js";
+} from "./chunk-EPWYRSHH.js";
 
 // src/viewport.ts
 function axisScaleOf(scale, pixelRows) {