@statelyai/graph 0.1.0 → 0.3.1

package/dist/formats/mermaid/index.mjs

@@ -0,0 +1,2237 @@
+import { n as createFormatConverter } from "../../converter-CchokMDg.mjs";
+
+//#region src/formats/mermaid/shared.ts
+const MERMAID_TO_DIRECTION = {
+	TB: "down",
+	TD: "down",
+	BT: "up",
+	LR: "right",
+	RL: "left"
+};
+const DIRECTION_TO_MERMAID = {
+	down: "TD",
+	up: "BT",
+	right: "LR",
+	left: "RL"
+};
+/** Escape a label for Mermaid output (quotes special chars). */
+function escapeMermaidLabel(s) {
+	return s.replace(/\\/g, "\\\\").replace(/"/g, "#quot;").replace(/;/g, "#59;").replace(/#(?!quot;|59;|35;)/g, "#35;");
+}
+/** Unescape a Mermaid label back to plain text. */
+function unescapeMermaidLabel(s) {
+	return s.replace(/#quot;/g, "\"").replace(/#59;/g, ";").replace(/#35;/g, "#");
+}
+/** Generate a deterministic edge ID from source, target, and index. */
+function generateEdgeId(sourceId, targetId, index) {
+	return `${sourceId}-${targetId}-${index}`;
+}
+/** Strip `%%` single-line comments from Mermaid input. */
+function stripComments(input) {
+	return input.split("\n").map((line) => {
+		const idx = line.indexOf("%%");
+		if (idx === -1) return line;
+		if ((line.slice(0, idx).match(/"/g) || []).length % 2 !== 0) return line;
+		return line.slice(0, idx);
+	}).join("\n");
+}
+/** Strip `%%{init: ...}%%` directives and return them separately. */
+function stripDirectives(input) {
+	const directives = {};
+	return {
+		directives,
+		cleaned: input.replace(/%%\{[\s]*init[\s]*:[\s]*(.*?)[\s]*\}%%/gs, (_match, json) => {
+			try {
+				Object.assign(directives, JSON.parse(`{${json}}`));
+			} catch {}
+			return "";
+		})
+	};
+}
+/**
+* Split input into non-empty trimmed lines, stripping comments and directives.
+* Returns the cleaned lines and any extracted directives.
+*/
+function prepareLines(input) {
+	const { directives, cleaned } = stripDirectives(input);
+	return {
+		lines: stripComments(cleaned).split("\n").map((l) => l.trimEnd()).filter((l) => l.trim() !== ""),
+		directives
+	};
+}
+/** Validate input is a non-empty string, throw with prefix if not. */
+function validateInput(input, prefix) {
+	if (typeof input !== "string") throw new Error(`${prefix}: expected a string`);
+	if (!input.trim()) throw new Error(`${prefix}: input is empty`);
+}
+
+//#endregion
+//#region src/formats/mermaid/sequence.ts
+const ARROW_PATTERNS = [
+	["<<-->>", {
+		stroke: "dotted",
+		arrowType: "filled",
+		bidirectional: true
+	}],
+	["<<->>", {
+		stroke: "solid",
+		arrowType: "filled",
+		bidirectional: true
+	}],
+	["-->>", {
+		stroke: "dotted",
+		arrowType: "filled",
+		bidirectional: false
+	}],
+	["-->", {
+		stroke: "dotted",
+		arrowType: "open",
+		bidirectional: false
+	}],
+	["--x", {
+		stroke: "dotted",
+		arrowType: "cross",
+		bidirectional: false
+	}],
+	["--)", {
+		stroke: "dotted",
+		arrowType: "async",
+		bidirectional: false
+	}],
+	["->>", {
+		stroke: "solid",
+		arrowType: "filled",
+		bidirectional: false
+	}],
+	["->", {
+		stroke: "solid",
+		arrowType: "open",
+		bidirectional: false
+	}],
+	["-x", {
+		stroke: "solid",
+		arrowType: "cross",
+		bidirectional: false
+	}],
+	["-)", {
+		stroke: "solid",
+		arrowType: "async",
+		bidirectional: false
+	}]
+];
+function parseArrow(arrow) {
+	for (const [pattern, info] of ARROW_PATTERNS) if (arrow === pattern) return info;
+}
+const MESSAGE_RE = /^(\S+?)\s*(<<-->>|<<->>|-->>|-->|--x|--\)|->>|->|-x|-\))\s*(\S+?)\s*:\s*(.*)$/;
+/**
+* Parses a Mermaid sequence diagram string into a Graph.
+*
+* @example
+* const graph = fromMermaidSequence(`
+* sequenceDiagram
+*     participant Alice
+*     participant Bob
+*     Alice->>Bob: Hello
+*     Bob-->>Alice: Hi back
+* `);
+*/
+function fromMermaidSequence(input) {
+	validateInput(input, "Mermaid sequence");
+	const { lines } = prepareLines(input);
+	const header = lines[0]?.trim();
+	if (!header || !header.startsWith("sequenceDiagram")) throw new Error("Mermaid sequence: expected \"sequenceDiagram\" header");
+	const nodeMap = /* @__PURE__ */ new Map();
+	const edges = [];
+	const blocks = [];
+	let autonumber = false;
+	let edgeCounter = 0;
+	let seqNum = 0;
+	const blockStack = [];
+	function ensureNode(id, actorType = "participant") {
+		if (!nodeMap.has(id)) nodeMap.set(id, {
+			type: "node",
+			id,
+			parentId: null,
+			initialNodeId: null,
+			label: id,
+			data: { actorType }
+		});
+	}
+	function addEdge(edge) {
+		edges.push(edge);
+		if (blockStack.length > 0) {
+			const top = blockStack[blockStack.length - 1];
+			if (top.branches && top.branches.length > 0) top.branches[top.branches.length - 1].edgeIds.push(edge.id);
+			else if (top.options && top.options.length > 0) top.options[top.options.length - 1].edgeIds.push(edge.id);
+			else top.edgeIds.push(edge.id);
+		}
+	}
+	for (let i = 1; i < lines.length; i++) {
+		const line = lines[i].trim();
+		if (!line) continue;
+		if (line === "autonumber") {
+			autonumber = true;
+			continue;
+		}
+		const participantMatch = line.match(/^(participant|actor)\s+(\S+?)(?:\s+as\s+(.+))?$/);
+		if (participantMatch) {
+			const actorType = participantMatch[1];
+			const id = participantMatch[2];
+			const alias = participantMatch[3]?.trim();
+			ensureNode(id, actorType);
+			const node = nodeMap.get(id);
+			node.data.actorType = actorType;
+			if (alias) {
+				node.data.alias = alias;
+				node.label = alias;
+			}
+			continue;
+		}
+		const createMatch = line.match(/^create\s+(participant|actor)\s+(\S+?)(?:\s+as\s+(.+))?$/);
+		if (createMatch) {
+			const actorType = createMatch[1];
+			const id = createMatch[2];
+			const alias = createMatch[3]?.trim();
+			ensureNode(id, actorType);
+			const node = nodeMap.get(id);
+			node.data.created = true;
+			if (alias) {
+				node.data.alias = alias;
+				node.label = alias;
+			}
+			continue;
+		}
+		const destroyMatch = line.match(/^destroy\s+(\S+)$/);
+		if (destroyMatch) {
+			const id = destroyMatch[1];
+			ensureNode(id);
+			nodeMap.get(id).data.destroyed = true;
+			continue;
+		}
+		const activateMatch = line.match(/^(activate|deactivate)\s+(\S+)$/);
+		if (activateMatch) {
+			const kind = activateMatch[1] === "activate" ? "activation" : "deactivation";
+			const actorId = activateMatch[2];
+			ensureNode(actorId);
+			addEdge({
+				type: "edge",
+				id: generateEdgeId(actorId, actorId, edgeCounter++),
+				sourceId: actorId,
+				targetId: actorId,
+				label: "",
+				data: {
+					kind,
+					...autonumber && { sequenceNumber: ++seqNum }
+				}
+			});
+			continue;
+		}
+		if (/^(loop|alt|opt|par|critical|break)\s+/.test(line) || line.startsWith("rect ")) {
+			const spaceIdx = line.indexOf(" ");
+			const keyword = line.slice(0, spaceIdx);
+			const label = line.slice(spaceIdx + 1).trim();
+			if (keyword === "alt" || keyword === "par" || keyword === "critical") blockStack.push({
+				type: keyword,
+				label,
+				edgeIds: [],
+				branches: keyword === "par" ? [{
+					label,
+					edgeIds: []
+				}] : keyword === "alt" ? [{
+					label,
+					edgeIds: []
+				}] : void 0,
+				options: keyword === "critical" ? [] : void 0
+			});
+			else if (keyword === "rect") blockStack.push({
+				type: "rect",
+				label: "",
+				edgeIds: [],
+				color: label
+			});
+			else blockStack.push({
+				type: keyword,
+				label,
+				edgeIds: []
+			});
+			continue;
+		}
+		if (line.startsWith("else") || line === "else") {
+			if (blockStack.length > 0) {
+				const top = blockStack[blockStack.length - 1];
+				if (top.branches) {
+					const elseLabel = line.length > 4 ? line.slice(5).trim() : void 0;
+					top.branches.push({
+						label: elseLabel,
+						edgeIds: []
+					});
+				}
+			}
+			continue;
+		}
+		if (line.startsWith("and ")) {
+			if (blockStack.length > 0) {
+				const top = blockStack[blockStack.length - 1];
+				if (top.branches) top.branches.push({
+					label: line.slice(4).trim(),
+					edgeIds: []
+				});
+			}
+			continue;
+		}
+		if (line.startsWith("option ")) {
+			if (blockStack.length > 0) {
+				const top = blockStack[blockStack.length - 1];
+				if (top.options) top.options.push({
+					label: line.slice(7).trim(),
+					edgeIds: []
+				});
+			}
+			continue;
+		}
+		if (line === "end") {
+			if (blockStack.length > 0) {
+				const finished = blockStack.pop();
+				const block = buildBlock(finished);
+				if (block) {
+					if (blockStack.length > 0) blockStack[blockStack.length - 1].edgeIds.push(...finished.edgeIds, ...finished.branches?.flatMap((b) => b.edgeIds) ?? [], ...finished.options?.flatMap((o) => o.edgeIds) ?? []);
+					blocks.push(block);
+				}
+			}
+			continue;
+		}
+		if (/^Note\s+(left|right|over)\s+/i.test(line)) continue;
+		const msgMatch = line.match(MESSAGE_RE);
+		if (msgMatch) {
+			let sourceId = msgMatch[1];
+			const arrowStr = msgMatch[2];
+			let targetId = msgMatch[3];
+			const messageText = msgMatch[4].trim();
+			let activationOnTarget = null;
+			if (targetId.startsWith("+")) {
+				activationOnTarget = "activation";
+				targetId = targetId.slice(1);
+			} else if (targetId.startsWith("-")) {
+				activationOnTarget = "deactivation";
+				targetId = targetId.slice(1);
+			}
+			let activationOnSource = null;
+			if (sourceId.endsWith("+")) {
+				activationOnSource = "activation";
+				sourceId = sourceId.slice(0, -1);
+			} else if (sourceId.endsWith("-")) {
+				activationOnSource = "deactivation";
+				sourceId = sourceId.slice(0, -1);
+			}
+			ensureNode(sourceId);
+			ensureNode(targetId);
+			const arrowInfo = parseArrow(arrowStr);
+			if (!arrowInfo) continue;
+			const edgeId = generateEdgeId(sourceId, targetId, edgeCounter++);
+			const data = {
+				kind: "message",
+				stroke: arrowInfo.stroke,
+				arrowType: arrowInfo.arrowType,
+				...arrowInfo.bidirectional && { bidirectional: true },
+				...autonumber && { sequenceNumber: ++seqNum }
+			};
+			addEdge({
+				type: "edge",
+				id: edgeId,
+				sourceId,
+				targetId,
+				label: unescapeMermaidLabel(messageText),
+				data
+			});
+			if (activationOnTarget) addEdge({
+				type: "edge",
+				id: generateEdgeId(targetId, targetId, edgeCounter++),
+				sourceId: targetId,
+				targetId,
+				label: "",
+				data: { kind: activationOnTarget }
+			});
+			if (activationOnSource) addEdge({
+				type: "edge",
+				id: generateEdgeId(sourceId, sourceId, edgeCounter++),
+				sourceId,
+				targetId: sourceId,
+				label: "",
+				data: { kind: activationOnSource }
+			});
+			continue;
+		}
+	}
+	return {
+		id: "",
+		type: "directed",
+		initialNodeId: null,
+		nodes: Array.from(nodeMap.values()),
+		edges,
+		data: {
+			diagramType: "sequence",
+			...autonumber && { autonumber: true },
+			...blocks.length > 0 && { blocks }
+		}
+	};
+}
+function buildBlock(raw) {
+	switch (raw.type) {
+		case "loop": return {
+			type: "loop",
+			label: raw.label,
+			edgeIds: raw.edgeIds
+		};
+		case "alt": return {
+			type: "alt",
+			label: raw.label,
+			branches: raw.branches ?? [{ edgeIds: raw.edgeIds }]
+		};
+		case "opt": return {
+			type: "opt",
+			label: raw.label,
+			edgeIds: raw.edgeIds
+		};
+		case "par": return {
+			type: "par",
+			branches: (raw.branches ?? []).map((b) => ({
+				label: b.label ?? "",
+				edgeIds: b.edgeIds
+			}))
+		};
+		case "critical": return {
+			type: "critical",
+			label: raw.label,
+			edgeIds: raw.edgeIds,
+			...raw.options && raw.options.length > 0 && { options: raw.options }
+		};
+		case "break": return {
+			type: "break",
+			label: raw.label,
+			edgeIds: raw.edgeIds
+		};
+		case "rect": return {
+			type: "rect",
+			color: raw.color ?? "",
+			edgeIds: raw.edgeIds
+		};
+		default: return null;
+	}
+}
+const ARROW_MAP = {
+	solid: {
+		open: "->",
+		filled: "->>",
+		cross: "-x",
+		async: "-)"
+	},
+	dotted: {
+		open: "-->",
+		filled: "-->>",
+		cross: "--x",
+		async: "--)"
+	}
+};
+/**
+* Converts a sequence diagram Graph to a Mermaid sequence diagram string.
+*
+* @example
+* const mermaid = toMermaidSequence(graph);
+* // "sequenceDiagram\n    participant Alice\n    ..."
+*/
+function toMermaidSequence(graph) {
+	const lines = ["sequenceDiagram"];
+	const gd = graph.data;
+	if (gd?.autonumber) lines.push("    autonumber");
+	for (const node of graph.nodes) {
+		const d = node.data;
+		const keyword = d?.actorType === "actor" ? "actor" : "participant";
+		const alias = d?.alias ? ` as ${escapeMermaidLabel(d.alias)}` : "";
+		if (d?.created) lines.push(`    create ${keyword} ${node.id}${alias}`);
+		else lines.push(`    ${keyword} ${node.id}${alias}`);
+	}
+	const blocks = gd?.blocks ?? [];
+	const edgeIdSet = new Set(graph.edges.map((e) => e.id));
+	const beforeEdge = /* @__PURE__ */ new Map();
+	const afterEdge = /* @__PURE__ */ new Map();
+	for (const block of blocks) if (block.type === "alt") {
+		const firstEdge = block.branches[0]?.edgeIds[0];
+		if (firstEdge && edgeIdSet.has(firstEdge)) {
+			const events = beforeEdge.get(firstEdge) ?? [];
+			events.push({
+				type: "open",
+				block
+			});
+			beforeEdge.set(firstEdge, events);
+		}
+		for (let bi = 1; bi < block.branches.length; bi++) {
+			const branchFirstEdge = block.branches[bi]?.edgeIds[0];
+			if (branchFirstEdge && edgeIdSet.has(branchFirstEdge)) {
+				const events = beforeEdge.get(branchFirstEdge) ?? [];
+				events.push({
+					type: "branch",
+					block,
+					branchIndex: bi,
+					label: block.branches[bi].label
+				});
+				beforeEdge.set(branchFirstEdge, events);
+			}
+		}
+		const lastBranch = block.branches[block.branches.length - 1];
+		const lastEdge = lastBranch?.edgeIds[lastBranch.edgeIds.length - 1];
+		if (lastEdge && edgeIdSet.has(lastEdge)) {
+			const events = afterEdge.get(lastEdge) ?? [];
+			events.push({
+				type: "close",
+				block
+			});
+			afterEdge.set(lastEdge, events);
+		}
+	} else if (block.type === "par") {
+		const firstEdge = block.branches[0]?.edgeIds[0];
+		if (firstEdge && edgeIdSet.has(firstEdge)) {
+			const events = beforeEdge.get(firstEdge) ?? [];
+			events.push({
+				type: "open",
+				block
+			});
+			beforeEdge.set(firstEdge, events);
+		}
+		for (let bi = 1; bi < block.branches.length; bi++) {
+			const branchFirstEdge = block.branches[bi]?.edgeIds[0];
+			if (branchFirstEdge && edgeIdSet.has(branchFirstEdge)) {
+				const events = beforeEdge.get(branchFirstEdge) ?? [];
+				events.push({
+					type: "branch",
+					block,
+					branchIndex: bi,
+					label: block.branches[bi].label
+				});
+				beforeEdge.set(branchFirstEdge, events);
+			}
+		}
+		const lastBranch = block.branches[block.branches.length - 1];
+		const lastEdge = lastBranch?.edgeIds[lastBranch.edgeIds.length - 1];
+		if (lastEdge && edgeIdSet.has(lastEdge)) {
+			const events = afterEdge.get(lastEdge) ?? [];
+			events.push({
+				type: "close",
+				block
+			});
+			afterEdge.set(lastEdge, events);
+		}
+	} else if (block.type === "critical") {
+		const firstEdge = block.edgeIds[0];
+		if (firstEdge && edgeIdSet.has(firstEdge)) {
+			const events = beforeEdge.get(firstEdge) ?? [];
+			events.push({
+				type: "open",
+				block
+			});
+			beforeEdge.set(firstEdge, events);
+		}
+		if (block.options) for (const opt of block.options) {
+			const optFirstEdge = opt.edgeIds[0];
+			if (optFirstEdge && edgeIdSet.has(optFirstEdge)) {
+				const events = beforeEdge.get(optFirstEdge) ?? [];
+				events.push({
+					type: "branch",
+					block,
+					label: opt.label
+				});
+				beforeEdge.set(optFirstEdge, events);
+			}
+		}
+		const allEdgeIds = [...block.edgeIds, ...block.options?.flatMap((o) => o.edgeIds) ?? []];
+		const lastEdge = allEdgeIds[allEdgeIds.length - 1];
+		if (lastEdge && edgeIdSet.has(lastEdge)) {
+			const events = afterEdge.get(lastEdge) ?? [];
+			events.push({
+				type: "close",
+				block
+			});
+			afterEdge.set(lastEdge, events);
+		}
+	} else {
+		const edgeIds = block.edgeIds;
+		const firstEdge = edgeIds[0];
+		const lastEdge = edgeIds[edgeIds.length - 1];
+		if (firstEdge && edgeIdSet.has(firstEdge)) {
+			const events = beforeEdge.get(firstEdge) ?? [];
+			events.push({
+				type: "open",
+				block
+			});
+			beforeEdge.set(firstEdge, events);
+		}
+		if (lastEdge && edgeIdSet.has(lastEdge)) {
+			const events = afterEdge.get(lastEdge) ?? [];
+			events.push({
+				type: "close",
+				block
+			});
+			afterEdge.set(lastEdge, events);
+		}
+	}
+	let depth = 1;
+	const indent = () => "    ".repeat(depth);
+	for (const edge of graph.edges) {
+		const befores = beforeEdge.get(edge.id);
+		if (befores) {
+			for (const ev of befores) if (ev.type === "open") {
+				const b = ev.block;
+				if (b.type === "alt") lines.push(`${indent()}alt ${b.label}`);
+				else if (b.type === "par") lines.push(`${indent()}par ${b.branches[0].label}`);
+				else if (b.type === "critical") lines.push(`${indent()}critical ${b.label}`);
+				else if (b.type === "rect") lines.push(`${indent()}rect ${b.color}`);
+				else if (b.type === "loop" || b.type === "opt" || b.type === "break") lines.push(`${indent()}${b.type} ${b.label}`);
+				depth++;
+			} else if (ev.type === "branch") {
+				depth--;
+				const b = ev.block;
+				if (b.type === "alt") lines.push(`${indent()}else${ev.label ? ` ${ev.label}` : ""}`);
+				else if (b.type === "par") lines.push(`${indent()}and ${ev.label ?? ""}`);
+				else if (b.type === "critical") lines.push(`${indent()}option ${ev.label ?? ""}`);
+				depth++;
+			}
+		}
+		const d = edge.data;
+		if (!d) continue;
+		if (d.kind === "activation") lines.push(`${indent()}activate ${edge.sourceId}`);
+		else if (d.kind === "deactivation") lines.push(`${indent()}deactivate ${edge.sourceId}`);
+		else {
+			const stroke = d.stroke ?? "solid";
+			const arrowType = d.arrowType ?? "filled";
+			let arrow;
+			if (d.bidirectional) arrow = stroke === "dotted" ? "<<-->>" : "<<->>";
+			else arrow = ARROW_MAP[stroke]?.[arrowType] ?? "->>";
+			const label = edge.label ? `: ${escapeMermaidLabel(edge.label)}` : ":";
+			lines.push(`${indent()}${edge.sourceId}${arrow}${edge.targetId}${label}`);
+		}
+		const afters = afterEdge.get(edge.id);
+		if (afters) for (const _ev of afters) {
+			depth--;
+			lines.push(`${indent()}end`);
+		}
+	}
+	return lines.join("\n");
+}
+/**
+* Bidirectional converter for Mermaid sequence diagram format.
+*
+* @example
+* const graph = mermaidSequenceConverter.from(`
+* sequenceDiagram
+*     Alice->>Bob: Hello
+* `);
+* const str = mermaidSequenceConverter.to(graph);
+*/
+const mermaidSequenceConverter = createFormatConverter(toMermaidSequence, fromMermaidSequence);
+
+//#endregion
+//#region src/formats/mermaid/flowchart.ts
+const SHAPE_OPENERS = [
+	[
+		"(((",
+		")))",
+		"double-circle"
+	],
+	[
+		"((",
+		"))",
+		"circle"
+	],
+	[
+		"([",
+		"])",
+		"stadium"
+	],
+	[
+		"[(",
+		")]",
+		"cylinder"
+	],
+	[
+		"[[",
+		"]]",
+		"subroutine"
+	],
+	[
+		"{{",
+		"}}",
+		"hexagon"
+	],
+	[
+		"[/",
+		"/]",
+		"parallelogram"
+	],
+	[
+		"[\\",
+		"\\]",
+		"parallelogram-alt"
+	],
+	[
+		"[/",
+		"\\]",
+		"trapezoid"
+	],
+	[
+		"[\\",
+		"/]",
+		"trapezoid-alt"
+	],
+	[
+		"(",
+		")",
+		"rounded"
+	],
+	[
+		"{",
+		"}",
+		"diamond"
+	],
+	[
+		">",
+		"]",
+		"asymmetric"
+	],
+	[
+		"[",
+		"]",
+		"rectangle"
+	]
+];
+const SHAPE_TO_BRACKETS$1 = {};
+for (const [opener, closer, name] of SHAPE_OPENERS) SHAPE_TO_BRACKETS$1[name] = [opener, closer];
+function parseNodeDecl(text) {
+	for (const [opener, closer, shapeName] of SHAPE_OPENERS) {
+		const opIdx = text.indexOf(opener);
+		if (opIdx < 0) continue;
+		const id = text.slice(0, opIdx);
+		if (!id) continue;
+		if (!text.endsWith(closer)) continue;
+		return {
+			id,
+			label: text.slice(opIdx + opener.length, text.length - closer.length).trim(),
+			shape: shapeName
+		};
+	}
+	if (/^[a-zA-Z_][\w]*$/.test(text)) return {
+		id: text,
+		label: "",
+		shape: "rectangle"
+	};
+	return null;
+}
+const EDGE_ARROWS = [
+	[/^<===>$/, {
+		stroke: "thick",
+		arrowType: "arrow",
+		endMarker: "arrow",
+		startMarker: "arrow",
+		bidirectional: true
+	}],
+	[/^<==>$/, {
+		stroke: "thick",
+		arrowType: "arrow",
+		endMarker: "arrow",
+		startMarker: "arrow",
+		bidirectional: true
+	}],
+	[/^<-.->$/, {
+		stroke: "dotted",
+		arrowType: "arrow",
+		endMarker: "arrow",
+		startMarker: "arrow",
+		bidirectional: true
+	}],
+	[/^<-->$/, {
+		stroke: "normal",
+		arrowType: "arrow",
+		endMarker: "arrow",
+		startMarker: "arrow",
+		bidirectional: true
+	}],
+	[/^===>$/, {
+		stroke: "thick",
+		arrowType: "arrow",
+		endMarker: "arrow",
+		bidirectional: false
+	}],
+	[/^==>$/, {
+		stroke: "thick",
+		arrowType: "arrow",
+		endMarker: "arrow",
+		bidirectional: false
+	}],
+	[/^===$/, {
+		stroke: "thick",
+		arrowType: "none",
+		endMarker: "arrow",
+		bidirectional: false
+	}],
+	[/^-\.->$/, {
+		stroke: "dotted",
+		arrowType: "arrow",
+		endMarker: "arrow",
+		bidirectional: false
+	}],
+	[/^\.-\.>$/, {
+		stroke: "dotted",
+		arrowType: "arrow",
+		endMarker: "arrow",
+		bidirectional: false
+	}],
+	[/^-\.-$/, {
+		stroke: "dotted",
+		arrowType: "none",
+		endMarker: "arrow",
+		bidirectional: false
+	}],
+	[/^---o$/, {
+		stroke: "normal",
+		arrowType: "arrow",
+		endMarker: "circle",
+		bidirectional: false
+	}],
+	[/^--o$/, {
+		stroke: "normal",
+		arrowType: "arrow",
+		endMarker: "circle",
+		bidirectional: false
+	}],
+	[/^---x$/, {
+		stroke: "normal",
+		arrowType: "arrow",
+		endMarker: "cross",
+		bidirectional: false
+	}],
+	[/^--x$/, {
+		stroke: "normal",
+		arrowType: "arrow",
+		endMarker: "cross",
+		bidirectional: false
+	}],
+	[/^--->$/, {
+		stroke: "normal",
+		arrowType: "arrow",
+		endMarker: "arrow",
+		bidirectional: false
+	}],
+	[/^-->$/, {
+		stroke: "normal",
+		arrowType: "arrow",
+		endMarker: "arrow",
+		bidirectional: false
+	}],
+	[/^---$/, {
+		stroke: "normal",
+		arrowType: "none",
+		endMarker: "arrow",
+		bidirectional: false
+	}],
+	[/^--$/, {
+		stroke: "normal",
+		arrowType: "none",
+		endMarker: "arrow",
+		bidirectional: false
+	}]
+];
+function findEdge(line) {
+	const pipeMatch = line.match(/^(.+?)\s*([-=.<>ox]+)\|([^|]*)\|\s*(.+)$/);
+	if (pipeMatch) {
+		const arrowStr = pipeMatch[2];
+		for (const [re, info] of EDGE_ARROWS) if (re.test(arrowStr)) return {
+			sourceText: pipeMatch[1].trim(),
+			targetText: pipeMatch[4].trim(),
+			info: {
+				...info,
+				label: pipeMatch[3].trim()
+			},
+			rest: ""
+		};
+	}
+	const inlineMatch = line.match(/^(.+?)\s*(--)\s+([^-][^>]*?)\s*(-->)\s*(.+)$/);
+	if (inlineMatch) return {
+		sourceText: inlineMatch[1].trim(),
+		targetText: inlineMatch[5].trim(),
+		info: {
+			stroke: "normal",
+			arrowType: "arrow",
+			endMarker: "arrow",
+			bidirectional: false,
+			label: inlineMatch[3].trim()
+		},
+		rest: ""
+	};
+	for (const [re, info] of EDGE_ARROWS) {
+		const arrowSource = re.source.replace(/^\^/, "").replace(/\$$/, "");
+		const fullRe = /* @__PURE__ */ new RegExp(`^(.+?)\\s*(${arrowSource})\\s*(.+)$`);
+		const m = line.match(fullRe);
+		if (m) return {
+			sourceText: m[1].trim(),
+			targetText: m[3].trim(),
+			info: {
+				...info,
+				label: ""
+			},
+			rest: ""
+		};
+	}
+	return null;
+}
+/**
+* Parses a Mermaid flowchart string into a Graph.
+*
+* @example
+* const graph = fromMermaidFlowchart(`
+* flowchart TD
+*     A[Start] --> B{Decision}
+*     B -->|Yes| C[End]
+* `);
+*/
+function fromMermaidFlowchart(input) {
+	validateInput(input, "Mermaid flowchart");
+	const { lines } = prepareLines(input);
+	const headerMatch = (lines[0]?.trim())?.match(/^(graph|flowchart)\s+(TD|TB|BT|LR|RL)\s*$/);
+	if (!headerMatch) throw new Error("Mermaid flowchart: expected \"graph <direction>\" or \"flowchart <direction>\" header");
+	const direction = MERMAID_TO_DIRECTION[headerMatch[2]] ?? "down";
+	const nodeMap = /* @__PURE__ */ new Map();
+	const edges = [];
+	const classDefs = {};
+	const classAssignments = {};
+	let edgeCounter = 0;
+	const parentStack = [null];
+	function ensureNode(id, label, shape) {
+		if (!nodeMap.has(id)) nodeMap.set(id, {
+			type: "node",
+			id,
+			parentId: parentStack[parentStack.length - 1],
+			initialNodeId: null,
+			label: label ?? "",
+			data: {},
+			...shape && shape !== "rectangle" && { shape }
+		});
+		const node = nodeMap.get(id);
+		if (label && !node.label) node.label = label;
+		if (shape && shape !== "rectangle" && !node.shape) node.shape = shape;
+		return node;
+	}
+	for (let i = 1; i < lines.length; i++) {
+		const line = lines[i].trim();
+		if (!line) continue;
+		const subgraphMatch = line.match(/^subgraph\s+(\S+?)(?:\s*\[(.+)\])?\s*$/);
+		if (subgraphMatch) {
+			const subId = subgraphMatch[1];
+			ensureNode(subId, subgraphMatch[2]?.trim() ?? subId);
+			parentStack.push(subId);
+			continue;
+		}
+		if (/^direction\s+(TD|TB|BT|LR|RL)\s*$/.test(line)) continue;
+		if (line === "end") {
+			if (parentStack.length > 1) parentStack.pop();
+			continue;
+		}
+		const classDefMatch = line.match(/^classDef\s+(\S+)\s+(.+)$/);
+		if (classDefMatch) {
+			const className = classDefMatch[1];
+			const propsStr = classDefMatch[2];
+			const props = {};
+			for (const pair of propsStr.split(",")) {
+				const [k, v] = pair.split(":").map((s) => s.trim());
+				if (k && v) props[k] = v;
+			}
+			classDefs[className] = props;
+			continue;
+		}
+		const classAssignMatch = line.match(/^class\s+(.+)\s+(\S+)\s*$/);
+		if (classAssignMatch) {
+			const nodeIds = classAssignMatch[1].split(",").map((s) => s.trim());
+			const className = classAssignMatch[2];
+			for (const nid of nodeIds) {
+				if (!classAssignments[nid]) classAssignments[nid] = [];
+				classAssignments[nid].push(className);
+			}
+			continue;
+		}
+		const styleMatch = line.match(/^style\s+(\S+)\s+(.+)$/);
+		if (styleMatch) {
+			const nodeId = styleMatch[1];
+			const propsStr = styleMatch[2];
+			ensureNode(nodeId);
+			const node = nodeMap.get(nodeId);
+			const style = {};
+			for (const pair of propsStr.split(",")) {
+				const [k, v] = pair.split(":").map((s) => s.trim());
+				if (k && v) {
+					if (k === "fill") node.color = v;
+					style[k] = v;
+				}
+			}
+			if (Object.keys(style).length > 0) node.style = {
+				...node.style ?? {},
+				...style
+			};
+			continue;
+		}
+		if (line.startsWith("linkStyle ")) continue;
+		const clickMatch = line.match(/^click\s+(\S+)\s+"([^"]*)"(?:\s+"([^"]*)")?\s*$/);
+		if (clickMatch) {
+			const nodeId = clickMatch[1];
+			ensureNode(nodeId);
+			const node = nodeMap.get(nodeId);
+			node.data.link = clickMatch[2];
+			if (clickMatch[3]) node.data.tooltip = clickMatch[3];
+			continue;
+		}
+		let remaining = line;
+		let foundEdge = false;
+		while (remaining) {
+			const edgeResult = findEdge(remaining);
+			if (!edgeResult) break;
+			foundEdge = true;
+			const sourceDecl = parseNodeDecl(edgeResult.sourceText);
+			if (sourceDecl) ensureNode(sourceDecl.id, sourceDecl.label, sourceDecl.shape);
+			const targetDecl = parseNodeDecl(edgeResult.targetText);
+			let targetId;
+			if (targetDecl) {
+				ensureNode(targetDecl.id, targetDecl.label, targetDecl.shape);
+				targetId = targetDecl.id;
+				remaining = "";
+			} else {
+				const nextEdge = findEdge(edgeResult.targetText);
+				if (nextEdge) {
+					const tDecl = parseNodeDecl(nextEdge.sourceText);
+					if (tDecl) {
+						ensureNode(tDecl.id, tDecl.label, tDecl.shape);
+						targetId = tDecl.id;
+					} else {
+						targetId = nextEdge.sourceText;
+						ensureNode(targetId);
+					}
+					remaining = edgeResult.targetText;
+				} else {
+					targetId = edgeResult.targetText;
+					ensureNode(targetId);
+					remaining = "";
+				}
+			}
+			const sourceId = sourceDecl ? sourceDecl.id : edgeResult.sourceText;
+			ensureNode(sourceId);
+			const edgeId = generateEdgeId(sourceId, targetId, edgeCounter++);
+			const info = edgeResult.info;
+			edges.push({
+				type: "edge",
+				id: edgeId,
+				sourceId,
+				targetId,
+				label: info.label ? unescapeMermaidLabel(info.label) : "",
+				data: {
+					stroke: info.stroke,
+					arrowType: info.arrowType,
+					...info.endMarker !== "arrow" && { endMarker: info.endMarker },
+					...info.startMarker && { startMarker: info.startMarker },
+					...info.bidirectional && { bidirectional: true }
+				}
+			});
+		}
+		if (foundEdge) continue;
+		const nodeDecl = parseNodeDecl(line);
+		if (nodeDecl) {
+			ensureNode(nodeDecl.id, nodeDecl.label, nodeDecl.shape);
+			continue;
+		}
+		if (line.includes(";")) {
+			const stmts = line.split(";").map((s) => s.trim()).filter(Boolean);
+			for (const stmt of stmts) {
+				const nd = parseNodeDecl(stmt);
+				if (nd) ensureNode(nd.id, nd.label, nd.shape);
+			}
+		}
+	}
+	for (const [nodeId, classes] of Object.entries(classAssignments)) {
+		const node = nodeMap.get(nodeId);
+		if (node) {
+			node.data.classes = classes;
+			for (const cls of classes) {
+				const def = classDefs[cls];
+				if (def) {
+					if (def.fill) node.color = def.fill;
+					const style = {};
+					for (const [k, v] of Object.entries(def)) style[k] = v;
+					if (Object.keys(style).length > 0) node.style = {
+						...node.style ?? {},
+						...style
+					};
+				}
+			}
+		}
+	}
+	return {
+		id: "",
+		type: "directed",
+		initialNodeId: null,
+		nodes: Array.from(nodeMap.values()),
+		edges,
+		data: {
+			diagramType: "flowchart",
+			...Object.keys(classDefs).length > 0 && { classDefs }
+		},
+		direction
+	};
+}
+/**
+* Converts a flowchart Graph to a Mermaid flowchart string.
+*
+* @example
+* const mermaid = toMermaidFlowchart(graph);
+* // "flowchart TD\n    A[Start] --> B{Decision}\n    ..."
+*/
+function toMermaidFlowchart(graph) {
+	const lines = [`flowchart ${DIRECTION_TO_MERMAID[graph.direction ?? "down"] ?? "TD"}`];
+	const gd = graph.data;
+	if (gd?.classDefs) for (const [name, props] of Object.entries(gd.classDefs)) {
+		const propsStr = Object.entries(props).map(([k, v]) => `${k}:${v}`).join(",");
+		lines.push(`    classDef ${name} ${propsStr}`);
+	}
+	const childrenMap = /* @__PURE__ */ new Map();
+	for (const node of graph.nodes) {
+		const pid = node.parentId;
+		if (!childrenMap.has(pid)) childrenMap.set(pid, []);
+		childrenMap.get(pid).push(node);
+	}
+	const isParent = /* @__PURE__ */ new Set();
+	for (const node of graph.nodes) if (childrenMap.has(node.id)) isParent.add(node.id);
+	function writeNodes(parentId, indent) {
+		const children = childrenMap.get(parentId) ?? [];
+		for (const node of children) if (isParent.has(node.id)) {
+			const label = node.label ? `[${escapeMermaidLabel(node.label)}]` : "";
+			lines.push(`${indent}subgraph ${node.id}${label}`);
+			writeNodes(node.id, indent + "    ");
+			lines.push(`${indent}end`);
+		} else {
+			const brackets = SHAPE_TO_BRACKETS$1[node.shape ?? "rectangle"] ?? ["[", "]"];
+			const label = node.label ? `${brackets[0]}${escapeMermaidLabel(node.label)}${brackets[1]}` : "";
+			lines.push(`${indent}${node.id}${label}`);
+		}
+	}
+	writeNodes(null, "    ");
+	for (const edge of graph.edges) {
+		const d = edge.data;
+		let arrow;
+		if (d?.bidirectional) arrow = d.stroke === "thick" ? "<==>" : d.stroke === "dotted" ? "<-.->" : "<-->";
+		else if (d?.stroke === "thick") arrow = d.arrowType === "none" ? "===" : "==>";
+		else if (d?.stroke === "dotted") arrow = d.arrowType === "none" ? "-.-" : "-.->";
+		else if (d?.endMarker === "circle") arrow = "--o";
+		else if (d?.endMarker === "cross") arrow = "--x";
+		else arrow = d?.arrowType === "none" ? "---" : "-->";
+		let labelStr = "";
+		if (edge.label) labelStr = `|${escapeMermaidLabel(edge.label)}|`;
+		lines.push(`    ${edge.sourceId} ${arrow}${labelStr} ${edge.targetId}`);
+	}
+	const classAssignments = /* @__PURE__ */ new Map();
+	for (const node of graph.nodes) if (node.data?.classes) for (const cls of node.data.classes) {
+		if (!classAssignments.has(cls)) classAssignments.set(cls, []);
+		classAssignments.get(cls).push(node.id);
+	}
+	for (const [cls, nodeIds] of classAssignments) lines.push(`    class ${nodeIds.join(",")} ${cls}`);
+	for (const node of graph.nodes) if (node.data?.link) {
+		const tip = node.data.tooltip ? ` "${escapeMermaidLabel(node.data.tooltip)}"` : "";
+		lines.push(`    click ${node.id} "${escapeMermaidLabel(node.data.link)}"${tip}`);
+	}
+	return lines.join("\n");
+}
+/**
+* Bidirectional converter for Mermaid flowchart format.
+*
+* @example
+* const graph = mermaidFlowchartConverter.from(`
+* flowchart TD
+*     A --> B
+* `);
+* const str = mermaidFlowchartConverter.to(graph);
+*/
+const mermaidFlowchartConverter = createFormatConverter(toMermaidFlowchart, fromMermaidFlowchart);
+
+//#endregion
+//#region src/formats/mermaid/state.ts
+/**
+* Parses a Mermaid state diagram string into a Graph.
+*
+* @example
+* const graph = fromMermaidState(`
+* stateDiagram-v2
+*     [*] --> Idle
+*     Idle --> Running : start
+*     Running --> [*]
+* `);
+*/
+function fromMermaidState(input) {
+	validateInput(input, "Mermaid state");
+	const { lines } = prepareLines(input);
+	const header = lines[0]?.trim();
+	if (!header || !header.startsWith("stateDiagram-v2") && !header.startsWith("stateDiagram")) throw new Error("Mermaid state: expected \"stateDiagram\" or \"stateDiagram-v2\" header");
+	const nodeMap = /* @__PURE__ */ new Map();
+	const edges = [];
+	let edgeCounter = 0;
+	let startCounter = 0;
+	let endCounter = 0;
+	const parentStack = [null];
+	function ensureNode(id) {
+		if (!nodeMap.has(id)) nodeMap.set(id, {
+			type: "node",
+			id,
+			parentId: parentStack[parentStack.length - 1],
+			initialNodeId: null,
+			label: id,
+			data: {}
+		});
+		return nodeMap.get(id);
+	}
+	function resolveStarNode(position) {
+		if (position === "source") {
+			const id = `[*]_start_${startCounter++}`;
+			const node = ensureNode(id);
+			node.label = "[*]";
+			node.data.isStart = true;
+			node.shape = "start";
+			return id;
+		} else {
+			const id = `[*]_end_${endCounter++}`;
+			const node = ensureNode(id);
+			node.label = "[*]";
+			node.data.isEnd = true;
+			node.shape = "end";
+			return id;
+		}
+	}
+	for (let i = 1; i < lines.length; i++) {
+		const line = lines[i].trim();
+		if (!line) continue;
+		if (/^direction\s+(TD|TB|BT|LR|RL)\s*$/.test(line)) continue;
+		const compositeMatch = line.match(/^state\s+(\S+)\s*\{?\s*$/);
+		if (compositeMatch && line.includes("{")) {
+			const stateId = compositeMatch[1];
+			ensureNode(stateId);
+			parentStack.push(stateId);
+			continue;
+		}
+		const stereotypeMatch = line.match(/^state\s+(\S+)\s+<<(choice|fork|join)>>\s*$/);
+		if (stereotypeMatch) {
+			const stateId = stereotypeMatch[1];
+			const stateType = stereotypeMatch[2];
+			const node = ensureNode(stateId);
+			node.data.stateType = stateType;
+			node.shape = stateType;
+			continue;
+		}
+		const stateAsMatch = line.match(/^state\s+"([^"]+)"\s+as\s+(\S+)\s*$/);
+		if (stateAsMatch) {
+			const description = stateAsMatch[1];
+			const stateId = stateAsMatch[2];
+			const node = ensureNode(stateId);
+			node.data.description = description;
+			continue;
+		}
+		if (line === "}" || line === "end") {
+			if (parentStack.length > 1) parentStack.pop();
+			continue;
+		}
+		const noteMatch = line.match(/^note\s+(left|right)\s+of\s+(\S+)\s*:\s*(.+)$/i);
+		if (noteMatch) {
+			const position = noteMatch[1].toLowerCase();
+			const stateId = noteMatch[2];
+			const text = noteMatch[3].trim();
+			const node = ensureNode(stateId);
+			if (!node.data.notes) node.data.notes = [];
+			node.data.notes.push({
+				position,
+				text
+			});
+			continue;
+		}
+		const transMatch = line.match(/^(\S+)\s*-->\s*(\S+)\s*(?::\s*(.+))?$/);
+		if (transMatch) {
+			let sourceId = transMatch[1];
+			let targetId = transMatch[2];
+			const label = transMatch[3]?.trim() ?? "";
+			if (sourceId === "[*]") sourceId = resolveStarNode("source");
+			else ensureNode(sourceId);
+			if (targetId === "[*]") targetId = resolveStarNode("target");
+			else ensureNode(targetId);
+			const edgeId = generateEdgeId(sourceId, targetId, edgeCounter++);
+			edges.push({
+				type: "edge",
+				id: edgeId,
+				sourceId,
+				targetId,
+				label: label ? unescapeMermaidLabel(label) : "",
+				data: {}
+			});
+			continue;
+		}
+		const descMatch = line.match(/^(\S+)\s*:\s*(.+)$/);
+		if (descMatch) {
+			const stateId = descMatch[1];
+			const description = descMatch[2].trim();
+			const node = ensureNode(stateId);
+			node.data.description = description;
+			continue;
+		}
+		if (/^[a-zA-Z_][\w]*$/.test(line)) {
+			ensureNode(line);
+			continue;
+		}
+	}
+	return {
+		id: "",
+		type: "directed",
+		initialNodeId: null,
+		nodes: Array.from(nodeMap.values()),
+		edges,
+		data: { diagramType: "stateDiagram" }
+	};
+}
+/**
+* Converts a state diagram Graph to a Mermaid state diagram string.
+*
+* @example
+* const mermaid = toMermaidState(graph);
+* // "stateDiagram-v2\n    [*] --> Idle\n    ..."
+*/
+function toMermaidState(graph) {
+	const lines = ["stateDiagram-v2"];
+	const childrenMap = /* @__PURE__ */ new Map();
+	for (const node of graph.nodes) {
+		const pid = node.parentId;
+		if (!childrenMap.has(pid)) childrenMap.set(pid, []);
+		childrenMap.get(pid).push(node);
+	}
+	const isParent = /* @__PURE__ */ new Set();
+	for (const node of graph.nodes) if (childrenMap.has(node.id)) isParent.add(node.id);
+	function writeNodes(parentId, indent) {
+		const children = childrenMap.get(parentId) ?? [];
+		for (const node of children) {
+			if (node.data?.isStart || node.data?.isEnd) continue;
+			if (node.data?.stateType) lines.push(`${indent}state ${node.id} <<${node.data.stateType}>>`);
+			if (node.data?.description) lines.push(`${indent}state "${escapeMermaidLabel(node.data.description)}" as ${node.id}`);
+			if (isParent.has(node.id)) {
+				lines.push(`${indent}state ${node.id} {`);
+				writeNodes(node.id, indent + "    ");
+				lines.push(`${indent}}`);
+			}
+			if (node.data?.notes) for (const note of node.data.notes) lines.push(`${indent}note ${note.position} of ${node.id} : ${escapeMermaidLabel(note.text)}`);
+		}
+	}
+	writeNodes(null, "    ");
+	for (const edge of graph.edges) {
+		let sourceId = edge.sourceId;
+		let targetId = edge.targetId;
+		const sourceNode = graph.nodes.find((n) => n.id === sourceId);
+		const targetNode = graph.nodes.find((n) => n.id === targetId);
+		if (sourceNode?.data?.isStart) sourceId = "[*]";
+		if (targetNode?.data?.isEnd) targetId = "[*]";
+		const label = edge.label ? ` : ${escapeMermaidLabel(edge.label)}` : "";
+		lines.push(`    ${sourceId} --> ${targetId}${label}`);
+	}
+	return lines.join("\n");
+}
+/**
+* Bidirectional converter for Mermaid state diagram format.
+*
+* @example
+* const graph = mermaidStateConverter.from(`
+* stateDiagram-v2
+*     [*] --> Active
+* `);
+* const str = mermaidStateConverter.to(graph);
+*/
+const mermaidStateConverter = createFormatConverter(toMermaidState, fromMermaidState);
+
+//#endregion
+//#region src/formats/mermaid/class-diagram.ts
+const RELATIONSHIP_ARROWS = [
+	[
+		"<|--",
+		"inheritance",
+		true
+	],
+	[
+		"--|>",
+		"inheritance",
+		false
+	],
+	[
+		"<|..",
+		"realization",
+		true
+	],
+	[
+		"..|>",
+		"realization",
+		false
+	],
+	[
+		"*--",
+		"composition",
+		true
+	],
+	[
+		"--*",
+		"composition",
+		false
+	],
+	[
+		"o--",
+		"aggregation",
+		true
+	],
+	[
+		"--o",
+		"aggregation",
+		false
+	],
+	[
+		"<--",
+		"association",
+		true
+	],
+	[
+		"-->",
+		"association",
+		false
+	],
+	[
+		"<..",
+		"dependency",
+		true
+	],
+	[
+		"..>",
+		"dependency",
+		false
+	],
+	[
+		"--",
+		"link",
+		false
+	],
+	[
+		"..",
+		"dashed",
+		false
+	]
+];
+function parseRelationship(line) {
+	for (const [arrow, relationType, reversed] of RELATIONSHIP_ARROWS) {
+		const idx = line.indexOf(arrow);
+		if (idx < 0) continue;
+		let left = line.slice(0, idx).trim();
+		let right = line.slice(idx + arrow.length).trim();
+		let label = "";
+		const colonIdx = right.indexOf(":");
+		if (colonIdx >= 0) {
+			label = right.slice(colonIdx + 1).trim();
+			right = right.slice(0, colonIdx).trim();
+		}
+		let leftCard;
+		let rightCard;
+		const leftCardMatch = left.match(/^"([^"]+)"\s+(.+)$/);
+		if (leftCardMatch) {
+			leftCard = leftCardMatch[1];
+			left = leftCardMatch[2].trim();
+		} else {
+			const leftCardTrail = left.match(/^(.+?)\s+"([^"]+)"$/);
+			if (leftCardTrail) {
+				leftCard = leftCardTrail[2];
+				left = leftCardTrail[1].trim();
+			}
+		}
+		const rightCardMatch = right.match(/^"([^"]+)"\s+(.+)$/);
+		if (rightCardMatch) {
+			rightCard = rightCardMatch[1];
+			right = rightCardMatch[2].trim();
+		} else {
+			const rightCardTrail = right.match(/^(.+?)\s+"([^"]+)"$/);
+			if (rightCardTrail) {
+				rightCard = rightCardTrail[2];
+				right = rightCardTrail[1].trim();
+			}
+		}
+		if (!left || !right) continue;
+		if (reversed) return {
+			leftClass: right,
+			rightClass: left,
+			relationType,
+			label,
+			leftCard: rightCard,
+			rightCard: leftCard
+		};
+		return {
+			leftClass: left,
+			rightClass: right,
+			relationType,
+			label,
+			leftCard,
+			rightCard
+		};
+	}
+	return null;
+}
+function parseMember(line) {
+	const trimmed = line.trim();
+	let visibility = "+";
+	let rest = trimmed;
+	if (/^[+\-#~]/.test(rest)) {
+		visibility = rest[0];
+		rest = rest.slice(1).trim();
+	}
+	const isMethod = rest.includes("(");
+	let name = rest;
+	let type;
+	if (isMethod) {
+		const methodMatch = rest.match(/^(.+\))\s*(.+)?$/);
+		if (methodMatch) {
+			name = methodMatch[1];
+			type = methodMatch[2];
+		}
+	} else {
+		const fieldMatch = rest.match(/^(\S+)\s+(\S+)$/);
+		if (fieldMatch) {
+			type = fieldMatch[1];
+			name = fieldMatch[2];
+		}
+	}
+	return {
+		visibility,
+		name,
+		type,
+		isMethod
+	};
+}
+/**
+* Parses a Mermaid class diagram string into a Graph.
+*
+* @example
+* const graph = fromMermaidClass(`
+* classDiagram
+*     class Animal {
+*         +String name
+*         +eat() void
+*     }
+*     Animal <|-- Dog
+* `);
+*/
+function fromMermaidClass(input) {
+	validateInput(input, "Mermaid class");
+	const { lines } = prepareLines(input);
+	const header = lines[0]?.trim();
+	if (!header || !header.startsWith("classDiagram")) throw new Error("Mermaid class: expected \"classDiagram\" header");
+	const nodeMap = /* @__PURE__ */ new Map();
+	const edges = [];
+	let edgeCounter = 0;
+	function ensureNode(id) {
+		if (!nodeMap.has(id)) nodeMap.set(id, {
+			type: "node",
+			id,
+			parentId: null,
+			initialNodeId: null,
+			label: id,
+			data: {}
+		});
+		return nodeMap.get(id);
+	}
+	let currentClass = null;
+	let inClassBlock = false;
+	let braceDepth = 0;
+	for (let i = 1; i < lines.length; i++) {
+		const line = lines[i].trim();
+		if (!line) continue;
+		const classBlockMatch = line.match(/^class\s+(\S+?)(?:~(.+?)~)?\s*\{\s*$/);
+		if (classBlockMatch) {
+			currentClass = classBlockMatch[1];
+			const node = ensureNode(currentClass);
+			if (classBlockMatch[2]) node.data.genericType = classBlockMatch[2];
+			inClassBlock = true;
+			braceDepth = 1;
+			continue;
+		}
+		if (inClassBlock && currentClass) {
+			if (line === "}") {
+				braceDepth--;
+				if (braceDepth <= 0) {
+					inClassBlock = false;
+					currentClass = null;
+				}
+				continue;
+			}
+			const annotMatch = line.match(/^<<(.+)>>$/);
+			if (annotMatch) {
+				nodeMap.get(currentClass).data.annotation = annotMatch[1];
+				continue;
+			}
+			const node = nodeMap.get(currentClass);
+			if (!node.data.members) node.data.members = [];
+			node.data.members.push(parseMember(line));
+			continue;
+		}
+		const classInlineMatch = line.match(/^class\s+(\S+?)(?:~(.+?)~)?\s*$/);
+		if (classInlineMatch) {
+			const node = ensureNode(classInlineMatch[1]);
+			if (classInlineMatch[2]) node.data.genericType = classInlineMatch[2];
+			continue;
+		}
+		const annotLineMatch = line.match(/^<<(.+)>>\s+(\S+)\s*$/);
+		if (annotLineMatch) {
+			const node = ensureNode(annotLineMatch[2]);
+			node.data.annotation = annotLineMatch[1];
+			continue;
+		}
+		const inlineMemberMatch = line.match(/^(\S+)\s*:\s*(.+)$/);
+		if (inlineMemberMatch) {
+			if (!parseRelationship(line)) {
+				const node = ensureNode(inlineMemberMatch[1]);
+				if (!node.data.members) node.data.members = [];
+				node.data.members.push(parseMember(inlineMemberMatch[2]));
+				continue;
+			}
+		}
+		const rel = parseRelationship(line);
+		if (rel) {
+			ensureNode(rel.leftClass);
+			ensureNode(rel.rightClass);
+			const edgeId = generateEdgeId(rel.leftClass, rel.rightClass, edgeCounter++);
+			edges.push({
+				type: "edge",
+				id: edgeId,
+				sourceId: rel.leftClass,
+				targetId: rel.rightClass,
+				label: rel.label ? unescapeMermaidLabel(rel.label) : "",
+				data: {
+					relationType: rel.relationType,
+					...rel.leftCard && { sourceCardinality: rel.leftCard },
+					...rel.rightCard && { targetCardinality: rel.rightCard }
+				}
+			});
+			continue;
+		}
+	}
+	return {
+		id: "",
+		type: "directed",
+		initialNodeId: null,
+		nodes: Array.from(nodeMap.values()),
+		edges,
+		data: { diagramType: "classDiagram" }
+	};
+}
+const RELATION_TO_ARROW = {
+	inheritance: "--|>",
+	composition: "--*",
+	aggregation: "--o",
+	association: "-->",
+	dependency: "..>",
+	realization: "..|>",
+	link: "--",
+	dashed: ".."
+};
+const VISIBILITY_SYMBOLS = {
+	"+": "+",
+	"-": "-",
+	"#": "#",
+	"~": "~"
+};
+/**
+* Converts a class diagram Graph to a Mermaid class diagram string.
+*
+* @example
+* const mermaid = toMermaidClass(graph);
+* // "classDiagram\n    class Animal {\n    ..."
+*/
+function toMermaidClass(graph) {
+	const lines = ["classDiagram"];
+	for (const node of graph.nodes) if (node.data?.members && node.data.members.length > 0) {
+		const generic = node.data.genericType ? `~${node.data.genericType}~` : "";
+		lines.push(`    class ${node.id}${generic} {`);
+		if (node.data.annotation) lines.push(`        <<${node.data.annotation}>>`);
+		for (const m of node.data.members) {
+			const vis = VISIBILITY_SYMBOLS[m.visibility] ?? "+";
+			const typeStr = m.type ? m.isMethod ? ` ${m.type}` : `${m.type} ` : "";
+			if (m.isMethod) lines.push(`        ${vis}${m.name}${typeStr}`);
+			else lines.push(`        ${vis}${typeStr}${m.name}`);
+		}
+		lines.push(`    }`);
+	} else {
+		const generic = node.data?.genericType ? `~${node.data.genericType}~` : "";
+		lines.push(`    class ${node.id}${generic}`);
+		if (node.data?.annotation) lines.push(`    <<${node.data.annotation}>> ${node.id}`);
+	}
+	for (const edge of graph.edges) {
+		const arrow = RELATION_TO_ARROW[edge.data?.relationType ?? "association"] ?? "-->";
+		const srcCard = edge.data?.sourceCardinality ? `"${edge.data.sourceCardinality}" ` : "";
+		const tgtCard = edge.data?.targetCardinality ? ` "${edge.data.targetCardinality}"` : "";
+		const label = edge.label ? ` : ${escapeMermaidLabel(edge.label)}` : "";
+		lines.push(`    ${srcCard}${edge.sourceId} ${arrow} ${edge.targetId}${tgtCard}${label}`);
+	}
+	return lines.join("\n");
+}
+/**
+* Bidirectional converter for Mermaid class diagram format.
+*
+* @example
+* const graph = mermaidClassConverter.from(`
+* classDiagram
+*     Animal <|-- Dog
+* `);
+* const str = mermaidClassConverter.to(graph);
+*/
+const mermaidClassConverter = createFormatConverter(toMermaidClass, fromMermaidClass);
+
+//#endregion
+//#region src/formats/mermaid/er-diagram.ts
+const LEFT_CARDINALITY = {
+	"||": "one",
+	"|o": "zero-or-one",
+	"}|": "one-or-more",
+	"}o": "zero-or-more"
+};
+const RIGHT_CARDINALITY = {
+	"||": "one",
+	"o|": "zero-or-one",
+	"|{": "one-or-more",
+	"o{": "zero-or-more"
+};
+const CARDINALITY_TO_LEFT = {
+	one: "||",
+	"zero-or-one": "|o",
+	"one-or-more": "}|",
+	"zero-or-more": "}o"
+};
+const CARDINALITY_TO_RIGHT = {
+	one: "||",
+	"zero-or-one": "o|",
+	"one-or-more": "|{",
+	"zero-or-more": "o{"
+};
+function parseERRelationship(symbol) {
+	if (symbol.length < 6) return null;
+	const left = symbol.slice(0, 2);
+	const mid = symbol.slice(2, 4);
+	const right = symbol.slice(4, 6);
+	const srcCard = LEFT_CARDINALITY[left];
+	const tgtCard = RIGHT_CARDINALITY[right];
+	if (!srcCard || !tgtCard) return null;
+	let identifying;
+	if (mid === "--") identifying = true;
+	else if (mid === "..") identifying = false;
+	else return null;
+	return {
+		sourceCardinality: srcCard,
+		targetCardinality: tgtCard,
+		identifying
+	};
+}
+const ER_LINE_RE = /^(\S+)\s+([|}{o.][|}{o.][-.][-.][|}{o.][|}{o.])\s+(\S+)\s*:\s*"?([^"]*)"?\s*$/;
+/**
+* Parses a Mermaid ER diagram string into a Graph.
+*
+* @example
+* const graph = fromMermaidER(`
+* erDiagram
+*     CUSTOMER ||--o{ ORDER : places
+*     ORDER ||--|{ LINE_ITEM : contains
+* `);
+*/
+function fromMermaidER(input) {
+	validateInput(input, "Mermaid ER");
+	const { lines } = prepareLines(input);
+	const header = lines[0]?.trim();
+	if (!header || !header.startsWith("erDiagram")) throw new Error("Mermaid ER: expected \"erDiagram\" header");
+	const nodeMap = /* @__PURE__ */ new Map();
+	const edges = [];
+	let edgeCounter = 0;
+	function ensureNode(id) {
+		if (!nodeMap.has(id)) nodeMap.set(id, {
+			type: "node",
+			id,
+			parentId: null,
+			initialNodeId: null,
+			label: id,
+			data: {}
+		});
+		return nodeMap.get(id);
+	}
+	let currentEntity = null;
+	let inBlock = false;
+	for (let i = 1; i < lines.length; i++) {
+		const line = lines[i].trim();
+		if (!line) continue;
+		const blockMatch = line.match(/^(\S+)\s*\{\s*$/);
+		if (blockMatch) {
+			currentEntity = blockMatch[1];
+			ensureNode(currentEntity);
+			inBlock = true;
+			continue;
+		}
+		if (inBlock && currentEntity) {
+			if (line === "}") {
+				inBlock = false;
+				currentEntity = null;
+				continue;
+			}
+			const attrMatch = line.match(/^(\S+)\s+(\S+)(?:\s+(PK|FK|UK))?(?:\s+"([^"]*)")?$/);
+			if (attrMatch) {
+				const node = nodeMap.get(currentEntity);
+				if (!node.data.attributes) node.data.attributes = [];
+				node.data.attributes.push({
+					type: attrMatch[1],
+					name: attrMatch[2],
+					...attrMatch[3] && { key: attrMatch[3] },
+					...attrMatch[4] && { comment: attrMatch[4] }
+				});
+			}
+			continue;
+		}
+		const relMatch = line.match(ER_LINE_RE);
+		if (relMatch) {
+			const leftEntity = relMatch[1];
+			const symbol = relMatch[2];
+			const rightEntity = relMatch[3];
+			const label = relMatch[4].trim();
+			ensureNode(leftEntity);
+			ensureNode(rightEntity);
+			const rel = parseERRelationship(symbol);
+			if (rel) {
+				const edgeId = generateEdgeId(leftEntity, rightEntity, edgeCounter++);
+				edges.push({
+					type: "edge",
+					id: edgeId,
+					sourceId: leftEntity,
+					targetId: rightEntity,
+					label: label ? unescapeMermaidLabel(label) : "",
+					data: rel
+				});
+			}
+			continue;
+		}
+		if (/^[A-Z_][\w]*$/i.test(line)) ensureNode(line);
+	}
+	return {
+		id: "",
+		type: "directed",
+		initialNodeId: null,
+		nodes: Array.from(nodeMap.values()),
+		edges,
+		data: { diagramType: "erDiagram" }
+	};
+}
+/**
+* Converts an ER diagram Graph to a Mermaid ER diagram string.
+*
+* @example
+* const mermaid = toMermaidER(graph);
+* // "erDiagram\n    CUSTOMER ||--o{ ORDER : \"places\"\n    ..."
+*/
+function toMermaidER(graph) {
+	const lines = ["erDiagram"];
+	for (const node of graph.nodes) if (node.data?.attributes && node.data.attributes.length > 0) {
+		lines.push(`    ${node.id} {`);
+		for (const attr of node.data.attributes) {
+			const keyStr = attr.key ? ` ${attr.key}` : "";
+			const commentStr = attr.comment ? ` "${escapeMermaidLabel(attr.comment)}"` : "";
+			lines.push(`        ${attr.type} ${attr.name}${keyStr}${commentStr}`);
+		}
+		lines.push(`    }`);
+	}
+	for (const edge of graph.edges) {
+		const d = edge.data;
+		if (!d) continue;
+		const leftMark = CARDINALITY_TO_LEFT[d.sourceCardinality] ?? "||";
+		const rightMark = CARDINALITY_TO_RIGHT[d.targetCardinality] ?? "||";
+		const symbol = `${leftMark}${d.identifying ? "--" : ".."}${rightMark}`;
+		const label = edge.label ? `"${escapeMermaidLabel(edge.label)}"` : "\"\"";
+		lines.push(`    ${edge.sourceId} ${symbol} ${edge.targetId} : ${label}`);
+	}
+	return lines.join("\n");
+}
+/**
+* Bidirectional converter for Mermaid ER diagram format.
+*
+* @example
+* const graph = mermaidERConverter.from(`
+* erDiagram
+*     CUSTOMER ||--o{ ORDER : places
+* `);
+* const str = mermaidERConverter.to(graph);
+*/
+const mermaidERConverter = createFormatConverter(toMermaidER, fromMermaidER);
+
+//#endregion
+//#region src/formats/mermaid/mindmap.ts
+const SHAPE_PATTERNS = [
+	[
+		"(((",
+		")))",
+		"double-circle"
+	],
+	[
+		"((",
+		"))",
+		"circle"
+	],
+	[
+		"([",
+		"])",
+		"stadium"
+	],
+	[
+		"{{",
+		"}}",
+		"hexagon"
+	],
+	[
+		"(",
+		")",
+		"rounded"
+	],
+	[
+		"[",
+		"]",
+		"rectangle"
+	]
+];
+const SHAPE_TO_BRACKETS = {};
+for (const [opener, closer, name] of SHAPE_PATTERNS) SHAPE_TO_BRACKETS[name] = [opener, closer];
+function parseNodeText(text) {
+	for (const [opener, closer, shapeName] of SHAPE_PATTERNS) if (text.startsWith(opener) && text.endsWith(closer)) return {
+		label: text.slice(opener.length, text.length - closer.length).trim(),
+		shape: shapeName
+	};
+	return { label: text.trim() };
+}
+/**
+* Parses a Mermaid mindmap string into a Graph.
+*
+* @example
+* const graph = fromMermaidMindmap(`
+* mindmap
+*   Root
+*     Child A
+*       Grandchild
+*     Child B
+* `);
+*/
+function fromMermaidMindmap(input) {
+	validateInput(input, "Mermaid mindmap");
+	const { lines } = prepareLines(input);
+	const header = lines[0]?.trim();
+	if (!header || !header.startsWith("mindmap")) throw new Error("Mermaid mindmap: expected \"mindmap\" header");
+	const nodeMap = /* @__PURE__ */ new Map();
+	const edges = [];
+	let nodeCounter = 0;
+	let edgeCounter = 0;
+	const stack = [];
+	for (let i = 1; i < lines.length; i++) {
+		const rawLine = lines[i];
+		if (!rawLine.trim()) continue;
+		const indent = rawLine.length - rawLine.trimStart().length;
+		const content = rawLine.trim();
+		let icon;
+		let cleanContent = content;
+		const iconMatch = content.match(/::icon\(([^)]+)\)/);
+		if (iconMatch) {
+			icon = iconMatch[1];
+			cleanContent = content.replace(/::icon\([^)]+\)/, "").trim();
+		}
+		const { label, shape } = parseNodeText(cleanContent);
+		const id = `mm_${nodeCounter++}`;
+		const node = {
+			type: "node",
+			id,
+			parentId: null,
+			initialNodeId: null,
+			label,
+			data: { ...icon && { icon } },
+			...shape && { shape }
+		};
+		while (stack.length > 0 && stack[stack.length - 1].indent >= indent) stack.pop();
+		if (stack.length > 0) {
+			const parent = stack[stack.length - 1];
+			node.parentId = parent.id;
+			const edgeId = generateEdgeId(parent.id, id, edgeCounter++);
+			edges.push({
+				type: "edge",
+				id: edgeId,
+				sourceId: parent.id,
+				targetId: id,
+				label: "",
+				data: {}
+			});
+		}
+		nodeMap.set(id, node);
+		stack.push({
+			id,
+			indent
+		});
+	}
+	return {
+		id: "",
+		type: "directed",
+		initialNodeId: null,
+		nodes: Array.from(nodeMap.values()),
+		edges,
+		data: { diagramType: "mindmap" }
+	};
+}
+/**
+* Converts a mindmap Graph to a Mermaid mindmap string.
+*
+* @example
+* const mermaid = toMermaidMindmap(graph);
+* // "mindmap\n  Root\n    Child A\n    ..."
+*/
+function toMermaidMindmap(graph) {
+	const lines = ["mindmap"];
+	const childrenMap = /* @__PURE__ */ new Map();
+	for (const node of graph.nodes) {
+		const pid = node.parentId;
+		if (!childrenMap.has(pid)) childrenMap.set(pid, []);
+		childrenMap.get(pid).push(node);
+	}
+	function writeNode(nodeId, depth) {
+		const children = childrenMap.get(nodeId) ?? [];
+		for (const child of children) {
+			const indent = "  ".repeat(depth + 1);
+			const shape = child.shape;
+			const brackets = shape ? SHAPE_TO_BRACKETS[shape] : void 0;
+			const label = escapeMermaidLabel(child.label);
+			const text = brackets ? `${brackets[0]}${label}${brackets[1]}` : label;
+			let extra = "";
+			if (child.data?.icon) extra = `\n${"  ".repeat(depth + 2)}::icon(${child.data.icon})`;
+			lines.push(`${indent}${text}${extra}`);
+			writeNode(child.id, depth + 1);
+		}
+	}
+	writeNode(null, 0);
+	return lines.join("\n");
+}
+/**
+* Bidirectional converter for Mermaid mindmap format.
+*
+* @example
+* const graph = mermaidMindmapConverter.from(`
+* mindmap
+*   Root
+*     Branch
+* `);
+* const str = mermaidMindmapConverter.to(graph);
+*/
+const mermaidMindmapConverter = createFormatConverter(toMermaidMindmap, fromMermaidMindmap);
+
+//#endregion
+//#region src/formats/mermaid/block.ts
+const BLOCK_SHAPES = [
+	[
+		"((",
+		"))",
+		"circle"
+	],
+	[
+		"(",
+		")",
+		"rounded"
+	],
+	[
+		"{{",
+		"}}",
+		"hexagon"
+	],
+	[
+		"{",
+		"}",
+		"diamond"
+	],
+	[
+		"[[",
+		"]]",
+		"subroutine"
+	],
+	[
+		"[",
+		"]",
+		"rectangle"
+	]
+];
+function parseBlockNode(text) {
+	for (const [opener, closer, shapeName] of BLOCK_SHAPES) {
+		const idx = text.indexOf(opener);
+		if (idx < 0) continue;
+		const id = text.slice(0, idx).trim();
+		if (!id) continue;
+		if (!text.endsWith(closer)) continue;
+		return {
+			id,
+			label: text.slice(idx + opener.length, text.length - closer.length).trim(),
+			shape: shapeName
+		};
+	}
+	if (/^[a-zA-Z_][\w]*$/.test(text.trim())) return {
+		id: text.trim(),
+		label: "",
+		shape: void 0
+	};
+	return null;
+}
+/**
+* Parses a Mermaid block diagram string into a Graph.
+*
+* @example
+* const graph = fromMermaidBlock(`
+* block-beta
+*     columns 2
+*     a["Task A"] b["Task B"]
+*     a --> b
+* `);
+*/
+function fromMermaidBlock(input) {
+	validateInput(input, "Mermaid block");
+	const { lines } = prepareLines(input);
+	const header = lines[0]?.trim();
+	if (!header || !header.startsWith("block-beta")) throw new Error("Mermaid block: expected \"block-beta\" header");
+	const nodeMap = /* @__PURE__ */ new Map();
+	const edges = [];
+	let edgeCounter = 0;
+	let columns;
+	const parentStack = [null];
+	let blockCounter = 0;
+	function ensureNode(id, label, shape) {
+		if (!nodeMap.has(id)) nodeMap.set(id, {
+			type: "node",
+			id,
+			parentId: parentStack[parentStack.length - 1],
+			initialNodeId: null,
+			label: label ?? id,
+			data: {},
+			...shape && { shape }
+		});
+		return nodeMap.get(id);
+	}
+	for (let i = 1; i < lines.length; i++) {
+		const line = lines[i].trim();
+		if (!line) continue;
+		const colsMatch = line.match(/^columns\s+(\d+)\s*$/);
+		if (colsMatch) {
+			columns = parseInt(colsMatch[1], 10);
+			continue;
+		}
+		if (line === "block" || line.startsWith("block:")) {
+			const blockId = line.includes(":") ? line.split(":")[1].trim() : `__block_${blockCounter++}`;
+			ensureNode(blockId);
+			parentStack.push(blockId);
+			continue;
+		}
+		if (line === "end") {
+			if (parentStack.length > 1) parentStack.pop();
+			continue;
+		}
+		const edgeMatch = line.match(/^(\S+)\s*(-->|---|==>|-\.->)\s*(\S+)\s*$/);
+		if (edgeMatch) {
+			const sourceId = edgeMatch[1];
+			const targetId = edgeMatch[3];
+			ensureNode(sourceId);
+			ensureNode(targetId);
+			const edgeId = generateEdgeId(sourceId, targetId, edgeCounter++);
+			edges.push({
+				type: "edge",
+				id: edgeId,
+				sourceId,
+				targetId,
+				label: "",
+				data: {}
+			});
+			continue;
+		}
+		const spanMatch = line.match(/^(\S+?)(?:\["([^"]*)"\])?:(\d+)\s*$/);
+		if (spanMatch) {
+			const id = spanMatch[1];
+			const label = spanMatch[2] ?? id;
+			const span = parseInt(spanMatch[3], 10);
+			const node = ensureNode(id, label);
+			node.data.span = span;
+			continue;
+		}
+		const parts = line.split(/\s+/);
+		let consumed = false;
+		for (const part of parts) {
+			const parsed = parseBlockNode(part);
+			if (parsed) {
+				ensureNode(parsed.id, parsed.label, parsed.shape);
+				consumed = true;
+			}
+		}
+		if (consumed) continue;
+		const nodeDecl = parseBlockNode(line);
+		if (nodeDecl) ensureNode(nodeDecl.id, nodeDecl.label, nodeDecl.shape);
+	}
+	return {
+		id: "",
+		type: "directed",
+		initialNodeId: null,
+		nodes: Array.from(nodeMap.values()),
+		edges,
+		data: {
+			diagramType: "block",
+			...columns !== void 0 && { columns }
+		}
+	};
+}
+/**
+* Converts a block diagram Graph to a Mermaid block diagram string.
+*
+* @example
+* const mermaid = toMermaidBlock(graph);
+* // "block-beta\n    columns 2\n    a[\"Task A\"]\n    ..."
+*/
+function toMermaidBlock(graph) {
+	const lines = ["block-beta"];
+	if (graph.data?.columns) lines.push(`    columns ${graph.data.columns}`);
+	const childrenMap = /* @__PURE__ */ new Map();
+	for (const node of graph.nodes) {
+		const pid = node.parentId;
+		if (!childrenMap.has(pid)) childrenMap.set(pid, []);
+		childrenMap.get(pid).push(node);
+	}
+	const isParent = /* @__PURE__ */ new Set();
+	for (const node of graph.nodes) if (childrenMap.has(node.id)) isParent.add(node.id);
+	function writeNodes(parentId, indent) {
+		const children = childrenMap.get(parentId) ?? [];
+		for (const child of children) if (isParent.has(child.id)) {
+			lines.push(`${indent}block:${child.id}`);
+			writeNodes(child.id, indent + "    ");
+			lines.push(`${indent}end`);
+		} else {
+			const label = child.label && child.label !== child.id ? `["${escapeMermaidLabel(child.label)}"]` : "";
+			const span = child.data?.span ? `:${child.data.span}` : "";
+			lines.push(`${indent}${child.id}${label}${span}`);
+		}
+	}
+	writeNodes(null, "    ");
+	for (const edge of graph.edges) lines.push(`    ${edge.sourceId} --> ${edge.targetId}`);
+	return lines.join("\n");
+}
+/**
+* Bidirectional converter for Mermaid block diagram format.
+*
+* @example
+* const graph = mermaidBlockConverter.from(`
+* block-beta
+*     columns 2
+*     a b
+* `);
+* const str = mermaidBlockConverter.to(graph);
+*/
+const mermaidBlockConverter = createFormatConverter(toMermaidBlock, fromMermaidBlock);
+
+//#endregion
+export { fromMermaidBlock, fromMermaidClass, fromMermaidER, fromMermaidFlowchart, fromMermaidMindmap, fromMermaidSequence, fromMermaidState, mermaidBlockConverter, mermaidClassConverter, mermaidERConverter, mermaidFlowchartConverter, mermaidMindmapConverter, mermaidSequenceConverter, mermaidStateConverter, toMermaidBlock, toMermaidClass, toMermaidER, toMermaidFlowchart, toMermaidMindmap, toMermaidSequence, toMermaidState };