mermaid2term 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1288 @@
+'use strict';
+
+// src/core/types.ts
+var DEFAULT_RENDER_OPTIONS = {
+  charset: "unicode",
+  maxWidth: 0,
+  paddingX: 2,
+  paddingY: 1,
+  borderPadding: 1,
+  showCoords: false
+};
+
+// src/diagrams/flowchart/parser.ts
+var DIRECTION_PATTERN = /^(?:graph|flowchart)\s+(LR|RL|TD|TB|BT)\s*$/i;
+var NODE_DEF_PATTERNS = [
+  { pattern: /^(\w+)\[\[(.+)\]\]$/, shape: "subroutine" },
+  { pattern: /^(\w+)\[\((.+)\)\]$/, shape: "cylinder" },
+  { pattern: /^(\w+)\(\((.+)\)\)$/, shape: "circle" },
+  { pattern: /^(\w+)\{\{(.+)\}\}$/, shape: "hexagon" },
+  { pattern: /^(\w+)\{(.+)\}$/, shape: "diamond" },
+  { pattern: /^(\w+)\((.+)\)$/, shape: "round" },
+  { pattern: /^(\w+)\[\/(.+)\/\]$/, shape: "parallelogram" },
+  { pattern: /^(\w+)\[\\(.+)\\\]$/, shape: "parallelogram" },
+  { pattern: /^(\w+)>(.+)\]$/, shape: "asymmetric" },
+  { pattern: /^(\w+)\[(.+)\]$/, shape: "rect" },
+  { pattern: /^(\w+)$/, shape: "rect" }
+];
+var EDGE_PATTERNS = [
+  { pattern: /^-->\|(.+?)\|$/, style: "solid", arrowType: "arrow", hasLabel: true },
+  { pattern: /^-->$/, style: "solid", arrowType: "arrow", hasLabel: false },
+  { pattern: /^---\|(.+?)\|$/, style: "solid", arrowType: "open", hasLabel: true },
+  { pattern: /^---$/, style: "solid", arrowType: "open", hasLabel: false },
+  { pattern: /^-\.->\|(.+?)\|$/, style: "dotted", arrowType: "arrow", hasLabel: true },
+  { pattern: /^-\.->$/, style: "dotted", arrowType: "arrow", hasLabel: false },
+  { pattern: /^-\.-\|(.+?)\|$/, style: "dotted", arrowType: "open", hasLabel: true },
+  { pattern: /^-\.-$/, style: "dotted", arrowType: "open", hasLabel: false },
+  { pattern: /^==>\|(.+?)\|$/, style: "thick", arrowType: "arrow", hasLabel: true },
+  { pattern: /^==>$/, style: "thick", arrowType: "arrow", hasLabel: false },
+  { pattern: /^--o$/, style: "solid", arrowType: "circle", hasLabel: false },
+  { pattern: /^--x$/, style: "solid", arrowType: "cross", hasLabel: false },
+  { pattern: /^<-->$/, style: "solid", arrowType: "arrow", hasLabel: false, bidirectional: true }
+];
+var CLASSDEF_PATTERN = /^classDef\s+(\w+)\s+(.+)$/;
+var CLASS_ASSIGNMENT_PATTERN = /^class\s+(.+)\s+(\w+)$/;
+var NODE_CLASS_PATTERN = /^(\w+):::(\w+)$/;
+var AMPERSAND_SPLIT = /\s*&\s*/;
+function parseNodeDefinition(text) {
+  const trimmed = text.trim();
+  const classMatch = trimmed.match(NODE_CLASS_PATTERN);
+  let nodeText = trimmed;
+  let styleClass;
+  if (classMatch) {
+    nodeText = classMatch[1];
+    styleClass = classMatch[2];
+  }
+  for (const { pattern, shape } of NODE_DEF_PATTERNS) {
+    const match = nodeText.match(pattern);
+    if (match) {
+      const id = match[1];
+      const label = match[2] ?? match[1];
+      return { id, label, shape, styleClass };
+    }
+  }
+  return { id: trimmed, label: trimmed, shape: "rect", styleClass };
+}
+function parseEdgeOperator(text) {
+  for (const edgeDef of EDGE_PATTERNS) {
+    const match = text.match(edgeDef.pattern);
+    if (match) {
+      return {
+        style: edgeDef.style,
+        arrowType: edgeDef.arrowType,
+        label: edgeDef.hasLabel ? match[1] : void 0,
+        bidirectional: edgeDef.bidirectional ?? false
+      };
+    }
+  }
+  return null;
+}
+function parseStyleClass(propsString) {
+  const props = {};
+  const pairs = propsString.split(",");
+  for (const pair of pairs) {
+    const [key, value] = pair.split(":").map((s) => s.trim());
+    if (key && value) {
+      switch (key) {
+        case "fill":
+          props.fill = value;
+          break;
+        case "stroke":
+          props.stroke = value;
+          break;
+        case "color":
+          props.color = value;
+          break;
+        case "stroke-width":
+          props.strokeWidth = value;
+          break;
+      }
+    }
+  }
+  return props;
+}
+var EDGE_OPERATOR_REGEX = /(<-->|-->\|[^|]+\||-->|---\|[^|]+\||---|-\.->\|[^|]+\||-\.->|-\.-\|[^|]+\||-\.-|==>\|[^|]+\||==>|--o|--x)/;
+function tokenizeEdgeLine(line) {
+  const tokens = [];
+  let current = "";
+  let inBracket = 0;
+  let inParen = 0;
+  let inBrace = 0;
+  let inPipe = false;
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i];
+    if (char === "[") inBracket++;
+    else if (char === "]") inBracket--;
+    else if (char === "(") inParen++;
+    else if (char === ")") inParen--;
+    else if (char === "{") inBrace++;
+    else if (char === "}") inBrace--;
+    else if (char === "|") inPipe = !inPipe;
+    const inContainer = inBracket > 0 || inParen > 0 || inBrace > 0 || inPipe;
+    if (!inContainer && char === " ") {
+      if (current.trim()) {
+        tokens.push(current.trim());
+      }
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  if (current.trim()) {
+    tokens.push(current.trim());
+  }
+  const expandedTokens = [];
+  for (const token of tokens) {
+    const parts = token.split(EDGE_OPERATOR_REGEX).filter((p) => p);
+    if (parts.length > 1) {
+      expandedTokens.push(...parts);
+    } else {
+      expandedTokens.push(token);
+    }
+  }
+  return expandedTokens;
+}
+function parseFlowchart(input) {
+  const trimmedInput = input.trim();
+  const normalizedInput = trimmedInput.includes(";") ? trimmedInput.replace(/;/g, "\n") : trimmedInput;
+  const lines = normalizedInput.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("%%"));
+  if (lines.length === 0) {
+    throw new Error("Empty flowchart input");
+  }
+  const directionMatch = lines[0].match(DIRECTION_PATTERN);
+  if (!directionMatch) {
+    throw new Error(`Invalid flowchart header. Expected "graph LR|RL|TD|TB|BT" or "flowchart LR|RL|TD|TB|BT", got: "${lines[0]}"`);
+  }
+  let direction = directionMatch[1].toUpperCase();
+  if (direction === "TB") direction = "TD";
+  const graphDirection = direction;
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = [];
+  const styleClasses = /* @__PURE__ */ new Map();
+  const subgraphs = [];
+  const nodeClassAssignments = /* @__PURE__ */ new Map();
+  let nodeIndex = 0;
+  let edgeIndex = 0;
+  function getOrCreateNode(parsed) {
+    let node = nodes.get(parsed.id);
+    if (!node) {
+      node = {
+        id: parsed.id,
+        label: parsed.label,
+        shape: parsed.shape,
+        styleClass: parsed.styleClass,
+        index: nodeIndex++
+      };
+      nodes.set(parsed.id, node);
+    } else {
+      if (parsed.label !== parsed.id) {
+        node.label = parsed.label;
+      }
+      if (parsed.shape !== "rect") {
+        node.shape = parsed.shape;
+      }
+      if (parsed.styleClass) {
+        node.styleClass = parsed.styleClass;
+      }
+    }
+    return node;
+  }
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i];
+    const classDefMatch = line.match(CLASSDEF_PATTERN);
+    if (classDefMatch) {
+      const [, name, propsString] = classDefMatch;
+      const props = parseStyleClass(propsString);
+      styleClasses.set(name, { name, ...props });
+      continue;
+    }
+    const classAssignMatch = line.match(CLASS_ASSIGNMENT_PATTERN);
+    if (classAssignMatch) {
+      const [, nodeIds, className] = classAssignMatch;
+      for (const nodeId of nodeIds.split(",").map((s) => s.trim())) {
+        nodeClassAssignments.set(nodeId, className);
+      }
+      continue;
+    }
+    if (line.startsWith("subgraph") || line === "end") {
+      continue;
+    }
+    const tokens = tokenizeEdgeLine(line);
+    if (tokens.length === 0) continue;
+    if (tokens.length === 1) {
+      const ampersandParts = tokens[0].split(AMPERSAND_SPLIT);
+      for (const part of ampersandParts) {
+        const parsed = parseNodeDefinition(part);
+        getOrCreateNode(parsed);
+      }
+      continue;
+    }
+    let currentFromNodes = [];
+    let expectingEdge = false;
+    for (const token of tokens) {
+      const edgeOp = parseEdgeOperator(token);
+      if (edgeOp) {
+        expectingEdge = true;
+        continue;
+      }
+      const ampersandParts = token.split(AMPERSAND_SPLIT);
+      const parsedNodes = ampersandParts.map(parseNodeDefinition);
+      if (currentFromNodes.length > 0 && expectingEdge) {
+        const lastEdgeOp = (() => {
+          for (let j = tokens.indexOf(token) - 1; j >= 0; j--) {
+            const op = parseEdgeOperator(tokens[j]);
+            if (op) return op;
+          }
+          return { style: "solid", arrowType: "arrow", label: void 0, bidirectional: false };
+        })();
+        for (const fromParsed of currentFromNodes) {
+          const fromNode = getOrCreateNode(fromParsed);
+          for (const toParsed of parsedNodes) {
+            const toNode = getOrCreateNode(toParsed);
+            edges.push({
+              from: fromNode.id,
+              to: toNode.id,
+              label: lastEdgeOp.label,
+              style: lastEdgeOp.style,
+              arrowType: lastEdgeOp.arrowType,
+              bidirectional: lastEdgeOp.bidirectional,
+              index: edgeIndex++
+            });
+            if (lastEdgeOp.bidirectional) {
+              edges.push({
+                from: toNode.id,
+                to: fromNode.id,
+                style: lastEdgeOp.style,
+                arrowType: lastEdgeOp.arrowType,
+                bidirectional: false,
+                index: edgeIndex++
+              });
+            }
+          }
+        }
+      }
+      currentFromNodes = parsedNodes;
+      expectingEdge = false;
+    }
+  }
+  for (const [nodeId, className] of nodeClassAssignments) {
+    const node = nodes.get(nodeId);
+    if (node) {
+      node.styleClass = className;
+    }
+  }
+  return {
+    type: "flowchart",
+    direction: graphDirection,
+    nodes,
+    edges,
+    subgraphs,
+    styleClasses
+  };
+}
+
+// src/core/characters.ts
+var UNICODE_CHARS = {
+  box: {
+    topLeft: "\u250C",
+    topRight: "\u2510",
+    bottomLeft: "\u2514",
+    bottomRight: "\u2518",
+    horizontal: "\u2500",
+    vertical: "\u2502"
+  },
+  line: {
+    horizontal: "\u2500",
+    vertical: "\u2502",
+    dottedHorizontal: "\u2508",
+    dottedVertical: "\u250A",
+    thickHorizontal: "\u2501",
+    thickVertical: "\u2503"
+  },
+  arrow: {
+    up: "\u25B2",
+    down: "\u25BC",
+    left: "\u25C4",
+    right: "\u25BA",
+    upOpen: "\u25B3",
+    downOpen: "\u25BD",
+    leftOpen: "\u25C1",
+    rightOpen: "\u25B7",
+    circle: "\u25CF",
+    cross: "\xD7"
+  },
+  junction: {
+    cross: "\u253C",
+    leftT: "\u251C",
+    rightT: "\u2524",
+    topT: "\u252C",
+    bottomT: "\u2534"
+  }
+};
+var ASCII_CHARS = {
+  box: {
+    topLeft: "+",
+    topRight: "+",
+    bottomLeft: "+",
+    bottomRight: "+",
+    horizontal: "-",
+    vertical: "|"
+  },
+  line: {
+    horizontal: "-",
+    vertical: "|",
+    dottedHorizontal: ".",
+    dottedVertical: ":",
+    thickHorizontal: "=",
+    thickVertical: "#"
+  },
+  arrow: {
+    up: "^",
+    down: "v",
+    left: "<",
+    right: ">",
+    upOpen: "^",
+    downOpen: "v",
+    leftOpen: "<",
+    rightOpen: ">",
+    circle: "o",
+    cross: "x"
+  },
+  junction: {
+    cross: "+",
+    leftT: "+",
+    rightT: "+",
+    topT: "+",
+    bottomT: "+"
+  }
+};
+function getCharacterSet(charset) {
+  return charset === "unicode" ? UNICODE_CHARS : ASCII_CHARS;
+}
+var JUNCTION_MERGE_MAP = {
+  "\u2500": { "\u2502": "\u253C", "\u250C": "\u252C", "\u2510": "\u252C", "\u2514": "\u2534", "\u2518": "\u2534", "\u251C": "\u253C", "\u2524": "\u253C", "\u252C": "\u252C", "\u2534": "\u2534" },
+  "\u2502": { "\u2500": "\u253C", "\u250C": "\u251C", "\u2510": "\u2524", "\u2514": "\u251C", "\u2518": "\u2524", "\u252C": "\u253C", "\u2534": "\u253C", "\u251C": "\u251C", "\u2524": "\u2524" },
+  "\u250C": { "\u2500": "\u252C", "\u2502": "\u251C", "\u2518": "\u253C", "\u2510": "\u252C", "\u2514": "\u251C" },
+  "\u2510": { "\u2500": "\u252C", "\u2502": "\u2524", "\u2514": "\u253C", "\u250C": "\u252C", "\u2518": "\u2524" },
+  "\u2514": { "\u2500": "\u2534", "\u2502": "\u251C", "\u2510": "\u253C", "\u250C": "\u251C", "\u2518": "\u2534" },
+  "\u2518": { "\u2500": "\u2534", "\u2502": "\u2524", "\u250C": "\u253C", "\u2514": "\u2534", "\u2510": "\u2524" },
+  "\u251C": { "\u2500": "\u253C", "\u2524": "\u253C", "\u252C": "\u253C", "\u2534": "\u253C" },
+  "\u2524": { "\u2500": "\u253C", "\u251C": "\u253C", "\u252C": "\u253C", "\u2534": "\u253C" },
+  "\u252C": { "\u2502": "\u253C", "\u251C": "\u253C", "\u2524": "\u253C", "\u2534": "\u253C" },
+  "\u2534": { "\u2502": "\u253C", "\u251C": "\u253C", "\u2524": "\u253C", "\u252C": "\u253C" }
+};
+function mergeJunctionChars(existing, incoming) {
+  if (existing === " ") return incoming;
+  if (incoming === " ") return existing;
+  if (existing === incoming) return existing;
+  const merged = JUNCTION_MERGE_MAP[existing]?.[incoming];
+  if (merged) return merged;
+  const reverseMerged = JUNCTION_MERGE_MAP[incoming]?.[existing];
+  if (reverseMerged) return reverseMerged;
+  return incoming;
+}
+function isLineOrJunctionChar(char) {
+  return "\u2500\u2502\u251C\u2524\u252C\u2534\u253C\u2508\u250A\u2501\u2503-|+".includes(char);
+}
+function isJunctionChar(char) {
+  return "\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2508\u250A\u2501\u2503-|+".includes(char);
+}
+function isHorizontalChar(char) {
+  return "\u2500\u2508\u2501-\u2550".includes(char);
+}
+function isVerticalChar(char) {
+  return "\u2502\u250A\u2503|\u2551".includes(char);
+}
+function connectsLeft(char) {
+  return "\u2500\u2508\u2501-\u2550\u253C\u2534\u252C\u2524\u2518\u2510\u251C\u2514\u250C+\u25C4<\u25C1".includes(char);
+}
+function connectsRight(char) {
+  return "\u2500\u2508\u2501-\u2550\u253C\u2534\u252C\u251C\u2518\u2510\u2524\u2514\u250C+\u25BA>\u25B7".includes(char);
+}
+function connectsUp(char) {
+  return "\u2502\u250A\u2503|\u2551\u253C\u251C\u2524\u2534\u2518\u2514+\u25B2^\u25B3".includes(char);
+}
+function connectsDown(char) {
+  return "\u2502\u250A\u2503|\u2551\u253C\u251C\u2524\u252C\u2510\u250C+\u25BCv\u25BD".includes(char);
+}
+function getJunctionChar(up, down, left, right, charset) {
+  const chars = getCharacterSet(charset);
+  const count = [up, down, left, right].filter(Boolean).length;
+  if (count === 4) return chars.junction.cross;
+  if (count === 3) {
+    if (!up) return chars.junction.topT;
+    if (!down) return chars.junction.bottomT;
+    if (!left) return chars.junction.leftT;
+    if (!right) return chars.junction.rightT;
+  }
+  if (count === 2) {
+    if (up && down) return chars.line.vertical;
+    if (left && right) return chars.line.horizontal;
+    if (down && right) return chars.box.topLeft;
+    if (down && left) return chars.box.topRight;
+    if (up && right) return chars.box.bottomLeft;
+    if (up && left) return chars.box.bottomRight;
+  }
+  if (count === 1) {
+    if (up || down) return chars.line.vertical;
+    if (left || right) return chars.line.horizontal;
+  }
+  return " ";
+}
+
+// src/core/canvas.ts
+var Canvas = class {
+  constructor(width, height, charset = "unicode") {
+    this.width = width;
+    this.height = height;
+    this.grid = Array.from(
+      { length: height },
+      () => Array.from({ length: width }, () => " ")
+    );
+    this.chars = getCharacterSet(charset);
+  }
+  grid;
+  chars;
+  getWidth() {
+    return this.width;
+  }
+  getHeight() {
+    return this.height;
+  }
+  set(x, y, char) {
+    if (x >= 0 && x < this.width && y >= 0 && y < this.height) {
+      const existing = this.grid[y][x];
+      if (isLineOrJunctionChar(existing) && isLineOrJunctionChar(char)) {
+        this.grid[y][x] = mergeJunctionChars(existing, char);
+      } else if (existing === " " || !isLineOrJunctionChar(existing)) {
+        this.grid[y][x] = char;
+      }
+    }
+  }
+  forceSet(x, y, char) {
+    if (x >= 0 && x < this.width && y >= 0 && y < this.height) {
+      this.grid[y][x] = char;
+    }
+  }
+  get(x, y) {
+    if (x >= 0 && x < this.width && y >= 0 && y < this.height) {
+      return this.grid[y][x];
+    }
+    return " ";
+  }
+  drawText(x, y, text) {
+    for (let i = 0; i < text.length; i++) {
+      if (x + i < this.width) {
+        this.grid[y][x + i] = text[i];
+      }
+    }
+  }
+  drawHorizontalLine(x1, x2, y, char) {
+    const lineChar = char ?? this.chars.line.horizontal;
+    const startX = Math.min(x1, x2);
+    const endX = Math.max(x1, x2);
+    for (let x = startX; x <= endX; x++) {
+      this.set(x, y, lineChar);
+    }
+  }
+  drawVerticalLine(x, y1, y2, char) {
+    const lineChar = char ?? this.chars.line.vertical;
+    const startY = Math.min(y1, y2);
+    const endY = Math.max(y1, y2);
+    for (let y = startY; y <= endY; y++) {
+      this.set(x, y, lineChar);
+    }
+  }
+  drawBox(x, y, width, height) {
+    const { topLeft, topRight, bottomLeft, bottomRight, horizontal, vertical } = this.chars.box;
+    this.set(x, y, topLeft);
+    this.set(x + width - 1, y, topRight);
+    this.set(x, y + height - 1, bottomLeft);
+    this.set(x + width - 1, y + height - 1, bottomRight);
+    for (let i = 1; i < width - 1; i++) {
+      this.set(x + i, y, horizontal);
+      this.set(x + i, y + height - 1, horizontal);
+    }
+    for (let i = 1; i < height - 1; i++) {
+      this.set(x, y + i, vertical);
+      this.set(x + width - 1, y + i, vertical);
+    }
+  }
+  drawArrow(x, y, direction) {
+    this.set(x, y, this.chars.arrow[direction]);
+  }
+  expandTo(newWidth, newHeight) {
+    if (newWidth > this.width) {
+      for (const row of this.grid) {
+        while (row.length < newWidth) {
+          row.push(" ");
+        }
+      }
+      this.width = newWidth;
+    }
+    if (newHeight > this.height) {
+      while (this.grid.length < newHeight) {
+        this.grid.push(Array.from({ length: this.width }, () => " "));
+      }
+      this.height = newHeight;
+    }
+  }
+  merge(other, offsetX, offsetY) {
+    const requiredWidth = offsetX + other.getWidth();
+    const requiredHeight = offsetY + other.getHeight();
+    this.expandTo(requiredWidth, requiredHeight);
+    for (let y = 0; y < other.getHeight(); y++) {
+      for (let x = 0; x < other.getWidth(); x++) {
+        const char = other.get(x, y);
+        if (char !== " ") {
+          this.set(offsetX + x, offsetY + y, char);
+        }
+      }
+    }
+  }
+  fixJunctions() {
+    const junctionChars = "\u253C\u252C\u2534\u251C\u2524+";
+    for (let y = 0; y < this.height; y++) {
+      for (let x = 0; x < this.width; x++) {
+        const char = this.grid[y][x];
+        if (!junctionChars.includes(char)) continue;
+        const above = y > 0 ? this.grid[y - 1][x] : " ";
+        const below = y < this.height - 1 ? this.grid[y + 1][x] : " ";
+        const left = x > 0 ? this.grid[y][x - 1] : " ";
+        const right = x < this.width - 1 ? this.grid[y][x + 1] : " ";
+        const hasUp = connectsDown(above);
+        const hasDown = connectsUp(below);
+        const hasLeft = connectsRight(left);
+        const hasRight = connectsLeft(right);
+        const charset = this.chars === getCharacterSet("unicode") ? "unicode" : "ascii";
+        const corrected = getJunctionChar(hasUp, hasDown, hasLeft, hasRight, charset);
+        if (corrected !== char) {
+          this.grid[y][x] = corrected;
+        }
+      }
+    }
+  }
+  toString() {
+    this.fixJunctions();
+    return this.grid.map((row) => row.join("").trimEnd()).join("\n").trimEnd();
+  }
+  static fromCoord(coord) {
+    return { x: coord.x, y: coord.y };
+  }
+};
+
+// src/layout/sugiyama.ts
+function getOutgoingEdges(nodeId, edges) {
+  return edges.filter((e) => e.from === nodeId);
+}
+function getIncomingEdges(nodeId, edges) {
+  return edges.filter((e) => e.to === nodeId);
+}
+function detectCyclesAndBackEdges(nodes, edges) {
+  const backEdges = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const inStack = /* @__PURE__ */ new Set();
+  function dfs(nodeId) {
+    visited.add(nodeId);
+    inStack.add(nodeId);
+    for (const edge of getOutgoingEdges(nodeId, edges)) {
+      if (inStack.has(edge.to)) {
+        backEdges.add(edge);
+      } else if (!visited.has(edge.to)) {
+        dfs(edge.to);
+      }
+    }
+    inStack.delete(nodeId);
+  }
+  for (const nodeId of nodes.keys()) {
+    if (!visited.has(nodeId)) {
+      dfs(nodeId);
+    }
+  }
+  const forwardEdges = edges.filter((e) => !backEdges.has(e));
+  return { backEdges, forwardEdges };
+}
+function assignLayers(nodes, forwardEdges) {
+  const layers = /* @__PURE__ */ new Map();
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const nodeId of nodes.keys()) {
+    inDegree.set(nodeId, 0);
+  }
+  for (const edge of forwardEdges) {
+    inDegree.set(edge.to, (inDegree.get(edge.to) ?? 0) + 1);
+  }
+  const queue = [];
+  for (const [nodeId, degree] of inDegree) {
+    if (degree === 0) {
+      queue.push(nodeId);
+      layers.set(nodeId, 0);
+    }
+  }
+  while (queue.length > 0) {
+    const nodeId = queue.shift();
+    const currentLayer = layers.get(nodeId) ?? 0;
+    for (const edge of getOutgoingEdges(nodeId, forwardEdges)) {
+      const targetLayer = Math.max(layers.get(edge.to) ?? 0, currentLayer + 1);
+      layers.set(edge.to, targetLayer);
+      const newDegree = (inDegree.get(edge.to) ?? 1) - 1;
+      inDegree.set(edge.to, newDegree);
+      if (newDegree === 0) {
+        queue.push(edge.to);
+      }
+    }
+  }
+  for (const nodeId of nodes.keys()) {
+    if (!layers.has(nodeId)) {
+      layers.set(nodeId, 0);
+    }
+  }
+  return layers;
+}
+function orderNodesInLayers(nodes, edges, layers, backEdges) {
+  const layerNodes = /* @__PURE__ */ new Map();
+  for (const [nodeId, layer] of layers) {
+    if (!layerNodes.has(layer)) {
+      layerNodes.set(layer, []);
+    }
+    layerNodes.get(layer).push(nodeId);
+  }
+  const forwardEdges = edges.filter((e) => !backEdges.has(e));
+  for (let iteration = 0; iteration < 4; iteration++) {
+    const sortedLayers = [...layerNodes.keys()].sort((a, b) => a - b);
+    for (const layer of sortedLayers) {
+      if (layer === 0) {
+        const nodeIds2 = layerNodes.get(layer);
+        nodeIds2.sort((a, b) => (nodes.get(a)?.index ?? 0) - (nodes.get(b)?.index ?? 0));
+        continue;
+      }
+      const nodeIds = layerNodes.get(layer);
+      const prevLayerNodes = layerNodes.get(layer - 1) ?? [];
+      const prevPositions = new Map(prevLayerNodes.map((id, idx) => [id, idx]));
+      nodeIds.sort((a, b) => {
+        const aIncoming = getIncomingEdges(a, forwardEdges);
+        const bIncoming = getIncomingEdges(b, forwardEdges);
+        const aBarycenter = aIncoming.length > 0 ? aIncoming.reduce((sum, e) => sum + (prevPositions.get(e.from) ?? 0), 0) / aIncoming.length : nodes.get(a)?.index ?? 0;
+        const bBarycenter = bIncoming.length > 0 ? bIncoming.reduce((sum, e) => sum + (prevPositions.get(e.from) ?? 0), 0) / bIncoming.length : nodes.get(b)?.index ?? 0;
+        return aBarycenter - bBarycenter;
+      });
+    }
+  }
+  return layerNodes;
+}
+function assignGridCoordinates(nodes, layerNodes, direction, _options) {
+  const isHorizontal = direction === "LR" || direction === "RL";
+  const isReversed = direction === "RL" || direction === "BT";
+  const spacing = 1;
+  const maxLayer = Math.max(...layerNodes.keys(), 0);
+  for (const [layer, nodeIds] of layerNodes) {
+    const actualLayer = isReversed ? maxLayer - layer : layer;
+    for (let pos = 0; pos < nodeIds.length; pos++) {
+      const nodeId = nodeIds[pos];
+      const node = nodes.get(nodeId);
+      if (!node) continue;
+      if (isHorizontal) {
+        node.gridCoord = {
+          x: actualLayer * spacing,
+          y: pos * spacing
+        };
+      } else {
+        node.gridCoord = {
+          x: pos * spacing,
+          y: actualLayer * spacing
+        };
+      }
+    }
+  }
+}
+function calculateDimensions(nodes, options) {
+  const columnWidths = /* @__PURE__ */ new Map();
+  const rowHeights = /* @__PURE__ */ new Map();
+  for (const node of nodes.values()) {
+    if (!node.gridCoord) continue;
+    const labelWidth = node.label.length + options.borderPadding * 2 + 2;
+    const labelHeight = 1 + options.borderPadding * 2 + 2;
+    node.width = labelWidth;
+    node.height = labelHeight;
+    const col = node.gridCoord.x;
+    const row = node.gridCoord.y;
+    const currentColWidth = columnWidths.get(col) ?? 0;
+    columnWidths.set(col, Math.max(currentColWidth, labelWidth));
+    const currentRowHeight = rowHeights.get(row) ?? 0;
+    rowHeights.set(row, Math.max(currentRowHeight, labelHeight));
+  }
+  const maxCol = columnWidths.size > 0 ? Math.max(...columnWidths.keys()) : 0;
+  const maxRow = rowHeights.size > 0 ? Math.max(...rowHeights.keys()) : 0;
+  for (let i = 0; i <= maxCol; i++) {
+    if (!columnWidths.has(i)) {
+      columnWidths.set(i, options.paddingX);
+    }
+  }
+  for (let i = 0; i <= maxRow; i++) {
+    if (!rowHeights.has(i)) {
+      rowHeights.set(i, options.paddingY);
+    }
+  }
+  return { columnWidths, rowHeights };
+}
+function gridToDrawingCoord(gridCoord, columnWidths, rowHeights, paddingX, paddingY) {
+  let x = 0;
+  for (let col = 0; col < gridCoord.x; col++) {
+    x += (columnWidths.get(col) ?? 0) + paddingX;
+  }
+  let y = 0;
+  for (let row = 0; row < gridCoord.y; row++) {
+    y += (rowHeights.get(row) ?? 0) + paddingY;
+  }
+  return { x, y };
+}
+function layoutFlowchart(ast, options) {
+  const { nodes, edges, direction } = ast;
+  if (nodes.size === 0) {
+    return {
+      nodes,
+      edges,
+      backEdges: /* @__PURE__ */ new Set(),
+      width: 0,
+      height: 0,
+      columnWidths: /* @__PURE__ */ new Map(),
+      rowHeights: /* @__PURE__ */ new Map()
+    };
+  }
+  const { backEdges, forwardEdges } = detectCyclesAndBackEdges(nodes, edges);
+  const layers = assignLayers(nodes, forwardEdges);
+  const layerNodes = orderNodesInLayers(nodes, edges, layers, backEdges);
+  assignGridCoordinates(nodes, layerNodes, direction);
+  const { columnWidths, rowHeights } = calculateDimensions(nodes, options);
+  for (const node of nodes.values()) {
+    if (node.gridCoord) {
+      const baseCoord = gridToDrawingCoord(
+        node.gridCoord,
+        columnWidths,
+        rowHeights,
+        options.paddingX,
+        options.paddingY
+      );
+      const colWidth = columnWidths.get(node.gridCoord.x) ?? 0;
+      const rowHeight = rowHeights.get(node.gridCoord.y) ?? 0;
+      const nodeWidth = node.width ?? 0;
+      const nodeHeight = node.height ?? 0;
+      node.drawingCoord = {
+        x: baseCoord.x + Math.floor((colWidth - nodeWidth) / 2),
+        y: baseCoord.y + Math.floor((rowHeight - nodeHeight) / 2)
+      };
+    }
+  }
+  let totalWidth = 0;
+  for (const width of columnWidths.values()) {
+    totalWidth += width + options.paddingX;
+  }
+  let totalHeight = 0;
+  for (const height of rowHeights.values()) {
+    totalHeight += height + options.paddingY;
+  }
+  return {
+    nodes,
+    edges,
+    backEdges,
+    width: totalWidth,
+    height: totalHeight,
+    columnWidths,
+    rowHeights
+  };
+}
+
+// src/diagrams/flowchart/renderer.ts
+function drawNode(canvas, node) {
+  if (!node.drawingCoord || !node.width || !node.height) return;
+  const { x, y } = node.drawingCoord;
+  const { width, height } = node;
+  canvas.drawBox(x, y, width, height);
+  const textX = x + Math.floor((width - node.label.length) / 2);
+  const textY = y + Math.floor(height / 2);
+  canvas.drawText(textX, textY, node.label);
+}
+function getNodeCenter(node) {
+  if (!node.drawingCoord || !node.width || !node.height) {
+    return { x: 0, y: 0 };
+  }
+  const { x, y } = node.drawingCoord;
+  return {
+    x: x + Math.floor(node.width / 2),
+    y: y + Math.floor(node.height / 2)
+  };
+}
+function getNodeBorderPoint(node, direction) {
+  if (!node.drawingCoord || !node.width || !node.height) {
+    return { x: 0, y: 0 };
+  }
+  const { x, y } = node.drawingCoord;
+  const { width, height } = node;
+  const centerX = x + Math.floor(width / 2);
+  const centerY = y + Math.floor(height / 2);
+  switch (direction) {
+    case "right":
+      return { x: x + width - 1, y: centerY };
+    case "left":
+      return { x, y: centerY };
+    case "down":
+      return { x: centerX, y: y + height - 1 };
+    case "up":
+      return { x: centerX, y };
+  }
+}
+function determineEdgeDirection(fromNode, toNode, graphDirection) {
+  const fromCenter = getNodeCenter(fromNode);
+  const toCenter = getNodeCenter(toNode);
+  const dx = toCenter.x - fromCenter.x;
+  const dy = toCenter.y - fromCenter.y;
+  switch (graphDirection) {
+    case "LR":
+      if (dx > 0) return { startDir: "right", endDir: "left" };
+      if (dx < 0) return { startDir: "left", endDir: "right" };
+      return dy > 0 ? { startDir: "down", endDir: "up" } : { startDir: "up", endDir: "down" };
+    case "RL":
+      if (dx < 0) return { startDir: "left", endDir: "right" };
+      if (dx > 0) return { startDir: "right", endDir: "left" };
+      return dy > 0 ? { startDir: "down", endDir: "up" } : { startDir: "up", endDir: "down" };
+    case "TD":
+      if (dy > 0) return { startDir: "down", endDir: "up" };
+      if (dy < 0) return { startDir: "up", endDir: "down" };
+      return dx > 0 ? { startDir: "right", endDir: "left" } : { startDir: "left", endDir: "right" };
+    case "BT":
+      if (dy < 0) return { startDir: "up", endDir: "down" };
+      if (dy > 0) return { startDir: "down", endDir: "up" };
+      return dx > 0 ? { startDir: "right", endDir: "left" } : { startDir: "left", endDir: "right" };
+  }
+}
+function drawBackEdge(canvas, edge, fromNode, toNode, graphDirection, options) {
+  const chars = getCharacterSet(options.charset);
+  const isVertical = graphDirection === "TD" || graphDirection === "BT";
+  const hChar = edge.style === "dotted" ? chars.line.dottedHorizontal : edge.style === "thick" ? chars.line.thickHorizontal : chars.line.horizontal;
+  const vChar = edge.style === "dotted" ? chars.line.dottedVertical : edge.style === "thick" ? chars.line.thickVertical : chars.line.vertical;
+  if (isVertical) {
+    const fromRight = getNodeBorderPoint(fromNode, "right");
+    const toRight = getNodeBorderPoint(toNode, "right");
+    const loopX = Math.max(fromRight.x, toRight.x) + 3;
+    canvas.drawHorizontalLine(fromRight.x + 1, loopX, fromRight.y, hChar);
+    canvas.drawVerticalLine(loopX, Math.min(fromRight.y, toRight.y), Math.max(fromRight.y, toRight.y), vChar);
+    canvas.drawHorizontalLine(toRight.x + 1, loopX, toRight.y, hChar);
+  } else {
+    const fromBottom = getNodeBorderPoint(fromNode, "down");
+    const toBottom = getNodeBorderPoint(toNode, "down");
+    const loopY = Math.max(fromBottom.y, toBottom.y) + 2;
+    canvas.drawVerticalLine(fromBottom.x, fromBottom.y + 1, loopY, vChar);
+    canvas.drawHorizontalLine(Math.min(fromBottom.x, toBottom.x), Math.max(fromBottom.x, toBottom.x), loopY, hChar);
+    canvas.drawVerticalLine(toBottom.x, toBottom.y + 1, loopY, vChar);
+  }
+}
+function drawEdge(canvas, edge, fromNode, toNode, graphDirection, options, isBackEdge = false, sourceIndex = 0, totalFromSource = 1, targetIndex = 0, totalToTarget = 1) {
+  if (isBackEdge) {
+    drawBackEdge(canvas, edge, fromNode, toNode, graphDirection, options);
+    return;
+  }
+  const chars = getCharacterSet(options.charset);
+  const { startDir, endDir } = determineEdgeDirection(fromNode, toNode, graphDirection);
+  const startBorder = getNodeBorderPoint(fromNode, startDir);
+  const endBorder = getNodeBorderPoint(toNode, endDir);
+  const hChar = edge.style === "dotted" ? chars.line.dottedHorizontal : edge.style === "thick" ? chars.line.thickHorizontal : chars.line.horizontal;
+  const vChar = edge.style === "dotted" ? chars.line.dottedVertical : edge.style === "thick" ? chars.line.thickVertical : chars.line.vertical;
+  let startX = startBorder.x;
+  let startY = startBorder.y;
+  let endX = endBorder.x;
+  let endY = endBorder.y;
+  if (startDir === "right") startX += 1;
+  else if (startDir === "left") startX -= 1;
+  else if (startDir === "down") startY += 1;
+  else if (startDir === "up") startY -= 1;
+  const dx = Math.abs(endX - startX);
+  const dy = Math.abs(endY - startY);
+  const isVerticalPrimary = startDir === "down" || startDir === "up";
+  const isHorizontalPrimary = startDir === "left" || startDir === "right";
+  const alignmentTolerance = 3;
+  const effectivelyAlignedX = dx <= alignmentTolerance && isVerticalPrimary;
+  const effectivelyAlignedY = dy <= alignmentTolerance && isHorizontalPrimary;
+  if (startY === endY || effectivelyAlignedY) {
+    canvas.drawHorizontalLine(Math.min(startX, endX), Math.max(startX, endX), startY, hChar);
+  } else if (startX === endX || effectivelyAlignedX) {
+    canvas.drawVerticalLine(endX, Math.min(startY, endY), Math.max(startY, endY), vChar);
+  } else {
+    const isVerticalFirst = startDir === "down" || startDir === "up";
+    if (isVerticalFirst) {
+      const sourceOffset = totalFromSource > 1 ? (sourceIndex - Math.floor(totalFromSource / 2)) * 2 : 0;
+      const baseTurnY = endY + (endDir === "up" ? -2 : 2);
+      const turnY = totalToTarget > 1 ? baseTurnY : baseTurnY + sourceOffset;
+      canvas.drawVerticalLine(startX, Math.min(startY, turnY), Math.max(startY, turnY), vChar);
+      canvas.drawHorizontalLine(Math.min(startX, endX), Math.max(startX, endX), turnY, hChar);
+      if (targetIndex === 0) {
+        canvas.drawVerticalLine(endX, Math.min(turnY, endY), Math.max(turnY, endY), vChar);
+      }
+    } else {
+      const sourceOffset = totalFromSource > 1 ? (sourceIndex - Math.floor(totalFromSource / 2)) * 2 : 0;
+      const baseTurnX = endX + (endDir === "left" ? -2 : 2);
+      const turnX = totalToTarget > 1 ? baseTurnX : baseTurnX + sourceOffset;
+      canvas.drawHorizontalLine(Math.min(startX, turnX), Math.max(startX, turnX), startY, hChar);
+      canvas.drawVerticalLine(turnX, Math.min(startY, endY), Math.max(startY, endY), vChar);
+      if (targetIndex === 0) {
+        canvas.drawHorizontalLine(Math.min(turnX, endX), Math.max(turnX, endX), endY, hChar);
+      }
+    }
+  }
+  if (edge.label) {
+    const isHorizontalEdge = startY === endY || effectivelyAlignedY;
+    const isVerticalEdge = startX === endX || effectivelyAlignedX;
+    if (isHorizontalEdge) {
+      const availableSpace = Math.abs(endX - startX) - 2;
+      if (availableSpace >= edge.label.length) {
+        const midX = Math.floor((startX + endX) / 2);
+        const labelX = midX - Math.floor(edge.label.length / 2);
+        canvas.drawText(labelX, startY - 1, edge.label);
+      }
+    } else if (isVerticalEdge) {
+      const midY = Math.floor((startY + endY) / 2);
+      canvas.drawText(endX + 2, midY, edge.label);
+    } else {
+      const isVerticalFirst = startDir === "down" || startDir === "up";
+      if (isVerticalFirst) {
+        const labelX = endX + 1;
+        const labelY = endY - 2;
+        canvas.drawText(labelX, labelY, edge.label);
+      } else {
+        const labelY = Math.min(startY, endY) + Math.floor(Math.abs(endY - startY) / 2);
+        const labelX = endX + 2;
+        canvas.drawText(labelX, labelY, edge.label);
+      }
+    }
+  }
+}
+function renderFlowchart(ast, options) {
+  const layout = layoutFlowchart(ast, options);
+  if (layout.nodes.size === 0) {
+    return "";
+  }
+  const canvas = new Canvas(layout.width + 10, layout.height + 10, options.charset);
+  const edgesBySource = /* @__PURE__ */ new Map();
+  const edgesByTarget = /* @__PURE__ */ new Map();
+  for (const edge of layout.edges) {
+    const fromList = edgesBySource.get(edge.from) ?? [];
+    fromList.push(edge);
+    edgesBySource.set(edge.from, fromList);
+    const toList = edgesByTarget.get(edge.to) ?? [];
+    toList.push(edge);
+    edgesByTarget.set(edge.to, toList);
+  }
+  for (const edge of layout.edges) {
+    const fromNode = layout.nodes.get(edge.from);
+    const toNode = layout.nodes.get(edge.to);
+    if (fromNode && toNode) {
+      const isBackEdge = layout.backEdges.has(edge);
+      const edgesFromSameSource = edgesBySource.get(edge.from) ?? [];
+      const edgesToSameTarget = edgesByTarget.get(edge.to) ?? [];
+      const sourceIndex = edgesFromSameSource.indexOf(edge);
+      const targetIndex = edgesToSameTarget.indexOf(edge);
+      drawEdge(
+        canvas,
+        edge,
+        fromNode,
+        toNode,
+        ast.direction,
+        options,
+        isBackEdge,
+        sourceIndex,
+        edgesFromSameSource.length,
+        targetIndex,
+        edgesToSameTarget.length
+      );
+    }
+  }
+  for (const node of layout.nodes.values()) {
+    drawNode(canvas, node);
+  }
+  for (const edge of layout.edges) {
+    const toNode = layout.nodes.get(edge.to);
+    if (toNode && edge.arrowType !== "open") {
+      const isBackEdge = layout.backEdges.has(edge);
+      const chars = getCharacterSet(options.charset);
+      let endDir;
+      if (isBackEdge) {
+        const isVertical = ast.direction === "TD" || ast.direction === "BT";
+        endDir = isVertical ? "right" : "down";
+      } else {
+        endDir = determineEdgeDirection(
+          layout.nodes.get(edge.from),
+          toNode,
+          ast.direction
+        ).endDir;
+      }
+      const endBorder = getNodeBorderPoint(toNode, endDir);
+      const arrowChar = edge.arrowType === "arrow" ? endDir === "left" ? chars.arrow.right : endDir === "right" ? chars.arrow.left : endDir === "up" ? chars.arrow.down : chars.arrow.up : edge.arrowType === "circle" ? chars.arrow.circle : chars.arrow.cross;
+      canvas.forceSet(endBorder.x, endBorder.y, arrowChar);
+    }
+  }
+  return canvas.toString();
+}
+
+// src/diagrams/sequence/parser.ts
+var SEQUENCE_HEADER = /^sequenceDiagram\s*$/i;
+var PARTICIPANT_PATTERN = /^participant\s+(\S+)(?:\s+as\s+(.+))?$/i;
+var ACTOR_PATTERN = /^actor\s+(\S+)(?:\s+as\s+(.+))?$/i;
+var MESSAGE_PATTERNS = [
+  // Order matters: longer arrow patterns must come before shorter ones
+  { pattern: /^(\w+)\s*->>>\s*(\w+)\s*:\s*(.*)$/, style: "solid", arrowStyle: "filled" },
+  { pattern: /^(\w+)\s*-->>>\s*(\w+)\s*:\s*(.*)$/, style: "dotted", arrowStyle: "filled" },
+  { pattern: /^(\w+)\s*->>\s*(\w+)\s*:\s*(.*)$/, style: "solid", arrowStyle: "filled" },
+  { pattern: /^(\w+)\s*-->>\s*(\w+)\s*:\s*(.*)$/, style: "dotted", arrowStyle: "filled" },
+  { pattern: /^(\w+)\s*-->\s*(\w+)\s*:\s*(.*)$/, style: "dotted", arrowStyle: "open" },
+  { pattern: /^(\w+)\s*->\s*(\w+)\s*:\s*(.*)$/, style: "solid", arrowStyle: "open" },
+  { pattern: /^(\w+)\s*--x\s*(\w+)\s*:\s*(.*)$/, style: "dotted", arrowStyle: "filled" },
+  { pattern: /^(\w+)\s*-x\s*(\w+)\s*:\s*(.*)$/, style: "solid", arrowStyle: "filled" }
+];
+function getOrCreateParticipant(participants, id, alias) {
+  let participant = participants.get(id);
+  if (!participant) {
+    participant = {
+      id,
+      alias: alias ?? id,
+      index: participants.size
+    };
+    participants.set(id, participant);
+  } else if (alias && participant.alias === participant.id) {
+    participant.alias = alias;
+  }
+  return participant;
+}
+function parseSequence(input) {
+  const lines = input.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("%%"));
+  if (lines.length === 0) {
+    throw new Error("Empty sequence diagram input");
+  }
+  if (!SEQUENCE_HEADER.test(lines[0])) {
+    throw new Error(`Invalid sequence diagram header. Expected "sequenceDiagram", got: "${lines[0]}"`);
+  }
+  const participants = /* @__PURE__ */ new Map();
+  const messages = [];
+  let messageIndex = 0;
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("Note ") || line.startsWith("note ")) continue;
+    if (line.startsWith("loop ") || line.startsWith("alt ") || line.startsWith("opt ")) continue;
+    if (line === "end") continue;
+    if (line.startsWith("rect ")) continue;
+    if (line.startsWith("activate ") || line.startsWith("deactivate ")) continue;
+    const participantMatch = line.match(PARTICIPANT_PATTERN);
+    if (participantMatch) {
+      const [, id, alias] = participantMatch;
+      getOrCreateParticipant(participants, id, alias);
+      continue;
+    }
+    const actorMatch = line.match(ACTOR_PATTERN);
+    if (actorMatch) {
+      const [, id, alias] = actorMatch;
+      getOrCreateParticipant(participants, id, alias);
+      continue;
+    }
+    for (const { pattern, style, arrowStyle } of MESSAGE_PATTERNS) {
+      const match = line.match(pattern);
+      if (match) {
+        const [, from, to, text] = match;
+        getOrCreateParticipant(participants, from);
+        getOrCreateParticipant(participants, to);
+        messages.push({
+          from,
+          to,
+          text: text.trim(),
+          style,
+          arrowStyle,
+          index: messageIndex++
+        });
+        break;
+      }
+    }
+  }
+  return {
+    type: "sequence",
+    participants,
+    messages
+  };
+}
+
+// src/diagrams/sequence/renderer.ts
+var PARTICIPANT_BOX_HEIGHT = 3;
+var PARTICIPANT_PADDING = 2;
+var PARTICIPANT_GAP = 6;
+var MESSAGE_ROW_HEIGHT = 2;
+var LIFELINE_START_OFFSET = 2;
+function layoutSequence(ast, _options) {
+  const participantList = Array.from(ast.participants.values()).sort((a, b) => a.index - b.index);
+  const layouts = [];
+  const participantMap = /* @__PURE__ */ new Map();
+  let currentX = PARTICIPANT_PADDING;
+  for (const participant of participantList) {
+    const labelWidth = participant.alias.length;
+    const boxWidth = Math.max(labelWidth + 4, 7);
+    const layout = {
+      participant,
+      x: currentX,
+      width: boxWidth,
+      centerX: currentX + Math.floor(boxWidth / 2)
+    };
+    layouts.push(layout);
+    participantMap.set(participant.id, layout);
+    currentX += boxWidth + PARTICIPANT_GAP;
+  }
+  const totalWidth = currentX - PARTICIPANT_GAP + PARTICIPANT_PADDING;
+  const lifelineHeight = ast.messages.length * MESSAGE_ROW_HEIGHT + LIFELINE_START_OFFSET;
+  const totalHeight = PARTICIPANT_BOX_HEIGHT + lifelineHeight + PARTICIPANT_BOX_HEIGHT + 2;
+  return {
+    participants: layouts,
+    participantMap,
+    width: totalWidth,
+    height: totalHeight
+  };
+}
+function drawParticipantBox(canvas, layout, y) {
+  canvas.drawBox(layout.x, y, layout.width, PARTICIPANT_BOX_HEIGHT);
+  const textX = layout.x + Math.floor((layout.width - layout.participant.alias.length) / 2);
+  const textY = y + 1;
+  canvas.drawText(textX, textY, layout.participant.alias);
+}
+function drawLifeline(canvas, layout, startY, endY, chars) {
+  const x = layout.centerX;
+  for (let y = startY; y <= endY; y++) {
+    canvas.set(x, y, chars.line.vertical);
+  }
+}
+function drawMessage(canvas, message, fromLayout, toLayout, y, chars) {
+  const fromX = fromLayout.centerX;
+  const toX = toLayout.centerX;
+  const isSelfMessage = fromLayout.participant.id === toLayout.participant.id;
+  if (isSelfMessage) {
+    const loopWidth = 4;
+    const lineChar2 = message.style === "dotted" ? chars.line.dottedHorizontal : chars.line.horizontal;
+    const vChar = message.style === "dotted" ? chars.line.dottedVertical : chars.line.vertical;
+    canvas.drawHorizontalLine(fromX, fromX + loopWidth, y, lineChar2);
+    canvas.set(fromX + loopWidth, y, vChar);
+    canvas.set(fromX + loopWidth, y + 1, vChar);
+    canvas.drawHorizontalLine(fromX, fromX + loopWidth, y + 1, lineChar2);
+    canvas.forceSet(fromX, y + 1, chars.arrow.left);
+    if (message.text) {
+      canvas.drawText(fromX + loopWidth + 2, y, message.text);
+    }
+    return;
+  }
+  const isLeftToRight = fromX < toX;
+  const startX = isLeftToRight ? fromX + 1 : fromX - 1;
+  const endX = isLeftToRight ? toX - 1 : toX + 1;
+  const lineChar = message.style === "dotted" ? chars.line.dottedHorizontal : chars.line.horizontal;
+  canvas.drawHorizontalLine(startX, endX, y, lineChar);
+  const arrowChar = message.arrowStyle === "filled" ? isLeftToRight ? chars.arrow.right : chars.arrow.left : isLeftToRight ? chars.arrow.rightOpen : chars.arrow.leftOpen;
+  canvas.forceSet(isLeftToRight ? toX : toX, y, arrowChar);
+  if (message.text) {
+    const textLen = message.text.length;
+    const midX = Math.floor((fromX + toX) / 2);
+    const textX = midX - Math.floor(textLen / 2);
+    canvas.drawText(textX, y - 1, message.text);
+  }
+}
+function renderSequence(ast, options) {
+  if (ast.participants.size === 0) {
+    return "";
+  }
+  const layout = layoutSequence(ast);
+  const chars = getCharacterSet(options.charset);
+  const canvas = new Canvas(layout.width + 4, layout.height + 4, options.charset);
+  const topBoxY = options.paddingY;
+  for (const pLayout of layout.participants) {
+    drawParticipantBox(canvas, pLayout, topBoxY);
+  }
+  const lifelineStartY = topBoxY + PARTICIPANT_BOX_HEIGHT;
+  const messagesEndY = lifelineStartY + ast.messages.length * MESSAGE_ROW_HEIGHT + LIFELINE_START_OFFSET;
+  const bottomBoxY = messagesEndY + 1;
+  for (const pLayout of layout.participants) {
+    drawLifeline(canvas, pLayout, lifelineStartY, messagesEndY, chars);
+  }
+  for (const message of ast.messages) {
+    const fromLayout = layout.participantMap.get(message.from);
+    const toLayout = layout.participantMap.get(message.to);
+    if (fromLayout && toLayout) {
+      const messageY = lifelineStartY + LIFELINE_START_OFFSET + message.index * MESSAGE_ROW_HEIGHT;
+      drawMessage(canvas, message, fromLayout, toLayout, messageY, chars);
+    }
+  }
+  for (const pLayout of layout.participants) {
+    drawParticipantBox(canvas, pLayout, bottomBoxY);
+  }
+  return canvas.toString();
+}
+
+// src/index.ts
+var FLOWCHART_PATTERN = /^(?:graph|flowchart)\s+(LR|RL|TD|TB|BT)/im;
+var SEQUENCE_PATTERN = /^sequenceDiagram/im;
+var CLASS_PATTERN = /^classDiagram/im;
+var STATE_PATTERN = /^stateDiagram/im;
+var ER_PATTERN = /^erDiagram/im;
+function detectDiagramType(input) {
+  const trimmed = input.trim();
+  if (FLOWCHART_PATTERN.test(trimmed)) return "flowchart";
+  if (SEQUENCE_PATTERN.test(trimmed)) return "sequence";
+  if (CLASS_PATTERN.test(trimmed)) return "class";
+  if (STATE_PATTERN.test(trimmed)) return "state";
+  if (ER_PATTERN.test(trimmed)) return "er";
+  return "unknown";
+}
+function render(input, options = {}) {
+  const fullOptions = { ...DEFAULT_RENDER_OPTIONS, ...options };
+  const diagramType = detectDiagramType(input);
+  switch (diagramType) {
+    case "flowchart": {
+      const ast = parseFlowchart(input);
+      return renderFlowchart(ast, fullOptions);
+    }
+    case "sequence": {
+      const ast = parseSequence(input);
+      return renderSequence(ast, fullOptions);
+    }
+    case "class":
+      throw new Error("Class diagrams not yet implemented");
+    case "state":
+      throw new Error("State diagrams not yet implemented");
+    case "er":
+      throw new Error("ER diagrams not yet implemented");
+    case "unknown":
+      throw new Error(`Unknown diagram type. Input must start with a valid Mermaid diagram declaration (e.g., "graph LR", "sequenceDiagram", etc.)`);
+  }
+}
+function renderToFlowchart(input, options = {}) {
+  const fullOptions = { ...DEFAULT_RENDER_OPTIONS, ...options };
+  const ast = parseFlowchart(input);
+  return renderFlowchart(ast, fullOptions);
+}
+function renderToSequence(input, options = {}) {
+  const fullOptions = { ...DEFAULT_RENDER_OPTIONS, ...options };
+  const ast = parseSequence(input);
+  return renderSequence(ast, fullOptions);
+}
+
+exports.Canvas = Canvas;
+exports.DEFAULT_RENDER_OPTIONS = DEFAULT_RENDER_OPTIONS;
+exports.connectsDown = connectsDown;
+exports.connectsLeft = connectsLeft;
+exports.connectsRight = connectsRight;
+exports.connectsUp = connectsUp;
+exports.detectDiagramType = detectDiagramType;
+exports.getCharacterSet = getCharacterSet;
+exports.getJunctionChar = getJunctionChar;
+exports.isHorizontalChar = isHorizontalChar;
+exports.isJunctionChar = isJunctionChar;
+exports.isLineOrJunctionChar = isLineOrJunctionChar;
+exports.isVerticalChar = isVerticalChar;
+exports.layoutFlowchart = layoutFlowchart;
+exports.mergeJunctionChars = mergeJunctionChars;
+exports.parseFlowchart = parseFlowchart;
+exports.parseSequence = parseSequence;
+exports.render = render;
+exports.renderFlowchart = renderFlowchart;
+exports.renderSequence = renderSequence;
+exports.renderToFlowchart = renderToFlowchart;
+exports.renderToSequence = renderToSequence;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map