schematex 0.1.0

package/dist/chunk-MDICUK6F.cjs

@@ -0,0 +1,1258 @@
+'use strict';
+
+var chunkN7KOXOMX_cjs = require('./chunk-N7KOXOMX.cjs');
+var chunkHDKDQAEQ_cjs = require('./chunk-HDKDQAEQ.cjs');
+
+// src/diagrams/flowchart/parser.ts
+var FlowchartParseError = class extends Error {
+  constructor(message, line, col) {
+    super(`[line ${line}:${col}] ${message}`);
+    this.line = line;
+    this.col = col;
+    this.name = "FlowchartParseError";
+  }
+  line;
+  col;
+};
+var DIRECTIONS = /* @__PURE__ */ new Set(["TB", "TD", "BT", "LR", "RL"]);
+function parseShapeSuffix(line, pos) {
+  const ch = line[pos];
+  if (ch === void 0) return null;
+  if (ch === "(" && line[pos + 1] === "[") {
+    const end = line.indexOf("])", pos + 2);
+    if (end < 0) return null;
+    return {
+      shape: "stadium",
+      label: line.slice(pos + 2, end).trim(),
+      end: end + 2
+    };
+  }
+  if (ch === "(" && line[pos + 1] === "(") {
+    const end = line.indexOf("))", pos + 2);
+    if (end < 0) return null;
+    return {
+      shape: "circle",
+      label: line.slice(pos + 2, end).trim(),
+      end: end + 2
+    };
+  }
+  if (ch === "[" && line[pos + 1] === "[") {
+    const end = line.indexOf("]]", pos + 2);
+    if (end < 0) return null;
+    return {
+      shape: "subroutine",
+      label: line.slice(pos + 2, end).trim(),
+      end: end + 2
+    };
+  }
+  if (ch === "[" && line[pos + 1] === "(") {
+    const end = line.indexOf(")]", pos + 2);
+    if (end < 0) return null;
+    return {
+      shape: "cylinder",
+      label: line.slice(pos + 2, end).trim(),
+      end: end + 2
+    };
+  }
+  if (ch === "{" && line[pos + 1] === "{") {
+    const end = line.indexOf("}}", pos + 2);
+    if (end < 0) return null;
+    return {
+      shape: "hexagon",
+      label: line.slice(pos + 2, end).trim(),
+      end: end + 2
+    };
+  }
+  if (ch === "[" && line[pos + 1] === "/") {
+    const end = line.indexOf("/]", pos + 2);
+    if (end < 0) return null;
+    return {
+      shape: "parallelogram",
+      label: line.slice(pos + 2, end).trim(),
+      end: end + 2
+    };
+  }
+  if (ch === "[" && line[pos + 1] === "\\") {
+    const end = line.indexOf("\\]", pos + 2);
+    if (end < 0) return null;
+    return {
+      shape: "parallelogram-alt",
+      label: line.slice(pos + 2, end).trim(),
+      end: end + 2
+    };
+  }
+  if (ch === "[") {
+    const end = line.indexOf("]", pos + 1);
+    if (end < 0) return null;
+    return {
+      shape: "rect",
+      label: line.slice(pos + 1, end).trim(),
+      end: end + 1
+    };
+  }
+  if (ch === "(") {
+    const end = line.indexOf(")", pos + 1);
+    if (end < 0) return null;
+    return {
+      shape: "round",
+      label: line.slice(pos + 1, end).trim(),
+      end: end + 1
+    };
+  }
+  if (ch === "{") {
+    const end = line.indexOf("}", pos + 1);
+    if (end < 0) return null;
+    return {
+      shape: "diamond",
+      label: line.slice(pos + 1, end).trim(),
+      end: end + 1
+    };
+  }
+  return null;
+}
+var ID_CHAR = /[A-Za-z0-9_-]/;
+function parseEdgeOp(line, pos) {
+  while (pos < line.length && line[pos] === " ") pos++;
+  const rest = line.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(line, pos) {
+  let i = pos;
+  while (i < line.length && ID_CHAR.test(line[i])) i++;
+  if (i === pos) return null;
+  const id = line.slice(pos, i);
+  const shape = parseShapeSuffix(line, i);
+  if (shape) {
+    return {
+      ref: { id, shape: shape.shape, label: shape.label },
+      end: shape.end
+    };
+  }
+  return { ref: { id }, end: i };
+}
+function parsePipeLabel(line, pos) {
+  if (line[pos] !== "|") return null;
+  const end = line.indexOf("|", pos + 1);
+  if (end < 0) return null;
+  return { label: line.slice(pos + 1, end).trim(), end: end + 1 };
+}
+function skipSpaces(line, pos) {
+  while (pos < line.length && (line[pos] === " " || line[pos] === "	")) pos++;
+  return pos;
+}
+function parseChainStatement(line, lineNo) {
+  const nodes = [];
+  const edges = [];
+  let pos = skipSpaces(line, 0);
+  const first = parseNodeRef(line, pos);
+  if (!first) {
+    throw new FlowchartParseError(
+      `expected node identifier, got ${JSON.stringify(line.slice(pos, pos + 10))}`,
+      lineNo,
+      pos + 1
+    );
+  }
+  if (first.ref.shape && first.ref.label !== void 0) {
+    nodes.push({ id: first.ref.id, shape: first.ref.shape, label: first.ref.label });
+  } else {
+    nodes.push({ id: first.ref.id, shape: "rect", label: first.ref.id });
+  }
+  let prev = first.ref;
+  pos = first.end;
+  while (pos < line.length) {
+    pos = skipSpaces(line, pos);
+    if (pos >= line.length) break;
+    const op = parseEdgeOp(line, pos);
+    if (!op) {
+      throw new FlowchartParseError(
+        `expected edge operator, got ${JSON.stringify(line.slice(pos, pos + 10))}`,
+        lineNo,
+        pos + 1
+      );
+    }
+    pos = op.end;
+    pos = skipSpaces(line, pos);
+    let label = op.inlineLabel;
+    const pipe = parsePipeLabel(line, pos);
+    if (pipe) {
+      label = pipe.label;
+      pos = pipe.end;
+    }
+    pos = skipSpaces(line, pos);
+    const target = parseNodeRef(line, pos);
+    if (!target) {
+      throw new FlowchartParseError(
+        `expected target node after edge, got ${JSON.stringify(line.slice(pos, pos + 10))}`,
+        lineNo,
+        pos + 1
+      );
+    }
+    if (target.ref.shape && target.ref.label !== void 0) {
+      nodes.push({
+        id: target.ref.id,
+        shape: target.ref.shape,
+        label: target.ref.label
+      });
+    } else {
+      nodes.push({ id: target.ref.id, shape: "rect", label: target.ref.id });
+    }
+    edges.push({
+      from: prev.id,
+      to: target.ref.id,
+      kind: op.kind,
+      label,
+      bidirectional: op.bidirectional
+    });
+    prev = target.ref;
+    pos = target.end;
+  }
+  return { nodes, edges };
+}
+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 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;
+  }
+  for (let i = headerIdx + 1; i < lines.length; i++) {
+    const raw = lines[i];
+    const trimmed = raw.trim();
+    if (trimmed.length === 0) continue;
+    if (trimmed.startsWith("%%")) 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 parsed = parseChainStatement(trimmed, i + 1);
+    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
+        };
+        nodeMap.set(ndef.id, node);
+        ast.nodes.push(node);
+      } else {
+        if (ndef.label !== ndef.id) {
+          existing.label = ndef.label;
+        }
+        if (ndef.shape !== "rect") {
+          existing.shape = ndef.shape;
+        }
+      }
+    }
+    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/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 medianOrder(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);
+  }
+  const indexOf = (layer, id) => layer.indexOf(id);
+  const reorderByMedian = (layer, fixed, useSucc) => {
+    const fixedIdx = /* @__PURE__ */ new Map();
+    fixed.forEach((id, i) => fixedIdx.set(id, i));
+    const scored = layer.map((id, i) => {
+      const neighbors = useSucc ? succ.get(id) ?? [] : pred.get(id) ?? [];
+      const positions = neighbors.map((n) => fixedIdx.get(n)).filter((p) => p !== void 0).sort((a, b) => a - b);
+      if (positions.length === 0) return { id, score: i, orig: i };
+      const m = positions.length;
+      const mid = positions[Math.floor(m / 2)];
+      const score = m % 2 === 1 ? mid : (positions[m / 2 - 1] + positions[m / 2]) / 2;
+      return { id, score, orig: i };
+    });
+    scored.sort((a, b) => a.score - b.score || a.orig - b.orig);
+    return scored.map((s) => s.id);
+  };
+  const result = layers.map((l) => l.slice());
+  let bestCrossings = countCrossings(result, segments, indexOf);
+  let best = result.map((l) => l.slice());
+  for (let iter = 0; iter < FC_CONST.crossingSweepIters; iter++) {
+    const down = iter % 2 === 0;
+    if (down) {
+      for (let i = 1; i < result.length; i++) {
+        result[i] = reorderByMedian(result[i], result[i - 1], false);
+      }
+    } else {
+      for (let i = result.length - 2; i >= 0; i--) {
+        result[i] = reorderByMedian(result[i], result[i + 1], true);
+      }
+    }
+    const c = countCrossings(result, segments, indexOf);
+    if (c < bestCrossings) {
+      bestCrossings = c;
+      best = result.map((l) => l.slice());
+    }
+  }
+  return best;
+}
+function countCrossings(layers, segments, indexOf) {
+  let total = 0;
+  for (let i = 0; i < layers.length - 1; i++) {
+    const upper = layers[i];
+    const lower = layers[i + 1];
+    const pairs = [];
+    for (const [u, v] of segments) {
+      const iu = indexOf(upper, u);
+      const iv = indexOf(lower, v);
+      if (iu >= 0 && iv >= 0) pairs.push([iu, iv]);
+    }
+    pairs.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+    for (let a = 0; a < pairs.length; a++) {
+      for (let b = a + 1; b < pairs.length; b++) {
+        if (pairs[a][1] > pairs[b][1]) total++;
+      }
+    }
+  }
+  return total;
+}
+function assignXCoords(layers, nodeSpacingX) {
+  const x = /* @__PURE__ */ new Map();
+  const layerWidths = [];
+  for (const layer of layers) {
+    let w = 0;
+    for (let i = 0; i < layer.length; i++) {
+      w += layer[i].width;
+      if (i < layer.length - 1) w += nodeSpacingX;
+    }
+    layerWidths.push(w);
+  }
+  const maxWidth = Math.max(...layerWidths, 1);
+  for (let li = 0; li < layers.length; li++) {
+    const layer = layers[li];
+    const layerW = layerWidths[li];
+    let cursor = (maxWidth - layerW) / 2;
+    for (const n of layer) {
+      x.set(n.id, cursor + n.width / 2);
+      cursor += n.width + nodeSpacingX;
+    }
+  }
+  return x;
+}
+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") {
+      shapeW += 20;
+    }
+    if (n.shape === "stadium" || n.shape === "round") {
+      shapeW = Math.max(shapeW, shapeH + 20);
+    }
+    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]]);
+      }
+    }
+  }
+  const ordered = medianOrder(layers, segments);
+  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))
+  );
+  const xMap = assignXCoords(layerNodes, FC_CONST.nodeSpacingX);
+  for (let pass = 0; pass < 4; pass++) {
+    for (let li = 0; li < layerNodes.length; li++) {
+      const layer = layerNodes[li];
+      const pullList = layer.map((n) => {
+        const neighbors = [];
+        for (const [u, v] of segments) {
+          if (v === n.id) {
+            const ux = xMap.get(u);
+            if (ux !== void 0) neighbors.push(ux);
+          }
+          if (u === n.id) {
+            const vx = xMap.get(v);
+            if (vx !== void 0) neighbors.push(vx);
+          }
+        }
+        if (neighbors.length === 0) return xMap.get(n.id) ?? 0;
+        neighbors.sort((a, b) => a - b);
+        return neighbors[Math.floor(neighbors.length / 2)];
+      });
+      let cursor = -Infinity;
+      for (let oi = 0; oi < layer.length; oi++) {
+        const n = layer[oi];
+        const desired = pullList[oi];
+        const minX2 = cursor + FC_CONST.nodeSpacingX + n.width / 2;
+        const newX = Math.max(desired, oi === 0 ? desired : minX2);
+        xMap.set(n.id, newX);
+        cursor = newX + n.width / 2;
+      }
+    }
+  }
+  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 layerCenterY = [];
+  {
+    let y = FC_CONST.padding;
+    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 - 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 canvasW = maxX - minX + 2 * padding;
+  const lastLayer = layerCenterY.length - 1;
+  const canvasH = lastLayer >= 0 ? layerCenterY[lastLayer] + layerHeights[lastLayer] / 2 + padding : 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
+    };
+  });
+  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) {
+    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" });
+    }
+    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" });
+    }
+    default:
+      return chunkHDKDQAEQ_cjs.rect({ x: 0, y: 0, width: w, height: h, rx: 6, ry: 6, class: "sx-fc-node" });
+  }
+}
+
+// src/diagrams/flowchart/renderer.ts
+var CSS_TEMPLATE = (themeName) => {
+  const t = chunkN7KOXOMX_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; }
+`.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 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 nodeSvg = layout.nodes.map(renderNode);
+  const edgeSvg = layout.edges.map(renderEdge);
+  const titleBlock = ast.title ? chunkHDKDQAEQ_cjs.text(
+    {
+      x: layout.width / 2,
+      y: 16,
+      class: "sx-fc-title",
+      "text-anchor": "middle"
+    },
+    ast.title
+  ) : "";
+  const inner = [
+    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)),
+    chunkHDKDQAEQ_cjs.defs([ARROW_MARKER])
+  ];
+  if (titleBlock) inner.push(titleBlock);
+  inner.push(chunkHDKDQAEQ_cjs.group({ class: "sx-fc-edges" }, edgeSvg));
+  inner.push(chunkHDKDQAEQ_cjs.group({ class: "sx-fc-nodes" }, nodeSvg));
+  const topPad = ast.title ? 24 : 0;
+  const totalH = layout.height + topPad;
+  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"
+    },
+    [
+      ...inner.slice(0, 4),
+      ...titleBlock ? [titleBlock] : [],
+      chunkHDKDQAEQ_cjs.group(
+        { transform: topPad > 0 ? `translate(0 ${topPad})` : "translate(0 0)" },
+        [
+          chunkHDKDQAEQ_cjs.group({ class: "sx-fc-edges" }, edgeSvg),
+          chunkHDKDQAEQ_cjs.group({ class: "sx-fc-nodes" }, nodeSvg)
+        ]
+      )
+    ]
+  );
+}
+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;
+  },
+  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-MDICUK6F.cjs.map
+//# sourceMappingURL=chunk-MDICUK6F.cjs.map