@weasel-js/diagram 1.10.1 → 1.11.1

package/dist/chunk-JZ4CVLAB.js

@@ -1,1247 +0,0 @@
-import { rectPath, polygonFromPoints, PathBuilder, PATH_M, PATH_L, PATH_C, flattenCubic, PATH_Q, PATH_Z, AUTO_POSE_DESCRIPTOR, rotatePoint } from '@weasel-js/core/math';
-import { cssFamilyName } from '@weasel-js/font';
-import { createSimulation } from '@weasel-js/simulation';
-
-// src/outline.ts
-var LEAN = 0.2;
-var KAPPA = 0.5522847498307936;
-function outlinePath(outline, bounds) {
-  if (typeof outline !== "string") return outline;
-  const { x, y, width: w, height: h } = bounds;
-  if (w <= 0 || h <= 0) return rectPath(x, y, Math.max(w, 0), Math.max(h, 0));
-  switch (outline) {
-    case "rect":
-      return rectPath(x, y, w, h);
-    case "diamond":
-      return polygonFromPoints([
-        { x: x + w / 2, y },
-        { x: x + w, y: y + h / 2 },
-        { x: x + w / 2, y: y + h },
-        { x, y: y + h / 2 }
-      ]);
-    case "parallelogram": {
-      const lean = Math.min(w * LEAN, w / 2);
-      return polygonFromPoints([
-        { x: x + lean, y },
-        { x: x + w, y },
-        { x: x + w - lean, y: y + h },
-        { x, y: y + h }
-      ]);
-    }
-    case "stadium":
-      return stadiumPath(x, y, w, h);
-  }
-}
-function stadiumPath(x, y, w, h) {
-  const r = Math.min(w, h) / 2;
-  const k = r * KAPPA;
-  const b = new PathBuilder();
-  if (w >= h) {
-    const left2 = x + r;
-    const right2 = x + w - r;
-    const top2 = y;
-    const bottom2 = y + h;
-    const midY = y + h / 2;
-    return b.moveTo(left2, top2).lineTo(right2, top2).curveTo(right2 + k, top2, x + w, midY - k, x + w, midY).curveTo(x + w, midY + k, right2 + k, bottom2, right2, bottom2).lineTo(left2, bottom2).curveTo(left2 - k, bottom2, x, midY + k, x, midY).curveTo(x, midY - k, left2 - k, top2, left2, top2).close().build();
-  }
-  const top = y + r;
-  const bottom = y + h - r;
-  const left = x;
-  const right = x + w;
-  const midX = x + w / 2;
-  return b.moveTo(right, top).lineTo(right, bottom).curveTo(right, bottom + k, midX + k, y + h, midX, y + h).curveTo(midX - k, y + h, left, bottom + k, left, bottom).lineTo(left, top).curveTo(left, top - k, midX - k, y, midX, y).curveTo(midX + k, y, right, top - k, right, top).close().build();
-}
-function contentBox(outline, bounds) {
-  if (typeof outline !== "string") return bounds;
-  const { x, y, width: w, height: h } = bounds;
-  switch (outline) {
-    case "rect":
-      return bounds;
-    case "diamond":
-      return { x: x + w / 4, y: y + h / 4, width: w / 2, height: h / 2 };
-    case "parallelogram": {
-      const lean = Math.min(w * LEAN, w / 2);
-      return { x: x + lean, y, width: Math.max(w - lean * 2, 0), height: h };
-    }
-    case "stadium": {
-      const r = Math.min(w, h) / 2;
-      return w >= h ? { x: x + r, y, width: Math.max(w - r * 2, 0), height: h } : { x, y: y + r, width: w, height: Math.max(h - r * 2, 0) };
-    }
-  }
-}
-function boxForContent(outline, content) {
-  if (typeof outline !== "string") return content;
-  switch (outline) {
-    case "rect":
-      return content;
-    case "diamond":
-      return { width: content.width * 2, height: content.height * 2 };
-    case "parallelogram":
-      return { width: content.width / (1 - LEAN * 2), height: content.height };
-    case "stadium":
-      return { width: content.width + content.height, height: content.height };
-  }
-}
-var TOLERANCE = 0.25;
-function outlinePolyline(outline, bounds) {
-  const path = outlinePath(outline, bounds);
-  return flattenPath(path);
-}
-function flattenPath(path) {
-  if (path.kind === "rect") {
-    const { x, y, width: w, height: h } = path;
-    return [x, y, x + w, y, x + w, y + h, x, y + h, x, y];
-  }
-  const out = [];
-  const { commands, coords } = path;
-  let ci = 0;
-  let cx = 0;
-  let cy = 0;
-  let sx = 0;
-  let sy = 0;
-  for (const cmd of commands) {
-    if (cmd === PATH_M) {
-      cx = coords[ci];
-      cy = coords[ci + 1];
-      ci += 2;
-      sx = cx;
-      sy = cy;
-      out.push(cx, cy);
-    } else if (cmd === PATH_L) {
-      cx = coords[ci];
-      cy = coords[ci + 1];
-      ci += 2;
-      out.push(cx, cy);
-    } else if (cmd === PATH_C) {
-      const x1 = coords[ci], y1 = coords[ci + 1];
-      const x2 = coords[ci + 2], y2 = coords[ci + 3];
-      const x3 = coords[ci + 4], y3 = coords[ci + 5];
-      ci += 6;
-      flattenCubic(cx, cy, x1, y1, x2, y2, x3, y3, TOLERANCE, out);
-      cx = x3;
-      cy = y3;
-    } else if (cmd === PATH_Q) {
-      const qx = coords[ci], qy = coords[ci + 1];
-      const x3 = coords[ci + 2], y3 = coords[ci + 3];
-      ci += 4;
-      flattenCubic(
-        cx,
-        cy,
-        cx + 2 / 3 * (qx - cx),
-        cy + 2 / 3 * (qy - cy),
-        x3 + 2 / 3 * (qx - x3),
-        y3 + 2 / 3 * (qy - y3),
-        x3,
-        y3,
-        TOLERANCE,
-        out
-      );
-      cx = x3;
-      cy = y3;
-    } else if (cmd === PATH_Z) {
-      out.push(sx, sy);
-      cx = sx;
-      cy = sy;
-    }
-  }
-  if (out.length >= 2 && (out[0] !== out[out.length - 2] || out[1] !== out[out.length - 1])) {
-    out.push(out[0], out[1]);
-  }
-  return out;
-}
-function rayHit(poly, center2, point) {
-  const dx = point.x - center2.x;
-  const dy = point.y - center2.y;
-  if (dx === 0 && dy === 0) return null;
-  let bestT = -Infinity;
-  let hit = null;
-  for (let i = 0; i + 3 < poly.length; i += 2) {
-    const ax = poly[i], ay = poly[i + 1];
-    const bx = poly[i + 2], by = poly[i + 3];
-    const ex = bx - ax;
-    const ey = by - ay;
-    const denom = dx * ey - dy * ex;
-    if (denom === 0) continue;
-    const t = ((ax - center2.x) * ey - (ay - center2.y) * ex) / denom;
-    const u = ((ax - center2.x) * dy - (ay - center2.y) * dx) / denom;
-    if (t < 0 || u < 0 || u > 1) continue;
-    if (t > bestT) {
-      bestT = t;
-      hit = { x: center2.x + dx * t, y: center2.y + dy * t };
-    }
-  }
-  return hit;
-}
-function portsOnOutline(ports, outline, bounds) {
-  if (bounds.width <= 0 || bounds.height <= 0) return [...ports];
-  const poly = outlinePolyline(outline, bounds);
-  const center2 = { x: bounds.x + bounds.width / 2, y: bounds.y + bounds.height / 2 };
-  return ports.map((port) => {
-    const hit = rayHit(poly, center2, port.point);
-    return hit === null ? port : { ...port, point: hit };
-  });
-}
-
-// src/trait.ts
-var DIAGRAM_TRAIT_KEY = "diagram";
-var dataKeyReader = (node) => {
-  const data = node.data;
-  if (data === null || typeof data !== "object") return null;
-  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) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const entry of entries) {
-    if (seen.has(entry.name)) {
-      throw new Error(`createDiagramNodes: duplicate entry name "${entry.name}"`);
-    }
-    seen.add(entry.name);
-  }
-  return (node) => {
-    const own = dataKeyReader(node);
-    if (own !== null) return own;
-    for (const entry of entries) {
-      if (!entry.matches(node.data)) continue;
-      return typeof entry.trait === "function" ? entry.trait(node.data) : entry.trait;
-    }
-    return null;
-  };
-}
-function diagramNodeOf(node, read = dataKeyReader) {
-  return read(node);
-}
-function isPinned(node, read) {
-  return diagramNodeOf(node, read)?.pinned === true;
-}
-var COMPASS = {
-  nw: { u: 0, v: 0 },
-  n: { u: 0.5, v: 0 },
-  ne: { u: 1, v: 0 },
-  e: { u: 1, v: 0.5 },
-  se: { u: 1, v: 1 },
-  s: { u: 0.5, v: 1 },
-  sw: { u: 0, v: 1 },
-  w: { u: 0, v: 0.5 }
-};
-var DEFAULT_PORTS = Object.freeze([
-  { id: "n", at: COMPASS.n },
-  { id: "e", at: COMPASS.e },
-  { id: "s", at: COMPASS.s },
-  { id: "w", at: COMPASS.w }
-]);
-function normalOf(at) {
-  const x = at.u * 2 - 1;
-  const y = at.v * 2 - 1;
-  const len = Math.hypot(x, y);
-  if (len === 0) return null;
-  return { x: x / len, y: y / len };
-}
-function portsOf(node, pose, opts = {}) {
-  const trait = diagramNodeOf(node, opts.read);
-  if (trait === null) return [];
-  const geometry = opts.geometry ?? AUTO_POSE_DESCRIPTOR;
-  const bounds = geometry.getBounds(pose);
-  const rotation = geometry.getRotation?.(pose) ?? 0;
-  const cx = bounds.x + bounds.width / 2;
-  const cy = bounds.y + bounds.height / 2;
-  const poly = trait.outline === void 0 || bounds.width <= 0 || bounds.height <= 0 ? null : outlinePolyline(trait.outline, bounds);
-  return (trait.ports ?? DEFAULT_PORTS).map((spec) => {
-    const anchored = {
-      x: bounds.x + spec.at.u * bounds.width,
-      y: bounds.y + spec.at.v * bounds.height
-    };
-    const flat = (poly === null ? null : rayHit(poly, { x: cx, y: cy }, anchored)) ?? anchored;
-    const normal = spec.normal === void 0 ? normalOf(spec.at) : spec.normal;
-    if (rotation === 0) {
-      return { id: spec.id, nodeId: node.id, point: flat, normal, ...typeOf(spec) };
-    }
-    return {
-      id: spec.id,
-      nodeId: node.id,
-      point: rotatePoint(flat.x, flat.y, cx, cy, rotation),
-      // A direction rotates about the origin, not about the node's center.
-      normal: normal === null ? null : rotatePoint(normal.x, normal.y, 0, 0, rotation),
-      ...typeOf(spec)
-    };
-  });
-}
-function portOf(node, pose, portId, opts = {}) {
-  return portsOf(node, pose, opts).find((p) => p.id === portId);
-}
-function typeOf(spec) {
-  return spec.type === void 0 ? {} : { type: spec.type };
-}
-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 ${cssFamilyName(style.fontFamily ?? "sans-serif")}`;
-    return { width: ctx.measureText(text).width, height: Math.ceil(size * 1.2) };
-  };
-}
-function measureRow(row, measure) {
-  const text = (s, style) => measure === void 0 ? {
-    width: s.length * (style?.fontSize ?? FALLBACK_LINE) * 0.6,
-    height: style?.fontSize === void 0 ? FALLBACK_LINE : Math.ceil(style.fontSize * 1.2)
-  } : measure(s, style ?? {});
-  switch (row.kind) {
-    case "label":
-      return text(row.text, row.style);
-    case "field": {
-      const l = text(row.label, row.style);
-      const v = text(row.value, row.style);
-      return { width: l.width + DEFAULT_GAP * 2 + v.width, height: Math.max(l.height, v.height) };
-    }
-    case "ports": {
-      const side = (ports) => (ports ?? []).reduce((w, p) => Math.max(w, p.label === void 0 ? 0 : text(p.label).width), 0);
-      const rows = Math.max(row.left?.length ?? 0, row.right?.length ?? 0, 1);
-      return {
-        width: side(row.left) + DEFAULT_GAP * 2 + side(row.right),
-        height: row.height ?? rows * FALLBACK_LINE
-      };
-    }
-    case "slot":
-      return { width: 0, height: row.height };
-  }
-}
-function measureBody(spec, measure) {
-  const padding = spec.padding ?? DEFAULT_PADDING;
-  const gap = spec.gap ?? DEFAULT_GAP;
-  let width = 0;
-  let height = 0;
-  for (const [i, row] of spec.rows.entries()) {
-    const m = measureRow(row, measure);
-    width = Math.max(width, m.width);
-    height += m.height + (i > 0 ? gap : 0);
-  }
-  const box = boxForContent(spec.outline, {
-    width: width + padding * 2,
-    height: height + padding * 2
-  });
-  return { minWidth: box.width, minHeight: box.height };
-}
-function sizeToBody(pose, floor) {
-  const width = Math.max(pose.width, floor.minWidth);
-  const height = Math.max(pose.height, floor.minHeight);
-  if (width === pose.width && height === pose.height) return pose;
-  return { ...pose, width, height };
-}
-function layoutBody(spec, bounds, measure) {
-  const padding = spec.padding ?? DEFAULT_PADDING;
-  const gap = spec.gap ?? DEFAULT_GAP;
-  const inner = contentBox(spec.outline, bounds);
-  const width = Math.max(inner.width - padding * 2, 0);
-  const heights = spec.rows.map((row) => measureRow(row, measure).height);
-  const used = heights.reduce((sum, h) => sum + h, 0) + gap * Math.max(heights.length - 1, 0);
-  const slack = Math.max(inner.height - padding * 2 - used, 0);
-  const share = { top: 0, center: 0.5, bottom: 1 }[spec.verticalAlign ?? "center"];
-  let y = inner.y + padding + slack * share;
-  return spec.rows.map((row, index) => {
-    const h = heights[index];
-    const box = { row, index, x: inner.x + padding, y, width, height: h };
-    y += h + gap;
-    return box;
-  });
-}
-function layoutRowPorts(row, box, measure) {
-  const width = (label) => label === void 0 ? 0 : measureRow({ kind: "label", text: label }, measure).width;
-  const slots = Math.max(row.left?.length ?? 0, row.right?.length ?? 0, 1);
-  const slotHeight = box.height / slots;
-  const out = [];
-  const side = (ports, which) => {
-    for (const [index, port] of (ports ?? []).entries()) {
-      const w = width(port.label);
-      out.push({
-        port,
-        side: which,
-        index,
-        x: which === "left" ? box.x : box.x + box.width - w,
-        y: box.y + index * slotHeight,
-        width: w,
-        height: slotHeight
-      });
-    }
-  };
-  side(row.left, "left");
-  side(row.right, "right");
-  return out;
-}
-function bodyTrait(spec, bounds, measure) {
-  const outline = spec.outline;
-  const compass = spec.ports ?? [
-    { id: "n", at: COMPASS.n },
-    { id: "e", at: COMPASS.e },
-    { id: "s", at: COMPASS.s },
-    { id: "w", at: COMPASS.w }
-  ];
-  if (bounds.height <= 0) return { outline, ports: [...compass] };
-  const rowPorts = [];
-  let hasLeft = false;
-  let hasRight = false;
-  for (const box of layoutBody(spec, bounds, measure)) {
-    if (box.row.kind !== "ports") continue;
-    for (const pb of layoutRowPorts(box.row, box, measure)) {
-      if (pb.side === "left") hasLeft = true;
-      else hasRight = true;
-      const v = (pb.y + pb.height / 2 - bounds.y) / bounds.height;
-      rowPorts.push(withType(
-        { id: pb.port.id, at: { u: pb.side === "left" ? 0 : 1, v } },
-        pb.port.type
-      ));
-    }
-  }
-  const kept = spec.ports !== void 0 ? compass : compass.filter((p) => !(p.id === "w" && hasLeft) && !(p.id === "e" && hasRight));
-  return { outline, ports: [...kept, ...rowPorts] };
-}
-function withType(spec, type) {
-  return type === void 0 ? spec : { ...spec, type };
-}
-function bodyOutline(spec, bounds) {
-  return outlinePath(spec.outline, bounds);
-}
-function buildBody(spec, at, opts) {
-  const pose = sizeToBody(at, measureBody(spec, opts.measure));
-  const specs = [{
-    kind: "container",
-    layer: opts.layer,
-    pose,
-    data: opts.body(bodyTrait(spec, pose, opts.measure), pose),
-    ...opts.id === void 0 ? {} : { id: opts.id }
-  }];
-  const leaf = (box, data) => {
-    specs.push({
-      kind: "leaf",
-      layer: opts.layer,
-      pose: { ...pose, x: box.x, y: box.y, width: box.width, height: box.height },
-      data,
-      pickable: false,
-      ...opts.id === void 0 ? {} : { parent: opts.id }
-    });
-  };
-  const portLabel = opts.portLabel;
-  for (const box of layoutBody(spec, pose, opts.measure)) {
-    const data = opts.row(rowText(box.row), box);
-    if (data !== null) leaf(box, data);
-    if (portLabel === void 0 || box.row.kind !== "ports") continue;
-    for (const pb of layoutRowPorts(box.row, box, opts.measure)) {
-      if (pb.port.label === void 0) continue;
-      const labelData = portLabel(pb.port.label, pb);
-      if (labelData !== null) leaf(pb, labelData);
-    }
-  }
-  return { pose, specs };
-}
-function rowText(row) {
-  if (row.kind === "label") return row.text;
-  if (row.kind === "field") return `${row.label}: ${row.value}`;
-  return "";
-}
-
-// src/layout.ts
-var DEFAULT_NODE_GAP = 48;
-var DEFAULT_RANK_GAP = 96;
-var DEFAULT_TOLERANCE = 1e-6;
-function axesFor(direction = "down") {
-  switch (direction) {
-    case "up":
-      return { rank: "y", cross: "x", sign: -1 };
-    case "right":
-      return { rank: "x", cross: "y", sign: 1 };
-    case "left":
-      return { rank: "x", cross: "y", sign: -1 };
-    default:
-      return { rank: "y", cross: "x", sign: 1 };
-  }
-}
-function extent(bounds, axis) {
-  return axis === "x" ? bounds.width : bounds.height;
-}
-function center(bounds, axis) {
-  return axis === "x" ? bounds.x + bounds.width / 2 : bounds.y + bounds.height / 2;
-}
-function pinnedSet(graph, opts = {}) {
-  const pinned = new Set(opts.pin ?? []);
-  for (const node of graph.nodes) {
-    if (node.pinned) pinned.add(node.id);
-  }
-  return pinned;
-}
-function settle(graph, slots, opts = {}) {
-  const axes = axesFor(opts.direction);
-  const pinned = pinnedSet(graph, opts);
-  const tolerance = opts.tolerance ?? DEFAULT_TOLERANCE;
-  const placed = /* @__PURE__ */ new Map();
-  for (const node of graph.nodes) {
-    const slot = slots.get(node.id);
-    if (slot === void 0) continue;
-    const along = axes.sign === 1 ? slot.rank : -(slot.rank + extent(node.bounds, axes.rank));
-    placed.set(
-      node.id,
-      axes.rank === "y" ? { x: slot.cross, y: along } : { x: along, y: slot.cross }
-    );
-  }
-  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();
-  for (const node of graph.nodes) {
-    const at = placed.get(node.id);
-    if (at === void 0 || pinned.has(node.id)) continue;
-    const x = at.x + anchor.x;
-    const y = at.y + anchor.y;
-    if (Math.abs(x - node.bounds.x) <= tolerance && Math.abs(y - node.bounds.y) <= tolerance) {
-      continue;
-    }
-    out.set(node.id, { x, y });
-  }
-  return out;
-}
-function anchorDelta(graph, placed, pinned) {
-  for (const node of graph.nodes) {
-    if (!pinned.has(node.id)) continue;
-    const at = placed.get(node.id);
-    if (at !== void 0) return { x: node.bounds.x - at.x, y: node.bounds.y - at.y };
-  }
-  let minCurX = Infinity;
-  let minCurY = Infinity;
-  let minNewX = Infinity;
-  let minNewY = Infinity;
-  for (const node of graph.nodes) {
-    const at = placed.get(node.id);
-    if (at === void 0) continue;
-    minCurX = Math.min(minCurX, node.bounds.x);
-    minCurY = Math.min(minCurY, node.bounds.y);
-    minNewX = Math.min(minNewX, at.x);
-    minNewY = Math.min(minNewY, at.y);
-  }
-  if (!Number.isFinite(minCurX)) return { x: 0, y: 0 };
-  return { x: minCurX - minNewX, y: minCurY - minNewY };
-}
-function packAcross(nodes, axis, gap) {
-  const at = /* @__PURE__ */ new Map();
-  let cursor = 0;
-  for (const node of nodes) {
-    at.set(node.id, cursor);
-    cursor += extent(node.bounds, axis) + gap;
-  }
-  return { at, span: nodes.length === 0 ? 0 : cursor - gap };
-}
-function seededOrder(nodes, axis, indexOf) {
-  return [...nodes].sort((a, b) => {
-    const d = center(a.bounds, axis) - center(b.bounds, axis);
-    return d !== 0 ? d : indexOf(a.id) - indexOf(b.id);
-  });
-}
-function graphOrder(graph) {
-  const index = /* @__PURE__ */ new Map();
-  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 };
-    const slack = widen(block, span.group, insets.get(span), axes);
-    byRow.forEach((items, r) => {
-      const shift = items.some((item) => item.kind === "group") ? slack : (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 widen(block, group, inset, axes) {
-  const floor = axes.cross === "x" ? (group.minWidth ?? 0) - inset.crossLo - inset.crossHi : 0;
-  const slack = Math.max(0, floor - block.width) / 2;
-  block.width += 2 * slack;
-  for (const [child, local] of block.childAt) block.childAt.set(child, local + slack);
-  return slack;
-}
-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,
-  groupStrength: 0.2
-};
-var GOLDEN = Math.PI * (3 - Math.sqrt(5));
-var NUDGE = 0.5;
-function charge(bodies, strength) {
-  return (alpha) => {
-    for (let i = 0; i < bodies.length; i++) {
-      const a = bodies[i];
-      for (let j = i + 1; j < bodies.length; j++) {
-        const b = bodies[j];
-        const dx = b.x - a.x;
-        const dy = b.y - a.y;
-        const d2 = dx * dx + dy * dy;
-        if (d2 === 0) continue;
-        const w = strength * alpha / d2;
-        a.vx += dx * w;
-        a.vy += dy * w;
-        b.vx -= dx * w;
-        b.vy -= dy * w;
-      }
-    }
-  };
-}
-function links(bodies, graph, distance, strength) {
-  return (alpha) => {
-    for (const edge of graph.edges) {
-      const a = bodies.get(edge.from);
-      const b = bodies.get(edge.to);
-      if (a === void 0 || b === void 0 || a === b) continue;
-      const dx = b.x - a.x;
-      const dy = b.y - a.y;
-      const d = Math.hypot(dx, dy);
-      if (d === 0) continue;
-      const pull = (d - distance) / d * alpha * strength;
-      a.vx += dx * pull;
-      a.vy += dy * pull;
-      b.vx -= dx * pull;
-      b.vy -= dy * pull;
-    }
-  };
-}
-function separateBoxes(bodies, padding) {
-  return () => {
-    for (let i = 0; i < bodies.length; i++) {
-      const a = bodies[i];
-      for (let j = i + 1; j < bodies.length; j++) {
-        const b = bodies[j];
-        const dx = b.x - a.x;
-        const dy = b.y - a.y;
-        const gapX = a.hw + b.hw + padding - Math.abs(dx);
-        const gapY = a.hh + b.hh + padding - Math.abs(dy);
-        if (gapX <= 0 || gapY <= 0) continue;
-        if (gapX < gapY) {
-          const push = (Math.sign(dx) || 1) * gapX * 0.5;
-          a.vx -= push;
-          b.vx += push;
-        } else {
-          const push = (Math.sign(dy) || 1) * gapY * 0.5;
-          a.vy -= push;
-          b.vy += push;
-        }
-      }
-    }
-  };
-}
-function gravity(bodies, at, strength) {
-  return (alpha) => {
-    for (const body of bodies) {
-      body.vx += (at.x - body.x) * strength * alpha;
-      body.vy += (at.y - body.y) * strength * alpha;
-    }
-  };
-}
-function forceRelaxation(graph, opts = {}) {
-  const {
-    linkDistance = DEFAULTS.linkDistance,
-    linkStrength = DEFAULTS.linkStrength,
-    charge: chargeStrength = DEFAULTS.charge,
-    gravity: gravityStrength = DEFAULTS.gravity,
-    padding = DEFAULTS.padding,
-    groupStrength = DEFAULTS.groupStrength
-  } = opts;
-  const pinned = pinnedSet(graph, opts);
-  const bodies = graph.nodes.map((node) => {
-    const body = {
-      id: node.id,
-      x: center(node.bounds, "x"),
-      y: center(node.bounds, "y"),
-      hw: node.bounds.width / 2,
-      hh: node.bounds.height / 2
-    };
-    if (pinned.has(node.id)) {
-      body.fx = body.x;
-      body.fy = body.y;
-    }
-    return body;
-  });
-  separate(bodies);
-  const byId = new Map(bodies.map((b) => [b.id, b]));
-  const centroid = {
-    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),
-      ...groups.length > 0 ? [groupCohesion(groups, byId, groupStrength), separateGroups(groups, bodies, byId, padding)] : []
-    ]
-  });
-  return {
-    bodies,
-    byId,
-    pinned,
-    sim,
-    placed() {
-      const placed = /* @__PURE__ */ new Map();
-      for (const node of graph.nodes) {
-        const body = byId.get(node.id);
-        placed.set(node.id, {
-          x: body.x - node.bounds.width / 2,
-          y: body.y - node.bounds.height / 2
-        });
-      }
-      return placed;
-    }
-  };
-}
-var force = (graph, opts = {}) => {
-  if (graph.nodes.length === 0) return /* @__PURE__ */ new Map();
-  const relaxation = forceRelaxation(graph, opts);
-  relaxation.sim.tick(opts.iterations ?? DEFAULTS.iterations);
-  return translated(graph, relaxation.placed(), relaxation.pinned, opts.tolerance);
-};
-function separate(bodies) {
-  const seen = /* @__PURE__ */ new Map();
-  bodies.forEach((body, i) => {
-    const key = `${body.x},${body.y}`;
-    const nth = seen.get(key) ?? 0;
-    seen.set(key, nth + 1);
-    if (nth === 0 || body.fx != null || body.fy != null) return;
-    const angle = GOLDEN * i;
-    const radius = NUDGE * nth;
-    body.x += Math.cos(angle) * radius;
-    body.y += Math.sin(angle) * radius;
-  });
-}
-
-// src/barycenter.ts
-var SWEEPS = 4;
-function barycenterOrder(graph, rows, back) {
-  const out = rows.map((row) => [...row]);
-  const index = /* @__PURE__ */ new Map();
-  const reindex = (row) => row.forEach((n, i) => index.set(n.id, i));
-  out.forEach(reindex);
-  const reorder = (row, neighbors) => {
-    const key = /* @__PURE__ */ new Map();
-    for (const [i, n] of row.entries()) {
-      const at = neighbors(n.id).map((id) => index.get(id)).filter((v) => v !== void 0);
-      key.set(n.id, at.length === 0 ? i : at.reduce((s, v) => s + v, 0) / at.length);
-    }
-    row.sort((a, b) => key.get(a.id) - key.get(b.id) || index.get(a.id) - index.get(b.id));
-    reindex(row);
-  };
-  const ups = (id) => graph.incoming(id).filter((e) => !back.has(e.id)).map((e) => e.from);
-  const downs = (id) => graph.outgoing(id).filter((e) => !back.has(e.id)).map((e) => e.to);
-  for (let s = 0; s < SWEEPS; s++) {
-    for (let r = 1; r < out.length; r++) reorder(out[r], ups);
-    for (let r = out.length - 2; r >= 0; r--) reorder(out[r], downs);
-  }
-  return out;
-}
-
-// src/layered.ts
-function backEdges(graph) {
-  const back = /* @__PURE__ */ new Set();
-  const done = /* @__PURE__ */ new Set();
-  const onStack = /* @__PURE__ */ new Set();
-  const walk = (id) => {
-    if (done.has(id)) return;
-    onStack.add(id);
-    for (const edge of graph.outgoing(id)) {
-      if (onStack.has(edge.to)) back.add(edge.id);
-      else walk(edge.to);
-    }
-    onStack.delete(id);
-    done.add(id);
-  };
-  for (const node of graph.nodes) walk(node.id);
-  return back;
-}
-function ranksOf(graph, back) {
-  const ranks = /* @__PURE__ */ new Map();
-  const resolving = /* @__PURE__ */ new Set();
-  const rankOf = (id) => {
-    const known = ranks.get(id);
-    if (known !== void 0) return known;
-    if (resolving.has(id)) return 0;
-    resolving.add(id);
-    let rank = 0;
-    for (const edge of graph.incoming(id)) {
-      if (back.has(edge.id)) continue;
-      rank = Math.max(rank, rankOf(edge.from) + 1);
-    }
-    resolving.delete(id);
-    ranks.set(id, rank);
-    return rank;
-  };
-  for (const node of graph.nodes) rankOf(node.id);
-  return ranks;
-}
-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;
-  const order = graphOrder(graph);
-  const back = backEdges(graph);
-  const ranks = ranksOf(graph, back);
-  const byRank = /* @__PURE__ */ new Map();
-  for (const node of graph.nodes) {
-    const rank = ranks.get(node.id) ?? 0;
-    const list = byRank.get(rank);
-    if (list === void 0) byRank.set(rank, [node]);
-    else list.push(node);
-  }
-  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 = 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 [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: 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 + (gaps[i] ?? 0);
-  }
-  return settle(graph, slots, opts);
-};
-
-// src/tree.ts
-function forestOf(graph, crossAxis) {
-  const order = graphOrder(graph);
-  const children = /* @__PURE__ */ new Map();
-  const depth = /* @__PURE__ */ new Map();
-  const roots = [];
-  const claim = (node, at) => {
-    depth.set(node.id, at);
-    const kids = [];
-    for (const edge of graph.outgoing(node.id)) {
-      if (edge.to === node.id || depth.has(edge.to)) continue;
-      const child = graph.node(edge.to);
-      if (child === void 0) continue;
-      depth.set(child.id, at + 1);
-      kids.push(child);
-    }
-    const ordered = seededOrder(kids, crossAxis, order);
-    children.set(node.id, ordered);
-    for (const child of ordered) claim(child, at + 1);
-  };
-  const rootish = graph.nodes.filter((node) => graph.incoming(node.id).every((edge) => edge.from === node.id));
-  for (const node of seededOrder(rootish, crossAxis, order)) {
-    if (depth.has(node.id)) continue;
-    roots.push(node);
-    claim(node, 0);
-  }
-  for (const node of graph.nodes) {
-    if (depth.has(node.id)) continue;
-    roots.push(node);
-    claim(node, 0);
-  }
-  return { roots, children, depth };
-}
-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;
-  const { roots, children, depth } = forestOf(graph, axes.cross);
-  const bands = /* @__PURE__ */ new Map();
-  for (const node of graph.nodes) {
-    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 [i, at] of depths.entries()) {
-    bandStart.set(at, along);
-    along += bands.get(at) + (gaps[i] ?? 0);
-  }
-  const slots = /* @__PURE__ */ new Map();
-  const measured = /* @__PURE__ */ new Map();
-  const measure = (node) => {
-    const known = measured.get(node.id);
-    if (known !== void 0) return known;
-    const kids = children.get(node.id) ?? [];
-    let width = 0;
-    for (const child of kids) width += measure(child);
-    if (kids.length > 0) width += nodeGap * (kids.length - 1);
-    const block = Math.max(extent(node.bounds, axes.cross), width);
-    measured.set(node.id, block);
-    return block;
-  };
-  const place = (node, from) => {
-    const kids = children.get(node.id) ?? [];
-    const block = measure(node);
-    const width = kids.reduce((sum, k) => sum + measure(k), 0) + Math.max(0, kids.length - 1) * nodeGap;
-    let cursor2 = from + (block - width) / 2;
-    for (const child of kids) {
-      place(child, cursor2);
-      cursor2 += measure(child) + nodeGap;
-    }
-    const own = extent(node.bounds, axes.cross);
-    const at = depth.get(node.id) ?? 0;
-    slots.set(node.id, {
-      cross: from + (block - own) / 2,
-      rank: bandStart.get(at) + (bands.get(at) - extent(node.bounds, axes.rank)) / 2
-    });
-  };
-  let cursor = 0;
-  for (const root of roots) {
-    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_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-JZ4CVLAB.js.map
-//# sourceMappingURL=chunk-JZ4CVLAB.js.map