compasso 0.4.0 → 0.5.0

package/dist/chunk-MIJTBYX2.js

@@ -0,0 +1,982 @@
+import { packGrid, allocateLanes, legendBlock, xmlEscape, measureCompartmentBox, glyphInset, estimateTextWidth, FONT_FAMILY, EDGE_STROKE, LEGEND_SWATCH_W, diamondPoints, trianglePoints, arrowOpenPoints, GLYPH_TRI_HALF } from './chunk-DVLWT565.js';
+
+// src/uml/types.ts
+var UML_VISIBILITIES = ["public", "private", "protected", "package"];
+var UML_VIS_GLYPH = {
+  public: "+",
+  private: "-",
+  protected: "#",
+  package: "~"
+};
+var UML_RELATIONSHIPS = [
+  "association",
+  "directed-association",
+  "aggregation",
+  "composition",
+  "generalization",
+  "realization",
+  "dependency"
+];
+var RELATION_GLYPHS = {
+  association: { sourceEnd: "none", targetEnd: "none", line: "solid" },
+  "directed-association": { sourceEnd: "none", targetEnd: "open-arrow", line: "solid" },
+  aggregation: { sourceEnd: "hollow-diamond", targetEnd: "none", line: "solid" },
+  composition: { sourceEnd: "solid-diamond", targetEnd: "none", line: "solid" },
+  generalization: { sourceEnd: "none", targetEnd: "hollow-triangle", line: "solid" },
+  realization: { sourceEnd: "none", targetEnd: "hollow-triangle", line: "dashed" },
+  dependency: { sourceEnd: "none", targetEnd: "open-arrow", line: "dashed" }
+};
+
+// src/uml/validate.ts
+var UmlValidationError = class extends Error {
+  issues;
+  constructor(issues) {
+    super(`invalid UML class diagram: ${issues.map((i) => i.message).join("; ")}`);
+    this.name = "UmlValidationError";
+    this.issues = issues;
+  }
+};
+function sortIssues(issues) {
+  const unique = /* @__PURE__ */ new Map();
+  for (const issue of issues) unique.set(`${issue.code} ${issue.message}`, issue);
+  return [...unique.values()].sort(
+    (a, b) => a.code !== b.code ? a.code < b.code ? -1 : 1 : a.message < b.message ? -1 : a.message > b.message ? 1 : 0
+  );
+}
+var GRAPH_BLOCKING = /* @__PURE__ */ new Set([
+  "duplicate-id",
+  "unknown-endpoint"
+]);
+var INHERITANCE_KINDS = /* @__PURE__ */ new Set([
+  "generalization",
+  "realization"
+]);
+function umlIssues(input) {
+  if (input.classes.length === 0 && input.relationships.length === 0) return [];
+  const issues = [];
+  const push = (code, message) => {
+    issues.push({ code, message });
+  };
+  const classById = /* @__PURE__ */ new Map();
+  const dupClassIds = /* @__PURE__ */ new Set();
+  for (const c of input.classes) {
+    if (classById.has(c.id)) dupClassIds.add(c.id);
+    else classById.set(c.id, c);
+  }
+  for (const id of [...dupClassIds].sort((a, b) => a - b)) {
+    push("duplicate-id", `duplicate class id ${id}`);
+  }
+  const relById = /* @__PURE__ */ new Map();
+  const dupRelIds = /* @__PURE__ */ new Set();
+  for (const r of input.relationships) {
+    if (relById.has(r.id)) dupRelIds.add(r.id);
+    else relById.set(r.id, r);
+  }
+  for (const id of [...dupRelIds].sort((a, b) => a - b)) {
+    push("duplicate-id", `duplicate relationship id ${id}`);
+  }
+  if (issues.length > 0) return sortIssues(issues);
+  const rels = [...relById.values()].sort((a, b) => a.id - b.id);
+  for (const r of rels) {
+    if (!classById.has(r.sourceId)) {
+      push("unknown-endpoint", `relationship ${r.id} sourceId ${r.sourceId} is not a declared class`);
+    }
+    if (!classById.has(r.targetId)) {
+      push("unknown-endpoint", `relationship ${r.id} targetId ${r.targetId} is not a declared class`);
+    }
+  }
+  for (const c of [...classById.values()].sort((a, b) => a.id - b.id)) {
+    if (!Number.isInteger(c.col) || c.col < 0) {
+      push("negative-cell", `class ${c.id} col ${c.col} must be a non-negative integer`);
+    }
+    if (!Number.isInteger(c.row) || c.row < 0) {
+      push("negative-cell", `class ${c.id} row ${c.row} must be a non-negative integer`);
+    }
+  }
+  const cellKey = (c) => `${c.col},${c.row}`;
+  const cellToClasses = /* @__PURE__ */ new Map();
+  for (const c of [...classById.values()].sort((a, b) => a.id - b.id)) {
+    const key = cellKey(c);
+    const arr = cellToClasses.get(key) ?? [];
+    arr.push(c.id);
+    cellToClasses.set(key, arr);
+  }
+  for (const [key, ids] of [...cellToClasses.entries()].sort()) {
+    if (ids.length > 1) {
+      push(
+        "cell-collision",
+        `classes ${ids.sort((a, b) => a - b).join(", ")} all declare cell (${key})`
+      );
+    }
+  }
+  for (const r of rels) {
+    if ((r.kind === "generalization" || r.kind === "realization") && r.sourceId === r.targetId) {
+      push(
+        "self-generalization",
+        `relationship ${r.id} is a ${r.kind} from class ${r.sourceId} to itself`
+      );
+    }
+  }
+  if (!issues.some((i) => GRAPH_BLOCKING.has(i.code))) {
+    const inheritanceChildren = /* @__PURE__ */ new Map();
+    for (const r of rels) {
+      if (!INHERITANCE_KINDS.has(r.kind)) continue;
+      if (r.sourceId === r.targetId) continue;
+      const arr = inheritanceChildren.get(r.sourceId) ?? [];
+      arr.push(r.targetId);
+      inheritanceChildren.set(r.sourceId, arr);
+    }
+    for (const arr of inheritanceChildren.values()) arr.sort((a, b) => a - b);
+    const color = /* @__PURE__ */ new Map();
+    const seenCycles = /* @__PURE__ */ new Set();
+    const dfs = (start) => {
+      const stack = [{ id: start, nextChild: 0 }];
+      color.set(start, 1);
+      while (stack.length > 0) {
+        const frame = stack[stack.length - 1];
+        const children = inheritanceChildren.get(frame.id) ?? [];
+        if (frame.nextChild >= children.length) {
+          color.set(frame.id, 2);
+          stack.pop();
+          continue;
+        }
+        const child = children[frame.nextChild];
+        frame.nextChild += 1;
+        const c = color.get(child) ?? 0;
+        if (c === 1) {
+          const from = stack.findIndex((f) => f.id === child);
+          const cycle = stack.slice(from).map((f) => f.id);
+          const minIdx = cycle.indexOf(Math.min(...cycle));
+          const rotated = [...cycle.slice(minIdx), ...cycle.slice(0, minIdx)];
+          const key = rotated.join(">");
+          if (!seenCycles.has(key)) {
+            seenCycles.add(key);
+            push(
+              "generalization-cycle",
+              `generalization cycle: ${[...rotated, rotated[0]].join(" \u2192 ")}`
+            );
+          }
+        } else if (c === 0) {
+          color.set(child, 1);
+          stack.push({ id: child, nextChild: 0 });
+        }
+      }
+    };
+    for (const c of [...classById.values()].sort((a, b) => a.id - b.id)) {
+      if ((color.get(c.id) ?? 0) === 0) dfs(c.id);
+    }
+  }
+  return sortIssues(issues);
+}
+function validateUml(input) {
+  const issues = umlIssues(input);
+  if (issues.length > 0) throw new UmlValidationError(issues);
+}
+function sideCapacity(boxH, rowGap, pitch, glyphHalf) {
+  const clear = boxH / 2 + rowGap / 2 - glyphHalf;
+  const k = Math.max(0, Math.floor(clear / pitch));
+  return 2 * k + 1;
+}
+function sideCapacityIssue(classId, side, count, capacity) {
+  return {
+    code: "too-many-side-edges",
+    message: `class ${classId} has ${count} edges on its ${side} side \u2014 at most ${capacity} fit without a port stub spilling through a neighbouring box`
+  };
+}
+
+// src/uml/labels.ts
+var UML_TITLE_LABELS_EN = {
+  kinds: {
+    association: "association",
+    "directed-association": "directed association",
+    aggregation: "aggregation",
+    composition: "composition",
+    generalization: "generalization",
+    realization: "realization",
+    dependency: "dependency"
+  },
+  visibilities: {
+    public: "public",
+    private: "private",
+    protected: "protected",
+    package: "package"
+  }
+};
+var UML_SVG_LABELS_EN = {
+  legend: {
+    association: "Association",
+    "directed-association": "Directed association",
+    aggregation: "Aggregation",
+    composition: "Composition",
+    generalization: "Generalization",
+    realization: "Realization",
+    dependency: "Dependency"
+  },
+  ariaLabel: "UML class diagram"
+};
+
+// src/uml/layout.ts
+var UML_PADDING = 32;
+var UML_COL_GAP = 64;
+var UML_ROW_GAP = 56;
+var UML_BOX_PAD_X = 10;
+var UML_BOX_PAD_Y = 8;
+var UML_LINE_H = 15;
+var UML_MIN_BOX_W = 120;
+var UML_NAME_FONT = 12;
+var UML_FEAT_FONT = 11;
+var UML_SEP_PAD = 4;
+var UML_PORT_PITCH = 12;
+var UML_SELF_LOOP_W = 28;
+var UML_LABEL_FONT = 10;
+var UML_ASSOC_ROUTE_BASE = 1e6;
+var UML_GLYPH_BASE = 2e6;
+var UML_SELF_LOOP_BASE = 3e6;
+var MIN_TERMINAL_STUB = 4;
+var round = (n) => Math.round(n * 100) / 100;
+function featureLine(f) {
+  const prefix = f.visibility !== null ? UML_VIS_GLYPH[f.visibility] + " " : "";
+  return prefix + f.text;
+}
+function measureClass(cls) {
+  const nameLines = [];
+  if (cls.stereotype !== null) nameLines.push(cls.stereotype);
+  nameLines.push(cls.name);
+  const attrLines = cls.attributes.map(featureLine);
+  const opLines = cls.operations.map(featureLine);
+  return measureCompartmentBox(
+    [
+      { lines: nameLines, font: UML_NAME_FONT },
+      { lines: attrLines, font: UML_FEAT_FONT },
+      { lines: opLines, font: UML_FEAT_FONT }
+    ],
+    {
+      padX: UML_BOX_PAD_X,
+      padY: UML_BOX_PAD_Y,
+      lineH: UML_LINE_H,
+      minW: UML_MIN_BOX_W,
+      sepPad: UML_SEP_PAD
+    }
+  );
+}
+function boxEdges(node) {
+  const left = round(node.cx - node.boxW / 2);
+  const right = round(left + node.boxW);
+  const top = round(node.cy - node.boxH / 2);
+  const bottom = round(top + node.boxH);
+  return { left, right, top, bottom };
+}
+function glyphInsetForKind(gk) {
+  switch (gk) {
+    case "none":
+      return 0;
+    case "open-arrow":
+      return glyphInset("right", "arrow");
+    case "hollow-triangle":
+      return glyphInset("right", "triangle");
+    case "hollow-diamond":
+    case "solid-diamond":
+      return glyphInset("right", "diamond");
+  }
+}
+var MAX_GLYPH_HALF = GLYPH_TRI_HALF;
+var GLYPH_SLOT_PITCH = Math.max(UML_PORT_PITCH, MAX_GLYPH_HALF * 2 + 2);
+function portOffset(slotIndex, slotSize) {
+  if (slotIndex === 0) return 0;
+  const sign = slotIndex % 2 === 1 ? 1 : -1;
+  const dist = Math.ceil(slotIndex / 2);
+  return sign * dist * slotSize;
+}
+function sidePort(node, side, dy) {
+  const { left, right } = boxEdges(node);
+  const x = side === "right" ? right : left;
+  return { x, y: round(node.cy + dy) };
+}
+function vGutterLeft(colIdx, colX, grid) {
+  return round(colX[colIdx] + grid.colW[colIdx]);
+}
+var V_GUTTER_MARGIN = 6;
+function horizontalGutterY(rowIdx, rowY, grid) {
+  return round(rowY[rowIdx] + grid.rowH[rowIdx] + UML_ROW_GAP / 2);
+}
+function moveAlongDir(p, dir, dist) {
+  switch (dir) {
+    case "right":
+      return { x: round(p.x + dist), y: p.y };
+    case "left":
+      return { x: round(p.x - dist), y: p.y };
+    case "down":
+      return { x: p.x, y: round(p.y + dist) };
+    case "up":
+      return { x: p.x, y: round(p.y - dist) };
+  }
+}
+function simplifyWaypoints(pts) {
+  const dedup = [pts[0]];
+  for (let i = 1; i < pts.length; i++) {
+    const prev = dedup[dedup.length - 1];
+    const cur = pts[i];
+    if (Math.abs(cur.x - prev.x) > 1e-6 || Math.abs(cur.y - prev.y) > 1e-6) dedup.push(cur);
+  }
+  if (dedup.length <= 2) return dedup;
+  const out = [dedup[0]];
+  for (let i = 1; i < dedup.length - 1; i++) {
+    const a = out[out.length - 1];
+    const b = dedup[i];
+    const c = dedup[i + 1];
+    const abH = Math.abs(a.y - b.y) <= 1e-6;
+    const bcH = Math.abs(b.y - c.y) <= 1e-6;
+    const abV = Math.abs(a.x - b.x) <= 1e-6;
+    const bcV = Math.abs(b.x - c.x) <= 1e-6;
+    if (abH && bcH || abV && bcV) continue;
+    out.push(b);
+  }
+  out.push(dedup[dedup.length - 1]);
+  return out;
+}
+function chooseSides(srcNode, tgtNode, maxCol) {
+  const sc = srcNode.col;
+  const tc = tgtNode.col;
+  if (tc > sc) return { srcSide: "right", tgtSide: "left", srcVCol: sc, tgtVCol: tc - 1 };
+  if (tc < sc) return { srcSide: "left", tgtSide: "right", srcVCol: sc - 1, tgtVCol: tc };
+  if (sc < maxCol) return { srcSide: "right", tgtSide: "right", srcVCol: sc, tgtVCol: sc };
+  if (sc > 0) return { srcSide: "left", tgtSide: "left", srcVCol: sc - 1, tgtVCol: sc - 1 };
+  return { srcSide: "right", tgtSide: "right", srcVCol: sc, tgtVCol: sc };
+}
+function hBaseY(plan, rowY, grid) {
+  if (plan.hKind === "pad-top") return round(UML_PADDING / 2);
+  return horizontalGutterY(plan.hRow, rowY, grid);
+}
+function hBandBounds(plan, rowY, grid) {
+  if (plan.hKind === "pad-top") return { lo: 0, hi: round(rowY[0] ?? UML_PADDING) };
+  const lo = round(rowY[plan.hRow] + grid.rowH[plan.hRow]);
+  const hi = round(rowY[plan.hRow + 1]);
+  return { lo, hi };
+}
+var LANE_EPS = 0.5;
+var X_OVERLAP_EPS = 1e-4;
+function allocateHorizontal(runs, base, usableHalf) {
+  const floating = runs.filter((r) => r.y === null);
+  if (floating.length === 0) return;
+  const pinned = runs.filter((r) => r.y !== null);
+  const trackCount = floating.length + pinned.length + 1;
+  const candidates = trackCount <= 1 || usableHalf <= 0 ? [base] : Array.from(
+    { length: trackCount },
+    (_, k) => round(base - usableHalf + (k + 0.5) * (2 * usableHalf) / trackCount)
+  );
+  const placed = pinned.map((r) => ({ lo: r.lo, hi: r.hi, y: r.y }));
+  const ordered = [...floating].sort((a, b) => a.lo - b.lo || a.hi - b.hi);
+  for (const run of ordered) {
+    let chosen = candidates[0];
+    for (const cy of candidates) {
+      const collides = placed.some(
+        (q) => Math.abs(q.y - cy) <= LANE_EPS && Math.min(run.hi, q.hi) - Math.max(run.lo, q.lo) > X_OVERLAP_EPS
+      );
+      if (!collides) {
+        chosen = cy;
+        break;
+      }
+    }
+    run.set(chosen);
+    placed.push({ lo: run.lo, hi: run.hi, y: chosen });
+  }
+}
+function applyGlyphInsets(pts, srcInset, tgtInset) {
+  if (pts.length < 2) return pts;
+  const out = pts.map((p) => ({ ...p }));
+  if (srcInset > 0) {
+    const p0 = out[0];
+    const p1 = out[1];
+    const dir = p1.x >= p0.x ? "right" : "left";
+    out[0] = moveAlongDir(p0, dir, srcInset);
+  }
+  if (tgtInset > 0) {
+    const pn = out[out.length - 1];
+    const pm = out[out.length - 2];
+    const dir = pm.x >= pn.x ? "right" : "left";
+    out[out.length - 1] = moveAlongDir(pn, dir, tgtInset);
+  }
+  return out;
+}
+function reserveTextBox(relId, slot, text, anchorX, anchorY, anchor) {
+  const w = round(estimateTextWidth(text, UML_LABEL_FONT));
+  const h = round(UML_LABEL_FONT * 1.2);
+  const x = anchor === "middle" ? round(anchorX - w / 2) : round(anchorX);
+  const y = round(anchorY);
+  return { relId, slot, text, x, y, w, h, anchor };
+}
+function computeUmlLayout(input, labels = UML_TITLE_LABELS_EN) {
+  validateUml(input);
+  const relTitle = (rel) => rel.title ?? labels.kinds[rel.kind];
+  if (input.classes.length === 0) {
+    return {
+      nodes: [],
+      elements: [],
+      textBoxes: [],
+      canvasW: UML_PADDING * 2,
+      canvasH: UML_PADDING * 2,
+      grid: { cellX: [], cellY: [], colW: [], rowH: [] },
+      colX: [],
+      rowY: []
+    };
+  }
+  const classes = [...input.classes].sort((a, b) => a.id - b.id);
+  const rels = [...input.relationships].sort((a, b) => a.id - b.id);
+  const metricsMap = /* @__PURE__ */ new Map();
+  for (const cls of classes) metricsMap.set(cls.id, measureClass(cls));
+  const gridCells = classes.map((cls) => ({
+    col: cls.col,
+    row: cls.row,
+    w: metricsMap.get(cls.id).boxW,
+    h: metricsMap.get(cls.id).boxH
+  }));
+  const grid = packGrid(gridCells, { colGap: UML_COL_GAP, rowGap: UML_ROW_GAP });
+  const colX = [];
+  {
+    let x = UML_PADDING;
+    for (let c = 0; c < grid.colW.length; c++) {
+      colX.push(round(x));
+      x = round(x + grid.colW[c] + UML_COL_GAP);
+    }
+  }
+  const rowY = [];
+  {
+    let y = UML_PADDING;
+    for (let r = 0; r < grid.rowH.length; r++) {
+      rowY.push(round(y));
+      y = round(y + grid.rowH[r] + UML_ROW_GAP);
+    }
+  }
+  const nodeByClassId = /* @__PURE__ */ new Map();
+  const nodes = [];
+  for (const cls of classes) {
+    const metrics = metricsMap.get(cls.id);
+    const cx = round(colX[cls.col] + grid.colW[cls.col] / 2);
+    const cy = round(rowY[cls.row] + grid.rowH[cls.row] / 2);
+    const title = cls.title ?? (cls.stereotype !== null ? `\xAB${cls.stereotype}\xBB ${cls.name}` : cls.name);
+    const node = {
+      classId: cls.id,
+      cx,
+      cy,
+      boxW: metrics.boxW,
+      boxH: metrics.boxH,
+      metrics,
+      title,
+      col: cls.col,
+      row: cls.row
+    };
+    nodes.push(node);
+    nodeByClassId.set(cls.id, node);
+  }
+  const maxCol = grid.colW.length - 1;
+  const maxRow = grid.rowH.length - 1;
+  const sideCount = /* @__PURE__ */ new Map();
+  const bumpSide = (classId, side) => {
+    const key = `${classId}:${side}`;
+    sideCount.set(key, (sideCount.get(key) ?? 0) + 1);
+  };
+  for (const rel of rels) {
+    const srcNode = nodeByClassId.get(rel.sourceId);
+    const tgtNode = nodeByClassId.get(rel.targetId);
+    if (!srcNode || !tgtNode) continue;
+    if (rel.sourceId === rel.targetId) {
+      bumpSide(srcNode.classId, "right");
+      bumpSide(srcNode.classId, "right");
+      continue;
+    }
+    const { srcSide, tgtSide } = chooseSides(srcNode, tgtNode, maxCol);
+    bumpSide(srcNode.classId, srcSide);
+    bumpSide(tgtNode.classId, tgtSide);
+  }
+  {
+    const capIssues = [];
+    for (const node of nodes) {
+      const cap = sideCapacity(node.boxH, UML_ROW_GAP, GLYPH_SLOT_PITCH, MAX_GLYPH_HALF);
+      for (const side of ["left", "right"]) {
+        const count = sideCount.get(`${node.classId}:${side}`) ?? 0;
+        if (count > cap) capIssues.push(sideCapacityIssue(node.classId, side, count, cap));
+      }
+    }
+    if (capIssues.length > 0) {
+      throw new UmlValidationError(capIssues);
+    }
+  }
+  const sidePortSlot = /* @__PURE__ */ new Map();
+  const nextSidePort = (classId, side) => {
+    const key = `${classId}:${side}`;
+    const idx = sidePortSlot.get(key) ?? 0;
+    sidePortSlot.set(key, idx + 1);
+    return idx;
+  };
+  const elements = [];
+  const textBoxes = [];
+  const plans = [];
+  for (const rel of rels) {
+    const srcNode = nodeByClassId.get(rel.sourceId);
+    const tgtNode = nodeByClassId.get(rel.targetId);
+    if (!srcNode || !tgtNode) continue;
+    const glyphs = RELATION_GLYPHS[rel.kind];
+    const srcInset = glyphInsetForKind(glyphs.sourceEnd);
+    const tgtInset = glyphInsetForKind(glyphs.targetEnd);
+    if (rel.sourceId === rel.targetId) {
+      const vCol = srcNode.col;
+      const armDy1 = portOffset(nextSidePort(srcNode.classId, "right"), GLYPH_SLOT_PITCH);
+      const armDy2 = portOffset(nextSidePort(srcNode.classId, "right"), GLYPH_SLOT_PITCH);
+      plans.push({
+        rel,
+        srcNode,
+        tgtNode,
+        srcSide: "right",
+        tgtSide: "right",
+        srcVCol: vCol,
+        tgtVCol: vCol,
+        srcInset,
+        tgtInset,
+        srcPortY: round(srcNode.cy + armDy1),
+        tgtPortY: round(srcNode.cy + armDy2),
+        hKind: "row",
+        hRow: 0,
+        // unused for self-loops (no H-leg)
+        isSelfLoop: true,
+        srcVx: 0,
+        tgtVx: 0,
+        hY: 0
+      });
+      continue;
+    }
+    const { srcSide, tgtSide, srcVCol, tgtVCol } = chooseSides(srcNode, tgtNode, maxCol);
+    const srcPortDy = portOffset(nextSidePort(srcNode.classId, srcSide), GLYPH_SLOT_PITCH);
+    const tgtPortDy = portOffset(nextSidePort(tgtNode.classId, tgtSide), GLYPH_SLOT_PITCH);
+    const sr = srcNode.row;
+    const tr = tgtNode.row;
+    let hKind;
+    let hRow;
+    if (sr !== tr) {
+      hKind = "row";
+      hRow = Math.min(sr, tr);
+    } else if (maxRow >= 1) {
+      hKind = "row";
+      hRow = sr < maxRow ? sr : sr - 1;
+    } else {
+      hKind = "pad-top";
+      hRow = -1;
+    }
+    plans.push({
+      rel,
+      srcNode,
+      tgtNode,
+      srcSide,
+      tgtSide,
+      srcVCol,
+      tgtVCol,
+      srcInset,
+      tgtInset,
+      srcPortY: round(srcNode.cy + srcPortDy),
+      tgtPortY: round(tgtNode.cy + tgtPortDy),
+      hKind,
+      hRow,
+      isSelfLoop: false,
+      srcVx: 0,
+      tgtVx: 0,
+      hY: 0
+    });
+  }
+  const hHalfBand = (p) => p.hKind === "pad-top" ? round(UML_PADDING / 2) : round(UML_ROW_GAP / 2);
+  const vByKey = /* @__PURE__ */ new Map();
+  const pushV = (col, side, portY, hBase, half, inset, set) => {
+    const lo = Math.min(portY, round(hBase - half));
+    const hi = Math.max(portY, round(hBase + half));
+    const key = `${col}:${side}`;
+    const arr = vByKey.get(key) ?? [];
+    arr.push({ lo, hi, inset, lane: 0, set });
+    vByKey.set(key, arr);
+  };
+  for (const p of plans) {
+    if (p.isSelfLoop) {
+      const lo = Math.min(p.srcPortY, p.tgtPortY);
+      const hi = Math.max(p.srcPortY, p.tgtPortY);
+      const key = `${p.srcVCol}:right`;
+      const arr = vByKey.get(key) ?? [];
+      arr.push({ lo, hi, inset: Math.max(p.srcInset, p.tgtInset), lane: 0, set: (x) => {
+        p.srcVx = x;
+        p.tgtVx = x;
+      } });
+      vByKey.set(key, arr);
+      continue;
+    }
+    if (p.srcVCol === p.tgtVCol && p.srcSide === p.tgtSide) {
+      const lo = Math.min(p.srcPortY, p.tgtPortY);
+      const hi = Math.max(p.srcPortY, p.tgtPortY);
+      const key = `${p.srcVCol}:${p.srcSide}`;
+      const arr = vByKey.get(key) ?? [];
+      arr.push({ lo, hi, inset: Math.max(p.srcInset, p.tgtInset), lane: 0, set: (x) => {
+        p.srcVx = x;
+        p.tgtVx = x;
+      } });
+      vByKey.set(key, arr);
+      continue;
+    }
+    const hBase = hBaseY(p, rowY, grid);
+    const half = hHalfBand(p);
+    pushV(p.srcVCol, p.srcSide, p.srcPortY, hBase, half, p.srcInset, (x) => {
+      p.srcVx = x;
+    });
+    pushV(p.tgtVCol, p.tgtSide, p.tgtPortY, hBase, half, p.tgtInset, (x) => {
+      p.tgtVx = x;
+    });
+  }
+  for (const [key, items] of vByKey.entries()) {
+    const side = key.endsWith(":right") ? "right" : "left";
+    const col = Number(key.slice(0, key.lastIndexOf(":")));
+    const laneCount = allocateLanes(
+      items.map((it) => ({ lo: it.lo, hi: it.hi, set: (l) => {
+        it.lane = l;
+      } }))
+    );
+    const left = vGutterLeft(col, colX, grid);
+    const right = round(left + UML_COL_GAP);
+    const center = round((left + right) / 2);
+    const maxBaseGap = Math.max(...items.map((it) => Math.max(V_GUTTER_MARGIN, it.inset + MIN_TERMINAL_STUB)));
+    for (const it of items) {
+      let x;
+      if (side === "right") {
+        const lo = left + maxBaseGap;
+        const hi = center - 1;
+        x = laneCount <= 1 ? lo : lo + it.lane * (hi - lo) / (laneCount - 1);
+      } else {
+        const hi = right - maxBaseGap;
+        const lo = center + 1;
+        x = laneCount <= 1 ? hi : hi - it.lane * (hi - lo) / (laneCount - 1);
+      }
+      it.set(round(x));
+    }
+  }
+  const usableHalfOf = (kind) => Math.max(0, (kind === "pad-top" ? round(UML_PADDING / 2) : round(UML_ROW_GAP / 2)) - 3);
+  const gutterKey = (p) => p.hKind === "pad-top" ? "pad-top" : `row:${p.hRow}`;
+  const gutterMeta = /* @__PURE__ */ new Map();
+  for (const p of plans) {
+    if (p.isSelfLoop) continue;
+    const key = gutterKey(p);
+    if (!gutterMeta.has(key)) gutterMeta.set(key, { base: hBaseY(p, rowY, grid), usableHalf: usableHalfOf(p.hKind) });
+  }
+  const hRunsByKey = /* @__PURE__ */ new Map();
+  const pushRun = (key, run) => {
+    const arr = hRunsByKey.get(key) ?? [];
+    arr.push(run);
+    hRunsByKey.set(key, arr);
+  };
+  const pinStub = (yy, a, b) => {
+    for (const [gk, meta] of gutterMeta.entries()) {
+      if (yy >= meta.base - meta.usableHalf - LANE_EPS && yy <= meta.base + meta.usableHalf + LANE_EPS) {
+        pushRun(gk, { lo: Math.min(a, b), hi: Math.max(a, b), y: yy, set: () => {
+        } });
+      }
+    }
+  };
+  for (const p of plans) {
+    if (p.isSelfLoop) {
+      const sideX = p.srcSide === "right" ? boxEdges(p.srcNode).right : boxEdges(p.srcNode).left;
+      pinStub(p.srcPortY, sideX, p.srcVx);
+      pinStub(p.tgtPortY, sideX, p.tgtVx);
+      continue;
+    }
+    const key = gutterKey(p);
+    if (Math.abs(p.srcVx - p.tgtVx) > LANE_EPS) {
+      pushRun(key, { lo: Math.min(p.srcVx, p.tgtVx), hi: Math.max(p.srcVx, p.tgtVx), y: null, set: (y) => {
+        p.hY = round(y);
+      } });
+    } else {
+      p.hY = p.srcPortY;
+    }
+    const srcPortX = p.srcSide === "right" ? boxEdges(p.srcNode).right : boxEdges(p.srcNode).left;
+    const tgtPortX = p.tgtSide === "right" ? boxEdges(p.tgtNode).right : boxEdges(p.tgtNode).left;
+    pinStub(p.srcPortY, srcPortX, p.srcVx);
+    pinStub(p.tgtPortY, tgtPortX, p.tgtVx);
+  }
+  for (const [key, runs] of hRunsByKey.entries()) {
+    const meta = gutterMeta.get(key);
+    allocateHorizontal(runs, meta.base, meta.usableHalf);
+  }
+  for (const p of plans) {
+    const srcPort = sidePort(p.srcNode, p.srcSide, p.srcPortY - p.srcNode.cy);
+    const tgtPort = sidePort(p.tgtNode, p.tgtSide, p.tgtPortY - p.tgtNode.cy);
+    if (p.isSelfLoop) {
+      const raw2 = [
+        srcPort,
+        { x: p.srcVx, y: srcPort.y },
+        { x: p.srcVx, y: tgtPort.y },
+        tgtPort
+      ];
+      const portPts2 = simplifyWaypoints(raw2);
+      const pts2 = applyGlyphInsets(portPts2, p.srcInset, p.tgtInset);
+      const edgeId2 = UML_SELF_LOOP_BASE + p.rel.id;
+      elements.push({ edgeId: edgeId2, relId: p.rel.id, points: pts2, kind: "self-loop", title: relTitle(p.rel) });
+      reserveSelfLoopText(p.rel, p, textBoxes);
+      continue;
+    }
+    const raw = [
+      srcPort,
+      { x: p.srcVx, y: srcPort.y },
+      { x: p.srcVx, y: p.hY },
+      { x: p.tgtVx, y: p.hY },
+      { x: p.tgtVx, y: tgtPort.y },
+      tgtPort
+    ];
+    const portPts = simplifyWaypoints(raw);
+    const pts = applyGlyphInsets(portPts, p.srcInset, p.tgtInset);
+    const edgeId = UML_ASSOC_ROUTE_BASE + p.rel.id;
+    elements.push({ edgeId, relId: p.rel.id, points: pts, kind: "route", title: relTitle(p.rel) });
+    reserveRouteText(p.rel, p, hBandBounds(p, rowY, grid), textBoxes);
+  }
+  let maxRight = 0;
+  let maxBottom = 0;
+  for (const node of nodes) {
+    const { right, bottom } = boxEdges(node);
+    if (right > maxRight) maxRight = right;
+    if (bottom > maxBottom) maxBottom = bottom;
+  }
+  for (const el of elements) {
+    for (const pt of el.points) {
+      if (pt.x > maxRight) maxRight = pt.x;
+      if (pt.y > maxBottom) maxBottom = pt.y;
+    }
+  }
+  for (const tb of textBoxes) {
+    if (tb.x + tb.w > maxRight) maxRight = tb.x + tb.w;
+    if (tb.y + tb.h > maxBottom) maxBottom = tb.y + tb.h;
+  }
+  const canvasW = round(maxRight + UML_PADDING);
+  const canvasH = round(maxBottom + UML_PADDING);
+  return { nodes, elements, textBoxes, canvasW, canvasH, grid, colX, rowY };
+}
+function reserveRouteText(rel, p, band, out) {
+  const textH = round(UML_LABEL_FONT * 1.2);
+  const clampY = (y) => round(Math.max(band.lo + 1, Math.min(y, band.hi - 1 - textH)));
+  const above = clampY(p.hY - textH - 1);
+  const below = clampY(p.hY + 1);
+  const srcX = round(p.srcVx + 3);
+  const tgtX = round(p.tgtVx + 3);
+  if (rel.sourceMultiplicity !== null) {
+    out.push(reserveTextBox(rel.id, "src-mult", rel.sourceMultiplicity, srcX, above, "start"));
+  }
+  if (rel.sourceRole !== null) {
+    out.push(reserveTextBox(rel.id, "src-role", rel.sourceRole, srcX, below, "start"));
+  }
+  if (rel.targetMultiplicity !== null) {
+    out.push(reserveTextBox(rel.id, "tgt-mult", rel.targetMultiplicity, tgtX, above, "start"));
+  }
+  if (rel.targetRole !== null) {
+    out.push(reserveTextBox(rel.id, "tgt-role", rel.targetRole, tgtX, below, "start"));
+  }
+  if (rel.label !== null) {
+    const midX = round((p.srcVx + p.tgtVx) / 2);
+    out.push(reserveTextBox(rel.id, "label", rel.label, midX, above, "middle"));
+  }
+}
+function reserveSelfLoopText(rel, p, out) {
+  const x0 = round(p.srcVx + 3);
+  const srcY = p.srcPortY;
+  const tgtY = p.tgtPortY;
+  if (rel.sourceMultiplicity !== null) {
+    out.push(reserveTextBox(rel.id, "src-mult", rel.sourceMultiplicity, x0, round(srcY - UML_LABEL_FONT - 1), "start"));
+  }
+  if (rel.sourceRole !== null) {
+    out.push(reserveTextBox(rel.id, "src-role", rel.sourceRole, x0, round(srcY + 1), "start"));
+  }
+  if (rel.targetMultiplicity !== null) {
+    out.push(reserveTextBox(rel.id, "tgt-mult", rel.targetMultiplicity, x0, round(tgtY - UML_LABEL_FONT - 1), "start"));
+  }
+  if (rel.targetRole !== null) {
+    out.push(reserveTextBox(rel.id, "tgt-role", rel.targetRole, x0, round(tgtY + 1), "start"));
+  }
+  if (rel.label !== null) {
+    out.push(reserveTextBox(rel.id, "label", rel.label, x0, round((srcY + tgtY) / 2 - UML_LABEL_FONT / 2), "start"));
+  }
+}
+
+// src/uml/svg.ts
+var GLYPH_STROKE = "#52525b";
+var LABEL_FILL = "#3f3f46";
+var EDGE_INK = "#71717a";
+var round2 = (n) => Math.round(n * 100) / 100;
+function emitGlyph(gk, tip, dir) {
+  switch (gk) {
+    case "none":
+      return "";
+    case "open-arrow": {
+      const pts = arrowOpenPoints(tip, dir);
+      return `<polyline points="${pts}" fill="none" stroke="${GLYPH_STROKE}" stroke-width="1.5"/>`;
+    }
+    case "hollow-triangle": {
+      const pts = trianglePoints(tip, dir);
+      return `<polygon points="${pts}" fill="#fff" stroke="${GLYPH_STROKE}" stroke-width="1.5"/>`;
+    }
+    case "hollow-diamond": {
+      const pts = diamondPoints(tip, dir);
+      return `<polygon points="${pts}" fill="#fff" stroke="${GLYPH_STROKE}" stroke-width="1.5"/>`;
+    }
+    case "solid-diamond": {
+      const pts = diamondPoints(tip, dir);
+      return `<polygon points="${pts}" fill="${GLYPH_STROKE}" stroke="${GLYPH_STROKE}" stroke-width="1.5"/>`;
+    }
+  }
+}
+function glyphDir(firstPt, secondPt) {
+  const dx = secondPt.x - firstPt.x;
+  const dy = secondPt.y - firstPt.y;
+  if (Math.abs(dx) >= Math.abs(dy)) {
+    return dx >= 0 ? "left" : "right";
+  }
+  return dy >= 0 ? "up" : "down";
+}
+function featureSvg(f, x, y, font) {
+  const prefix = f.visibility !== null ? UML_VIS_GLYPH[f.visibility] + " " : "";
+  const text = prefix + f.text;
+  const baseline = round2(y + font * 0.8);
+  let out = `<text x="${x}" y="${baseline}" font-family="${FONT_FAMILY}" font-size="${font}" fill="${LABEL_FILL}">${xmlEscape(text)}</text>`;
+  if (f.isStatic) {
+    const lineY = round2(baseline + 1);
+    const approxW = round2(text.length * font * 0.6);
+    out += `<line x1="${x}" y1="${lineY}" x2="${round2(x + approxW)}" y2="${lineY}" stroke="${LABEL_FILL}" stroke-width="0.8"/>`;
+  }
+  return out;
+}
+function boxSvg(node, cls) {
+  const left = round2(node.cx - node.boxW / 2);
+  const top = round2(node.cy - node.boxH / 2);
+  const metrics = node.metrics;
+  const pieces = [];
+  pieces.push(`<title>${xmlEscape(node.title)}</title>`);
+  pieces.push(
+    `<rect x="${left}" y="${top}" width="${node.boxW}" height="${node.boxH}" rx="2" fill="#fff" stroke="${GLYPH_STROKE}" stroke-width="1.5"/>`
+  );
+  for (const dy of metrics.dividerYs) {
+    const y = round2(top + dy);
+    pieces.push(
+      `<line x1="${left}" y1="${y}" x2="${round2(left + node.boxW)}" y2="${y}" stroke="${GLYPH_STROKE}" stroke-width="0.75"/>`
+    );
+  }
+  const compartment0 = metrics.rows[0];
+  const textX = round2(left + node.boxW / 2);
+  let lineIdx = 0;
+  if (cls.stereotype !== null) {
+    const stereoY = round2(top + compartment0.top + lineIdx * UML_LINE_H + UML_NAME_FONT * 0.8);
+    pieces.push(
+      `<text x="${textX}" y="${stereoY}" font-family="${FONT_FAMILY}" font-size="${UML_NAME_FONT}" fill="${LABEL_FILL}" text-anchor="middle">${xmlEscape(cls.stereotype)}</text>`
+    );
+    lineIdx++;
+  }
+  const nameY = round2(top + compartment0.top + lineIdx * UML_LINE_H + UML_NAME_FONT * 0.8);
+  const nameStyle = cls.isAbstract ? ` font-style="italic"` : "";
+  const nameText = metrics.rows[0].lines[lineIdx] ?? "";
+  pieces.push(
+    `<text x="${textX}" y="${nameY}" font-family="${FONT_FAMILY}" font-size="${UML_NAME_FONT}" fill="${LABEL_FILL}" text-anchor="middle"${nameStyle}>${xmlEscape(nameText)}</text>`
+  );
+  const attrCompartment = metrics.rows[1];
+  const attrX = round2(left + UML_BOX_PAD_X);
+  for (let i = 0; i < cls.attributes.length; i++) {
+    const f = cls.attributes[i];
+    const fy = round2(top + attrCompartment.top + i * UML_LINE_H);
+    pieces.push(featureSvg(f, attrX, fy, UML_FEAT_FONT));
+  }
+  const opCompartment = metrics.rows[2];
+  const opX = round2(left + UML_BOX_PAD_X);
+  for (let i = 0; i < cls.operations.length; i++) {
+    const f = cls.operations[i];
+    const fy = round2(top + opCompartment.top + i * UML_LINE_H);
+    pieces.push(featureSvg(f, opX, fy, UML_FEAT_FONT));
+  }
+  return `<g data-node-id="c${node.classId}">${pieces.join("")}</g>`;
+}
+function edgeSvg(el, rel, textBoxes) {
+  const glyphs = RELATION_GLYPHS[rel.kind];
+  const isDashed = glyphs.line === "dashed";
+  const stroke = isDashed ? EDGE_STROKE.distant : { width: 1.5, opacity: 0.7 };
+  const strokeAttrs = isDashed ? `stroke="${EDGE_INK}" stroke-width="${stroke.width}" stroke-dasharray="4,4" opacity="${stroke.opacity}"` : `stroke="${EDGE_INK}" stroke-width="${stroke.width}" opacity="${stroke.opacity}"`;
+  const pts = el.points;
+  const pieces = [`<title>${xmlEscape(el.title)}</title>`];
+  if (pts.length >= 2) {
+    pieces.push(`<polyline points="${pts.map((p) => `${p.x},${p.y}`).join(" ")}" fill="none" ${strokeAttrs}/>`);
+    if (glyphs.sourceEnd !== "none") {
+      const tip = pts[0];
+      const next = pts[1];
+      const dir = glyphDir(tip, next);
+      pieces.push(emitGlyph(glyphs.sourceEnd, tip, dir));
+    }
+    if (glyphs.targetEnd !== "none") {
+      const tip = pts[pts.length - 1];
+      const prev = pts[pts.length - 2];
+      const dir = glyphDir(tip, prev);
+      pieces.push(emitGlyph(glyphs.targetEnd, tip, dir));
+    }
+    for (const tb of textBoxes) {
+      if (tb.relId !== rel.id) continue;
+      const italic = tb.slot === "src-role" || tb.slot === "tgt-role" ? ` font-style="italic"` : "";
+      const anchor = tb.anchor === "middle" ? ` text-anchor="middle"` : "";
+      const drawX = tb.anchor === "middle" ? round2(tb.x + tb.w / 2) : tb.x;
+      const baseline = round2(tb.y + UML_LABEL_FONT * 0.8);
+      pieces.push(
+        `<text x="${drawX}" y="${baseline}" font-family="${FONT_FAMILY}" font-size="${UML_LABEL_FONT}" fill="${LABEL_FILL}"${anchor}${italic}>${xmlEscape(tb.text)}</text>`
+      );
+    }
+  }
+  return `<g data-edge-id="${el.edgeId}">${pieces.join("")}</g>`;
+}
+function makeSwatchLine(isDashed) {
+  return (x, y) => {
+    const attrs = isDashed ? `stroke="${EDGE_INK}" stroke-width="1.5" stroke-dasharray="4,4"` : `stroke="${EDGE_INK}" stroke-width="1.5"`;
+    return `<line x1="${x}" y1="${y}" x2="${x + LEGEND_SWATCH_W}" y2="${y}" ${attrs}/>`;
+  };
+}
+function umlLayoutSvg(layout, input, opts = {}) {
+  const labels = opts.labels ?? UML_SVG_LABELS_EN;
+  const showLegend = opts.legend !== false;
+  const classMap = new Map(input.classes.map((c) => [c.id, c]));
+  const relMap = new Map(input.relationships.map((r) => [r.id, r]));
+  const parts = [];
+  for (const node of layout.nodes) {
+    const cls = classMap.get(node.classId);
+    parts.push(boxSvg(node, cls));
+  }
+  for (const el of layout.elements) {
+    const rel = relMap.get(el.relId);
+    if (!rel) continue;
+    parts.push(edgeSvg(el, rel, layout.textBoxes));
+  }
+  let canvasW = layout.canvasW;
+  let canvasH = layout.canvasH;
+  if (showLegend) {
+    const usedKinds = new Set(
+      input.relationships.map((r) => r.kind)
+    );
+    const entries = [];
+    for (const kind of UML_RELATIONSHIPS) {
+      if (!usedKinds.has(kind)) continue;
+      const isDashed = RELATION_GLYPHS[kind].line === "dashed";
+      entries.push({
+        swatch: makeSwatchLine(isDashed),
+        label: labels.legend[kind]
+      });
+    }
+    if (entries.length > 0) {
+      const block = legendBlock(entries, canvasH);
+      parts.push(block.svg);
+      canvasH = block.height;
+      canvasW = Math.max(canvasW, block.width);
+    }
+  }
+  const roundedW = round2(canvasW);
+  const roundedH = round2(canvasH);
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${roundedW}" height="${roundedH}" viewBox="0 0 ${roundedW} ${roundedH}" role="img" aria-label="${xmlEscape(labels.ariaLabel)}">` + parts.join("") + `</svg>`;
+}
+
+// src/uml/render.ts
+function umlSvg(input, opts = {}) {
+  const layout = computeUmlLayout(input, opts.titleLabels ?? UML_TITLE_LABELS_EN);
+  const svg = umlLayoutSvg(layout, input, opts);
+  return { svg, layout };
+}
+
+export { RELATION_GLYPHS, UML_ASSOC_ROUTE_BASE, UML_BOX_PAD_X, UML_BOX_PAD_Y, UML_COL_GAP, UML_FEAT_FONT, UML_GLYPH_BASE, UML_LABEL_FONT, UML_LINE_H, UML_MIN_BOX_W, UML_NAME_FONT, UML_PADDING, UML_PORT_PITCH, UML_RELATIONSHIPS, UML_ROW_GAP, UML_SELF_LOOP_BASE, UML_SELF_LOOP_W, UML_SEP_PAD, UML_SVG_LABELS_EN, UML_TITLE_LABELS_EN, UML_VISIBILITIES, UML_VIS_GLYPH, UmlValidationError, computeUmlLayout, sideCapacity, sideCapacityIssue, umlIssues, umlLayoutSvg, umlSvg, validateUml };
+//# sourceMappingURL=chunk-MIJTBYX2.js.map
+//# sourceMappingURL=chunk-MIJTBYX2.js.map