@diagrammo/dgmo 0.46.0 → 0.48.0

package/dist/chunk-YGJTDXVR.js

@@ -0,0 +1,692 @@
+import {
+  NODE_HEIGHT,
+  NODE_WIDTH
+} from "./chunk-IJZFN3HM.js";
+
+// src/boxes-and-lines/layout-grouped.ts
+var NODESEP = 50;
+var RANKSEP = 60;
+var DUMMY_THICK = 10;
+var MARGIN = 40;
+var GROUP_PAD = 16;
+var GROUP_LABEL_ZONE = 32;
+var GROUP_GAP = 24;
+var TIER_GAP = GROUP_LABEL_ZONE + 2 * GROUP_PAD;
+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 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);
+}
+function acyclicOrient(ids, edges) {
+  const adj = /* @__PURE__ */ new Map();
+  for (const l of ids) adj.set(l, []);
+  for (const e of edges) adj.get(e.from)?.push({ to: e.to, idx: e.idx });
+  const reversed = /* @__PURE__ */ new Set();
+  const state = /* @__PURE__ */ new Map();
+  for (const l of ids) state.set(l, 0);
+  const stack = [];
+  const visit = (root) => {
+    stack.push(root);
+    const it = /* @__PURE__ */ new Map();
+    while (stack.length) {
+      const u = stack[stack.length - 1];
+      if (state.get(u) === 0) state.set(u, 1);
+      const list = adj.get(u);
+      let i = it.get(u) ?? 0;
+      let descended = false;
+      for (; i < list.length; i++) {
+        const { to, idx } = list[i];
+        const st = state.get(to);
+        if (st === 1) reversed.add(idx);
+        else if (st === 0) {
+          it.set(u, i + 1);
+          stack.push(to);
+          descended = true;
+          break;
+        }
+      }
+      if (!descended) {
+        it.set(u, list.length);
+        state.set(u, 2);
+        stack.pop();
+      }
+    }
+  };
+  for (const l of ids) if (state.get(l) === 0) visit(l);
+  const dag = edges.map(
+    (e) => reversed.has(e.idx) ? { from: e.to, to: e.from, idx: e.idx, rev: true } : { from: e.from, to: e.to, idx: e.idx, rev: false }
+  );
+  return { dag };
+}
+function longestPath(ids, dag) {
+  const out = /* @__PURE__ */ new Map();
+  const inDeg = /* @__PURE__ */ new Map();
+  for (const l of ids) {
+    out.set(l, []);
+    inDeg.set(l, 0);
+  }
+  for (const d of dag) {
+    out.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 ids) rank.set(l, 0);
+  const queue = ids.filter((l) => (inDeg.get(l) ?? 0) === 0);
+  const indeg2 = new Map(inDeg);
+  let seen = 0;
+  while (queue.length) {
+    const u = queue.shift();
+    seen++;
+    for (const v of out.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);
+    }
+  }
+  return seen === ids.length ? rank : null;
+}
+function groupedTierCandidates(parsed, sizes, opts) {
+  if (parsed.groups.length === 0) return [];
+  const nCount = parsed.nodes.length;
+  if (nCount < 3 || nCount > 60) return [];
+  const isTB = parsed.direction === "TB";
+  const labels = parsed.nodes.map((n) => n.label);
+  const labelSet = new Set(labels);
+  for (const e of parsed.edges)
+    if (e.source.startsWith("__group_") || e.target.startsWith("__group_"))
+      return [];
+  const groupByLabel = new Map(parsed.groups.map((g) => [g.label, g]));
+  const directGroupOf = /* @__PURE__ */ new Map();
+  for (const grp of parsed.groups)
+    for (const c of grp.children)
+      if (labelSet.has(c)) directGroupOf.set(c, grp.label);
+  const topGroupOf = (groupLabel) => {
+    let cur = groupLabel;
+    const guard = /* @__PURE__ */ new Set();
+    while (true) {
+      const g = groupByLabel.get(cur);
+      if (!g?.parentGroup || guard.has(cur)) return cur;
+      guard.add(cur);
+      cur = g.parentGroup;
+    }
+  };
+  const pathOf = (label) => {
+    const direct = directGroupOf.get(label);
+    if (!direct) return [];
+    const chain = [direct];
+    let cur = direct;
+    const guard = /* @__PURE__ */ new Set([direct]);
+    while (true) {
+      const g = groupByLabel.get(cur);
+      if (!g?.parentGroup || guard.has(g.parentGroup)) break;
+      chain.push(g.parentGroup);
+      guard.add(g.parentGroup);
+      cur = g.parentGroup;
+    }
+    return chain.reverse();
+  };
+  const SINGLE = "\0node\0";
+  const unitOf = (label) => {
+    const direct = directGroupOf.get(label);
+    return direct ? topGroupOf(direct) : SINGLE + label;
+  };
+  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 unitOfNode = /* @__PURE__ */ new Map();
+  for (const l of labels) unitOfNode.set(l, unitOf(l));
+  const units = Array.from(new Set(labels.map((l) => unitOfNode.get(l))));
+  const interUnit = edges.filter(({ e }) => unitOfNode.get(e.source) !== unitOfNode.get(e.target)).map(({ e, i }) => ({
+    from: unitOfNode.get(e.source),
+    to: unitOfNode.get(e.target),
+    idx: i
+  }));
+  const { dag: unitDag } = acyclicOrient(units, interUnit);
+  const tier = longestPath(
+    units,
+    unitDag.map((d) => ({ from: d.from, to: d.to }))
+  );
+  if (!tier) return [];
+  const localRank = /* @__PURE__ */ new Map();
+  const unitMembers = /* @__PURE__ */ new Map();
+  for (const l of labels) {
+    const u = unitOfNode.get(l);
+    (unitMembers.get(u) ?? unitMembers.set(u, []).get(u)).push(l);
+  }
+  for (const [u, members] of unitMembers) {
+    const memberSet = new Set(members);
+    const intra = edges.filter(
+      ({ e }) => unitOfNode.get(e.source) === u && unitOfNode.get(e.target) === u && memberSet.has(e.source) && memberSet.has(e.target)
+    ).map(({ e, i }) => ({ from: e.source, to: e.target, idx: i }));
+    const { dag } = acyclicOrient(members, intra);
+    const lr = longestPath(
+      members,
+      dag.map((d) => ({ from: d.from, to: d.to }))
+    );
+    if (!lr) return [];
+    for (const m of members) localRank.set(m, lr.get(m));
+  }
+  const maxTier = Math.max(...units.map((u) => tier.get(u)));
+  const bandHeight = Array.from({ length: maxTier + 1 }, () => 1);
+  for (const u of units) {
+    const h = Math.max(
+      ...unitMembers.get(u).map((m) => localRank.get(m) + 1)
+    );
+    const t = tier.get(u);
+    bandHeight[t] = Math.max(bandHeight[t], h);
+  }
+  const tierBase = [];
+  let accBase = 0;
+  for (let t = 0; t <= maxTier; t++) {
+    tierBase[t] = accBase;
+    accBase += bandHeight[t];
+  }
+  const tierStartRanks = new Set(tierBase.slice(1));
+  const globalRank = /* @__PURE__ */ new Map();
+  for (const l of labels)
+    globalRank.set(
+      l,
+      tierBase[tier.get(unitOfNode.get(l))] + localRank.get(l)
+    );
+  const maxRank = Math.max(...labels.map((l) => globalRank.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: globalRank.get(n.label),
+      cross: 0,
+      thick: isTB ? s.width : s.height,
+      depth: isTB ? s.height : s.width,
+      realW: s.width,
+      realH: s.height,
+      unit: unitOfNode.get(n.label),
+      path: pathOf(n.label)
+    });
+  }
+  const chains = [];
+  const segs = [];
+  const backEdges = [];
+  const flatEdges = [];
+  for (const { e, i } of edges) {
+    const rs = globalRank.get(e.source);
+    const rt = globalRank.get(e.target);
+    if (rs === rt) {
+      flatEdges.push({ edgeIdx: i, a: e.source, b: e.target });
+      continue;
+    }
+    if (rt < rs) {
+      backEdges.push({ edgeIdx: i, src: e.source, tgt: e.target });
+      continue;
+    }
+    const chain = [e.source];
+    let prev = e.source;
+    for (let r = rs + 1; r < rt; r++) {
+      const id = `__d${i}_${r}`;
+      node.set(id, {
+        id,
+        dummy: true,
+        rank: r,
+        cross: 0,
+        thick: DUMMY_THICK,
+        depth: 0,
+        realW: 0,
+        realH: 0,
+        unit: SINGLE + id,
+        path: []
+      });
+      segs.push({ a: prev, b: id });
+      chain.push(id);
+      prev = id;
+    }
+    segs.push({ a: prev, b: e.target });
+    chain.push(e.target);
+    chains.push({ edgeIdx: i, chain });
+  }
+  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 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 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 restarts = opts?.restarts ?? (nCount <= 16 ? 20 : nCount <= 30 ? 12 : 6);
+  const keepK = opts?.keepK ?? 3;
+  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++) {
+      if (iter % 2 === 0)
+        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;
+    }
+    for (const [k, v] of bestSnap) orderOf.set(k, v);
+    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) {
+    for (const [k, v] of cand.order) orderOf.set(k, v);
+    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 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, gap) {
+    const n = ids.length;
+    if (n === 0) return;
+    const off = [0];
+    for (let i = 1; i < n; i++) off[i] = off[i - 1] + gap[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];
+  }
+  function gapBetween(a, b) {
+    const base = a.thick / 2 + b.thick / 2 + NODESEP;
+    if (a.dummy || b.dummy) return base;
+    if (a.unit !== b.unit) return base + 2 * GROUP_PAD + GROUP_GAP;
+    const da = a.path[a.path.length - 1];
+    const db = b.path[b.path.length - 1];
+    if (da !== db && (da || db)) return base + 2 * GROUP_PAD;
+    return base;
+  }
+  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++) {
+      if (r > 0) acc += RANKSEP + (tierStartRanks.has(r) ? TIER_GAP : 0);
+      bandCenter[r] = acc + bandDepth[r] / 2;
+      acc += bandDepth[r];
+    }
+    const gapsFor = (ids) => ids.map(
+      (id, i) => i === 0 ? 0 : gapBetween(node.get(ids[i - 1]), node.get(id))
+    );
+    for (let r = 0; r <= maxRank; r++) {
+      const ids = rk[r];
+      const gap = gapsFor(ids);
+      let x = MARGIN;
+      for (let i = 0; i < ids.length; i++) {
+        const n = node.get(ids[i]);
+        x += gap[i];
+        n.cross = i === 0 ? MARGIN + n.thick / 2 : x;
+      }
+    }
+    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, gapsFor(ids));
+      }
+    }
+    let minC = Infinity;
+    for (const n of node.values()) minC = Math.min(minC, n.cross - n.thick / 2);
+    const shiftC = MARGIN - minC;
+    for (const n of node.values()) n.cross += shiftC;
+    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 faceLim = (depth) => Math.max(0, depth / 2 - 6);
+    const sideOf = (b) => {
+      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();
+    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, rr) => isTB ? { x: c, y: rr } : { x: rr, y: c };
+      const off = 10;
+      const srcEdgeC = src.cross + s * (src.thick / 2 + off);
+      const tgtEdgeC = tgt.cross + s * (tgt.thick / 2 + off);
+      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 flatPoints = /* @__PURE__ */ new Map();
+    for (const f of flatEdges) {
+      const a = node.get(f.a);
+      const b = node.get(f.b);
+      const ctr = bandCenter[a.rank];
+      const bow = ctr - (a.depth / 2 + 26);
+      const m = (c, rr) => isTB ? { x: c, y: rr } : { x: rr, y: c };
+      flatPoints.set(f.edgeIdx, [
+        m(a.cross, ctr),
+        m(a.cross, bow),
+        m(b.cross, bow),
+        m(b.cross, ctr)
+      ]);
+    }
+    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 if (flatPoints.has(i)) points = flatPoints.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
+      });
+    }
+    const nodeBox = new Map(
+      layoutNodes.map((n) => [
+        n.label,
+        {
+          l: n.x - n.width / 2,
+          r: n.x + n.width / 2,
+          t: n.y - n.height / 2,
+          b: n.y + n.height / 2
+        }
+      ])
+    );
+    const depthOf = (label) => {
+      let d = 0;
+      let cur = label;
+      const guard = /* @__PURE__ */ new Set();
+      while (cur && !guard.has(cur)) {
+        guard.add(cur);
+        cur = groupByLabel.get(cur)?.parentGroup;
+        if (cur) d++;
+      }
+      return d;
+    };
+    const childGroups = /* @__PURE__ */ new Map();
+    for (const g of parsed.groups)
+      if (g.parentGroup)
+        (childGroups.get(g.parentGroup) ?? childGroups.set(g.parentGroup, []).get(g.parentGroup)).push(g.label);
+    const rectByGroup = /* @__PURE__ */ new Map();
+    const ordered = [...parsed.groups].sort(
+      (a, b) => depthOf(b.label) - depthOf(a.label)
+    );
+    const layoutGroups = [];
+    for (const grp of ordered) {
+      let l = Infinity, r = -Infinity, t = Infinity, bm = -Infinity;
+      const acc2 = (box) => {
+        l = Math.min(l, box.l);
+        r = Math.max(r, box.r);
+        t = Math.min(t, box.t);
+        bm = Math.max(bm, box.b);
+      };
+      for (const c of grp.children) {
+        const nb = nodeBox.get(c);
+        if (nb) acc2(nb);
+      }
+      for (const sub of childGroups.get(grp.label) ?? []) {
+        const sr = rectByGroup.get(sub);
+        if (sr) acc2(sr);
+      }
+      if (!Number.isFinite(l)) continue;
+      const x0 = l - GROUP_PAD;
+      const x1 = r + GROUP_PAD;
+      const y0 = t - GROUP_LABEL_ZONE;
+      const y1 = bm + GROUP_PAD;
+      rectByGroup.set(grp.label, { l: x0, r: x1, t: y0, b: y1 });
+      layoutGroups.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
+      });
+    }
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    const ext = (x0, y0, x1, y1) => {
+      minX = Math.min(minX, x0);
+      minY = Math.min(minY, y0);
+      maxX = Math.max(maxX, x1);
+      maxY = Math.max(maxY, y1);
+    };
+    for (const n of layoutNodes)
+      ext(
+        n.x - n.width / 2,
+        n.y - n.height / 2,
+        n.x + n.width / 2,
+        n.y + n.height / 2
+      );
+    for (const e of layoutEdges)
+      for (const p of e.points) ext(p.x, p.y, p.x, p.y);
+    for (const g of layoutGroups)
+      ext(
+        g.x - g.width / 2,
+        g.y - g.height / 2,
+        g.x + g.width / 2,
+        g.y + g.height / 2
+      );
+    const sx = MARGIN - minX;
+    const sy = MARGIN - minY;
+    const shift = sx !== 0 || sy !== 0;
+    return {
+      nodes: shift ? layoutNodes.map((n) => ({ ...n, x: n.x + sx, y: n.y + sy })) : layoutNodes,
+      edges: shift ? layoutEdges.map((e) => ({
+        ...e,
+        points: e.points.map((p) => ({ x: p.x + sx, y: p.y + sy }))
+      })) : layoutEdges,
+      groups: shift ? layoutGroups.map((g) => ({ ...g, x: g.x + sx, y: g.y + sy })) : layoutGroups,
+      width: maxX + sx + MARGIN,
+      height: maxY + sy + MARGIN
+    };
+  }
+}
+
+export {
+  acyclicOrient,
+  groupedTierCandidates
+};
+//# sourceMappingURL=chunk-YGJTDXVR.js.map