@weasel-js/diagram 1.5.0 → 1.5.1

package/dist/chunk-M34HI5RG.js

@@ -0,0 +1,862 @@
+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';
+
+// 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;
+  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 };
+}
+
+// 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"}`;
+    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: FALLBACK_LINE } : 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);
+  let y = inner.y + padding;
+  return spec.rows.map((row, index) => {
+    const h = measureRow(row, measure).height;
+    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 = [
+    { 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 = 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 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;
+}
+var DEFAULTS = {
+  iterations: 300,
+  linkDistance: 160,
+  linkStrength: 0.35,
+  charge: -3e3,
+  gravity: 0.02,
+  padding: 24
+};
+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
+  } = 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 sim = createSimulation({
+    nodes: bodies,
+    forces: [
+      charge(bodies, chargeStrength),
+      links(byId, graph, linkDistance, linkStrength),
+      gravity(bodies, centroid, gravityStrength),
+      separateBoxes(bodies, 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/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 = {}) => {
+  const axes = axesFor(opts.direction);
+  const nodeGap = opts.nodeGap ?? DEFAULT_NODE_GAP;
+  const rankGap = opts.rankGap ?? DEFAULT_RANK_GAP;
+  const order = graphOrder(graph);
+  const ranks = ranksOf(graph, backEdges(graph));
+  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);
+  const packed = /* @__PURE__ */ new Map();
+  let widest = 0;
+  for (const rank of rows) {
+    const row = seededOrder(byRank.get(rank), axes.cross, order);
+    const p = packAcross(row, axes.cross, nodeGap);
+    packed.set(rank, p);
+    widest = Math.max(widest, p.span);
+  }
+  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;
+    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),
+        // 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;
+  }
+  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 = {}) => {
+  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 bandStart = /* @__PURE__ */ new Map();
+  let along = 0;
+  for (const at of [...bands.keys()].sort((a, b) => a - b)) {
+    bandStart.set(at, along);
+    along += bands.get(at) + rankGap;
+  }
+  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;
+  }
+  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-M34HI5RG.js.map
+//# sourceMappingURL=chunk-M34HI5RG.js.map