@weasel-js/diagram 1.9.2 → 1.9.4

package/README.md

@@ -108,6 +108,22 @@ starting `at`, and a minimum `width`/`height`; `lines` is shorthand for one
 label row each. An edge can name `fromPort`/`toPort`, its own `router`,
 `waypoints` and `labelPlacement`.
 
+`groups` draws a box around some nodes, with an optional `label` inside it:
+
+```tsx
+diagramScene({ nodes, edges, groups: [{ id: 'ingest', members: ['fetch', 'decode'], label: 'ingest' }] });
+```
+
+`layered` and `tree` keep a group's members together. Each group gets a column
+on the cross axis that nothing else enters, in every rank from its first
+member's to its last, and rank gaps widen where a box needs the room. The box
+is an ordinary scene node that depends on its members and derives its pose from
+theirs (`groupDerivePose`), so dragging a member carries the box along. An edge
+whose `from` or `to` names a group meets the box, and ranks against the
+group's first stage. Groups are flat, and `force` ignores them. A scene built
+any other way joins in with a node whose trait carries `group` and whose
+`dependsOn` lists its members.
+
 Text is sized from character counts unless `measure` is given, so layout runs
 without a canvas. The layout defaults to `layered`, picked by name or passed as
 any `LayoutFn`; `layoutOptions` merge over `order: 'barycenter'`, and

package/dist/{chunk-UBM2J3HJ.js → chunk-EDSBULQM.js}

@@ -1,4 +1,5 @@
 import { rectPath, polygonFromPoints, PathBuilder, PATH_M, PATH_L, PATH_C, flattenCubic, PATH_Q, PATH_Z, AUTO_POSE_DESCRIPTOR, rotatePoint, createSimulation } from '@weasel-js/core/math';
+import { cssFamilyName } from '@weasel-js/font';
 
 // src/outline.ts
 var LEAN = 0.2;
