schematex 0.1.1 → 0.2.0

package/dist/chunk-HAIBAF6J.cjs

@@ -0,0 +1,1880 @@
+'use strict';
+
+var chunkS6VPECM3_cjs = require('./chunk-S6VPECM3.cjs');
+var chunkHDKDQAEQ_cjs = require('./chunk-HDKDQAEQ.cjs');
+
+// src/diagrams/flowchart/parser.ts
+var FlowchartParseError = class extends Error {
+  constructor(message, line2, col) {
+    super(`[line ${line2}:${col}] ${message}`);
+    this.line = line2;
+    this.col = col;
+    this.name = "FlowchartParseError";
+  }
+  line;
+  col;
+};
+var DIRECTIONS = /* @__PURE__ */ new Set(["TB", "TD", "BT", "LR", "RL"]);
+function parseShapeSuffix(line2, pos) {
+  const ch = line2[pos];
+  if (ch === void 0) return null;
+  if (ch === ">") {
+    const end = line2.indexOf("]", pos + 1);
+    if (end < 0) return null;
+    return { shape: "asymmetric", label: line2.slice(pos + 1, end).trim(), end: end + 1 };
+  }
+  if (ch === "(" && line2[pos + 1] === "(" && line2[pos + 2] === "(") {
+    const end = line2.indexOf(")))", pos + 3);
+    if (end < 0) return null;
+    return { shape: "double-circle", label: line2.slice(pos + 3, end).trim(), end: end + 3 };
+  }
+  if (ch === "(" && line2[pos + 1] === "[") {
+    const end = line2.indexOf("])", pos + 2);
+    if (end < 0) return null;
+    return { shape: "stadium", label: line2.slice(pos + 2, end).trim(), end: end + 2 };
+  }
+  if (ch === "(" && line2[pos + 1] === "(") {
+    const end = line2.indexOf("))", pos + 2);
+    if (end < 0) return null;
+    return { shape: "circle", label: line2.slice(pos + 2, end).trim(), end: end + 2 };
+  }
+  if (ch === "[" && line2[pos + 1] === "[") {
+    const end = line2.indexOf("]]", pos + 2);
+    if (end < 0) return null;
+    return { shape: "subroutine", label: line2.slice(pos + 2, end).trim(), end: end + 2 };
+  }
+  if (ch === "[" && line2[pos + 1] === "(") {
+    const end = line2.indexOf(")]", pos + 2);
+    if (end < 0) return null;
+    return { shape: "cylinder", label: line2.slice(pos + 2, end).trim(), end: end + 2 };
+  }
+  if (ch === "{" && line2[pos + 1] === "{") {
+    const end = line2.indexOf("}}", pos + 2);
+    if (end < 0) return null;
+    return { shape: "hexagon", label: line2.slice(pos + 2, end).trim(), end: end + 2 };
+  }
+  if (ch === "[" && line2[pos + 1] === "/") {
+    const endSlash = line2.indexOf("\\]", pos + 2);
+    if (endSlash >= 0) {
+      return { shape: "trapezoid", label: line2.slice(pos + 2, endSlash).trim(), end: endSlash + 2 };
+    }
+    const end = line2.indexOf("/]", pos + 2);
+    if (end < 0) return null;
+    return { shape: "parallelogram", label: line2.slice(pos + 2, end).trim(), end: end + 2 };
+  }
+  if (ch === "[" && line2[pos + 1] === "\\") {
+    const endFwd = line2.indexOf("/]", pos + 2);
+    if (endFwd >= 0) {
+      return { shape: "trapezoid-alt", label: line2.slice(pos + 2, endFwd).trim(), end: endFwd + 2 };
+    }
+    const end = line2.indexOf("\\]", pos + 2);
+    if (end < 0) return null;
+    return { shape: "parallelogram-alt", label: line2.slice(pos + 2, end).trim(), end: end + 2 };
+  }
+  if (ch === "[") {
+    const end = line2.indexOf("]", pos + 1);
+    if (end < 0) return null;
+    return { shape: "rect", label: line2.slice(pos + 1, end).trim(), end: end + 1 };
+  }
+  if (ch === "(") {
+    const end = line2.indexOf(")", pos + 1);
+    if (end < 0) return null;
+    return { shape: "round", label: line2.slice(pos + 1, end).trim(), end: end + 1 };
+  }
+  if (ch === "{") {
+    const end = line2.indexOf("}", pos + 1);
+    if (end < 0) return null;
+    return { shape: "diamond", label: line2.slice(pos + 1, end).trim(), end: end + 1 };
+  }
+  return null;
+}
+var ID_CHAR = /[A-Za-z0-9_-]/;
+function parseEdgeOp(line2, pos) {
+  while (pos < line2.length && line2[pos] === " ") pos++;
+  const rest = line2.slice(pos);
+  const bi = rest.startsWith("<");
+  const i = bi ? 1 : 0;
+  if (rest[i] === "=") {
+    const m = /^(=+)(?:([^=<>]*)(=+))?(>)?/.exec(rest.slice(i));
+    if (!m) return null;
+    const full = m[0];
+    const inlineLabel = m[2]?.trim();
+    const hasArrow = m[4] === ">";
+    return {
+      kind: "thick",
+      bidirectional: bi && hasArrow,
+      end: pos + i + full.length,
+      inlineLabel: inlineLabel && inlineLabel.length > 0 ? inlineLabel : void 0
+    };
+  }
+  if (rest[i] === "-") {
+    const dm = /^-\.+/.exec(rest.slice(i));
+    if (dm) {
+      const mWithLabel = /^(-\.+)([^.\-<>]+)(\.+->|\.+-)/.exec(rest.slice(i));
+      if (mWithLabel) {
+        const full = mWithLabel[0];
+        const label = mWithLabel[2]?.trim();
+        const hasArrow = mWithLabel[3].endsWith(">");
+        return {
+          kind: "dotted",
+          bidirectional: bi && hasArrow,
+          end: pos + i + full.length,
+          inlineLabel: label && label.length > 0 ? label : void 0
+        };
+      }
+      const mPlain2 = /^(-\.+)(->|-)?/.exec(rest.slice(i));
+      if (mPlain2) {
+        const full = mPlain2[0];
+        const hasArrow = mPlain2[2] === "->";
+        return { kind: "dotted", bidirectional: bi && hasArrow, end: pos + i + full.length };
+      }
+      return null;
+    }
+    const mLabeled = /^(-{2,})([^-<>|=][^-<>|=]*?)(-{2,})(>|x|o)?/.exec(rest.slice(i));
+    if (mLabeled) {
+      const full = mLabeled[0];
+      const label = mLabeled[2]?.trim();
+      const endCh = mLabeled[4];
+      const kind = endCh === "x" ? "crossed" : endCh === "o" ? "round-end" : endCh === ">" ? "solid" : "none";
+      return {
+        kind,
+        bidirectional: bi && endCh === ">",
+        end: pos + i + full.length,
+        inlineLabel: label && label.length > 0 ? label : void 0
+      };
+    }
+    const mPlain = /^(-{2,})(>|x|o)?/.exec(rest.slice(i));
+    if (mPlain) {
+      const full = mPlain[0];
+      const endCh = mPlain[2];
+      const kind = endCh === "x" ? "crossed" : endCh === "o" ? "round-end" : endCh === ">" ? "solid" : "none";
+      return { kind, bidirectional: bi && endCh === ">", end: pos + i + full.length };
+    }
+  }
+  return null;
+}
+function parseNodeRef(line2, pos) {
+  let i = pos;
+  while (i < line2.length && ID_CHAR.test(line2[i])) i++;
+  if (i === pos) return null;
+  const id = line2.slice(pos, i);
+  const shape = parseShapeSuffix(line2, i);
+  if (shape) {
+    return { ref: { id, shape: shape.shape, label: shape.label }, end: shape.end };
+  }
+  return { ref: { id }, end: i };
+}
+function parsePipeLabel(line2, pos) {
+  if (line2[pos] !== "|") return null;
+  const end = line2.indexOf("|", pos + 1);
+  if (end < 0) return null;
+  return { label: line2.slice(pos + 1, end).trim(), end: end + 1 };
+}
+function skipSpaces(line2, pos) {
+  while (pos < line2.length && (line2[pos] === " " || line2[pos] === "	")) pos++;
+  return pos;
+}
+function registerNode(ref, nodes) {
+  if (ref.shape && ref.label !== void 0) {
+    nodes.push({ id: ref.id, shape: ref.shape, label: ref.label });
+  } else {
+    nodes.push({ id: ref.id, shape: "rect", label: ref.id });
+  }
+}
+function parseNodeGroup(line2, startPos, lineNo, nodes) {
+  let pos = skipSpaces(line2, startPos);
+  const first = parseNodeRef(line2, pos);
+  if (!first) {
+    throw new FlowchartParseError(
+      `expected node identifier, got ${JSON.stringify(line2.slice(pos, pos + 10))}`,
+      lineNo,
+      pos + 1
+    );
+  }
+  registerNode(first.ref, nodes);
+  const refs = [first.ref];
+  pos = first.end;
+  while (true) {
+    const p2 = skipSpaces(line2, pos);
+    if (line2[p2] !== "&") break;
+    const p3 = skipSpaces(line2, p2 + 1);
+    const next = parseNodeRef(line2, p3);
+    if (!next) break;
+    registerNode(next.ref, nodes);
+    refs.push(next.ref);
+    pos = next.end;
+  }
+  return { refs, end: pos };
+}
+function parseChainStatement(line2, lineNo) {
+  const nodes = [];
+  const edges = [];
+  let pos = skipSpaces(line2, 0);
+  const firstGroup = parseNodeGroup(line2, pos, lineNo, nodes);
+  let prevGroup = firstGroup.refs;
+  pos = firstGroup.end;
+  while (pos < line2.length) {
+    pos = skipSpaces(line2, pos);
+    if (pos >= line2.length) break;
+    const op = parseEdgeOp(line2, pos);
+    if (!op) {
+      const tail = line2.slice(pos).trim();
+      if (tail.length > 0) {
+        throw new FlowchartParseError(
+          `expected edge operator, got ${JSON.stringify(tail.slice(0, 10))}`,
+          lineNo,
+          pos + 1
+        );
+      }
+      break;
+    }
+    pos = op.end;
+    pos = skipSpaces(line2, pos);
+    let label = op.inlineLabel;
+    const pipe = parsePipeLabel(line2, pos);
+    if (pipe) {
+      label = pipe.label;
+      pos = pipe.end;
+    }
+    pos = skipSpaces(line2, pos);
+    const targetGroup = parseNodeGroup(line2, pos, lineNo, nodes);
+    pos = targetGroup.end;
+    for (const from of prevGroup) {
+      for (const to of targetGroup.refs) {
+        edges.push({
+          from: from.id,
+          to: to.id,
+          kind: op.kind,
+          label,
+          bidirectional: op.bidirectional
+        });
+      }
+    }
+    prevGroup = targetGroup.refs;
+  }
+  return { nodes, edges };
+}
+function parseSubgraphHeader(rest, idx) {
+  const defaultId = `sg_${idx}`;
+  const s = rest.trim();
+  if (!s) return { id: defaultId, label: defaultId, children: [], subgraphs: [] };
+  const idBracket = /^(\w[\w-]*)\s+\[([^\]]*)\]$/.exec(s);
+  if (idBracket) return { id: idBracket[1], label: idBracket[2], children: [], subgraphs: [] };
+  const idQuoted = /^(\w[\w-]*)\s+"([^"]*)"$/.exec(s);
+  if (idQuoted) return { id: idQuoted[1], label: idQuoted[2], children: [], subgraphs: [] };
+  const quotedOnly = /^"([^"]*)"$/.exec(s);
+  if (quotedOnly) return { id: defaultId, label: quotedOnly[1], children: [], subgraphs: [] };
+  const plainId = s.split(/\s/)[0];
+  return { id: plainId, label: plainId, children: [], subgraphs: [] };
+}
+function normalizeDirection(dir) {
+  const up = dir.toUpperCase();
+  if (up === "TD") return "TB";
+  if (up === "TB" || up === "BT" || up === "LR" || up === "RL") return up;
+  return "TB";
+}
+function parseCssProps(s) {
+  const props = {};
+  for (const part of s.split(",")) {
+    const colon = part.indexOf(":");
+    if (colon < 0) continue;
+    const key = part.slice(0, colon).trim();
+    const val = part.slice(colon + 1).trim();
+    if (key) props[key] = val;
+  }
+  return props;
+}
+function parseFlowchart(source) {
+  const lines = source.replace(/\r\n/g, "\n").split("\n");
+  const ast = {
+    type: "flowchart",
+    direction: "TB",
+    nodes: [],
+    edges: [],
+    subgraphs: [],
+    classDefs: [],
+    linkStyles: /* @__PURE__ */ new Map()
+  };
+  const nodeMap = /* @__PURE__ */ new Map();
+  let headerIdx = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const t = lines[i].trim();
+    if (t.length === 0 || t.startsWith("%%")) continue;
+    headerIdx = i;
+    break;
+  }
+  if (headerIdx < 0) throw new FlowchartParseError("empty flowchart source", 1, 1);
+  const header = lines[headerIdx].trim();
+  const headerMatch = /^(flowchart|graph)(?:\s+(\w+))?(?:\s+(.*))?$/i.exec(header);
+  if (!headerMatch) {
+    throw new FlowchartParseError(
+      `expected 'flowchart' or 'graph' header, got ${JSON.stringify(header)}`,
+      headerIdx + 1,
+      1
+    );
+  }
+  const dirTok = headerMatch[2];
+  if (dirTok) {
+    if (!DIRECTIONS.has(dirTok.toUpperCase())) {
+      throw new FlowchartParseError(`unknown direction ${JSON.stringify(dirTok)}`, headerIdx + 1, 1);
+    }
+    ast.direction = normalizeDirection(dirTok);
+  }
+  const extra = headerMatch[3]?.trim();
+  if (extra) {
+    const mQuoted = /^"([^"]*)"$/.exec(extra);
+    ast.title = mQuoted ? mQuoted[1] : extra;
+  }
+  const subgraphStack = [];
+  for (let i = headerIdx + 1; i < lines.length; i++) {
+    const raw = lines[i];
+    const trimmed = raw.trim();
+    if (trimmed.length === 0 || trimmed.startsWith("%%")) continue;
+    const sgMatch = /^subgraph(?:\s+(.*))?$/.exec(trimmed);
+    if (sgMatch) {
+      const sg = parseSubgraphHeader(sgMatch[1] ?? "", ast.subgraphs.length);
+      let finalId = sg.id;
+      let collision = 0;
+      while (ast.subgraphs.some((s) => s.id === finalId)) {
+        finalId = `${sg.id}_${++collision}`;
+      }
+      sg.id = finalId;
+      ast.subgraphs.push(sg);
+      if (subgraphStack.length > 0) {
+        const parent = subgraphStack[subgraphStack.length - 1];
+        if (!parent.subgraphs.includes(sg.id)) parent.subgraphs.push(sg.id);
+      }
+      subgraphStack.push(sg);
+      continue;
+    }
+    const dirMatch = /^direction\s+(TB|TD|BT|LR|RL)$/i.exec(trimmed);
+    if (dirMatch && subgraphStack.length > 0) {
+      subgraphStack[subgraphStack.length - 1].direction = normalizeDirection(dirMatch[1]);
+      continue;
+    }
+    if (trimmed === "end" && subgraphStack.length > 0) {
+      subgraphStack.pop();
+      continue;
+    }
+    const classMatch = /^class\s+([\w,\s]+?)\s+(\w[\w-]*)\s*$/.exec(trimmed);
+    if (classMatch) {
+      const idList = classMatch[1].split(/[,\s]+/).map((s) => s.trim()).filter((s) => s.length > 0);
+      const className = classMatch[2];
+      for (const nid of idList) {
+        const existing = nodeMap.get(nid);
+        if (!existing) {
+          const node = { id: nid, shape: "rect", label: nid, classes: [className] };
+          nodeMap.set(nid, node);
+          ast.nodes.push(node);
+        } else {
+          existing.classes = [...existing.classes ?? [], className];
+        }
+      }
+      continue;
+    }
+    const classDefMatch = /^classDef\s+(\w[\w-]*)\s+(.+)$/.exec(trimmed);
+    if (classDefMatch) {
+      const cdef = {
+        id: classDefMatch[1],
+        props: parseCssProps(classDefMatch[2])
+      };
+      const existIdx = ast.classDefs.findIndex((c) => c.id === cdef.id);
+      if (existIdx >= 0) ast.classDefs[existIdx] = cdef;
+      else ast.classDefs.push(cdef);
+      continue;
+    }
+    const styleMatch = /^style\s+(\w[\w-]*)\s+(.+)$/.exec(trimmed);
+    if (styleMatch) {
+      const nid = styleMatch[1];
+      const props = parseCssProps(styleMatch[2]);
+      const existing = nodeMap.get(nid);
+      if (existing) {
+        existing.style = { ...existing.style ?? {}, ...props };
+      } else {
+        const node = { id: nid, shape: "rect", label: nid, style: props };
+        nodeMap.set(nid, node);
+        ast.nodes.push(node);
+      }
+      continue;
+    }
+    if (/^linkStyle\s/.test(trimmed)) continue;
+    let parsed;
+    try {
+      parsed = parseChainStatement(trimmed, i + 1);
+    } catch (e) {
+      if (e instanceof FlowchartParseError) throw e;
+      continue;
+    }
+    const currentSg = subgraphStack.length > 0 ? subgraphStack[subgraphStack.length - 1] : null;
+    for (const ndef of parsed.nodes) {
+      const existing = nodeMap.get(ndef.id);
+      if (!existing) {
+        const node = {
+          id: ndef.id,
+          shape: ndef.shape,
+          label: ndef.label,
+          parent: currentSg?.id
+        };
+        nodeMap.set(ndef.id, node);
+        ast.nodes.push(node);
+        if (currentSg && !currentSg.children.includes(ndef.id)) {
+          currentSg.children.push(ndef.id);
+        }
+      } else {
+        if (ndef.label !== ndef.id) existing.label = ndef.label;
+        if (ndef.shape !== "rect") existing.shape = ndef.shape;
+        if (currentSg && !existing.parent) {
+          existing.parent = currentSg.id;
+          if (!currentSg.children.includes(existing.id)) currentSg.children.push(existing.id);
+        }
+      }
+    }
+    for (const e of parsed.edges) {
+      const edge = {
+        from: e.from,
+        to: e.to,
+        kind: e.kind,
+        label: e.label,
+        arrowEnd: e.kind === "solid" || e.kind === "thick" || e.kind === "dotted" || e.kind === "bidirectional" ? "arrow" : e.kind === "crossed" ? "cross" : e.kind === "round-end" ? "circle" : "none",
+        arrowStart: e.bidirectional ? "arrow" : "none"
+      };
+      ast.edges.push(edge);
+    }
+  }
+  return ast;
+}
+
+// src/core/layered/bk.ts
+function bkXCoords(layers, segments, nodeSep) {
+  if (layers.length === 0) return /* @__PURE__ */ new Map();
+  const preds = /* @__PURE__ */ new Map();
+  const succs = /* @__PURE__ */ new Map();
+  const indexInLayer = /* @__PURE__ */ new Map();
+  const nodeById = /* @__PURE__ */ new Map();
+  for (const layer of layers) {
+    for (let i = 0; i < layer.length; i++) {
+      const n = layer[i];
+      indexInLayer.set(n.id, i);
+      nodeById.set(n.id, n);
+      preds.set(n.id, []);
+      succs.set(n.id, []);
+    }
+  }
+  for (const [u, v] of segments) {
+    if (!nodeById.has(u) || !nodeById.has(v)) continue;
+    succs.get(u).push(v);
+    preds.get(v).push(u);
+  }
+  const conflicts = findType1Conflicts(layers, preds, nodeById);
+  const xss = {};
+  for (const vertDir of ["u", "d"]) {
+    const adjNeighbors = vertDir === "u" ? (v) => preds.get(v) ?? [] : (v) => succs.get(v) ?? [];
+    const flippedV = vertDir === "u" ? layers : layers.slice().reverse();
+    for (const horizDir of ["l", "r"]) {
+      const flippedH = horizDir === "l" ? flippedV : flippedV.map((l) => l.slice().reverse());
+      const { root, align } = verticalAlignment(
+        flippedH,
+        conflicts,
+        adjNeighbors
+      );
+      let xs = horizontalCompaction(flippedH, root, align, nodeById, nodeSep);
+      if (horizDir === "r") {
+        const neg = /* @__PURE__ */ new Map();
+        for (const [k, v] of xs) neg.set(k, -v);
+        xs = neg;
+      }
+      xss[vertDir + horizDir] = xs;
+    }
+  }
+  alignCoordinates(xss, findSmallestWidthAlignment(xss, nodeById));
+  return balance(xss);
+}
+function findType1Conflicts(layers, preds, nodeById) {
+  const conflicts = /* @__PURE__ */ new Set();
+  if (layers.length < 2) return conflicts;
+  for (let li = 1; li < layers.length; li++) {
+    const prev = layers[li - 1];
+    const layer = layers[li];
+    const prevIdx = /* @__PURE__ */ new Map();
+    prev.forEach((n, i) => prevIdx.set(n.id, i));
+    let k0 = 0;
+    let scanPos = 0;
+    const lastIdx = layer.length - 1;
+    for (let i1 = 0; i1 < layer.length; i1++) {
+      const v = layer[i1];
+      let w = null;
+      if (v.isDummy) {
+        for (const p of preds.get(v.id) ?? []) {
+          if (nodeById.get(p)?.isDummy && prevIdx.has(p)) {
+            w = p;
+            break;
+          }
+        }
+      }
+      if (w !== null || i1 === lastIdx) {
+        const k1 = w !== null ? prevIdx.get(w) : prev.length - 1;
+        for (let i = scanPos; i <= i1; i++) {
+          const vv = layer[i];
+          for (const u of preds.get(vv.id) ?? []) {
+            const uPos = prevIdx.get(u);
+            if (uPos === void 0) continue;
+            if (uPos < k0 || uPos > k1) {
+              conflicts.add(conflictKey(u, vv.id));
+            }
+          }
+        }
+        scanPos = i1 + 1;
+        k0 = k1;
+      }
+    }
+  }
+  return conflicts;
+}
+function conflictKey(a, b) {
+  return a < b ? `${a}\0${b}` : `${b}\0${a}`;
+}
+function hasConflict(conflicts, a, b) {
+  return conflicts.has(conflictKey(a, b));
+}
+function verticalAlignment(layers, conflicts, neighborsOf) {
+  const root = /* @__PURE__ */ new Map();
+  const align = /* @__PURE__ */ new Map();
+  const pos = /* @__PURE__ */ new Map();
+  for (const layer of layers) {
+    for (let i = 0; i < layer.length; i++) {
+      const v = layer[i].id;
+      root.set(v, v);
+      align.set(v, v);
+      pos.set(v, i);
+    }
+  }
+  for (const layer of layers) {
+    let prevIdx = -1;
+    for (const vn of layer) {
+      const v = vn.id;
+      const ws = neighborsOf(v).slice();
+      if (ws.length === 0) continue;
+      ws.sort((a, b) => (pos.get(a) ?? 0) - (pos.get(b) ?? 0));
+      const mp = (ws.length - 1) / 2;
+      const mids = [Math.floor(mp), Math.ceil(mp)];
+      for (const mi of mids) {
+        if (align.get(v) !== v) continue;
+        const w = ws[mi];
+        if (hasConflict(conflicts, w, v)) continue;
+        const wPos = pos.get(w) ?? 0;
+        if (wPos <= prevIdx) continue;
+        align.set(w, v);
+        root.set(v, root.get(w));
+        align.set(v, root.get(v));
+        prevIdx = wPos;
+      }
+    }
+  }
+  return { root, align };
+}
+function horizontalCompaction(layers, root, align, nodeById, nodeSep) {
+  const xs = /* @__PURE__ */ new Map();
+  const sink = /* @__PURE__ */ new Map();
+  const shift = /* @__PURE__ */ new Map();
+  for (const layer of layers) {
+    for (const v of layer) {
+      sink.set(v.id, v.id);
+      shift.set(v.id, Number.POSITIVE_INFINITY);
+    }
+  }
+  const indexInLayer = /* @__PURE__ */ new Map();
+  const layerOf = /* @__PURE__ */ new Map();
+  for (let li = 0; li < layers.length; li++) {
+    for (let i = 0; i < layers[li].length; i++) {
+      const id = layers[li][i].id;
+      indexInLayer.set(id, i);
+      layerOf.set(id, li);
+    }
+  }
+  const sep = (uId, vId) => {
+    const u = nodeById.get(uId);
+    const v = nodeById.get(vId);
+    return u.width / 2 + nodeSep + v.width / 2;
+  };
+  const placeBlock = (v) => {
+    if (xs.has(v)) return;
+    xs.set(v, 0);
+    let w = v;
+    do {
+      const wi = indexInLayer.get(w);
+      const wLayer = layerOf.get(w);
+      if (wi > 0) {
+        const pred = layers[wLayer][wi - 1].id;
+        const u = root.get(pred);
+        placeBlock(u);
+        if (sink.get(v) === v) sink.set(v, sink.get(u));
+        if (sink.get(v) !== sink.get(u)) {
+          const candidate = xs.get(v) - xs.get(u) - sep(pred, w);
+          const cur = shift.get(sink.get(u)) ?? Number.POSITIVE_INFINITY;
+          shift.set(sink.get(u), Math.min(cur, candidate));
+        } else {
+          const candidate = xs.get(u) + sep(pred, w);
+          if (candidate > xs.get(v)) xs.set(v, candidate);
+        }
+      }
+      w = align.get(w);
+    } while (w !== v);
+  };
+  for (const layer of layers) {
+    for (const v of layer) {
+      if (root.get(v.id) === v.id) placeBlock(v.id);
+    }
+  }
+  const result = /* @__PURE__ */ new Map();
+  for (const layer of layers) {
+    for (const v of layer) {
+      const r = root.get(v.id);
+      const rx = xs.get(r) ?? 0;
+      const s = shift.get(sink.get(r));
+      const sx = s !== void 0 && s !== Number.POSITIVE_INFINITY ? s : 0;
+      result.set(v.id, rx + sx);
+    }
+  }
+  return result;
+}
+function findSmallestWidthAlignment(xss, nodeById, _nodeSep) {
+  let best = null;
+  let bestWidth = Number.POSITIVE_INFINITY;
+  for (const key of Object.keys(xss)) {
+    const xs = xss[key];
+    let minX = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    for (const [id, x] of xs) {
+      const n = nodeById.get(id);
+      if (!n) continue;
+      minX = Math.min(minX, x - n.width / 2);
+      maxX = Math.max(maxX, x + n.width / 2);
+    }
+    const w = maxX - minX;
+    if (w < bestWidth) {
+      bestWidth = w;
+      best = xs;
+    }
+  }
+  return best ?? /* @__PURE__ */ new Map();
+}
+function alignCoordinates(xss, ref) {
+  let refMin = Number.POSITIVE_INFINITY;
+  let refMax = Number.NEGATIVE_INFINITY;
+  for (const [, v] of ref) {
+    refMin = Math.min(refMin, v);
+    refMax = Math.max(refMax, v);
+  }
+  for (const key of Object.keys(xss)) {
+    const xs = xss[key];
+    if (xs === ref) continue;
+    let xMin = Number.POSITIVE_INFINITY;
+    let xMax = Number.NEGATIVE_INFINITY;
+    for (const [, v] of xs) {
+      xMin = Math.min(xMin, v);
+      xMax = Math.max(xMax, v);
+    }
+    const delta = key.endsWith("r") ? refMax - xMax : refMin - xMin;
+    if (delta === 0) continue;
+    for (const [k, v] of xs) xs.set(k, v + delta);
+  }
+}
+function balance(xss) {
+  const keys = Object.keys(xss);
+  const result = /* @__PURE__ */ new Map();
+  if (keys.length === 0) return result;
+  const ids = /* @__PURE__ */ new Set();
+  for (const k of keys) for (const id of xss[k].keys()) ids.add(id);
+  for (const id of ids) {
+    const vals = [];
+    for (const k of keys) {
+      const v = xss[k].get(id);
+      if (v !== void 0) vals.push(v);
+    }
+    vals.sort((a, b) => a - b);
+    const n = vals.length;
+    if (n === 0) continue;
+    if (n % 2 === 0) {
+      result.set(id, (vals[n / 2 - 1] + vals[n / 2]) / 2);
+    } else {
+      result.set(id, vals[(n - 1) / 2]);
+    }
+  }
+  return result;
+}
+
+// src/diagrams/flowchart/layout.ts
+var FC_CONST = {
+  nodeWidth: 120,
+  nodeHeight: 44,
+  nodeSpacingX: 32,
+  // cross-flow gap between nodes in same layer
+  layerSpacingY: 56,
+  // flow-direction gap between layers
+  dummyWidth: 1,
+  padding: 24,
+  charWidth: 6.8,
+  // approx font-size 12 proportional width
+  labelHPad: 16,
+  minNodeWidth: 72,
+  maxLabelWidth: 220,
+  crossingSweepIters: 24
+};
+function greedyFAS(nodeIds, edges) {
+  const outAdj = /* @__PURE__ */ new Map();
+  const inAdj = /* @__PURE__ */ new Map();
+  for (const id of nodeIds) {
+    outAdj.set(id, /* @__PURE__ */ new Set());
+    inAdj.set(id, /* @__PURE__ */ new Set());
+  }
+  for (const e of edges) {
+    if (e.from === e.to) continue;
+    outAdj.get(e.from)?.add(e.to);
+    inAdj.get(e.to)?.add(e.from);
+  }
+  const s1 = [];
+  const s2 = [];
+  const remaining = new Set(nodeIds);
+  while (remaining.size > 0) {
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const v of Array.from(remaining)) {
+        if ((outAdj.get(v)?.size ?? 0) === 0) {
+          s2.unshift(v);
+          removeVertex(v, remaining, outAdj, inAdj);
+          changed = true;
+        }
+      }
+    }
+    changed = true;
+    while (changed) {
+      changed = false;
+      for (const v of Array.from(remaining)) {
+        if ((inAdj.get(v)?.size ?? 0) === 0) {
+          s1.push(v);
+          removeVertex(v, remaining, outAdj, inAdj);
+          changed = true;
+        }
+      }
+    }
+    if (remaining.size === 0) break;
+    let best = null;
+    let bestScore = -Infinity;
+    for (const v of remaining) {
+      const score = (outAdj.get(v)?.size ?? 0) - (inAdj.get(v)?.size ?? 0);
+      if (score > bestScore) {
+        bestScore = score;
+        best = v;
+      }
+    }
+    if (best !== null) {
+      s1.push(best);
+      removeVertex(best, remaining, outAdj, inAdj);
+    }
+  }
+  const ordering = [...s1, ...s2];
+  const rank = /* @__PURE__ */ new Map();
+  ordering.forEach((id, i) => rank.set(id, i));
+  const feedback = /* @__PURE__ */ new Set();
+  edges.forEach((e, i) => {
+    if (e.from === e.to) {
+      feedback.add(i);
+      return;
+    }
+    const ru = rank.get(e.from);
+    const rv = rank.get(e.to);
+    if (ru !== void 0 && rv !== void 0 && ru > rv) {
+      feedback.add(i);
+    }
+  });
+  return feedback;
+}
+function removeVertex(v, remaining, outAdj, inAdj) {
+  remaining.delete(v);
+  const outs = outAdj.get(v);
+  if (outs) {
+    for (const w of outs) inAdj.get(w)?.delete(v);
+  }
+  const ins = inAdj.get(v);
+  if (ins) {
+    for (const u of ins) outAdj.get(u)?.delete(v);
+  }
+  outAdj.delete(v);
+  inAdj.delete(v);
+}
+function longestPathLayers(nodeIds, edges) {
+  const layer = /* @__PURE__ */ new Map();
+  for (const id of nodeIds) layer.set(id, 0);
+  const outAdj = /* @__PURE__ */ new Map();
+  const inDeg = /* @__PURE__ */ new Map();
+  for (const id of nodeIds) {
+    outAdj.set(id, []);
+    inDeg.set(id, 0);
+  }
+  for (const e of edges) {
+    if (e.from === e.to) continue;
+    outAdj.get(e.from)?.push(e.to);
+    inDeg.set(e.to, (inDeg.get(e.to) ?? 0) + 1);
+  }
+  const queue = [];
+  for (const id of nodeIds) {
+    if ((inDeg.get(id) ?? 0) === 0) queue.push(id);
+  }
+  const order = [];
+  const remIn = new Map(inDeg);
+  while (queue.length > 0) {
+    const v = queue.shift();
+    order.push(v);
+    for (const w of outAdj.get(v) ?? []) {
+      const d = (remIn.get(w) ?? 0) - 1;
+      remIn.set(w, d);
+      if (d === 0) queue.push(w);
+    }
+  }
+  if (order.length !== nodeIds.length) {
+    for (const id of nodeIds) {
+      if (!order.includes(id)) order.push(id);
+    }
+  }
+  for (const v of order) {
+    for (const w of outAdj.get(v) ?? []) {
+      const lv = layer.get(v) ?? 0;
+      const lw = layer.get(w) ?? 0;
+      if (lw < lv + 1) layer.set(w, lv + 1);
+    }
+  }
+  return layer;
+}
+function insertDummies(ledges, layerMap, genDummyId) {
+  const dummyIds = [];
+  const updated = [];
+  for (const e of ledges) {
+    if (e.from === e.to) {
+      updated.push(e);
+      continue;
+    }
+    const lu = layerMap.get(e.from) ?? 0;
+    const lv = layerMap.get(e.to) ?? 0;
+    const diff = Math.abs(lv - lu);
+    if (diff <= 1) {
+      e.chain = [e.from, e.to];
+      updated.push(e);
+      continue;
+    }
+    const step = lv > lu ? 1 : -1;
+    const chain = [e.from];
+    let curLayer = lu + step;
+    while (curLayer !== lv) {
+      const d = genDummyId();
+      layerMap.set(d, curLayer);
+      dummyIds.push(d);
+      chain.push(d);
+      curLayer += step;
+    }
+    chain.push(e.to);
+    e.chain = chain;
+    updated.push(e);
+  }
+  return { dummyIds, updatedEdges: updated };
+}
+function dfsInitOrder(layers, segments) {
+  const layerOf = /* @__PURE__ */ new Map();
+  layers.forEach((l, i) => l.forEach((id) => layerOf.set(id, i)));
+  const succ = /* @__PURE__ */ new Map();
+  for (const [u, v] of segments) {
+    if (!succ.has(u)) succ.set(u, []);
+    succ.get(u).push(v);
+  }
+  const order = layers.map(() => []);
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (id) => {
+    if (seen.has(id)) return;
+    seen.add(id);
+    const l = layerOf.get(id);
+    if (l === void 0) return;
+    order[l].push(id);
+    for (const n of succ.get(id) ?? []) visit(n);
+  };
+  for (const id of layers[0] ?? []) visit(id);
+  for (const layer of layers) {
+    for (const id of layer) if (!seen.has(id)) {
+      seen.add(id);
+      const l = layerOf.get(id);
+      order[l].push(id);
+    }
+  }
+  return order;
+}
+function barycenterReorder(layer, fixed, neighborsOf, biasRight) {
+  const fixedIdx = /* @__PURE__ */ new Map();
+  fixed.forEach((id, i) => fixedIdx.set(id, i));
+  const scored = layer.map((id, i) => {
+    const neighbors = neighborsOf(id).map((n) => fixedIdx.get(n)).filter((p) => p !== void 0);
+    if (neighbors.length === 0) return { id, score: -1, orig: i, hasNeighbors: false };
+    const sum = neighbors.reduce((s, n) => s + n, 0);
+    return { id, score: sum / neighbors.length, orig: i, hasNeighbors: true };
+  });
+  const withNbrs = scored.filter((s) => s.hasNeighbors);
+  const withoutNbrs = scored.filter((s) => !s.hasNeighbors);
+  withNbrs.sort((a, b) => {
+    if (a.score !== b.score) return a.score - b.score;
+    return biasRight ? b.orig - a.orig : a.orig - b.orig;
+  });
+  const result = new Array(layer.length);
+  for (const s of withoutNbrs) result[s.orig] = s;
+  let k = 0;
+  for (let i = 0; i < result.length; i++) {
+    if (result[i] !== void 0) continue;
+    result[i] = withNbrs[k++];
+  }
+  return result.map((s) => s.id);
+}
+function orderLayers(layers, segments) {
+  const succ = /* @__PURE__ */ new Map();
+  const pred = /* @__PURE__ */ new Map();
+  for (const layer of layers) for (const id of layer) {
+    succ.set(id, []);
+    pred.set(id, []);
+  }
+  for (const [u, v] of segments) {
+    succ.get(u)?.push(v);
+    pred.get(v)?.push(u);
+  }
+  let result = dfsInitOrder(layers, segments);
+  let bestCrossings = countCrossings(result, segments);
+  let best = result.map((l) => l.slice());
+  const maxStale = 4;
+  let stale = 0;
+  for (let iter = 0; iter < FC_CONST.crossingSweepIters && stale < maxStale; iter++) {
+    const down = iter % 2 === 0;
+    const biasRight = iter % 4 >= 2;
+    const next = result.map((l) => l.slice());
+    if (down) {
+      for (let i = 1; i < next.length; i++) {
+        next[i] = barycenterReorder(
+          next[i],
+          next[i - 1],
+          (id) => pred.get(id) ?? [],
+          biasRight
+        );
+      }
+    } else {
+      for (let i = next.length - 2; i >= 0; i--) {
+        next[i] = barycenterReorder(
+          next[i],
+          next[i + 1],
+          (id) => succ.get(id) ?? [],
+          biasRight
+        );
+      }
+    }
+    const c = countCrossings(next, segments);
+    if (c < bestCrossings) {
+      bestCrossings = c;
+      best = next.map((l) => l.slice());
+      stale = 0;
+    } else {
+      stale++;
+    }
+    result = next;
+  }
+  return best;
+}
+function countCrossings(layers, segments) {
+  let total = 0;
+  const layerIdx = layers.map((l) => {
+    const m = /* @__PURE__ */ new Map();
+    l.forEach((id, i) => m.set(id, i));
+    return m;
+  });
+  for (let i = 0; i < layers.length - 1; i++) {
+    const upper = layerIdx[i];
+    const lower = layerIdx[i + 1];
+    const n = layers[i + 1].length;
+    if (n === 0) continue;
+    const edges = [];
+    for (const [u, v] of segments) {
+      const iu = upper.get(u);
+      const iv = lower.get(v);
+      if (iu !== void 0 && iv !== void 0) edges.push([iu, iv]);
+    }
+    edges.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+    let firstIndex = 1;
+    while (firstIndex < n) firstIndex <<= 1;
+    const treeSize = 2 * firstIndex - 1;
+    firstIndex -= 1;
+    const tree = new Uint32Array(treeSize);
+    for (const [, iv] of edges) {
+      let idx = iv + firstIndex;
+      tree[idx] += 1;
+      let weightSum = 0;
+      while (idx > 0) {
+        if (idx % 2) weightSum += tree[idx + 1] ?? 0;
+        idx = idx - 1 >> 1;
+        tree[idx] += 1;
+      }
+      total += weightSum;
+    }
+  }
+  return total;
+}
+function laneBasedXCoords(layerNodes, pathOf, nodeSpacingX, segments) {
+  const INNER_PAD = 28;
+  const LANE_GAP = 36;
+  const laneOf = (id) => {
+    const p = pathOf(id);
+    return p.length > 0 ? p[0] : null;
+  };
+  const laneOrder = [];
+  const laneSeen = /* @__PURE__ */ new Set();
+  for (const layer of layerNodes) {
+    for (const n of layer) {
+      if (n.isDummy) continue;
+      const lane = laneOf(n.id);
+      if (!laneSeen.has(lane)) {
+        laneSeen.add(lane);
+        laneOrder.push(lane);
+      }
+    }
+  }
+  const lanesPerLayer = layerNodes.map(
+    (layer) => {
+      const m = /* @__PURE__ */ new Map();
+      for (const n of layer) {
+        if (n.isDummy) continue;
+        const lane = laneOf(n.id);
+        if (!m.has(lane)) m.set(lane, []);
+        m.get(lane).push(n);
+      }
+      return m;
+    }
+  );
+  const laneWidths = laneOrder.map((lane) => {
+    let maxInner = 0;
+    for (const layerLanes of lanesPerLayer) {
+      const members = layerLanes.get(lane) ?? [];
+      if (members.length === 0) continue;
+      const inner = members.reduce((s, n) => s + n.width, 0) + (members.length - 1) * nodeSpacingX;
+      if (inner > maxInner) maxInner = inner;
+    }
+    const pad = lane !== null ? 2 * INNER_PAD : 0;
+    return maxInner + pad;
+  });
+  const laneStartX = [];
+  {
+    let x = 0;
+    for (let i = 0; i < laneWidths.length; i++) {
+      laneStartX.push(x);
+      x += laneWidths[i];
+      if (i < laneWidths.length - 1) x += LANE_GAP;
+    }
+  }
+  const result = /* @__PURE__ */ new Map();
+  for (let li = 0; li < lanesPerLayer.length; li++) {
+    for (let laneIdx = 0; laneIdx < laneOrder.length; laneIdx++) {
+      const lane = laneOrder[laneIdx];
+      const members = lanesPerLayer[li].get(lane) ?? [];
+      if (members.length === 0) continue;
+      const laneW = laneWidths[laneIdx];
+      const laneStart = laneStartX[laneIdx];
+      const innerW = members.reduce((s, n) => s + n.width, 0) + (members.length - 1) * nodeSpacingX;
+      let cursor = laneStart + (laneW - innerW) / 2;
+      for (const n of members) {
+        result.set(n.id, cursor + n.width / 2);
+        cursor += n.width + nodeSpacingX;
+      }
+    }
+  }
+  for (let pass = 0; pass < 4; pass++) {
+    for (const layer of layerNodes) {
+      for (const n of layer) {
+        if (!n.isDummy) continue;
+        const neighbors = [];
+        for (const [u, v] of segments) {
+          if (v === n.id) {
+            const ux = result.get(u);
+            if (ux !== void 0) neighbors.push(ux);
+          }
+          if (u === n.id) {
+            const vx = result.get(v);
+            if (vx !== void 0) neighbors.push(vx);
+          }
+        }
+        if (neighbors.length === 0) {
+          if (!result.has(n.id)) result.set(n.id, 0);
+          continue;
+        }
+        neighbors.sort((a, b) => a - b);
+        result.set(n.id, neighbors[Math.floor(neighbors.length / 2)]);
+      }
+    }
+  }
+  return result;
+}
+function layoutFlowchart(ast) {
+  const dir = ast.direction;
+  const isHorizontalDir = dir === "LR" || dir === "RL";
+  const sizeOf = (n) => {
+    const labelW = Math.min(
+      FC_CONST.maxLabelWidth,
+      Math.ceil(n.label.length * FC_CONST.charWidth) + FC_CONST.labelHPad * 2
+    );
+    let shapeW = Math.max(FC_CONST.minNodeWidth, labelW);
+    let shapeH = FC_CONST.nodeHeight;
+    if (n.shape === "diamond") {
+      shapeW = Math.max(shapeW, labelW * 1.25);
+      shapeH = Math.max(shapeH, 52);
+    }
+    if (n.shape === "parallelogram" || n.shape === "parallelogram-alt" || n.shape === "trapezoid" || n.shape === "trapezoid-alt") {
+      shapeW += 20;
+    }
+    if (n.shape === "stadium" || n.shape === "round") {
+      shapeW = Math.max(shapeW, shapeH + 20);
+    }
+    if (n.shape === "circle" || n.shape === "double-circle") {
+      const side = Math.max(shapeW, shapeH) + 8;
+      shapeW = side;
+      shapeH = side;
+    }
+    if (n.shape === "hexagon") {
+      shapeW = Math.max(shapeW, labelW + 44);
+    }
+    if (n.shape === "cylinder") {
+      shapeH = Math.max(shapeH, 52);
+    }
+    if (n.shape === "subroutine") {
+      shapeW = Math.max(shapeW, labelW + 36);
+    }
+    return isHorizontalDir ? { w: shapeH, h: shapeW } : { w: shapeW, h: shapeH };
+  };
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const n of ast.nodes) nodeMap.set(n.id, n);
+  for (const e of ast.edges) {
+    for (const id of [e.from, e.to]) {
+      if (!nodeMap.has(id)) {
+        const implicit = { id, label: id, shape: "rect" };
+        nodeMap.set(id, implicit);
+        ast.nodes.push(implicit);
+      }
+    }
+  }
+  const allIds = Array.from(nodeMap.keys());
+  const feedbackIdx = greedyFAS(allIds, ast.edges);
+  const ledges = ast.edges.map((e, i) => {
+    const reversed = feedbackIdx.has(i) && e.from !== e.to;
+    return {
+      from: reversed ? e.to : e.from,
+      to: reversed ? e.from : e.to,
+      original: e,
+      isReversed: reversed,
+      chain: []
+    };
+  });
+  const layerMap = longestPathLayers(allIds, ledges);
+  let dummyCounter = 0;
+  const dummies = [];
+  const { updatedEdges } = insertDummies(ledges, layerMap, () => {
+    const id = `__dummy_${dummyCounter++}`;
+    dummies.push(id);
+    return id;
+  });
+  const lnodes = /* @__PURE__ */ new Map();
+  for (const id of allIds) {
+    const n = nodeMap.get(id);
+    const { w, h } = sizeOf(n);
+    lnodes.set(id, {
+      id,
+      node: n,
+      layer: layerMap.get(id) ?? 0,
+      order: 0,
+      width: w,
+      height: h,
+      isDummy: false
+    });
+  }
+  for (const id of dummies) {
+    lnodes.set(id, {
+      id,
+      layer: layerMap.get(id) ?? 0,
+      order: 0,
+      width: FC_CONST.dummyWidth,
+      height: 0,
+      isDummy: true
+    });
+  }
+  const maxLayer = Math.max(0, ...Array.from(layerMap.values()));
+  const layers = [];
+  for (let i = 0; i <= maxLayer; i++) layers.push([]);
+  for (const [id, layer] of layerMap) {
+    layers[layer].push(id);
+  }
+  const segments = [];
+  for (const e of updatedEdges) {
+    if (e.chain.length >= 2) {
+      for (let i = 0; i < e.chain.length - 1; i++) {
+        segments.push([e.chain[i], e.chain[i + 1]]);
+      }
+    }
+  }
+  let ordered = orderLayers(layers, segments);
+  const parentOf = /* @__PURE__ */ new Map();
+  for (const n of ast.nodes) parentOf.set(n.id, n.parent);
+  const sgParent = /* @__PURE__ */ new Map();
+  for (const sg of ast.subgraphs) {
+    for (const childSg of sg.subgraphs) sgParent.set(childSg, sg.id);
+    if (!sgParent.has(sg.id)) sgParent.set(sg.id, void 0);
+  }
+  const ancestryPath = (id) => {
+    const path2 = [];
+    let cur = parentOf.get(id);
+    while (cur !== void 0) {
+      path2.unshift(cur);
+      cur = sgParent.get(cur);
+    }
+    return path2;
+  };
+  const dummyAncestry = /* @__PURE__ */ new Map();
+  for (const e of updatedEdges) {
+    if (e.chain.length < 3) continue;
+    const fromA = ancestryPath(e.chain[0]);
+    const toA = ancestryPath(e.chain[e.chain.length - 1]);
+    const common = [];
+    for (let k = 0; k < Math.min(fromA.length, toA.length); k++) {
+      if (fromA[k] === toA[k]) common.push(fromA[k]);
+      else break;
+    }
+    for (let i = 1; i < e.chain.length - 1; i++) {
+      dummyAncestry.set(e.chain[i], common);
+    }
+  }
+  const pathOf = (id) => dummyAncestry.get(id) ?? ancestryPath(id);
+  if (ast.subgraphs.length > 0) {
+    ordered = ordered.map((layer) => {
+      const keyed = layer.map((id, i) => ({ id, i, path: pathOf(id) }));
+      keyed.sort((a, b) => {
+        const la = a.path;
+        const lb = b.path;
+        const len = Math.min(la.length, lb.length);
+        for (let k = 0; k < len; k++) {
+          if (la[k] !== lb[k]) return la[k].localeCompare(lb[k]);
+        }
+        if (la.length !== lb.length) return la.length - lb.length;
+        return a.i - b.i;
+      });
+      return keyed.map((k) => k.id);
+    });
+  }
+  for (let li = 0; li < ordered.length; li++) {
+    const layer = ordered[li];
+    for (let oi = 0; oi < layer.length; oi++) {
+      const n = lnodes.get(layer[oi]);
+      if (n) n.order = oi;
+    }
+  }
+  const layerNodes = ordered.map(
+    (layer) => layer.map((id) => lnodes.get(id))
+  );
+  let xMap;
+  if (ast.subgraphs.length > 0) {
+    xMap = laneBasedXCoords(
+      layerNodes,
+      pathOf,
+      FC_CONST.nodeSpacingX,
+      segments
+    );
+  } else {
+    const bkLayers = layerNodes.map(
+      (layer) => layer.map((n) => ({ id: n.id, width: n.width, isDummy: n.isDummy }))
+    );
+    xMap = bkXCoords(bkLayers, segments, FC_CONST.nodeSpacingX);
+  }
+  const isHorizontal = dir === "LR" || dir === "RL";
+  const layerGap = FC_CONST.layerSpacingY;
+  const layerHeights = layerNodes.map((layer) => {
+    let maxH = 0;
+    for (const n of layer) {
+      if (n.isDummy) continue;
+      if (n.height > maxH) maxH = n.height;
+    }
+    return maxH > 0 ? maxH : FC_CONST.nodeHeight;
+  });
+  const hasClusters = ast.subgraphs.length > 0;
+  const CLUSTER_OVERHEAD_TITLE = hasClusters ? 44 : 0;
+  const CLUSTER_OVERHEAD_SIDE = hasClusters ? 24 : 0;
+  const extraTopPad = isHorizontal ? CLUSTER_OVERHEAD_SIDE : CLUSTER_OVERHEAD_TITLE;
+  const extraLeftPad = isHorizontal ? CLUSTER_OVERHEAD_TITLE : CLUSTER_OVERHEAD_SIDE;
+  const layerCenterY = [];
+  {
+    let y = FC_CONST.padding + extraTopPad;
+    for (let li = 0; li < layerHeights.length; li++) {
+      y += layerHeights[li] / 2;
+      layerCenterY.push(y);
+      y += layerHeights[li] / 2 + layerGap;
+    }
+  }
+  let minX = Infinity;
+  let maxX = -Infinity;
+  for (const [id, x] of xMap) {
+    const n = lnodes.get(id);
+    if (n.isDummy) continue;
+    minX = Math.min(minX, x - n.width / 2);
+    maxX = Math.max(maxX, x + n.width / 2);
+  }
+  if (!isFinite(minX)) {
+    minX = 0;
+    maxX = 100;
+  }
+  const padding = FC_CONST.padding;
+  const shiftX = padding + extraLeftPad - minX;
+  const placed = [];
+  for (let li = 0; li < layerNodes.length; li++) {
+    const y = layerCenterY[li];
+    for (const n of layerNodes[li]) {
+      if (n.isDummy) continue;
+      const cx = (xMap.get(n.id) ?? 0) + shiftX;
+      placed.push({
+        id: n.id,
+        x: cx - n.width / 2,
+        y: y - n.height / 2,
+        width: n.width,
+        height: n.height,
+        layer: li,
+        order: n.order
+      });
+    }
+  }
+  const dummyPos = /* @__PURE__ */ new Map();
+  for (let li = 0; li < layerNodes.length; li++) {
+    const y = layerCenterY[li];
+    for (const n of layerNodes[li]) {
+      if (!n.isDummy) continue;
+      dummyPos.set(n.id, {
+        x: (xMap.get(n.id) ?? 0) + shiftX,
+        y
+      });
+    }
+  }
+  const extraRightPad = isHorizontal ? CLUSTER_OVERHEAD_SIDE : CLUSTER_OVERHEAD_SIDE;
+  const extraBottomPad = isHorizontal ? CLUSTER_OVERHEAD_SIDE : CLUSTER_OVERHEAD_SIDE;
+  const canvasW = maxX - minX + 2 * padding + extraLeftPad + extraRightPad;
+  const lastLayer = layerCenterY.length - 1;
+  const canvasH = lastLayer >= 0 ? layerCenterY[lastLayer] + layerHeights[lastLayer] / 2 + padding + extraBottomPad : 2 * padding;
+  const outNodes = placed.map((p) => {
+    const base = lnodes.get(p.id).node;
+    if (!isHorizontal) {
+      return {
+        node: base,
+        x: p.x,
+        y: p.y,
+        width: p.width,
+        height: p.height,
+        layer: p.layer,
+        order: p.order
+      };
+    }
+    return {
+      node: base,
+      x: p.y,
+      y: p.x,
+      width: p.height,
+      height: p.width,
+      layer: p.layer,
+      order: p.order
+    };
+  });
+  const outWidth = isHorizontal ? canvasH : canvasW;
+  const outHeight = isHorizontal ? canvasW : canvasH;
+  const nodeCenter = /* @__PURE__ */ new Map();
+  for (const ln of outNodes) {
+    nodeCenter.set(ln.node.id, {
+      x: ln.x + ln.width / 2,
+      y: ln.y + ln.height / 2,
+      w: ln.width,
+      h: ln.height
+    });
+  }
+  const dummyCenter = /* @__PURE__ */ new Map();
+  for (const [id, p] of dummyPos) {
+    if (!isHorizontal) dummyCenter.set(id, p);
+    else dummyCenter.set(id, { x: p.y, y: p.x });
+  }
+  const outEdges = updatedEdges.map((le) => {
+    const chain = le.chain.length > 0 ? le.chain : [le.from, le.to];
+    const points = [];
+    for (let i = 0; i < chain.length; i++) {
+      const id = chain[i];
+      const nc = nodeCenter.get(id);
+      const dc = dummyCenter.get(id);
+      if (nc) {
+        points.push({ x: nc.x, y: nc.y });
+      } else if (dc) {
+        points.push({ x: dc.x, y: dc.y });
+      }
+    }
+    if (points.length < 2) {
+      return { edge: le.original, path: "" };
+    }
+    const startNode = nodeCenter.get(chain[0]);
+    const endNode = nodeCenter.get(chain[chain.length - 1]);
+    if (startNode) {
+      points[0] = clipToBox(points[0], points[1], startNode, dir);
+    }
+    if (endNode) {
+      points[points.length - 1] = clipToBox(
+        points[points.length - 1],
+        points[points.length - 2],
+        endNode,
+        dir);
+    }
+    const d = buildManhattanPath(points, dir);
+    let labelAnchor;
+    if (le.original.label) {
+      labelAnchor = edgeLabelAnchor(points, dir);
+    }
+    return {
+      edge: {
+        ...le.original,
+        isReversed: le.isReversed
+      },
+      path: d,
+      labelAnchor
+    };
+  });
+  function collectDescendantNodeIds(sgId) {
+    const sg = ast.subgraphs.find((s) => s.id === sgId);
+    if (!sg) return [];
+    const ids = [...sg.children];
+    for (const childSgId of sg.subgraphs) ids.push(...collectDescendantNodeIds(childSgId));
+    return ids;
+  }
+  function computeDepth(sgId) {
+    for (const s of ast.subgraphs) {
+      if (s.subgraphs.includes(sgId)) return 1 + computeDepth(s.id);
+    }
+    return 0;
+  }
+  const CLUSTER_PAD = 24;
+  const CLUSTER_TITLE_H = 20;
+  const clusters = ast.subgraphs.map((sg) => {
+    const memberIds = collectDescendantNodeIds(sg.id);
+    const members = outNodes.filter((n) => memberIds.includes(n.node.id));
+    if (members.length === 0) return null;
+    const minX2 = Math.min(...members.map((n) => n.x)) - CLUSTER_PAD;
+    const minY = Math.min(...members.map((n) => n.y)) - CLUSTER_PAD - CLUSTER_TITLE_H;
+    const maxX2 = Math.max(...members.map((n) => n.x + n.width)) + CLUSTER_PAD;
+    const maxY = Math.max(...members.map((n) => n.y + n.height)) + CLUSTER_PAD;
+    return {
+      subgraph: sg,
+      x: minX2,
+      y: minY,
+      width: maxX2 - minX2,
+      height: maxY - minY,
+      depth: computeDepth(sg.id)
+    };
+  }).filter((c) => c !== null);
+  return {
+    width: outWidth,
+    height: outHeight,
+    direction: dir,
+    nodes: outNodes,
+    edges: outEdges,
+    clusters
+  };
+}
+function clipToBox(from, toward, box, dir, isStart) {
+  const cx = box.x;
+  const cy = box.y;
+  if (dir === "TB" || dir === "BT") {
+    const goingDown = toward.y >= from.y;
+    return { x: cx, y: cy + (goingDown ? box.h / 2 : -box.h / 2) };
+  }
+  const goingRight = toward.x >= from.x;
+  return { x: cx + (goingRight ? box.w / 2 : -box.w / 2), y: cy };
+}
+function buildManhattanPath(pts, dir) {
+  if (pts.length === 0) return "";
+  const parts = [`M ${fmt(pts[0].x)} ${fmt(pts[0].y)}`];
+  const isHorizontal = dir === "LR" || dir === "RL";
+  for (let i = 1; i < pts.length; i++) {
+    const a = pts[i - 1];
+    const b = pts[i];
+    if (isHorizontal) {
+      const midX = (a.x + b.x) / 2;
+      parts.push(`L ${fmt(midX)} ${fmt(a.y)}`);
+      parts.push(`L ${fmt(midX)} ${fmt(b.y)}`);
+      parts.push(`L ${fmt(b.x)} ${fmt(b.y)}`);
+    } else {
+      const midY = (a.y + b.y) / 2;
+      parts.push(`L ${fmt(a.x)} ${fmt(midY)}`);
+      parts.push(`L ${fmt(b.x)} ${fmt(midY)}`);
+      parts.push(`L ${fmt(b.x)} ${fmt(b.y)}`);
+    }
+  }
+  return parts.join(" ");
+}
+function fmt(n) {
+  return (Math.round(n * 100) / 100).toString();
+}
+function edgeLabelAnchor(pts, dir) {
+  if (pts.length < 2) return pts[0] ?? { x: 0, y: 0 };
+  const a = pts[0];
+  const b = pts[1];
+  const isHorizontal = dir === "LR" || dir === "RL";
+  if (isHorizontal) {
+    const midX = (a.x + b.x) / 2;
+    const bends2 = Math.abs(a.y - b.y) > 1;
+    if (bends2) {
+      const midY2 = (a.y + b.y) / 2;
+      return { x: midX + 6, y: midY2, textAnchor: "start" };
+    }
+    return { x: midX, y: a.y - 8, textAnchor: "middle" };
+  }
+  const midY = (a.y + b.y) / 2;
+  const bends = Math.abs(a.x - b.x) > 1;
+  if (bends) {
+    const midX = (a.x + b.x) / 2;
+    return { x: midX, y: midY - 8, textAnchor: "middle" };
+  }
+  return { x: a.x + 6, y: midY, textAnchor: "start" };
+}
+
+// src/diagrams/flowchart/shapes.ts
+function shapeSVG(shape, w, h) {
+  switch (shape) {
+    // ── M1 core shapes ─────────────────────────────────────────
+    case "rect":
+      return chunkHDKDQAEQ_cjs.rect({ x: 0, y: 0, width: w, height: h, rx: 14, ry: 14, class: "sx-fc-node" });
+    case "round":
+      return chunkHDKDQAEQ_cjs.rect({ x: 0, y: 0, width: w, height: h, rx: 20, ry: 20, class: "sx-fc-node sx-fc-node-round" });
+    case "stadium": {
+      const r = Math.min(h / 2, 24);
+      return chunkHDKDQAEQ_cjs.rect({ x: 0, y: 0, width: w, height: h, rx: r, ry: r, class: "sx-fc-node sx-fc-node-stadium" });
+    }
+    case "diamond": {
+      const points = `${w / 2},0 ${w},${h / 2} ${w / 2},${h} 0,${h / 2}`;
+      return chunkHDKDQAEQ_cjs.polygon({ points, class: "sx-fc-node sx-fc-node-diamond" });
+    }
+    case "parallelogram": {
+      const slant = 20;
+      const points = `${slant},0 ${w},0 ${w - slant},${h} 0,${h}`;
+      return chunkHDKDQAEQ_cjs.polygon({ points, class: "sx-fc-node" });
+    }
+    // ── M2 additional shapes ────────────────────────────────────
+    case "parallelogram-alt": {
+      const slant = 20;
+      const points = `0,0 ${w - slant},0 ${w},${h} ${slant},${h}`;
+      return chunkHDKDQAEQ_cjs.polygon({ points, class: "sx-fc-node" });
+    }
+    case "trapezoid": {
+      const slant = 16;
+      const points = `0,0 ${w},0 ${w - slant},${h} ${slant},${h}`;
+      return chunkHDKDQAEQ_cjs.polygon({ points, class: "sx-fc-node" });
+    }
+    case "trapezoid-alt": {
+      const slant = 16;
+      const points = `${slant},0 ${w - slant},0 ${w},${h} 0,${h}`;
+      return chunkHDKDQAEQ_cjs.polygon({ points, class: "sx-fc-node" });
+    }
+    case "subroutine": {
+      const barX = 10;
+      const body = chunkHDKDQAEQ_cjs.rect({ x: 0, y: 0, width: w, height: h, rx: 2, class: "sx-fc-node" });
+      const left = chunkHDKDQAEQ_cjs.line({ x1: barX, y1: 0, x2: barX, y2: h, class: "sx-fc-node-subline" });
+      const right = chunkHDKDQAEQ_cjs.line({ x1: w - barX, y1: 0, x2: w - barX, y2: h, class: "sx-fc-node-subline" });
+      return body + left + right;
+    }
+    case "cylinder": {
+      const ry = Math.min(8, h / 4);
+      const silhouette = chunkHDKDQAEQ_cjs.path({
+        d: `M0,${ry} A${w / 2},${ry} 0 0,1 ${w},${ry} L${w},${h - ry} A${w / 2},${ry} 0 0,1 0,${h - ry} Z`,
+        class: "sx-fc-node"
+      });
+      const topRim = chunkHDKDQAEQ_cjs.path({
+        d: `M0,${ry} A${w / 2},${ry} 0 0,0 ${w},${ry}`,
+        class: "sx-fc-node-arc"
+      });
+      return silhouette + topRim;
+    }
+    case "circle": {
+      const r = Math.min(w, h) / 2 - 1;
+      return chunkHDKDQAEQ_cjs.circle({ cx: w / 2, cy: h / 2, r, class: "sx-fc-node sx-fc-node-circle" });
+    }
+    case "double-circle": {
+      const r1 = Math.min(w, h) / 2 - 1;
+      const r2 = r1 - 5;
+      const outer = chunkHDKDQAEQ_cjs.circle({ cx: w / 2, cy: h / 2, r: r1, class: "sx-fc-node" });
+      const inner = chunkHDKDQAEQ_cjs.circle({ cx: w / 2, cy: h / 2, r: r2, class: "sx-fc-node-ring" });
+      return outer + inner;
+    }
+    case "hexagon": {
+      const cut = Math.min(20, w / 4);
+      const points = `${cut},0 ${w - cut},0 ${w},${h / 2} ${w - cut},${h} ${cut},${h} 0,${h / 2}`;
+      return chunkHDKDQAEQ_cjs.polygon({ points, class: "sx-fc-node sx-fc-node-hexagon" });
+    }
+    case "asymmetric": {
+      const pts = `0,0 ${w - 15},0 ${w},${h / 2} ${w - 15},${h} 0,${h}`;
+      return chunkHDKDQAEQ_cjs.polygon({ points: pts, class: "sx-fc-node" });
+    }
+    default:
+      return chunkHDKDQAEQ_cjs.rect({ x: 0, y: 0, width: w, height: h, rx: 14, ry: 14, class: "sx-fc-node" });
+  }
+}
+
+// src/diagrams/flowchart/renderer.ts
+var CSS_TEMPLATE = (themeName) => {
+  const t = chunkS6VPECM3_cjs.resolveFlowchartTheme(themeName);
+  const c = t.classes;
+  return `
+.sx-fc { background: ${t.bg}; font-family: system-ui, -apple-system, "Segoe UI", sans-serif; }
+.sx-fc-node { fill: ${t.fillMuted}; stroke: ${t.stroke}; stroke-width: 1.5; stroke-linejoin: round; }
+.sx-fc-node-stadium { fill: ${t.stadiumFill}; stroke: ${t.stroke}; }
+.sx-fc-node-diamond { fill: ${t.diamondFill}; stroke: ${t.stroke}; }
+.sx-fc-node-round { fill: ${t.roundFill}; stroke: ${t.stroke}; }
+.sx-fc-node-text { fill: ${t.text}; font: 12px system-ui, -apple-system, "Segoe UI", sans-serif; }
+/* Semantic class presets (applied via 'class A start') \u2014 override shape fills */
+.sx-fc-class-start    > .sx-fc-node { fill: ${c.start.fill}; stroke: ${c.start.stroke}; }
+.sx-fc-class-start    > .sx-fc-node-text { fill: ${c.start.text}; font-weight: 600; }
+.sx-fc-class-process  > .sx-fc-node { fill: ${c.process.fill}; stroke: ${c.process.stroke}; }
+.sx-fc-class-process  > .sx-fc-node-text { fill: ${c.process.text}; font-weight: 600; }
+.sx-fc-class-decision > .sx-fc-node { fill: ${c.decision.fill}; stroke: ${c.decision.stroke}; }
+.sx-fc-class-decision > .sx-fc-node-text { fill: ${c.decision.text}; font-weight: 600; }
+.sx-fc-class-success  > .sx-fc-node { fill: ${c.success.fill}; stroke: ${c.success.stroke}; }
+.sx-fc-class-success  > .sx-fc-node-text { fill: ${c.success.text}; font-weight: 600; }
+.sx-fc-class-danger   > .sx-fc-node { fill: ${c.danger.fill}; stroke: ${c.danger.stroke}; }
+.sx-fc-class-danger   > .sx-fc-node-text { fill: ${c.danger.text}; font-weight: 600; }
+.sx-fc-class-neutral  > .sx-fc-node { fill: ${c.neutral.fill}; stroke: ${c.neutral.stroke}; }
+.sx-fc-class-neutral  > .sx-fc-node-text { fill: ${c.neutral.text}; font-weight: 600; }
+.sx-fc-edge { fill: none; stroke: ${t.neutral}; stroke-width: 1.5; stroke-linecap: round; stroke-linejoin: round; }
+.sx-fc-edge-thick { stroke: ${t.stroke}; stroke-width: 2.4; }
+.sx-fc-edge-dashed { stroke-dasharray: 5 3; }
+.sx-fc-edge-dotted { stroke-dasharray: 1.5 3; }
+.sx-fc-edge-label { fill: ${t.textMuted}; font: 11px system-ui, -apple-system, "Segoe UI", sans-serif; }
+.sx-fc-edge-label-bg { fill: ${t.bg}; fill-opacity: 0.96; stroke: ${t.neutral}; stroke-width: 0.5; }
+.sx-fc-title { fill: ${t.text}; font: 600 14px system-ui, -apple-system, "Segoe UI", sans-serif; }
+/* Shape sub-elements */
+.sx-fc-node-subline { fill: none; stroke: ${t.stroke}; stroke-width: 1.5; }
+.sx-fc-node-arc { fill: none; stroke: ${t.stroke}; stroke-width: 1.5; }
+.sx-fc-node-ring { fill: none; stroke: ${t.stroke}; stroke-width: 1.8; }
+/* Cluster (subgraph) */
+.sx-fc-cluster { fill: ${t.fillMuted}; fill-opacity: 0.35; stroke: ${t.neutral}; stroke-width: 1.5; stroke-dasharray: 5,3; }
+.sx-fc-cluster-title { fill: ${t.textMuted}; font: 500 11px system-ui, -apple-system, "Segoe UI", sans-serif; }
+`.trim();
+};
+var ARROW_MARKER = `
+<marker id="sx-fc-arrow" markerWidth="8" markerHeight="8" refX="7" refY="4" orient="auto-start-reverse" markerUnits="userSpaceOnUse">
+  <path d="M0,0 L8,4 L0,8 L2,4 Z" fill="context-stroke"/>
+</marker>
+<marker id="sx-fc-arrow-o" markerWidth="8" markerHeight="8" refX="7" refY="4" orient="auto" markerUnits="userSpaceOnUse">
+  <circle cx="4" cy="4" r="3" fill="none" stroke="context-stroke" stroke-width="1"/>
+</marker>
+<marker id="sx-fc-arrow-x" markerWidth="8" markerHeight="8" refX="4" refY="4" orient="auto" markerUnits="userSpaceOnUse">
+  <path d="M1,1 L7,7 M1,7 L7,1" stroke="context-stroke" stroke-width="1.2"/>
+</marker>
+`.trim();
+function edgeCssClass(edge) {
+  const classes = ["sx-fc-edge"];
+  if (edge.kind === "thick") classes.push("sx-fc-edge-thick");
+  if (edge.kind === "dotted") classes.push("sx-fc-edge-dotted");
+  return classes.join(" ");
+}
+function markerEndFor(edge) {
+  switch (edge.arrowEnd) {
+    case "arrow":
+      return "url(#sx-fc-arrow)";
+    case "circle":
+      return "url(#sx-fc-arrow-o)";
+    case "cross":
+      return "url(#sx-fc-arrow-x)";
+    default:
+      return void 0;
+  }
+}
+function markerStartFor(edge) {
+  return edge.arrowStart === "arrow" ? "url(#sx-fc-arrow)" : void 0;
+}
+function renderCluster(lc) {
+  const sg = lc.subgraph;
+  const bg = chunkHDKDQAEQ_cjs.rect({ x: lc.x, y: lc.y, width: lc.width, height: lc.height, rx: 8, class: "sx-fc-cluster" });
+  const label = chunkHDKDQAEQ_cjs.text(
+    { x: lc.x + 12, y: lc.y + 15, class: "sx-fc-cluster-title" },
+    sg.label
+  );
+  return chunkHDKDQAEQ_cjs.group(
+    { "data-cluster-id": sg.id, "data-depth": lc.depth, class: "sx-fc-cluster-g" },
+    [bg, label]
+  );
+}
+function renderNode(ln) {
+  const n = ln.node;
+  const shapeEl = shapeSVG(n.shape, ln.width, ln.height);
+  const label = chunkHDKDQAEQ_cjs.text(
+    {
+      x: ln.width / 2,
+      y: ln.height / 2,
+      class: "sx-fc-node-text",
+      "text-anchor": "middle",
+      "dominant-baseline": "central"
+    },
+    n.label
+  );
+  const nodeTitle = chunkHDKDQAEQ_cjs.title(n.label);
+  const classAttr = ["sx-fc-node-g", ...(n.classes ?? []).map((c) => `sx-fc-class-${c}`)].join(" ");
+  return chunkHDKDQAEQ_cjs.group(
+    {
+      "data-node-id": n.id,
+      "data-shape": n.shape,
+      "data-layer": ln.layer,
+      "data-classes": n.classes?.join(" "),
+      class: classAttr,
+      transform: `translate(${fmt2(ln.x)} ${fmt2(ln.y)})`
+    },
+    [shapeEl, label, nodeTitle]
+  );
+}
+function renderEdge(le) {
+  const e = le.edge;
+  const attrs = {
+    d: le.path,
+    class: edgeCssClass(e)
+  };
+  const me = markerEndFor(e);
+  const ms = markerStartFor(e);
+  if (me) attrs["marker-end"] = me;
+  if (ms) attrs["marker-start"] = ms;
+  const p = chunkHDKDQAEQ_cjs.path(attrs);
+  const labelEl = e.label && le.labelAnchor ? renderEdgeLabel(
+    e.label,
+    le.labelAnchor.x,
+    le.labelAnchor.y,
+    le.labelAnchor.textAnchor ?? "middle"
+  ) : "";
+  const edgeTitle = chunkHDKDQAEQ_cjs.title(
+    e.label ? `${e.from} \u2192 ${e.to}: ${e.label}` : `${e.from} \u2192 ${e.to}`
+  );
+  return chunkHDKDQAEQ_cjs.group(
+    {
+      "data-edge-id": e.id ?? `${e.from}->${e.to}`,
+      "data-kind": e.kind,
+      "data-from": e.from,
+      "data-to": e.to
+    },
+    [p, edgeTitle, labelEl].filter((s) => s.length > 0)
+  );
+}
+function renderEdgeLabel(label, cx, cy, textAnchor) {
+  const w = Math.max(20, label.length * 6.5 + 10);
+  const h = 16;
+  const rx = cx - (textAnchor === "start" ? 0 : textAnchor === "end" ? w : w / 2);
+  const ry = cy - h / 2;
+  const bg = chunkHDKDQAEQ_cjs.rect({
+    x: rx,
+    y: ry,
+    width: w,
+    height: h,
+    rx: 3,
+    class: "sx-fc-edge-label-bg"
+  });
+  const t = chunkHDKDQAEQ_cjs.text(
+    {
+      x: cx,
+      y: cy,
+      class: "sx-fc-edge-label",
+      "text-anchor": textAnchor,
+      "dominant-baseline": "central"
+    },
+    label
+  );
+  return chunkHDKDQAEQ_cjs.group({ class: "sx-fc-edge-label-g" }, [bg, t]);
+}
+function fmt2(n) {
+  return (Math.round(n * 100) / 100).toString();
+}
+function renderFlowchartAST(ast, themeName = "default") {
+  const layout = layoutFlowchart(ast);
+  const clusterSvg = layout.clusters.map(renderCluster);
+  const nodeSvg = layout.nodes.map(renderNode);
+  const edgeSvg = layout.edges.map(renderEdge);
+  const nodeStyleOverrides = ast.nodes.filter((n) => n.style && Object.keys(n.style).length > 0).map((n) => {
+    const props = Object.entries(n.style).map(([k, v]) => `${k}:${v}`).join(";");
+    return `g[data-node-id="${n.id}"] .sx-fc-node { ${props} }`;
+  }).join("\n");
+  const classDefOverrides = ast.classDefs.map((cd) => {
+    const props = Object.entries(cd.props).map(([k, v]) => `${k}:${v}`).join(";");
+    return `.sx-fc-class-${cd.id} > .sx-fc-node { ${props} }`;
+  }).join("\n");
+  const titleBlock = ast.title ? chunkHDKDQAEQ_cjs.text(
+    {
+      x: layout.width / 2,
+      y: 16,
+      class: "sx-fc-title",
+      "text-anchor": "middle"
+    },
+    ast.title
+  ) : "";
+  const cssOverrides = [nodeStyleOverrides, classDefOverrides].filter((s) => s.length > 0).join("\n");
+  const headMeta = [
+    chunkHDKDQAEQ_cjs.title(ast.title ? `${ast.title} \u2014 Flowchart` : "Flowchart"),
+    chunkHDKDQAEQ_cjs.desc(
+      `Flowchart with ${ast.nodes.length} node${ast.nodes.length === 1 ? "" : "s"} and ${ast.edges.length} edge${ast.edges.length === 1 ? "" : "s"}.`
+    ),
+    chunkHDKDQAEQ_cjs.el("style", {}, CSS_TEMPLATE(themeName) + (cssOverrides ? "\n" + cssOverrides : "")),
+    chunkHDKDQAEQ_cjs.defs([ARROW_MARKER])
+  ];
+  const content = [];
+  if (clusterSvg.length > 0) content.push(chunkHDKDQAEQ_cjs.group({ class: "sx-fc-clusters" }, clusterSvg));
+  content.push(chunkHDKDQAEQ_cjs.group({ class: "sx-fc-edges" }, edgeSvg));
+  content.push(chunkHDKDQAEQ_cjs.group({ class: "sx-fc-nodes" }, nodeSvg));
+  const hasClusters = layout.clusters.length > 0;
+  const topPad = ast.title ? hasClusters ? 56 : 24 : 0;
+  const totalH = layout.height + topPad;
+  const titleSvg = titleBlock;
+  return chunkHDKDQAEQ_cjs.svgRoot(
+    {
+      viewBox: `0 0 ${fmt2(layout.width)} ${fmt2(totalH)}`,
+      width: fmt2(layout.width),
+      height: fmt2(totalH),
+      class: "sx-fc",
+      "data-diagram-type": "flowchart",
+      "data-direction": layout.direction,
+      role: "graphics-document"
+    },
+    topPad > 0 ? [
+      ...headMeta,
+      titleSvg,
+      chunkHDKDQAEQ_cjs.group({ transform: `translate(0 ${topPad})` }, content)
+    ] : [...headMeta, titleSvg, ...content]
+  );
+}
+function renderFlowchart(text2, themeName = "default") {
+  const ast = parseFlowchart(text2);
+  return renderFlowchartAST(ast, themeName);
+}
+
+// src/diagrams/flowchart/index.ts
+var flowchart = {
+  type: "flowchart",
+  detect(text2) {
+    for (const raw of text2.split(/\r?\n/)) {
+      const t = raw.trim();
+      if (t.length === 0) continue;
+      if (t.startsWith("%%")) continue;
+      const first = t.split(/\s+/)[0]?.toLowerCase() ?? "";
+      return first === "flowchart" || first === "graph";
+    }
+    return false;
+  },
+  parse: parseFlowchart,
+  render(text2, config) {
+    const themeName = config?.theme ?? "default";
+    return renderFlowchart(text2, themeName);
+  }
+};
+
+exports.FC_CONST = FC_CONST;
+exports.flowchart = flowchart;
+exports.layoutFlowchart = layoutFlowchart;
+exports.parseFlowchart = parseFlowchart;
+exports.renderFlowchart = renderFlowchart;
+exports.renderFlowchartAST = renderFlowchartAST;
+//# sourceMappingURL=chunk-HAIBAF6J.cjs.map
+//# sourceMappingURL=chunk-HAIBAF6J.cjs.map