schematex 0.1.0 → 0.2.0

package/dist/chunk-ADOXGKAK.js

@@ -1,1251 +0,0 @@
-import { resolveFlowchartTheme } from './chunk-IX554O5K.js';
-import { text, title, desc, el, defs, group, svgRoot, path, rect, polygon } from './chunk-KLJEK547.js';
-
-// 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 rect({ x: 0, y: 0, width: w, height: h, rx: 14, ry: 14, class: "sx-fc-node" });
-    case "round":
-      return 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 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 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 polygon({ points, class: "sx-fc-node" });
-    }
-    case "parallelogram-alt": {
-      const slant = 20;
-      const points = `0,0 ${w - slant},0 ${w},${h} ${slant},${h}`;
-      return polygon({ points, class: "sx-fc-node" });
-    }
-    default:
-      return 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 = 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 = text(
-    {
-      x: ln.width / 2,
-      y: ln.height / 2,
-      class: "sx-fc-node-text",
-      "text-anchor": "middle",
-      "dominant-baseline": "central"
-    },
-    n.label
-  );
-  const nodeTitle = title(n.label);
-  const classAttr = ["sx-fc-node-g", ...(n.classes ?? []).map((c) => `sx-fc-class-${c}`)].join(" ");
-  return 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 = path(attrs);
-  const labelEl = e.label && le.labelAnchor ? renderEdgeLabel(
-    e.label,
-    le.labelAnchor.x,
-    le.labelAnchor.y,
-    le.labelAnchor.textAnchor ?? "middle"
-  ) : "";
-  const edgeTitle = title(
-    e.label ? `${e.from} \u2192 ${e.to}: ${e.label}` : `${e.from} \u2192 ${e.to}`
-  );
-  return 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 = rect({
-    x: rx,
-    y: ry,
-    width: w,
-    height: h,
-    rx: 3,
-    class: "sx-fc-edge-label-bg"
-  });
-  const t = text(
-    {
-      x: cx,
-      y: cy,
-      class: "sx-fc-edge-label",
-      "text-anchor": textAnchor,
-      "dominant-baseline": "central"
-    },
-    label
-  );
-  return 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 ? text(
-    {
-      x: layout.width / 2,
-      y: 16,
-      class: "sx-fc-title",
-      "text-anchor": "middle"
-    },
-    ast.title
-  ) : "";
-  const inner = [
-    title(ast.title ? `${ast.title} \u2014 Flowchart` : "Flowchart"),
-    desc(
-      `Flowchart with ${ast.nodes.length} node${ast.nodes.length === 1 ? "" : "s"} and ${ast.edges.length} edge${ast.edges.length === 1 ? "" : "s"}.`
-    ),
-    el("style", {}, CSS_TEMPLATE(themeName)),
-    defs([ARROW_MARKER])
-  ];
-  if (titleBlock) inner.push(titleBlock);
-  inner.push(group({ class: "sx-fc-edges" }, edgeSvg));
-  inner.push(group({ class: "sx-fc-nodes" }, nodeSvg));
-  const topPad = ast.title ? 24 : 0;
-  const totalH = layout.height + topPad;
-  return 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] : [],
-      group(
-        { transform: topPad > 0 ? `translate(0 ${topPad})` : "translate(0 0)" },
-        [
-          group({ class: "sx-fc-edges" }, edgeSvg),
-          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);
-  }
-};
-
-export { FC_CONST, flowchart, layoutFlowchart, parseFlowchart, renderFlowchart, renderFlowchartAST };
-//# sourceMappingURL=chunk-ADOXGKAK.js.map
-//# sourceMappingURL=chunk-ADOXGKAK.js.map