@diagrammo/dgmo 0.45.0 → 0.47.0

package/dist/layout-search-OYV77HHS.js

@@ -0,0 +1,1655 @@
+import {
+  groupedTierCandidates
+} from "./chunk-YGJTDXVR.js";
+import {
+  EDGE_LABEL_FONT_SIZE,
+  NODE_HEIGHT,
+  NODE_WIDTH,
+  computeNodeSize,
+  measureEdgeLabel
+} from "./chunk-IJZFN3HM.js";
+import "./chunk-JED6ZDEE.js";
+import "./chunk-6EK55ART.js";
+import "./chunk-TYS6CSS5.js";
+import "./chunk-5DH3KYFH.js";
+import "./chunk-BMR4CIEO.js";
+import "./chunk-WCT3NYCV.js";
+import "./chunk-FMDSF3OV.js";
+import "./chunk-NOTA6TEI.js";
+import "./chunk-CXK4DZH3.js";
+import "./chunk-5WRI5ZAA.js";
+
+// src/boxes-and-lines/layout-search.ts
+import dagre from "@dagrejs/dagre";
+import { line as d3line, curveBasis } from "d3-shape";
+
+// src/boxes-and-lines/layout-layered.ts
+var NODESEP = 50;
+var RANKSEP = 60;
+var DUMMY_THICK = 10;
+var MARGIN = 40;
+var W_REAL_REAL = 1;
+var W_REAL_DUMMY = 2;
+var W_DUMMY_DUMMY = 8;
+function rng(s) {
+  return () => {
+    s |= 0;
+    s = s + 1831565813 | 0;
+    let t = Math.imul(s ^ s >>> 15, 1 | s);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function layeredCandidates(parsed, sizes, opts) {
+  if (parsed.groups.length > 0) return [];
+  const nCount = parsed.nodes.length;
+  if (nCount < 3 || nCount > 40) return [];
+  const isTB = parsed.direction === "TB";
+  const nodesep = opts?.nodesep ?? NODESEP;
+  const ranksep = opts?.ranksep ?? RANKSEP;
+  const backEdgeSide = opts?.backEdgeSide ?? "nearest";
+  const restarts = opts?.restarts ?? (nCount <= 14 ? 28 : nCount <= 25 ? 14 : 6);
+  const keepK = opts?.keepK ?? 3;
+  const labels = parsed.nodes.map((n) => n.label);
+  const labelSet = new Set(labels);
+  const edges = parsed.edges.map((e, i) => ({ e, i })).filter(
+    ({ e }) => labelSet.has(e.source) && labelSet.has(e.target) && e.source !== e.target
+  );
+  if (edges.length === 0) return [];
+  const adj = /* @__PURE__ */ new Map();
+  for (const l of labels) adj.set(l, []);
+  for (const { e, i } of edges)
+    adj.get(e.source).push({ to: e.target, idx: i });
+  const reversed = /* @__PURE__ */ new Set();
+  const state = /* @__PURE__ */ new Map();
+  for (const l of labels) state.set(l, 0);
+  const dfs = (u) => {
+    state.set(u, 1);
+    for (const { to, idx } of adj.get(u)) {
+      const st = state.get(to);
+      if (st === 1)
+        reversed.add(idx);
+      else if (st === 0) dfs(to);
+    }
+    state.set(u, 2);
+  };
+  for (const l of labels) if (state.get(l) === 0) dfs(l);
+  const dag = edges.map(
+    ({ e, i }) => reversed.has(i) ? { from: e.target, to: e.source, idx: i, rev: true } : { from: e.source, to: e.target, idx: i, rev: false }
+  );
+  const outDag = /* @__PURE__ */ new Map();
+  const inDeg = /* @__PURE__ */ new Map();
+  for (const l of labels) {
+    outDag.set(l, []);
+    inDeg.set(l, 0);
+  }
+  for (const d of dag) {
+    outDag.get(d.from).push(d.to);
+    inDeg.set(d.to, (inDeg.get(d.to) ?? 0) + 1);
+  }
+  const rank = /* @__PURE__ */ new Map();
+  for (const l of labels) rank.set(l, 0);
+  const queue = labels.filter((l) => (inDeg.get(l) ?? 0) === 0);
+  const indeg2 = new Map(inDeg);
+  const topo = [];
+  while (queue.length) {
+    const u = queue.shift();
+    topo.push(u);
+    for (const v of outDag.get(u)) {
+      rank.set(v, Math.max(rank.get(v), rank.get(u) + 1));
+      indeg2.set(v, indeg2.get(v) - 1);
+      if (indeg2.get(v) === 0) queue.push(v);
+    }
+  }
+  if (topo.length !== labels.length) return [];
+  const maxRank = Math.max(...labels.map((l) => rank.get(l)));
+  const node = /* @__PURE__ */ new Map();
+  for (const n of parsed.nodes) {
+    const s = sizes.get(n.label) ?? { width: NODE_WIDTH, height: NODE_HEIGHT };
+    node.set(n.label, {
+      id: n.label,
+      dummy: false,
+      rank: rank.get(n.label),
+      cross: 0,
+      thick: isTB ? s.width : s.height,
+      depth: isTB ? s.height : s.width,
+      realW: s.width,
+      realH: s.height
+    });
+  }
+  const segs = [];
+  const chains = [];
+  const backEdges = [];
+  for (const d of dag) {
+    if (d.rev) {
+      backEdges.push({ edgeIdx: d.idx, src: d.to, tgt: d.from });
+      continue;
+    }
+    const r0 = rank.get(d.from);
+    const r1 = rank.get(d.to);
+    const dagChain = [d.from];
+    let prev = d.from;
+    for (let r = r0 + 1; r < r1; r++) {
+      const id = `__d${d.idx}_${r}`;
+      node.set(id, {
+        id,
+        dummy: true,
+        rank: r,
+        cross: 0,
+        thick: DUMMY_THICK,
+        depth: 0,
+        realW: 0,
+        realH: 0
+      });
+      segs.push({ a: prev, b: id });
+      dagChain.push(id);
+      prev = id;
+    }
+    segs.push({ a: prev, b: d.to });
+    dagChain.push(d.to);
+    chains.push({
+      edgeIdx: d.idx,
+      chain: d.rev ? dagChain.slice().reverse() : dagChain
+    });
+  }
+  const ranks = Array.from({ length: maxRank + 1 }, () => []);
+  for (const n of node.values()) ranks[n.rank].push(n.id);
+  const up = /* @__PURE__ */ new Map();
+  const down = /* @__PURE__ */ new Map();
+  for (const id of node.keys()) {
+    up.set(id, []);
+    down.set(id, []);
+  }
+  for (const s of segs) {
+    down.get(s.a).push(s.b);
+    up.get(s.b).push(s.a);
+  }
+  const orderOf = /* @__PURE__ */ new Map();
+  const applyOrder = (ord) => {
+    for (const id of node.keys()) orderOf.set(id, ord.get(id));
+  };
+  const gapCrossings = (r) => {
+    const lower = ranks[r + 1];
+    if (!lower) return 0;
+    const es = [];
+    for (const a of ranks[r]) {
+      const pa = orderOf.get(a);
+      for (const b of down.get(a)) es.push({ p: pa, q: orderOf.get(b) });
+    }
+    let c = 0;
+    for (let i = 0; i < es.length; i++)
+      for (let j = i + 1; j < es.length; j++) {
+        const A = es[i], B = es[j];
+        if ((A.p - B.p) * (A.q - B.q) < 0) c++;
+      }
+    return c;
+  };
+  const totalCrossings = () => {
+    let c = 0;
+    for (let r = 0; r < maxRank; r++) c += gapCrossings(r);
+    return c;
+  };
+  const median = (vals) => {
+    if (vals.length === 0) return -1;
+    vals.sort((x, y) => x - y);
+    const m = Math.floor(vals.length / 2);
+    if (vals.length % 2 === 1) return vals[m];
+    if (vals.length === 2) return (vals[0] + vals[1]) / 2;
+    const left = vals[m - 1] - vals[0];
+    const right = vals[vals.length - 1] - vals[m];
+    return left + right === 0 ? (vals[m - 1] + vals[m]) / 2 : (vals[m - 1] * right + vals[m] * left) / (left + right);
+  };
+  const wmedianRank = (r, useUp) => {
+    const ids = ranks[r];
+    const neigh = useUp ? up : down;
+    const med = /* @__PURE__ */ new Map();
+    for (const id of ids)
+      med.set(id, median(neigh.get(id).map((x) => orderOf.get(x))));
+    const movable = ids.filter((id) => med.get(id) >= 0).sort((a, b) => med.get(a) - med.get(b));
+    const out = new Array(ids.length).fill(null);
+    for (const id of ids) if (med.get(id) < 0) out[orderOf.get(id)] = id;
+    let mi = 0;
+    for (let slot = 0; slot < out.length; slot++)
+      if (out[slot] === null) out[slot] = movable[mi++];
+    const final = out;
+    final.forEach((id, i) => orderOf.set(id, i));
+    ranks[r] = final;
+  };
+  const transpose = () => {
+    let improved = true;
+    let guard = 0;
+    while (improved && guard++ < 12) {
+      improved = false;
+      for (let r = 0; r <= maxRank; r++) {
+        const ids = ranks[r];
+        for (let i = 0; i < ids.length - 1; i++) {
+          const before = (r > 0 ? gapCrossings(r - 1) : 0) + (r < maxRank ? gapCrossings(r) : 0);
+          const a = ids[i], b = ids[i + 1];
+          ids[i] = b;
+          ids[i + 1] = a;
+          orderOf.set(b, i);
+          orderOf.set(a, i + 1);
+          const after = (r > 0 ? gapCrossings(r - 1) : 0) + (r < maxRank ? gapCrossings(r) : 0);
+          if (after < before) {
+            improved = true;
+          } else {
+            ids[i] = a;
+            ids[i + 1] = b;
+            orderOf.set(a, i);
+            orderOf.set(b, i + 1);
+          }
+        }
+      }
+    }
+  };
+  const initOrder = (seed) => {
+    const r = seed === 0 ? null : rng(seed);
+    for (let rr = 0; rr <= maxRank; rr++) {
+      const ids = ranks[rr].slice();
+      if (r) {
+        for (let i = ids.length - 1; i > 0; i--) {
+          const j = Math.floor(r() * (i + 1));
+          [ids[i], ids[j]] = [ids[j], ids[i]];
+        }
+      }
+      ranks[rr] = ids;
+      ids.forEach((id, i) => orderOf.set(id, i));
+    }
+  };
+  const found = [];
+  for (let s = 0; s < restarts; s++) {
+    initOrder(s);
+    let best = totalCrossings();
+    let bestSnap = new Map(orderOf);
+    for (let iter = 0; iter < 8; iter++) {
+      const down1 = iter % 2 === 0;
+      if (down1) for (let r = 1; r <= maxRank; r++) wmedianRank(r, true);
+      else for (let r = maxRank - 1; r >= 0; r--) wmedianRank(r, false);
+      transpose();
+      const c = totalCrossings();
+      if (c < best) {
+        best = c;
+        bestSnap = new Map(orderOf);
+      }
+      if (c === 0) break;
+    }
+    applyOrder(bestSnap);
+    for (let r = 0; r <= maxRank; r++)
+      ranks[r].sort((a, b) => orderOf.get(a) - orderOf.get(b));
+    const sig = ranks.map((r) => r.join(",")).join("|");
+    if (!found.some((f) => f.sig === sig))
+      found.push({ sig, cross: best, order: new Map(bestSnap) });
+  }
+  found.sort((a, b) => a.cross - b.cross);
+  const keep = found.slice(0, keepK);
+  if (keep.length === 0) return [];
+  const results = [];
+  for (const cand of keep) {
+    applyOrder(cand.order);
+    const rk = Array.from({ length: maxRank + 1 }, () => []);
+    for (const n of node.values()) rk[n.rank].push(n.id);
+    for (let r = 0; r <= maxRank; r++)
+      rk[r].sort((a, b) => cand.order.get(a) - cand.order.get(b));
+    results.push(realize(rk));
+  }
+  return results;
+  function realize(rk) {
+    const bandDepth = rk.map(
+      (ids) => Math.max(0, ...ids.map((id) => node.get(id).depth))
+    );
+    const bandCenter = [];
+    let acc = MARGIN;
+    for (let r = 0; r <= maxRank; r++) {
+      bandCenter[r] = acc + bandDepth[r] / 2;
+      acc += bandDepth[r] + ranksep;
+    }
+    for (let r = 0; r <= maxRank; r++) {
+      let x = MARGIN;
+      for (const id of rk[r]) {
+        const n = node.get(id);
+        n.cross = x + n.thick / 2;
+        x += n.thick + nodesep;
+      }
+    }
+    const ITER = 18;
+    for (let it = 0; it < ITER; it++) {
+      const downPass = it % 2 === 0;
+      const order = downPass ? Array.from({ length: maxRank + 1 }, (_, i) => i) : Array.from({ length: maxRank + 1 }, (_, i) => maxRank - i);
+      for (const r of order) {
+        const ids = rk[r];
+        const desired = ids.map((id) => {
+          const n = node.get(id);
+          let sw = 0, sx2 = 0;
+          for (const nb of up.get(id)) {
+            const w = weight(n, node.get(nb));
+            sw += w;
+            sx2 += w * node.get(nb).cross;
+          }
+          for (const nb of down.get(id)) {
+            const w = weight(n, node.get(nb));
+            sw += w;
+            sx2 += w * node.get(nb).cross;
+          }
+          return sw > 0 ? sx2 / sw : n.cross;
+        });
+        placeWithSeparation(ids, desired);
+      }
+    }
+    let minC = Infinity;
+    for (const n of node.values()) minC = Math.min(minC, n.cross - n.thick / 2);
+    const shift = MARGIN - minC;
+    for (const n of node.values()) n.cross += shift;
+    const coord = (n) => isTB ? { x: n.cross, y: bandCenter[n.rank] } : { x: bandCenter[n.rank], y: n.cross };
+    const layoutNodes = parsed.nodes.map((pn) => {
+      const n = node.get(pn.label);
+      const c = coord(n);
+      return {
+        label: pn.label,
+        x: c.x,
+        y: c.y,
+        width: n.realW,
+        height: n.realH
+      };
+    });
+    const chainById = /* @__PURE__ */ new Map();
+    for (const ch of chains) chainById.set(ch.edgeIdx, ch.chain);
+    let minCross = Infinity, maxCross = -Infinity;
+    for (const n of node.values()) {
+      if (n.dummy) continue;
+      minCross = Math.min(minCross, n.cross - n.thick / 2);
+      maxCross = Math.max(maxCross, n.cross + n.thick / 2);
+    }
+    const GAP = 34;
+    const LANE = 28;
+    const sideOf = (b) => {
+      if (backEdgeSide === "left") return -1;
+      if (backEdgeSide === "right") return 1;
+      const d = node.get(b.src).cross - node.get(b.tgt).cross;
+      return d >= 0 ? 1 : -1;
+    };
+    const backSorted = backEdges.map((b) => ({
+      ...b,
+      side: sideOf(b),
+      span: Math.abs(node.get(b.src).rank - node.get(b.tgt).rank)
+    })).sort((a, b) => a.side - b.side || a.span - b.span);
+    const sideCounts = /* @__PURE__ */ new Map();
+    for (const b of backSorted)
+      sideCounts.set(b.side, (sideCounts.get(b.side) ?? 0) + 1);
+    const laneCounter = /* @__PURE__ */ new Map();
+    const backPoints = /* @__PURE__ */ new Map();
+    const faceLim = (depth) => Math.max(0, depth / 2 - 6);
+    const hubIndex = /* @__PURE__ */ new Map();
+    const hubSize = /* @__PURE__ */ new Map();
+    {
+      const counter = /* @__PURE__ */ new Map();
+      for (const b of backSorted) {
+        const key = `${b.side}|${b.tgt}`;
+        const idx = counter.get(key) ?? 0;
+        counter.set(key, idx + 1);
+        hubIndex.set(b.edgeIdx, idx);
+      }
+      for (const [key, v] of counter) hubSize.set(key, v);
+    }
+    for (const b of backSorted) {
+      const s = b.side;
+      const k = laneCounter.get(s) ?? 0;
+      laneCounter.set(s, k + 1);
+      const K = sideCounts.get(s);
+      const src = node.get(b.src);
+      const tgt = node.get(b.tgt);
+      const laneC = s > 0 ? maxCross + GAP + k * LANE : minCross - GAP - k * LANE;
+      const srcCtr = bandCenter[src.rank];
+      const tgtCtr = bandCenter[tgt.rank];
+      const frac = K > 1 ? (k + 1) / (K + 1) : 0;
+      const srcR = srcCtr + frac * faceLim(src.depth);
+      const tgtR = tgtCtr - frac * faceLim(tgt.depth);
+      const m = (c, r) => isTB ? { x: c, y: r } : { x: r, y: c };
+      const off = 10;
+      const srcEdgeC = src.cross + s * (src.thick / 2 + off);
+      const tgtEdgeC = tgt.cross + s * (tgt.thick / 2 + off);
+      const hubK = hubIndex.get(b.edgeIdx);
+      const hubN = hubSize.get(`${s}|${b.tgt}`);
+      if (hubN > 1 && hubK > 0) {
+        const tgtTop = tgtCtr - (tgt.depth / 2 + GAP + (hubK - 1) * LANE);
+        const entryCross = tgt.cross + s * faceLim(tgt.thick) * (hubK / hubN);
+        backPoints.set(b.edgeIdx, [
+          m(src.cross, srcCtr),
+          m(srcEdgeC, srcR),
+          m(laneC, srcR),
+          m(laneC, tgtTop),
+          m(entryCross, tgtTop),
+          m(tgt.cross, tgtCtr)
+        ]);
+      } else {
+        backPoints.set(b.edgeIdx, [
+          m(src.cross, srcCtr),
+          m(srcEdgeC, srcR),
+          m(laneC, srcR),
+          m(laneC, tgtR),
+          m(tgtEdgeC, tgtR),
+          m(tgt.cross, tgtCtr)
+        ]);
+      }
+    }
+    const layoutEdges = [];
+    for (let i = 0; i < parsed.edges.length; i++) {
+      const e = parsed.edges[i];
+      if (!labelSet.has(e.source) || !labelSet.has(e.target)) continue;
+      let points;
+      if (e.source === e.target) {
+        const c = coord(node.get(e.source));
+        points = [c, c];
+      } else if (backPoints.has(i)) {
+        points = backPoints.get(i);
+      } else {
+        const chain = chainById.get(i);
+        if (!chain) continue;
+        points = chain.map((id) => coord(node.get(id)));
+      }
+      layoutEdges.push({
+        source: e.source,
+        target: e.target,
+        ...e.label !== void 0 && { label: e.label },
+        bidirectional: e.bidirectional,
+        lineNumber: e.lineNumber,
+        points,
+        yOffset: 0,
+        parallelCount: 1,
+        metadata: e.metadata
+      });
+    }
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    for (const n of layoutNodes) {
+      minX = Math.min(minX, n.x - n.width / 2);
+      minY = Math.min(minY, n.y - n.height / 2);
+      maxX = Math.max(maxX, n.x + n.width / 2);
+      maxY = Math.max(maxY, n.y + n.height / 2);
+    }
+    for (const e of layoutEdges)
+      for (const p of e.points) {
+        minX = Math.min(minX, p.x);
+        minY = Math.min(minY, p.y);
+        maxX = Math.max(maxX, p.x);
+        maxY = Math.max(maxY, p.y);
+      }
+    const sx = MARGIN - minX;
+    const sy = MARGIN - minY;
+    const shifted = sx !== 0 || sy !== 0 ? {
+      nodes: layoutNodes.map((n) => ({ ...n, x: n.x + sx, y: n.y + sy })),
+      edges: layoutEdges.map((e) => ({
+        ...e,
+        points: e.points.map((p) => ({ x: p.x + sx, y: p.y + sy }))
+      }))
+    } : { nodes: layoutNodes, edges: layoutEdges };
+    return {
+      nodes: shifted.nodes,
+      edges: shifted.edges,
+      groups: [],
+      width: maxX + sx + MARGIN,
+      height: maxY + sy + MARGIN
+    };
+  }
+  function weight(a, b) {
+    if (a.dummy && b.dummy) return W_DUMMY_DUMMY;
+    if (a.dummy || b.dummy) return W_REAL_DUMMY;
+    return W_REAL_REAL;
+  }
+  function placeWithSeparation(ids, desired) {
+    const n = ids.length;
+    if (n === 0) return;
+    const half = ids.map((id) => node.get(id).thick / 2);
+    const off = [0];
+    for (let i = 1; i < n; i++)
+      off[i] = off[i - 1] + half[i - 1] + nodesep + half[i];
+    const d = desired.map((v, i) => v - off[i]);
+    const blocks = [];
+    for (let i = 0; i < n; i++) {
+      let b = { pos: d[i], count: 1, sumOffset: d[i], first: i };
+      while (blocks.length && blocks[blocks.length - 1].pos >= b.pos) {
+        const prev = blocks.pop();
+        const count = prev.count + b.count;
+        const sumOffset = prev.sumOffset + b.sumOffset;
+        b = { pos: sumOffset / count, count, sumOffset, first: prev.first };
+      }
+      blocks.push(b);
+    }
+    const xs = new Array(n);
+    for (const b of blocks)
+      for (let k = 0; k < b.count; k++) xs[b.first + k] = b.pos;
+    for (let i = 0; i < n; i++) node.get(ids[i]).cross = xs[i] + off[i];
+  }
+}
+
+// src/boxes-and-lines/layout-search.ts
+var DEFAULT_LAMBDA = 4;
+var ESCALATE_THRESHOLD = 4;
+var ESCALATE_MAX_N = 45;
+var ESCALATE_SEEDS = 18;
+var ESCALATE_REFINE = 10;
+function rng2(s) {
+  return () => {
+    s |= 0;
+    s = s + 1831565813 | 0;
+    let t = Math.imul(s ^ s >>> 15, 1 | s);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function shuffle(a, r) {
+  const x = a.slice();
+  for (let i = x.length - 1; i > 0; i--) {
+    const j = Math.floor(r() * (i + 1));
+    [x[i], x[j]] = [x[j], x[i]];
+  }
+  return x;
+}
+var splineGen = d3line().x((d) => d.x).y((d) => d.y).curve(curveBasis);
+var PATH_TOKEN_RE = /[MLQC]|-?\d*\.?\d+(?:e-?\d+)?/gi;
+function flatten(d) {
+  const toks = d.match(PATH_TOKEN_RE) ?? [];
+  const pts = [];
+  let i = 0, cx = 0, cy = 0, cmd = "";
+  const num = () => parseFloat(toks[i++]);
+  const samp = (p0, c1, c2, p1) => {
+    for (let t = 0; t <= 1; t += 0.12) {
+      const u = 1 - t;
+      if (c2)
+        pts.push({
+          x: u * u * u * p0.x + 3 * u * u * t * c1.x + 3 * u * t * t * c2.x + t * t * t * p1.x,
+          y: u * u * u * p0.y + 3 * u * u * t * c1.y + 3 * u * t * t * c2.y + t * t * t * p1.y
+        });
+      else
+        pts.push({
+          x: u * u * p0.x + 2 * u * t * c1.x + t * t * p1.x,
+          y: u * u * p0.y + 2 * u * t * c1.y + t * t * p1.y
+        });
+    }
+  };
+  while (i < toks.length) {
+    const tk = toks[i];
+    if (/[MLQC]/i.test(tk)) {
+      cmd = tk;
+      i++;
+    }
+    if (cmd === "M" || cmd === "L") {
+      const x = num(), y = num();
+      pts.push({ x, y });
+      cx = x;
+      cy = y;
+    } else if (cmd === "Q") {
+      const c1 = { x: num(), y: num() }, p1 = { x: num(), y: num() };
+      samp({ x: cx, y: cy }, c1, null, p1);
+      cx = p1.x;
+      cy = p1.y;
+    } else if (cmd === "C") {
+      const c1 = { x: num(), y: num() }, c2 = { x: num(), y: num() }, p1 = { x: num(), y: num() };
+      samp({ x: cx, y: cy }, c1, c2, p1);
+      cx = p1.x;
+      cy = p1.y;
+    } else i++;
+  }
+  return pts;
+}
+var FLAT_CACHE = /* @__PURE__ */ new WeakMap();
+function flatPolys(layout) {
+  const key = layout.edges;
+  const hit = FLAT_CACHE.get(key);
+  if (hit) return hit;
+  const polys = layout.edges.map((e) => {
+    const pts = e.points.length >= 2 ? flatten(splineGen(e.points) ?? "") : [];
+    let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+    for (const p of pts) {
+      if (p.x < x0) x0 = p.x;
+      if (p.x > x1) x1 = p.x;
+      if (p.y < y0) y0 = p.y;
+      if (p.y > y1) y1 = p.y;
+    }
+    return { pts, x0, y0, x1, y1 };
+  });
+  FLAT_CACHE.set(key, polys);
+  return polys;
+}
+function segPoint(p1, p2, p3, p4) {
+  const den = (p2.x - p1.x) * (p4.y - p3.y) - (p2.y - p1.y) * (p4.x - p3.x);
+  if (Math.abs(den) < 1e-9) return null;
+  const t = ((p3.x - p1.x) * (p4.y - p3.y) - (p3.y - p1.y) * (p4.x - p3.x)) / den, u = ((p3.x - p1.x) * (p2.y - p1.y) - (p3.y - p1.y) * (p2.x - p1.x)) / den;
+  return t > 0 && t < 1 && u > 0 && u < 1 ? { x: p1.x + t * (p2.x - p1.x), y: p1.y + t * (p2.y - p1.y) } : null;
+}
+function countSplineCrossings(layout, floor = Infinity) {
+  const center = /* @__PURE__ */ new Map();
+  for (const n of layout.nodes) center.set(n.label, { x: n.x, y: n.y });
+  for (const g of layout.groups)
+    if (g.collapsed) center.set("__group_" + g.label, { x: g.x, y: g.y });
+  const polys = flatPolys(layout);
+  const edges = layout.edges;
+  const R = 34;
+  let total = 0;
+  for (let a = 0; a < polys.length; a++)
+    for (let b = a + 1; b < polys.length; b++) {
+      const A = polys[a], B = polys[b];
+      if (A.pts.length < 2 || B.pts.length < 2) continue;
+      if (A.x1 < B.x0 || B.x1 < A.x0 || A.y1 < B.y0 || B.y1 < A.y0) continue;
+      const ea = edges[a], eb = edges[b];
+      let sh0, sh1;
+      if (ea.source === eb.source || ea.source === eb.target)
+        sh0 = center.get(ea.source);
+      if (ea.target === eb.source || ea.target === eb.target)
+        sh1 = center.get(ea.target);
+      const hits = [];
+      const ap = A.pts, bp = B.pts;
+      for (let i = 1; i < ap.length; i++) {
+        const a0 = ap[i - 1], a1 = ap[i];
+        const axMin = a0.x < a1.x ? a0.x : a1.x, axMax = a0.x > a1.x ? a0.x : a1.x, ayMin = a0.y < a1.y ? a0.y : a1.y, ayMax = a0.y > a1.y ? a0.y : a1.y;
+        for (let j = 1; j < bp.length; j++) {
+          const b0 = bp[j - 1], b1 = bp[j];
+          if (axMax < (b0.x < b1.x ? b0.x : b1.x)) continue;
+          if ((b0.x > b1.x ? b0.x : b1.x) < axMin) continue;
+          if (ayMax < (b0.y < b1.y ? b0.y : b1.y)) continue;
+          if ((b0.y > b1.y ? b0.y : b1.y) < ayMin) continue;
+          const p = segPoint(a0, a1, b0, b1);
+          if (!p) continue;
+          if (sh0 && Math.hypot(p.x - sh0.x, p.y - sh0.y) < R) continue;
+          if (sh1 && Math.hypot(p.x - sh1.x, p.y - sh1.y) < R) continue;
+          if (!hits.some((h) => Math.hypot(h.x - p.x, h.y - p.y) < 6))
+            hits.push(p);
+        }
+      }
+      total += hits.length;
+      if (total > floor) return total;
+    }
+  return total;
+}
+function pointSegDist(p, a, b) {
+  const dx = b.x - a.x, dy = b.y - a.y;
+  const len2 = dx * dx + dy * dy;
+  if (len2 < 1e-9) return Math.hypot(p.x - a.x, p.y - a.y);
+  let t = ((p.x - a.x) * dx + (p.y - a.y) * dy) / len2;
+  t = Math.max(0, Math.min(1, t));
+  return Math.hypot(p.x - (a.x + t * dx), p.y - (a.y + t * dy));
+}
+function distToPoly(p, poly) {
+  let m = Infinity;
+  for (let i = 1; i < poly.length; i++)
+    m = Math.min(m, pointSegDist(p, poly[i - 1], poly[i]));
+  return m;
+}
+function pointRectDist(p, r) {
+  const dx = Math.max(r.x - r.w / 2 - p.x, 0, p.x - (r.x + r.w / 2));
+  const dy = Math.max(r.y - r.h / 2 - p.y, 0, p.y - (r.y + r.h / 2));
+  return Math.hypot(dx, dy);
+}
+function detectEdgeOverlaps(layout, opts) {
+  const dist = opts?.dist ?? 8;
+  const minLen = opts?.minLen ?? 16;
+  const nodeClear = opts?.nodeClear ?? 12;
+  const rect = /* @__PURE__ */ new Map();
+  for (const n of layout.nodes)
+    rect.set(n.label, { x: n.x, y: n.y, w: n.width, h: n.height });
+  for (const g of layout.groups)
+    if (g.collapsed)
+      rect.set("__group_" + g.label, {
+        x: g.x,
+        y: g.y,
+        w: g.width,
+        h: g.height
+      });
+  const polys = flatPolys(layout);
+  const edges = layout.edges;
+  const runs = [];
+  for (let a = 0; a < polys.length; a++)
+    for (let b = a + 1; b < polys.length; b++) {
+      const A = polys[a], B = polys[b];
+      if (A.pts.length < 2 || B.pts.length < 2) continue;
+      if (A.x1 + dist < B.x0 || B.x1 + dist < A.x0 || A.y1 + dist < B.y0 || B.y1 + dist < A.y0)
+        continue;
+      const ea = edges[a], eb = edges[b];
+      let shr0, shr1;
+      if (ea.source === eb.source || ea.source === eb.target)
+        shr0 = rect.get(ea.source);
+      if (ea.target === eb.source || ea.target === eb.target)
+        shr1 = rect.get(ea.target);
+      let run = [];
+      let runLen = 0;
+      const flush = () => {
+        if (runLen >= minLen && run.length >= 2)
+          runs.push({
+            mid: run[Math.floor(run.length / 2)],
+            length: runLen,
+            pts: run.slice()
+          });
+        run = [];
+        runLen = 0;
+      };
+      for (const p of A.pts) {
+        const nearShared = shr0 !== void 0 && pointRectDist(p, shr0) < nodeClear || shr1 !== void 0 && pointRectDist(p, shr1) < nodeClear;
+        const covered = !nearShared && distToPoly(p, B.pts) < dist;
+        if (covered) {
+          if (run.length)
+            runLen += Math.hypot(
+              p.x - run[run.length - 1].x,
+              p.y - run[run.length - 1].y
+            );
+          run.push(p);
+        } else flush();
+      }
+      flush();
+    }
+  return runs;
+}
+function countEdgeOverlaps(layout, opts) {
+  return detectEdgeOverlaps(layout, opts).length;
+}
+function detectEdgeNodePierces(layout, opts) {
+  const inset = opts?.inset ?? 6;
+  const minPts = opts?.minPts ?? 2;
+  const rects = [];
+  for (const n of layout.nodes)
+    rects.push({ key: n.label, x: n.x, y: n.y, w: n.width, h: n.height });
+  for (const g of layout.groups)
+    if (g.collapsed)
+      rects.push({
+        key: "__group_" + g.label,
+        x: g.x,
+        y: g.y,
+        w: g.width,
+        h: g.height
+      });
+  const inside = (p, r) => Math.abs(p.x - r.x) < r.w / 2 - inset && Math.abs(p.y - r.y) < r.h / 2 - inset;
+  const out = [];
+  const polys = flatPolys(layout);
+  layout.edges.forEach((e, idx) => {
+    if (e.points.length < 2) return;
+    const poly = polys[idx].pts;
+    for (const r of rects) {
+      if (r.key === e.source || r.key === e.target || "__group_" + r.key === e.source || "__group_" + r.key === e.target)
+        continue;
+      const hits = poly.filter((p) => inside(p, r));
+      if (hits.length >= minPts)
+        out.push({ edgeIdx: idx, node: r.key, pts: hits });
+    }
+  });
+  return out;
+}
+function countEdgeNodePierces(layout, opts) {
+  return detectEdgeNodePierces(layout, opts).length;
+}
+function deroutePierces(layout) {
+  const pierces = detectEdgeNodePierces(layout);
+  if (!pierces.length) return layout;
+  const rect = /* @__PURE__ */ new Map();
+  for (const n of layout.nodes)
+    rect.set(n.label, { x: n.x, y: n.y, w: n.width, h: n.height });
+  for (const g of layout.groups)
+    if (g.collapsed)
+      rect.set("__group_" + g.label, {
+        x: g.x,
+        y: g.y,
+        w: g.width,
+        h: g.height
+      });
+  const byEdge = /* @__PURE__ */ new Map();
+  for (const p of pierces) {
+    const arr = byEdge.get(p.edgeIdx);
+    if (arr) arr.push(p.node);
+    else byEdge.set(p.edgeIdx, [p.node]);
+  }
+  const edges = layout.edges.map((e, idx) => {
+    const nodes = byEdge.get(idx);
+    if (!nodes) return e;
+    let pts = e.points.map((p) => ({ x: p.x, y: p.y }));
+    for (const label of nodes) {
+      const r = rect.get(label);
+      if (r) pts = detourAround(pts, r);
+    }
+    return { ...e, points: pts };
+  });
+  return { ...layout, edges };
+}
+function detourAround(pts, r) {
+  if (pts.length < 2) return pts;
+  const c = { x: r.x, y: r.y };
+  let bestSeg = -1;
+  let bestT = 0;
+  let bestD = Infinity;
+  let bestPt = pts[0];
+  for (let i = 0; i < pts.length - 1; i++) {
+    const a2 = pts[i], b2 = pts[i + 1];
+    const dx = b2.x - a2.x, dy = b2.y - a2.y;
+    const len2 = dx * dx + dy * dy || 1e-9;
+    let t = ((c.x - a2.x) * dx + (c.y - a2.y) * dy) / len2;
+    t = Math.max(0, Math.min(1, t));
+    const q = { x: a2.x + t * dx, y: a2.y + t * dy };
+    const d = Math.hypot(q.x - c.x, q.y - c.y);
+    if (d < bestD) {
+      bestD = d;
+      bestSeg = i;
+      bestT = t;
+      bestPt = q;
+    }
+  }
+  if (bestSeg < 0) return pts;
+  let nx = bestPt.x - c.x;
+  let ny = bestPt.y - c.y;
+  if (Math.hypot(nx, ny) < 1) {
+    if (r.w <= r.h) {
+      nx = 1;
+      ny = 0;
+    } else {
+      nx = 0;
+      ny = 1;
+    }
+  }
+  const nlen = Math.hypot(nx, ny) || 1;
+  nx /= nlen;
+  ny /= nlen;
+  const a = pts[bestSeg], b = pts[bestSeg + 1];
+  let ex = b.x - a.x, ey = b.y - a.y;
+  const elen = Math.hypot(ex, ey) || 1;
+  ex /= elen;
+  ey /= elen;
+  const clear = Math.hypot(r.w, r.h) / 2 + 18;
+  const hw = Math.hypot(r.w, r.h) / 2;
+  void bestT;
+  const before = {
+    x: bestPt.x - ex * hw + nx * clear * 0.5,
+    y: bestPt.y - ey * hw + ny * clear * 0.5
+  };
+  const peak = { x: c.x + nx * clear, y: c.y + ny * clear };
+  const after = {
+    x: bestPt.x + ex * hw + nx * clear * 0.5,
+    y: bestPt.y + ey * hw + ny * clear * 0.5
+  };
+  const out = pts.slice(0, bestSeg + 1);
+  out.push(before, peak, after);
+  out.push(...pts.slice(bestSeg + 1));
+  return out;
+}
+function countEdgeNearMiss(layout, opts) {
+  const near = opts?.near ?? 14;
+  const tight = opts?.tight ?? 8;
+  const minLen = opts?.minLen ?? 18;
+  const close = detectEdgeOverlaps(layout, { dist: near, minLen }).length;
+  const over = detectEdgeOverlaps(layout, { dist: tight, minLen }).length;
+  return Math.max(0, close - over);
+}
+var GROUP_LABEL_ZONE = 32;
+function detectGroupOverlaps(layout, opts) {
+  const margin = opts?.margin ?? 4;
+  const raw = layout.groups.map((g) => ({
+    label: g.label,
+    l: g.x - g.width / 2,
+    r: g.x + g.width / 2,
+    t: g.y - g.height / 2,
+    b: g.y + g.height / 2
+  }));
+  const contains = (outer, inner) => outer.l <= inner.l + margin && outer.r >= inner.r - margin && outer.t <= inner.t + margin && outer.b >= inner.b - margin;
+  const rend = raw.map((a, i) => {
+    const parent = raw.some((b, j) => j !== i && contains(a, b));
+    return parent ? { ...a, t: a.t - GROUP_LABEL_ZONE } : a;
+  });
+  const hit = /* @__PURE__ */ new Set();
+  for (let i = 0; i < raw.length; i++)
+    for (let j = i + 1; j < raw.length; j++) {
+      if (contains(raw[i], raw[j]) || contains(raw[j], raw[i])) continue;
+      const a = rend[i], b = rend[j];
+      const dx = Math.max(a.l - b.r, b.l - a.r);
+      const dy = Math.max(a.t - b.b, b.t - a.b);
+      if (Math.max(dx, dy) < margin) {
+        hit.add(raw[i].label);
+        hit.add(raw[j].label);
+      }
+    }
+  return [...hit];
+}
+function countGroupOverlaps(layout, opts) {
+  const margin = opts?.margin ?? 4;
+  const raw = layout.groups.map((g) => ({
+    l: g.x - g.width / 2,
+    r: g.x + g.width / 2,
+    t: g.y - g.height / 2,
+    b: g.y + g.height / 2
+  }));
+  const contains = (outer, inner) => outer.l <= inner.l + margin && outer.r >= inner.r - margin && outer.t <= inner.t + margin && outer.b >= inner.b - margin;
+  const rend = raw.map((a, i) => {
+    const parent = raw.some((b, j) => j !== i && contains(a, b));
+    return parent ? { ...a, t: a.t - GROUP_LABEL_ZONE } : a;
+  });
+  let count = 0;
+  for (let i = 0; i < raw.length; i++)
+    for (let j = i + 1; j < raw.length; j++) {
+      if (contains(raw[i], raw[j]) || contains(raw[j], raw[i])) continue;
+      const a = rend[i], b = rend[j];
+      const dx = Math.max(a.l - b.r, b.l - a.r);
+      const dy = Math.max(a.t - b.b, b.t - a.b);
+      if (Math.max(dx, dy) < margin) count++;
+    }
+  return count;
+}
+function separateGroupBands(layout, parsed) {
+  if (layout.groups.some((g) => g.collapsed)) return layout;
+  if (countGroupOverlaps(layout) === 0) return layout;
+  const parentOf = /* @__PURE__ */ new Map();
+  for (const g of parsed.groups) parentOf.set(g.label, g.parentGroup);
+  const topOf = (label) => {
+    let cur = label;
+    const seen = /* @__PURE__ */ new Set();
+    for (; ; ) {
+      const p = parentOf.get(cur);
+      if (!p || seen.has(p)) return cur;
+      seen.add(cur);
+      cur = p;
+    }
+  };
+  const topLabels = parsed.groups.filter((g) => !g.parentGroup).map((g) => g.label);
+  if (topLabels.length < 2) return layout;
+  const nodeTop = /* @__PURE__ */ new Map();
+  for (const g of parsed.groups)
+    for (const child of g.children)
+      if (!parsed.groups.some((gg) => gg.label === child))
+        nodeTop.set(child, topOf(g.label));
+  const axis = parsed.direction === "TB" ? "x" : "y";
+  const boxByLabel = new Map(layout.groups.map((g) => [g.label, g]));
+  const bands = topLabels.map((label) => {
+    const g = boxByLabel.get(label);
+    const half2 = (axis === "y" ? g.height : g.width) / 2;
+    let lo = (axis === "y" ? g.y : g.x) - half2;
+    const hi = (axis === "y" ? g.y : g.x) + half2;
+    const isParent = parsed.groups.some((c) => c.parentGroup === label);
+    if (axis === "y" && isParent) lo -= GROUP_LABEL_ZONE;
+    return { label, lo, hi, c: (lo + hi) / 2 };
+  });
+  bands.sort((a, b) => a.c - b.c);
+  const GAP = 16;
+  const half = bands.map((b) => (b.hi - b.lo) / 2);
+  const off = [0];
+  for (let i = 1; i < bands.length; i++)
+    off[i] = off[i - 1] + half[i - 1] + GAP + half[i];
+  const desired = bands.map((b, i) => b.c - off[i]);
+  const blocks = [];
+  for (let i = 0; i < bands.length; i++) {
+    let blk = { pos: desired[i], count: 1, sum: desired[i], first: i };
+    while (blocks.length && blocks[blocks.length - 1].pos >= blk.pos) {
+      const prev = blocks.pop();
+      const count = prev.count + blk.count;
+      const sum = prev.sum + blk.sum;
+      blk = { pos: sum / count, count, sum, first: prev.first };
+    }
+    blocks.push(blk);
+  }
+  const newC = new Array(bands.length);
+  for (const blk of blocks)
+    for (let k = 0; k < blk.count; k++)
+      newC[blk.first + k] = blk.pos + off[blk.first + k];
+  const delta = /* @__PURE__ */ new Map();
+  let moved = false;
+  bands.forEach((b, i) => {
+    const d = newC[i] - b.c;
+    delta.set(b.label, d);
+    if (Math.abs(d) > 0.5) moved = true;
+  });
+  if (!moved) return layout;
+  const nodeDelta = (label) => {
+    if (label.startsWith("__group_"))
+      return delta.get(topOf(label.slice("__group_".length))) ?? 0;
+    const top = nodeTop.get(label);
+    return top ? delta.get(top) ?? 0 : 0;
+  };
+  const shift = (p, d) => axis === "y" ? { x: p.x, y: p.y + d } : { x: p.x + d, y: p.y };
+  const nodes = layout.nodes.map((n) => {
+    const d = nodeDelta(n.label);
+    return d ? { ...n, ...axis === "y" ? { y: n.y + d } : { x: n.x + d } } : n;
+  });
+  const groups = layout.groups.map((g) => {
+    const d = delta.get(topOf(g.label)) ?? 0;
+    return d ? { ...g, ...axis === "y" ? { y: g.y + d } : { x: g.x + d } } : g;
+  });
+  const edges = layout.edges.map((e) => {
+    const ds = nodeDelta(e.source);
+    const dt = nodeDelta(e.target);
+    if (!ds && !dt) return e;
+    const N = e.points.length;
+    const points = e.points.map((p, i) => {
+      const f = N > 1 ? i / (N - 1) : 0;
+      return shift(p, ds * (1 - f) + dt * f);
+    });
+    return { ...e, points };
+  });
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  const acc = (x, y) => {
+    if (x < minX) minX = x;
+    if (x > maxX) maxX = x;
+    if (y < minY) minY = y;
+    if (y > maxY) maxY = y;
+  };
+  for (const n of nodes) {
+    acc(n.x - n.width / 2, n.y - n.height / 2);
+    acc(n.x + n.width / 2, n.y + n.height / 2);
+  }
+  for (const g of groups) {
+    acc(g.x - g.width / 2, g.y - g.height / 2 - GROUP_LABEL_ZONE);
+    acc(g.x + g.width / 2, g.y + g.height / 2);
+  }
+  for (const e of edges) for (const p of e.points) acc(p.x, p.y);
+  const M = 40;
+  const sx = M - minX, sy = M - minY;
+  const reshift = sx !== 0 || sy !== 0;
+  return {
+    nodes: reshift ? nodes.map((n) => ({ ...n, x: n.x + sx, y: n.y + sy })) : nodes,
+    groups: reshift ? groups.map((g) => ({ ...g, x: g.x + sx, y: g.y + sy })) : groups,
+    edges: reshift ? edges.map((e) => ({
+      ...e,
+      points: e.points.map((p) => ({ x: p.x + sx, y: p.y + sy }))
+    })) : edges,
+    width: maxX - minX + 2 * M,
+    height: maxY - minY + 2 * M
+  };
+}
+function segCross(p1, p2, p3, p4) {
+  const d1x = p2.x - p1.x, d1y = p2.y - p1.y, d2x = p4.x - p3.x, d2y = p4.y - p3.y;
+  const den = d1x * d2y - d1y * d2x;
+  if (Math.abs(den) < 1e-9) return false;
+  const t = ((p3.x - p1.x) * d2y - (p3.y - p1.y) * d2x) / den;
+  const s = ((p3.x - p1.x) * d1y - (p3.y - p1.y) * d1x) / den;
+  return t > 1e-3 && t < 0.999 && s > 1e-3 && s < 0.999;
+}
+function countCrossingsFast(layout) {
+  const E = layout.edges.filter((e) => e.points.length >= 2);
+  const bb = E.map((e) => {
+    let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+    for (const p of e.points) {
+      if (p.x < x0) x0 = p.x;
+      if (p.x > x1) x1 = p.x;
+      if (p.y < y0) y0 = p.y;
+      if (p.y > y1) y1 = p.y;
+    }
+    return { x0, y0, x1, y1 };
+  });
+  let count = 0;
+  for (let i = 0; i < E.length; i++)
+    for (let j = i + 1; j < E.length; j++) {
+      const A = E[i], B = E[j];
+      if (A.source === B.source || A.source === B.target || A.target === B.source || A.target === B.target)
+        continue;
+      const a = bb[i], b = bb[j];
+      if (a.x1 < b.x0 || b.x1 < a.x0 || a.y1 < b.y0 || b.y1 < a.y0) continue;
+      const pa = A.points, pb = B.points;
+      let hit = false;
+      for (let ai = 0; ai < pa.length - 1 && !hit; ai++)
+        for (let bi = 0; bi < pb.length - 1; bi++) {
+          if (segCross(pa[ai], pa[ai + 1], pb[bi], pb[bi + 1])) {
+            hit = true;
+            break;
+          }
+        }
+      if (hit) count++;
+    }
+  return count;
+}
+function meanDrift(layout, prev) {
+  if (!prev?.size) return 0;
+  let sum = 0, n = 0;
+  for (const node of layout.nodes) {
+    const p = prev.get(node.label);
+    if (p) {
+      sum += Math.hypot(node.x - p.x, node.y - p.y);
+      n++;
+    }
+  }
+  return n ? sum / n : 0;
+}
+function edgeLength(layout) {
+  let total = 0;
+  for (const e of layout.edges)
+    for (let i = 1; i < e.points.length; i++)
+      total += Math.hypot(
+        e.points[i].x - e.points[i - 1].x,
+        e.points[i].y - e.points[i - 1].y
+      );
+  return total;
+}
+async function layoutBoxesAndLinesSearch(parsed, collapseInfo, opts) {
+  const hideDescriptions = opts?.hideDescriptions ?? false;
+  const reserveEdgeLabels = opts?.reserveEdgeLabels ?? false;
+  const onProgress = opts?.onProgress;
+  const tick = onProgress ? () => new Promise((r) => setTimeout(r)) : () => void 0;
+  const YIELD_AFTER_MS = 150;
+  const YIELD_EVERY_MS = 30;
+  const searchStart = performance.now();
+  let lastYield = searchStart;
+  const collapsedGroupLabels = /* @__PURE__ */ new Set();
+  if (collapseInfo) {
+    const missing = /* @__PURE__ */ new Set();
+    for (const og of collapseInfo.originalGroups)
+      if (!parsed.groups.some((g) => g.label === og.label))
+        missing.add(og.label);
+    for (const label of missing) {
+      const og = collapseInfo.originalGroups.find((g) => g.label === label);
+      const parent = og?.parentGroup;
+      if (!parent || !missing.has(parent)) collapsedGroupLabels.add(label);
+    }
+  }
+  const sizes = /* @__PURE__ */ new Map();
+  let maxDescH = 0;
+  for (const node of parsed.nodes) {
+    const s = hideDescriptions ? { width: NODE_WIDTH, height: NODE_HEIGHT } : computeNodeSize(node, parsed.showValues === true);
+    sizes.set(node.label, s);
+    if (!hideDescriptions && node.description && node.description.length > 0)
+      maxDescH = Math.max(maxDescH, s.height);
+  }
+  if (maxDescH > 0) {
+    for (const node of parsed.nodes)
+      if (node.description && node.description.length > 0) {
+        const s = sizes.get(node.label);
+        sizes.set(node.label, { width: s.width, height: maxDescH });
+      }
+  }
+  const gid = (label) => `__group_${label}`;
+  const rankdir = parsed.direction === "TB" ? "TB" : "LR";
+  const nodeLabelSet = new Set(parsed.nodes.map((n2) => n2.label));
+  const directNodeChildren = /* @__PURE__ */ new Map();
+  const childGroupsOf = /* @__PURE__ */ new Map();
+  for (const grp of parsed.groups) {
+    directNodeChildren.set(
+      grp.label,
+      grp.children.filter((c) => nodeLabelSet.has(c))
+    );
+    if (grp.parentGroup) {
+      const arr = childGroupsOf.get(grp.parentGroup) ?? [];
+      arr.push(grp.label);
+      childGroupsOf.set(grp.parentGroup, arr);
+    }
+  }
+  const membersCache = /* @__PURE__ */ new Map();
+  const membersOf = (label) => {
+    const cached = membersCache.get(label);
+    if (cached) return cached;
+    membersCache.set(label, []);
+    const out = [...directNodeChildren.get(label) ?? []];
+    for (const sub of childGroupsOf.get(label) ?? [])
+      out.push(...membersOf(sub));
+    membersCache.set(label, out);
+    return out;
+  };
+  const gidSourceRep = /* @__PURE__ */ new Map();
+  const gidTargetRep = /* @__PURE__ */ new Map();
+  for (const grp of parsed.groups) {
+    const members = membersOf(grp.label);
+    if (members.length === 0) continue;
+    const memberSet = new Set(members);
+    const preds = /* @__PURE__ */ new Map();
+    for (const e of parsed.edges)
+      if (memberSet.has(e.source) && memberSet.has(e.target)) {
+        const arr = preds.get(e.target) ?? [];
+        arr.push(e.source);
+        preds.set(e.target, arr);
+      }
+    const rankCache = /* @__PURE__ */ new Map();
+    const onPath = /* @__PURE__ */ new Set();
+    const rankOf = (n2) => {
+      const c = rankCache.get(n2);
+      if (c !== void 0) return c;
+      if (onPath.has(n2)) return 0;
+      onPath.add(n2);
+      let r = 0;
+      for (const p of preds.get(n2) ?? []) r = Math.max(r, rankOf(p) + 1);
+      onPath.delete(n2);
+      rankCache.set(n2, r);
+      return r;
+    };
+    let exit = members[0];
+    let entry = members[0];
+    for (const mem of members) {
+      if (rankOf(mem) > rankOf(exit)) exit = mem;
+      if (rankOf(mem) < rankOf(entry)) entry = mem;
+    }
+    gidSourceRep.set(gid(grp.label), exit);
+    gidTargetRep.set(gid(grp.label), entry);
+  }
+  const srcRep = (label) => gidSourceRep.get(label) ?? label;
+  const tgtRep = (label) => gidTargetRep.get(label) ?? label;
+  const edgeKey = (e) => `${e.source}->${e.target}#${e.lineNumber}`;
+  const rectBorderPoint = (rect, toward) => {
+    const dx = toward.x - rect.x;
+    const dy = toward.y - rect.y;
+    const sx = dx === 0 ? Infinity : rect.w / 2 / Math.abs(dx);
+    const sy = dy === 0 ? Infinity : rect.h / 2 / Math.abs(dy);
+    const s = Math.min(sx, sy);
+    if (!Number.isFinite(s)) return { x: rect.x, y: rect.y };
+    return { x: rect.x + dx * s, y: rect.y + dy * s };
+  };
+  const isInsideRect = (p, rect) => Math.abs(p.x - rect.x) <= rect.w / 2 && Math.abs(p.y - rect.y) <= rect.h / 2;
+  const pinned = parsed.nodePositions;
+  const groupLabelSet = new Set(parsed.groups.map((g) => g.label));
+  const groupsAreFlat = parsed.groups.every(
+    (g) => !g.parentGroup && !g.children.some((c) => groupLabelSet.has(c))
+  );
+  const allOriginalGroupLabels = new Set(
+    (collapseInfo?.originalGroups ?? parsed.groups).map((g) => g.label)
+  );
+  const collapsedAreFlatPinned = collapsedGroupLabels.size === 0 || pinned !== void 0 && collapseInfo !== void 0 && [...collapsedGroupLabels].every((label) => {
+    const og = collapseInfo.originalGroups.find((g) => g.label === label);
+    if (!og || og.parentGroup) return false;
+    return og.children.every(
+      (c) => pinned.has(c) && !allOriginalGroupLabels.has(c)
+    );
+  });
+  const allPinned = pinned !== void 0 && (parsed.nodes.length > 0 || collapsedGroupLabels.size > 0) && parsed.nodes.every((n2) => pinned.has(n2.label)) && groupsAreFlat && collapsedAreFlatPinned;
+  function placePinned(pins) {
+    const collapsedPosByGid = /* @__PURE__ */ new Map();
+    const collapsedBoxes = [];
+    if (collapseInfo)
+      for (const label of collapsedGroupLabels) {
+        const og = collapseInfo.originalGroups.find((g) => g.label === label);
+        if (!og) continue;
+        let cx0 = Infinity, cy0 = Infinity, cx1 = -Infinity, cy1 = -Infinity;
+        for (const c of og.children) {
+          const p = pins.get(c);
+          if (!p) continue;
+          cx0 = Math.min(cx0, p.x);
+          cx1 = Math.max(cx1, p.x);
+          cy0 = Math.min(cy0, p.y);
+          cy1 = Math.max(cy1, p.y);
+        }
+        if (!Number.isFinite(cx0)) continue;
+        const cx = (cx0 + cx1) / 2;
+        const cy = (cy0 + cy1) / 2;
+        collapsedPosByGid.set(`__group_${label}`, { x: cx, y: cy });
+        collapsedBoxes.push({
+          label,
+          lineNumber: og.lineNumber,
+          childCount: collapseInfo.collapsedChildCounts.get(label) ?? og.children.length,
+          x: cx,
+          y: cy
+        });
+      }
+    const posOf = (label) => pins.get(label) ?? collapsedPosByGid.get(label);
+    const rectOf = (label) => {
+      const p = posOf(label);
+      const s = sizes.get(label) ?? { width: NODE_WIDTH, height: NODE_HEIGHT };
+      return { x: p.x, y: p.y, w: s.width, h: s.height };
+    };
+    const nodes = parsed.nodes.map((n2) => {
+      const r = rectOf(n2.label);
+      return { label: n2.label, x: r.x, y: r.y, width: r.w, height: r.h };
+    });
+    const edges = parsed.edges.flatMap((e) => {
+      const sp = posOf(e.source);
+      const tp = posOf(e.target);
+      if (!sp || !tp) return [];
+      const srcRect = rectOf(e.source);
+      const tgtRect = rectOf(e.target);
+      const p0 = rectBorderPoint(srcRect, tp);
+      const p1 = rectBorderPoint(tgtRect, sp);
+      return [
+        {
+          source: e.source,
+          target: e.target,
+          ...e.label !== void 0 && { label: e.label },
+          bidirectional: e.bidirectional,
+          lineNumber: e.lineNumber,
+          points: [p0, p1],
+          yOffset: 0,
+          parallelCount: 1,
+          metadata: e.metadata,
+          straight: true
+        }
+      ];
+    });
+    const GROUP_PAD = 16;
+    const nodeByLabel = new Map(nodes.map((n2) => [n2.label, n2]));
+    const groups = [];
+    for (const grp of parsed.groups) {
+      let gx0 = Infinity, gy0 = Infinity, gx1 = -Infinity, gy1 = -Infinity;
+      for (const c of grp.children) {
+        const n2 = nodeByLabel.get(c);
+        if (!n2) continue;
+        gx0 = Math.min(gx0, n2.x - n2.width / 2);
+        gx1 = Math.max(gx1, n2.x + n2.width / 2);
+        gy0 = Math.min(gy0, n2.y - n2.height / 2);
+        gy1 = Math.max(gy1, n2.y + n2.height / 2);
+      }
+      if (!Number.isFinite(gx0)) continue;
+      const x0 = gx0 - GROUP_PAD;
+      const x1 = gx1 + GROUP_PAD;
+      const y0 = gy0 - GROUP_LABEL_ZONE;
+      const y1 = gy1 + GROUP_PAD;
+      groups.push({
+        label: grp.label,
+        lineNumber: grp.lineNumber,
+        x: (x0 + x1) / 2,
+        y: (y0 + y1) / 2,
+        width: x1 - x0,
+        height: y1 - y0,
+        collapsed: false,
+        childCount: grp.children.length
+      });
+    }
+    for (const cb of collapsedBoxes) {
+      groups.push({
+        label: cb.label,
+        lineNumber: cb.lineNumber,
+        x: cb.x,
+        y: cb.y,
+        width: NODE_WIDTH,
+        height: NODE_HEIGHT,
+        collapsed: true,
+        childCount: cb.childCount
+      });
+    }
+    const M = 40;
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    const acc = (x, y) => {
+      if (x < minX) minX = x;
+      if (x > maxX) maxX = x;
+      if (y < minY) minY = y;
+      if (y > maxY) maxY = y;
+    };
+    for (const n2 of nodes) {
+      acc(n2.x - n2.width / 2, n2.y - n2.height / 2);
+      acc(n2.x + n2.width / 2, n2.y + n2.height / 2);
+    }
+    for (const e of edges) for (const p of e.points) acc(p.x, p.y);
+    for (const gr of groups) {
+      acc(gr.x - gr.width / 2, gr.y - gr.height / 2);
+      acc(gr.x + gr.width / 2, gr.y + gr.height / 2);
+    }
+    const TOL = 2;
+    const sx = minX < M - TOL ? M - minX : 0;
+    const sy = minY < M - TOL ? M - minY : 0;
+    const shifted = sx !== 0 || sy !== 0;
+    return {
+      nodes: shifted ? nodes.map((n2) => ({ ...n2, x: n2.x + sx, y: n2.y + sy })) : nodes,
+      edges: shifted ? edges.map((e) => ({
+        ...e,
+        points: e.points.map((p) => ({ x: p.x + sx, y: p.y + sy }))
+      })) : edges,
+      groups: shifted ? groups.map((gr) => ({ ...gr, x: gr.x + sx, y: gr.y + sy })) : groups,
+      width: maxX + sx + M,
+      height: maxY + sy + M
+    };
+  }
+  function place(cfg) {
+    const r = cfg.seed === void 0 ? null : rng2(cfg.seed + 1);
+    const ord = (a) => r ? shuffle(a, r) : a.slice();
+    const g = new dagre.graphlib.Graph({ compound: true, multigraph: true });
+    g.setGraph({
+      rankdir,
+      ranker: cfg.ranker,
+      nodesep: cfg.nodesep,
+      ranksep: cfg.ranksep,
+      edgesep: 20,
+      marginx: 40,
+      marginy: 40
+    });
+    g.setDefaultEdgeLabel(() => ({}));
+    for (const grp of ord(parsed.groups))
+      g.setNode(gid(grp.label), { label: grp.label });
+    for (const node of ord(parsed.nodes)) {
+      const s = sizes.get(node.label);
+      g.setNode(node.label, { width: s.width, height: s.height });
+    }
+    for (const label of collapsedGroupLabels)
+      g.setNode(gid(label), { width: NODE_WIDTH, height: NODE_HEIGHT });
+    for (const grp of parsed.groups) {
+      if (grp.parentGroup && g.hasNode(gid(grp.parentGroup)))
+        g.setParent(gid(grp.label), gid(grp.parentGroup));
+      for (const c of ord(grp.children)) {
+        if (g.hasNode(c)) g.setParent(c, gid(grp.label));
+      }
+    }
+    if (collapseInfo)
+      for (const label of collapsedGroupLabels) {
+        const og = collapseInfo.originalGroups.find((x) => x.label === label);
+        if (og?.parentGroup && !collapsedGroupLabels.has(og.parentGroup) && g.hasNode(gid(og.parentGroup)))
+          g.setParent(gid(label), gid(og.parentGroup));
+      }
+    for (const e of ord(parsed.edges)) {
+      const s = srcRep(e.source);
+      const t = tgtRep(e.target);
+      if (s !== t && g.hasNode(s) && g.hasNode(t)) {
+        let edgeLabel = {};
+        if (reserveEdgeLabels && e.label) {
+          const m = measureEdgeLabel(e.label, EDGE_LABEL_FONT_SIZE);
+          edgeLabel = { width: m.width, height: m.height, labelpos: "c" };
+        }
+        g.setEdge(s, t, edgeLabel, edgeKey(e));
+      }
+    }
+    dagre.layout(g);
+    const nodes = parsed.nodes.map((n2) => {
+      const p = g.node(n2.label);
+      return {
+        label: n2.label,
+        x: p.x,
+        y: p.y,
+        width: p.width,
+        height: p.height
+      };
+    });
+    const groups = parsed.groups.map(
+      (grp) => {
+        const p = g.node(gid(grp.label));
+        return {
+          label: grp.label,
+          lineNumber: grp.lineNumber,
+          x: p.x,
+          y: p.y,
+          width: p.width,
+          height: p.height,
+          collapsed: false,
+          childCount: grp.children.length
+        };
+      }
+    );
+    for (const label of collapsedGroupLabels) {
+      const p = g.node(gid(label));
+      groups.push({
+        label,
+        lineNumber: 0,
+        x: p.x,
+        y: p.y,
+        width: p.width,
+        height: p.height,
+        collapsed: true,
+        childCount: collapseInfo?.collapsedChildCounts.get(label) ?? 0
+      });
+    }
+    const groupRectByGid = /* @__PURE__ */ new Map();
+    for (const grp of parsed.groups) {
+      const p = g.node(gid(grp.label));
+      if (p)
+        groupRectByGid.set(gid(grp.label), {
+          x: p.x,
+          y: p.y,
+          w: p.width,
+          h: p.height
+        });
+    }
+    const clipPointsToGroups = (pts, source, target) => {
+      if (pts.length < 2) return pts;
+      let out = pts;
+      const srcRect = groupRectByGid.get(source);
+      if (srcRect) {
+        let k = 0;
+        while (k < out.length - 1 && isInsideRect(out[k], srcRect)) k++;
+        out = [rectBorderPoint(srcRect, out[k]), ...out.slice(k)];
+      }
+      const tgtRect = groupRectByGid.get(target);
+      if (tgtRect) {
+        let k = out.length - 1;
+        while (k > 0 && isInsideRect(out[k], tgtRect)) k--;
+        out = [...out.slice(0, k + 1), rectBorderPoint(tgtRect, out[k])];
+      }
+      return out;
+    };
+    const edges = parsed.edges.flatMap((e) => {
+      const s = srcRep(e.source);
+      const t = tgtRep(e.target);
+      const key = edgeKey(e);
+      if (s === t || !g.hasEdge(s, t, key)) return [];
+      const ed = g.edge(s, t, key);
+      const points = clipPointsToGroups(ed?.points ?? [], e.source, e.target);
+      return [
+        {
+          source: e.source,
+          target: e.target,
+          ...e.label !== void 0 && { label: e.label },
+          bidirectional: e.bidirectional,
+          lineNumber: e.lineNumber,
+          points,
+          yOffset: 0,
+          parallelCount: 1,
+          metadata: e.metadata
+        }
+      ];
+    });
+    const gg = g.graph();
+    return {
+      nodes,
+      edges,
+      groups,
+      width: gg.width ?? 800,
+      height: gg.height ?? 600
+    };
+  }
+  if (allPinned) return placePinned(pinned);
+  const n = parsed.nodes.length;
+  const seedCount = opts?.seeds ?? (n <= 12 ? 80 : n <= 22 ? 40 : n <= 35 ? 22 : 10);
+  const REFINE_K = opts?.refineK ?? 6;
+  const lambda = opts?.lambda ?? DEFAULT_LAMBDA;
+  const prev = opts?.previousPositions;
+  const RANKERS = ["network-simplex", "tight-tree", "longest-path"];
+  const SPACINGS = [
+    { nodesep: 50, ranksep: 60 },
+    { nodesep: 34, ranksep: 46 },
+    { nodesep: 66, ranksep: 82 }
+  ];
+  const configs = [];
+  for (const ranker of RANKERS)
+    for (const sp of SPACINGS) configs.push({ ranker, ...sp });
+  for (let s = 0; s < seedCount; s++)
+    configs.push({
+      ranker: "network-simplex",
+      nodesep: 50,
+      ranksep: 60,
+      seed: s
+    });
+  const badness = (lay, floor) => {
+    const x = countSplineCrossings(lay, floor);
+    if (x > floor) return Infinity;
+    return x + countEdgeOverlaps(lay) + countEdgeNodePierces(lay) + countGroupOverlaps(lay);
+  };
+  const objective = (lay, viol) => viol * 1e6 + edgeLength(lay) + lambda * meanDrift(lay, prev) * 10;
+  const progressTotal = configs.length + Math.min(opts?.refineK ?? 6, configs.length);
+  let progressDone = 0;
+  const step = async (phase) => {
+    if (!onProgress) return;
+    onProgress(++progressDone, progressTotal, phase);
+    const now = performance.now();
+    if (now - searchStart > YIELD_AFTER_MS && now - lastYield > YIELD_EVERY_MS) {
+      lastYield = now;
+      await tick();
+    }
+  };
+  const pool = [];
+  for (const cfg of configs) {
+    try {
+      pool.push(place(cfg));
+    } catch {
+    }
+    await step("Optimizing layout");
+  }
+  if (!pool.length)
+    return place({ ranker: "network-simplex", nodesep: 50, ranksep: 60 });
+  let layered = [];
+  try {
+    layered = layeredCandidates(parsed, sizes);
+  } catch {
+  }
+  if (parsed.groups.length > 0 && collapsedGroupLabels.size === 0) {
+    try {
+      layered = layered.concat(groupedTierCandidates(parsed, sizes));
+    } catch {
+    }
+  }
+  const fastKey = /* @__PURE__ */ new Map();
+  for (const lay of pool)
+    fastKey.set(lay, objective(lay, countCrossingsFast(lay)));
+  pool.sort((a, b) => fastKey.get(a) - fastKey.get(b));
+  const refineK = Math.min(REFINE_K, pool.length);
+  let best = pool[0];
+  let bestObj = Infinity;
+  let bestBad = Infinity;
+  const consider = (lay) => {
+    const bad = badness(lay, bestBad);
+    if (bad === Infinity) return;
+    const sc = objective(lay, bad);
+    if (sc < bestObj) {
+      bestObj = sc;
+      bestBad = bad;
+      best = lay;
+    }
+  };
+  for (const lay of pool.slice(0, refineK)) {
+    consider(lay);
+    await step("Refining layout");
+  }
+  if (bestBad >= ESCALATE_THRESHOLD && n <= ESCALATE_MAX_N) {
+    const extra = [];
+    for (let s = seedCount; s < seedCount + ESCALATE_SEEDS; s++) {
+      try {
+        extra.push(
+          place({
+            ranker: "network-simplex",
+            nodesep: 50,
+            ranksep: 60,
+            seed: s
+          })
+        );
+      } catch {
+      }
+    }
+    const extraKey = /* @__PURE__ */ new Map();
+    for (const lay of extra)
+      extraKey.set(lay, objective(lay, countCrossingsFast(lay)));
+    extra.sort((a, b) => extraKey.get(a) - extraKey.get(b));
+    for (const lay of extra.slice(0, ESCALATE_REFINE)) consider(lay);
+  }
+  for (const lay of layered) {
+    const variants = [lay];
+    const dp = deroutePierces(lay);
+    if (dp !== lay) variants.push(dp);
+    for (const v of variants) {
+      const bad = badness(v, bestBad - 1);
+      if (bad < bestBad) {
+        bestBad = bad;
+        best = v;
+      }
+    }
+  }
+  if (bestBad > 0) {
+    const rerouted = deroutePierces(best);
+    if (rerouted !== best && badness(rerouted, bestBad - 1) < bestBad)
+      best = rerouted;
+  }
+  if (bestBad > 0 && countGroupOverlaps(best) > 0) {
+    const separated = separateGroupBands(best, parsed);
+    if (separated !== best && badness(separated, bestBad - 1) < bestBad)
+      best = separated;
+  }
+  return best;
+}
+export {
+  countEdgeNearMiss,
+  countEdgeNodePierces,
+  countEdgeOverlaps,
+  countGroupOverlaps,
+  countSplineCrossings,
+  deroutePierces,
+  detectEdgeNodePierces,
+  detectEdgeOverlaps,
+  detectGroupOverlaps,
+  layoutBoxesAndLinesSearch,
+  separateGroupBands
+};
+//# sourceMappingURL=layout-search-OYV77HHS.js.map