@@ -188,6 +189,7 @@ var dataKeyReader = (node) => {
   const trait = data[DIAGRAM_TRAIT_KEY];
   if (trait === null || typeof trait !== "object") return null;
   if ("from" in trait && "to" in trait) return null;
+  if ("label" in trait || "anchor" in trait) return null;
   return trait;
 };
 function createDiagramNodes(entries) {
@@ -272,15 +274,13 @@ function portOf(node, pose, portId, opts = {}) {
 function typeOf(spec) {
   return spec.type === void 0 ? {} : { type: spec.type };
 }
-
-// src/body.ts
 var DEFAULT_PADDING = 8;
 var DEFAULT_GAP = 4;
 var FALLBACK_LINE = 16;
 function canvasMeasure(ctx) {
   return (text, style) => {
     const size = style.fontSize ?? FALLBACK_LINE;
-    ctx.font = `${style.bold === true ? "bold " : ""}${size}px ${style.fontFamily ?? "sans-serif"}`;
+    ctx.font = `${style.bold === true ? "bold " : ""}${size}px ${cssFamilyName(style.fontFamily ?? "sans-serif")}`;
     return { width: ctx.measureText(text).width, height: Math.ceil(size * 1.2) };
   };
 }
@@ -487,6 +487,30 @@ function settle(graph, slots, opts = {}) {
   }
   return translated(graph, placed, pinned, tolerance);
 }
+function untilSettled(once, graph, opts = {}, passes = 8) {
+  const first = once(graph, opts);
+  if (first.size === 0) return first;
+  const at = new Map(first);
+  for (let pass = 1; pass < passes; pass++) {
+    const nodes = graph.nodes.map((node) => {
+      const to = at.get(node.id);
+      return to === void 0 ? node : { ...node, bounds: { ...node.bounds, x: to.x, y: to.y } };
+    });
+    const byId = new Map(nodes.map((n) => [n.id, n]));
+    const next = once({ ...graph, nodes, node: (id) => byId.get(id) }, opts);
+    if (next.size === 0) break;
+    for (const [id, to] of next) at.set(id, to);
+  }
+  const tolerance = opts.tolerance ?? DEFAULT_TOLERANCE;
+  const out = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    const to = at.get(node.id);
+    if (to === void 0) continue;
+    if (Math.abs(to.x - node.bounds.x) <= tolerance && Math.abs(to.y - node.bounds.y) <= tolerance) continue;
+    out.set(node.id, to);
+  }
+  return out;
+}
 function translated(graph, placed, pinned, tolerance = DEFAULT_TOLERANCE) {
   const anchor = anchorDelta(graph, placed, pinned);
   const out = /* @__PURE__ */ new Map();
@@ -543,13 +567,313 @@ function graphOrder(graph) {
   graph.nodes.forEach((node, i) => index.set(node.id, i));
   return (id) => index.get(id) ?? Number.MAX_SAFE_INTEGER;
 }
+
+// src/cluster.ts
+function insetOf(inset) {
+  if (typeof inset === "number") return { top: inset, right: inset, bottom: inset, left: inset };
+  return {
+    top: inset?.top ?? DEFAULT_GROUP_INSET,
+    right: inset?.right ?? DEFAULT_GROUP_INSET,
+    bottom: inset?.bottom ?? DEFAULT_GROUP_INSET,
+    left: inset?.left ?? DEFAULT_GROUP_INSET
+  };
+}
+var DEFAULT_GROUP_INSET = 12;
+function canonical(inset, axes) {
+  if (axes.rank === "y") {
+    return axes.sign === 1 ? { crossLo: inset.left, crossHi: inset.right, rankLo: inset.top, rankHi: inset.bottom } : { crossLo: inset.left, crossHi: inset.right, rankLo: inset.bottom, rankHi: inset.top };
+  }
+  return axes.sign === 1 ? { crossLo: inset.top, crossHi: inset.bottom, rankLo: inset.left, rankHi: inset.right } : { crossLo: inset.top, crossHi: inset.bottom, rankLo: inset.right, rankHi: inset.left };
+}
+function rankGaps(graph, rows, axes, rankGap) {
+  const gaps = rows.slice(1).map(() => rankGap);
+  const ends = /* @__PURE__ */ new Map();
+  const starts = /* @__PURE__ */ new Map();
+  const reach = (span, side) => {
+    const own = canonical(span.group.inset, axes)[side === "lo" ? "rankLo" : "rankHi"];
+    const flush = span.children.filter((c) => c[side] === span[side]);
+    return own + Math.max(0, ...flush.map((c) => reach(c, side)));
+  };
+  for (const span of groupSpans(graph, rows)) {
+    ends.set(span.hi, Math.max(ends.get(span.hi) ?? 0, reach(span, "hi")));
+    starts.set(span.lo, Math.max(starts.get(span.lo) ?? 0, reach(span, "lo")));
+  }
+  for (let i = 0; i < gaps.length; i++) {
+    gaps[i] = Math.max(gaps[i], rankGap + (ends.get(i) ?? 0) + (starts.get(i + 1) ?? 0));
+  }
+  return gaps;
+}
+function groupSpans(graph, rows) {
+  const rankOf = /* @__PURE__ */ new Map();
+  rows.forEach((row, i) => row.forEach((n) => rankOf.set(n.id, i)));
+  const spans = [];
+  const byId = /* @__PURE__ */ new Map();
+  for (const group of graph.groups ?? []) {
+    const ranks = group.members.map((id) => rankOf.get(id)).filter((r) => r !== void 0);
+    if (ranks.length === 0) continue;
+    const span = { group, lo: Math.min(...ranks), hi: Math.max(...ranks), children: [] };
+    spans.push(span);
+    byId.set(group.id, span);
+  }
+  for (const span of spans) {
+    const parent = span.group.parent === void 0 ? void 0 : byId.get(span.group.parent);
+    if (parent === void 0) continue;
+    span.parent = parent;
+    parent.children.push(span);
+  }
+  return spans;
+}
+function packClusters(graph, rows, preferred, axes, nodeGap) {
+  const spans = groupSpans(graph, rows);
+  const spanById = new Map(spans.map((s) => [s.group.id, s]));
+  const spanOf = (n) => n.group === void 0 ? void 0 : spanById.get(n.group);
+  const width = (n) => extent(n.bounds, axes.cross);
+  const pref = (n) => preferred.get(n.id) ?? 0;
+  const insets = new Map(spans.map((s) => [s, canonical(s.group.inset, axes)]));
+  const centerOf = /* @__PURE__ */ new Map();
+  for (const span of spans) {
+    const inside = new Set(span.group.members);
+    let sum = 0;
+    let count = 0;
+    for (const row of rows) {
+      for (const n of row) {
+        if (!inside.has(n.id)) continue;
+        sum += pref(n) + width(n) / 2;
+        count++;
+      }
+    }
+    centerOf.set(span, count === 0 ? 0 : sum / count);
+  }
+  const itemsByRow = (owner, among) => rows.map((row, r) => {
+    const items = [];
+    for (const node of row) {
+      if (spanOf(node) === owner) items.push({ kind: "node", node, center: pref(node) + width(node) / 2 });
+    }
+    for (const span of among) {
+      if (r >= span.lo && r <= span.hi) items.push({ kind: "group", span, center: centerOf.get(span) });
+    }
+    return items.map((item, i) => ({ item, i })).sort((a, b) => a.item.center - b.item.center || a.i - b.i).map(({ item }) => item);
+  });
+  const settle2 = (byRow, start2, nodeFloor, origin) => {
+    const nodeAt = /* @__PURE__ */ new Map();
+    let ends = [];
+    for (let pass = 0; pass <= start2.size; pass++) {
+      let raised = false;
+      ends = byRow.map((items) => {
+        let cursor = origin;
+        for (const item of items) {
+          if (item.kind === "node") {
+            const x2 = Math.max(nodeFloor(item.node), cursor);
+            nodeAt.set(item.node.id, x2);
+            cursor = x2 + width(item.node) + nodeGap;
+            continue;
+          }
+          const s = start2.get(item.span);
+          const x = Math.max(s, cursor);
+          if (x > s) {
+            start2.set(item.span, x);
+            raised = true;
+          }
+          cursor = x + outer(item.span) + nodeGap;
+        }
+        return items.length === 0 ? origin : cursor - nodeGap;
+      });
+      if (!raised) break;
+    }
+    return { nodeAt, ends };
+  };
+  const blocks = /* @__PURE__ */ new Map();
+  const blockOf = (span) => {
+    const known = blocks.get(span);
+    if (known !== void 0) return known;
+    const byRow = itemsByRow(span, span.children);
+    const childAt = new Map(span.children.map((c) => [c, 0]));
+    const { nodeAt, ends } = settle2(byRow, childAt, () => 0, 0);
+    const block = { width: Math.max(0, ...ends), nodeAt, childAt };
+    byRow.forEach((items, r) => {
+      if (items.some((item) => item.kind === "group")) return;
+      const shift = (block.width - ends[r]) / 2;
+      for (const item of items) {
+        if (item.kind === "node") nodeAt.set(item.node.id, nodeAt.get(item.node.id) + shift);
+      }
+    });
+    blocks.set(span, block);
+    return block;
+  };
+  function outer(span) {
+    const inset = insets.get(span);
+    return blockOf(span).width + inset.crossLo + inset.crossHi;
+  }
+  const roots = spans.filter((s) => s.parent === void 0);
+  const start = new Map(roots.map((s) => [s, centerOf.get(s) - outer(s) / 2]));
+  const { nodeAt: at } = settle2(itemsByRow(void 0, roots), start, pref, -Infinity);
+  const place = (span, from) => {
+    const origin = from + insets.get(span).crossLo;
+    const block = blockOf(span);
+    for (const [id, local] of block.nodeAt) at.set(id, origin + local);
+    for (const [child, local] of block.childAt) place(child, origin + local);
+  };
+  for (const root of roots) place(root, start.get(root));
+  return at;
+}
+function expandGroupEdges(edges, groups) {
+  const byId = new Map(groups.map((g) => [g.id, g]));
+  if (byId.size === 0) return [...edges];
+  const within = (id, group) => {
+    if (!byId.has(id)) return group.members.includes(id);
+    for (let at = byId.get(id); at !== void 0; at = at.parent === void 0 ? void 0 : byId.get(at.parent)) {
+      if (at === group) return true;
+    }
+    return false;
+  };
+  const entries = /* @__PURE__ */ new Map();
+  const exits = /* @__PURE__ */ new Map();
+  for (const g of groups) {
+    const inside = new Set(g.members);
+    const pointedAt = /* @__PURE__ */ new Set();
+    const pointing = /* @__PURE__ */ new Set();
+    for (const e of edges) {
+      if (inside.has(e.from) && inside.has(e.to) && e.from !== e.to) {
+        pointedAt.add(e.to);
+        pointing.add(e.from);
+      }
+    }
+    const entry = g.members.filter((m) => !pointedAt.has(m));
+    const exit = g.members.filter((m) => !pointing.has(m));
+    entries.set(g.id, entry.length > 0 ? entry : g.members);
+    exits.set(g.id, exit.length > 0 ? exit : g.members);
+  }
+  const out = [];
+  for (const e of edges) {
+    const fromGroup = byId.has(e.from) ? e.from : void 0;
+    const toGroup = byId.has(e.to) ? e.to : void 0;
+    if (fromGroup === void 0 && toGroup === void 0) {
+      out.push(e);
+      continue;
+    }
+    if (fromGroup !== void 0 && within(e.to, byId.get(fromGroup))) continue;
+    if (toGroup !== void 0 && within(e.from, byId.get(toGroup))) continue;
+    const froms = fromGroup !== void 0 ? exits.get(fromGroup) : [e.from];
+    const tos = toGroup !== void 0 ? entries.get(toGroup) : [e.to];
+    let k = 0;
+    for (const from of froms) {
+      for (const to of tos) out.push({ id: `${e.id}#${k++}`, from, to });
+    }
+  }
+  return out;
+}
+
+// src/forceGroups.ts
+function resolve(groups, byId) {
+  const out = [];
+  for (const group of groups) {
+    const members = group.members.map((id) => byId.get(id)).filter((b) => b !== void 0);
+    if (members.length > 0) out.push({ members, group, children: [] });
+  }
+  const byGroup = new Map(out.map((g) => [g.group.id, g]));
+  for (const g of out) {
+    const parent = g.group.parent === void 0 ? void 0 : byGroup.get(g.group.parent);
+    if (parent === void 0) continue;
+    g.parent = parent;
+    parent.children.push(g);
+  }
+  return out;
+}
+function groupCohesion(groups, byId, strength) {
+  const resolved = resolve(groups, byId);
+  return (alpha) => {
+    for (const { members } of resolved) {
+      let cx = 0;
+      let cy = 0;
+      for (const m of members) {
+        cx += m.x;
+        cy += m.y;
+      }
+      cx /= members.length;
+      cy /= members.length;
+      for (const m of members) {
+        m.vx += (cx - m.x) * strength * alpha;
+        m.vy += (cy - m.y) * strength * alpha;
+      }
+    }
+  };
+}
+function boxOf(g) {
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  for (const m of g.members) {
+    x0 = Math.min(x0, m.x - m.hw);
+    y0 = Math.min(y0, m.y - m.hh);
+    x1 = Math.max(x1, m.x + m.hw);
+    y1 = Math.max(y1, m.y + m.hh);
+  }
+  for (const child of g.children) {
+    const b = boxOf(child);
+    x0 = Math.min(x0, b.x0);
+    y0 = Math.min(y0, b.y0);
+    x1 = Math.max(x1, b.x1);
+    y1 = Math.max(y1, b.y1);
+  }
+  const { inset } = g.group;
+  return { x0: x0 - inset.left, y0: y0 - inset.top, x1: x1 + inset.right, y1: y1 + inset.bottom };
+}
+function clearance(a, b, padding) {
+  const gapX = Math.min(a.x1, b.x1) - Math.max(a.x0, b.x0) + padding;
+  const gapY = Math.min(a.y1, b.y1) - Math.max(a.y0, b.y0) + padding;
+  if (gapX <= 0 || gapY <= 0) return null;
+  const dx = b.x0 + b.x1 - (a.x0 + a.x1);
+  const dy = b.y0 + b.y1 - (a.y0 + a.y1);
+  return gapX < gapY ? { x: (Math.sign(dx) || 1) * gapX, y: 0 } : { x: 0, y: (Math.sign(dy) || 1) * gapY };
+}
+function holds(outer, inner) {
+  for (let at = inner.parent; at !== void 0; at = at.parent) {
+    if (at === outer) return true;
+  }
+  return false;
+}
+function shove(bodies, x, y) {
+  for (const body of bodies) {
+    body.vx += x;
+    body.vy += y;
+  }
+}
+function separateGroups(groups, bodies, byId, padding) {
+  const resolved = resolve(groups, byId);
+  const memberSets = resolved.map((g) => new Set(g.members));
+  return () => {
+    const boxes = resolved.map(boxOf);
+    for (let i = 0; i < resolved.length; i++) {
+      for (let j = i + 1; j < resolved.length; j++) {
+        if (holds(resolved[i], resolved[j]) || holds(resolved[j], resolved[i])) continue;
+        const push = clearance(boxes[i], boxes[j], padding);
+        if (push === null) continue;
+        shove(resolved[i].members, -push.x / 2, -push.y / 2);
+        shove(resolved[j].members, push.x / 2, push.y / 2);
+      }
+      for (const body of bodies) {
+        if (memberSets[i].has(body)) continue;
+        const box = { x0: body.x - body.hw, y0: body.y - body.hh, x1: body.x + body.hw, y1: body.y + body.hh };
+        const push = clearance(boxes[i], box, padding);
+        if (push === null) continue;
+        shove(resolved[i].members, -push.x / 2, -push.y / 2);
+        body.vx += push.x / 2;
+        body.vy += push.y / 2;
+      }
+    }
+  };
+}
+
+// src/force.ts
 var DEFAULTS = {
   iterations: 300,
   linkDistance: 160,
   linkStrength: 0.35,
   charge: -3e3,
   gravity: 0.02,
-  padding: 24
+  padding: 24,
+  groupStrength: 0.2
 };
 var GOLDEN = Math.PI * (3 - Math.sqrt(5));
 var NUDGE = 0.5;
@@ -628,7 +952,8 @@ function forceRelaxation(graph, opts = {}) {
     linkStrength = DEFAULTS.linkStrength,
     charge: chargeStrength = DEFAULTS.charge,
     gravity: gravityStrength = DEFAULTS.gravity,
-    padding = DEFAULTS.padding
+    padding = DEFAULTS.padding,
+    groupStrength = DEFAULTS.groupStrength
   } = opts;
   const pinned = pinnedSet(graph, opts);
   const bodies = graph.nodes.map((node) => {
@@ -651,13 +976,15 @@ function forceRelaxation(graph, opts = {}) {
     x: bodies.reduce((sum, b) => sum + b.x, 0) / bodies.length,
     y: bodies.reduce((sum, b) => sum + b.y, 0) / bodies.length
   };
+  const groups = graph.groups ?? [];
   const sim = createSimulation({
     nodes: bodies,
     forces: [
       charge(bodies, chargeStrength),
       links(byId, graph, linkDistance, linkStrength),
       gravity(bodies, centroid, gravityStrength),
-      separateBoxes(bodies, padding)
+      separateBoxes(bodies, padding),
+      ...groups.length > 0 ? [groupCohesion(groups, byId, groupStrength), separateGroups(groups, bodies, byId, padding)] : []
     ]
   });
   return {
@@ -761,7 +1088,12 @@ function ranksOf(graph, back) {
   for (const node of graph.nodes) rankOf(node.id);
   return ranks;
 }
-var layered = (graph, opts = {}) => {
+var layered = (graph, opts = {}) => (
+  // Barycenter ordering reorders on every run by design, so it has no
+  // arrangement to settle on.
+  (graph.groups?.length ?? 0) > 0 && opts.order !== "barycenter" ? untilSettled(layeredOnce, graph, opts) : layeredOnce(graph, opts)
+);
+var layeredOnce = (graph, opts = {}) => {
   const axes = axesFor(opts.direction);
   const nodeGap = opts.nodeGap ?? DEFAULT_NODE_GAP;
   const rankGap = opts.rankGap ?? DEFAULT_RANK_GAP;
@@ -778,29 +1110,29 @@ var layered = (graph, opts = {}) => {
   const rows = [...byRank.keys()].sort((a, b) => a - b);
   let ordered = rows.map((rank) => seededOrder(byRank.get(rank), axes.cross, order));
   if (opts.order === "barycenter") ordered = barycenterOrder(graph, ordered, back);
-  const packed = /* @__PURE__ */ new Map();
-  let widest = 0;
-  for (const [i, rank] of rows.entries()) {
-    const p = packAcross(ordered[i], axes.cross, nodeGap);
-    packed.set(rank, p);
-    widest = Math.max(widest, p.span);
+  const packed = ordered.map((row) => packAcross(row, axes.cross, nodeGap));
+  const widest = Math.max(0, ...packed.map((p) => p.span));
+  const preferred = /* @__PURE__ */ new Map();
+  for (const [i, row] of ordered.entries()) {
+    const indent = (widest - packed[i].span) / 2;
+    for (const node of row) preferred.set(node.id, indent + packed[i].at.get(node.id));
   }
+  const grouped = (graph.groups?.length ?? 0) > 0;
+  const crossAt = grouped ? packClusters(graph, ordered, preferred, axes, nodeGap) : preferred;
+  const gaps = grouped ? rankGaps(graph, ordered, axes, rankGap) : ordered.slice(1).map(() => rankGap);
   const slots = /* @__PURE__ */ new Map();
   let along = 0;
-  for (const rank of rows) {
-    const row = byRank.get(rank);
-    const p = packed.get(rank);
-    const indent = (widest - p.span) / 2;
+  for (const [i, row] of ordered.entries()) {
     const depth = Math.max(0, ...row.map((n) => extent(n.bounds, axes.rank)));
     for (const node of row) {
       slots.set(node.id, {
-        cross: indent + p.at.get(node.id),
+        cross: crossAt.get(node.id),
         // Centered in its rank's band, so a tall node does not push its
         // neighbors' edges off the line they read along.
         rank: along + (depth - extent(node.bounds, axes.rank)) / 2
       });
     }
-    along += depth + rankGap;
+    along += depth + (gaps[i] ?? 0);
   }
   return settle(graph, slots, opts);
 };
@@ -838,7 +1170,8 @@ function forestOf(graph, crossAxis) {
   }
   return { roots, children, depth };
 }
-var tree = (graph, opts = {}) => {
+var tree = (graph, opts = {}) => (graph.groups?.length ?? 0) > 0 ? untilSettled(treeOnce, graph, opts) : treeOnce(graph, opts);
+var treeOnce = (graph, opts = {}) => {
   const axes = axesFor(opts.direction);
   const nodeGap = opts.nodeGap ?? DEFAULT_NODE_GAP;
   const rankGap = opts.rankGap ?? DEFAULT_RANK_GAP;
@@ -848,11 +1181,15 @@ var tree = (graph, opts = {}) => {
     const at = depth.get(node.id) ?? 0;
     bands.set(at, Math.max(bands.get(at) ?? 0, extent(node.bounds, axes.rank)));
   }
+  const depths = [...bands.keys()].sort((a, b) => a - b);
+  const rowsAt = depths.map((at) => graph.nodes.filter((n) => (depth.get(n.id) ?? 0) === at));
+  const grouped = (graph.groups?.length ?? 0) > 0;
+  const gaps = grouped ? rankGaps(graph, rowsAt, axes, rankGap) : depths.slice(1).map(() => rankGap);
   const bandStart = /* @__PURE__ */ new Map();
   let along = 0;
-  for (const at of [...bands.keys()].sort((a, b) => a - b)) {
+  for (const [i, at] of depths.entries()) {
     bandStart.set(at, along);
-    along += bands.get(at) + rankGap;
+    along += bands.get(at) + (gaps[i] ?? 0);
   }
   const slots = /* @__PURE__ */ new Map();
   const measured = /* @__PURE__ */ new Map();
@@ -888,9 +1225,15 @@ var tree = (graph, opts = {}) => {
     place(root, cursor);
     cursor += measure(root) + nodeGap;
   }
+  if (grouped) {
+    const preferred = new Map([...slots].map(([id, slot]) => [id, slot.cross]));
+    const ordered = rowsAt.map((row) => [...row].sort((a, b) => preferred.get(a.id) - preferred.get(b.id)));
+    const crossAt = packClusters(graph, ordered, preferred, axes, nodeGap);
+    for (const [id, slot] of slots) slots.set(id, { ...slot, cross: crossAt.get(id) ?? slot.cross });
+  }
   return settle(graph, slots, opts);
 };
 
-export { COMPASS, DEFAULT_NODE_GAP, DEFAULT_PORTS, DEFAULT_RANK_GAP, DIAGRAM_TRAIT_KEY, axesFor, backEdges, bodyOutline, bodyTrait, boxForContent, buildBody, canvasMeasure, center, contentBox, createDiagramNodes, dataKeyReader, diagramNodeOf, extent, force, forceRelaxation, forestOf, graphOrder, isPinned, layered, layoutBody, layoutRowPorts, measureBody, outlinePath, outlinePolyline, packAcross, pinnedSet, portOf, portsOf, portsOnOutline, ranksOf, rayHit, seededOrder, settle, sizeToBody, translated, tree };
-//# sourceMappingURL=chunk-UBM2J3HJ.js.map
-//# sourceMappingURL=chunk-UBM2J3HJ.js.map
+export { COMPASS, DEFAULT_GROUP_INSET, DEFAULT_NODE_GAP, DEFAULT_PORTS, DEFAULT_RANK_GAP, DIAGRAM_TRAIT_KEY, axesFor, backEdges, bodyOutline, bodyTrait, boxForContent, buildBody, canvasMeasure, center, contentBox, createDiagramNodes, dataKeyReader, diagramNodeOf, expandGroupEdges, extent, force, forceRelaxation, forestOf, graphOrder, insetOf, isPinned, layered, layoutBody, layoutRowPorts, measureBody, outlinePath, outlinePolyline, packAcross, packClusters, pinnedSet, portOf, portsOf, portsOnOutline, rankGaps, ranksOf, rayHit, seededOrder, settle, sizeToBody, translated, tree, untilSettled };
+//# sourceMappingURL=chunk-EDSBULQM.js.map
+//# sourceMappingURL=chunk-EDSBULQM.js.map