@statelyai/graph 0.13.0 → 2.0.0

package/dist/formats/d2/index.mjs

@@ -0,0 +1,1100 @@
+import { n as createFormatConverter } from "../../converter-DyCJJfTe.mjs";
+
+//#region src/formats/d2/shared.ts
+/** Map a d2 connector glyph to a graph edge mode. */
+const ARROW_TO_MODE = {
+	"->": "directed",
+	"<-": "directed",
+	"--": "undirected",
+	"<->": "bidirectional"
+};
+const RESERVED_KEYWORDS = new Set([
+	"shape",
+	"label",
+	"icon",
+	"near",
+	"tooltip",
+	"link",
+	"direction",
+	"constraint",
+	"width",
+	"height",
+	"top",
+	"left",
+	"style",
+	"class",
+	"classes",
+	"vars",
+	"source-arrowhead",
+	"target-arrowhead",
+	"grid-rows",
+	"grid-columns",
+	"grid-gap",
+	"vertical-gap",
+	"horizontal-gap"
+]);
+/** Style sub-keys that are booleans in d2. */
+const BOOLEAN_STYLE_KEYS = new Set([
+	"3d",
+	"multiple",
+	"double-border",
+	"animated",
+	"bold",
+	"italic",
+	"underline",
+	"filled",
+	"shadow"
+]);
+/** Style sub-keys whose value is numeric in d2. */
+const NUMERIC_STYLE_KEYS = new Set([
+	"stroke-width",
+	"stroke-dash",
+	"opacity",
+	"border-radius",
+	"font-size"
+]);
+const SAFE_ID = /^[A-Za-z0-9_][A-Za-z0-9_ -]*$/;
+/** Quote a d2 key/id if it contains characters that need escaping. */
+function escapeD2Key(id) {
+	if (id === "") return "\"\"";
+	if (RESERVED_KEYWORDS.has(id)) return `"${id}"`;
+	if (SAFE_ID.test(id) && !id.includes("  ")) return id;
+	return `"${id.replace(/"/g, "\\\"")}"`;
+}
+/** Quote a d2 label value if needed (contains `:`, `#`, leading/trailing space, etc.). */
+function escapeD2Label(label) {
+	if (label === "") return "\"\"";
+	if (/[:;#{}|<>"\n]/.test(label) || label !== label.trim()) return `"${label.replace(/"/g, "\\\"")}"`;
+	return label;
+}
+/** Remove surrounding quotes from a d2 string token and unescape. */
+function unquoteD2(s) {
+	const t = s.trim();
+	if (t.length >= 2 && t[0] === "\"" && t[t.length - 1] === "\"") return t.slice(1, -1).replace(/\\"/g, "\"");
+	if (t.length >= 2 && t[0] === "'" && t[t.length - 1] === "'") return t.slice(1, -1);
+	return t;
+}
+function validateD2Input(input) {
+	if (typeof input !== "string") throw new Error("D2: expected a string");
+}
+
+//#endregion
+//#region src/formats/d2/parser.ts
+const BLOCK_BOUNDARY_CHARS = new Set([
+	"`",
+	"'",
+	"\"",
+	".",
+	"*",
+	"+",
+	"=",
+	"-",
+	"_"
+]);
+/**
+* Read a block string starting at index `i` (text[i] === '|'). Returns the end
+* index (exclusive) and the raw fence open. d2 block strings are delimited by
+* `|`, optionally with one boundary char (e.g. `` |` `` ... `` `| ``).
+*/
+function readBlockString(text, i) {
+	if (text[i] !== "|") return null;
+	let open = "|";
+	let close = "|";
+	const next = text[i + 1];
+	if (next !== void 0 && BLOCK_BOUNDARY_CHARS.has(next)) {
+		open = "|" + next;
+		close = next + "|";
+	}
+	const contentStart = i + open.length;
+	const closeIdx = text.indexOf(close, contentStart);
+	if (closeIdx === -1) return null;
+	return {
+		end: closeIdx + close.length,
+		open,
+		close
+	};
+}
+/** Split a scope body into top-level statements and comments. */
+function splitStatements(body) {
+	const tokens = [];
+	let i = 0;
+	const len = body.length;
+	let buf = "";
+	let braceDepth = 0;
+	let blockStart = -1;
+	const flush = () => {
+		const raw = buf;
+		buf = "";
+		const trimmed = raw.trim();
+		if (trimmed === "") {
+			blockStart = -1;
+			return;
+		}
+		if (blockStart >= 0) {
+			const braceIdx = raw.indexOf("{", blockStart);
+			const head = raw.slice(0, braceIdx).trim();
+			const closeIdx = raw.lastIndexOf("}");
+			const block = raw.slice(braceIdx + 1, closeIdx);
+			tokens.push({
+				type: "stmt",
+				head,
+				block
+			});
+		} else tokens.push({
+			type: "stmt",
+			head: trimmed
+		});
+		blockStart = -1;
+	};
+	while (i < len) {
+		const ch = body[i];
+		if (ch === "#" && braceDepth === 0 && buf.trim() === "") {
+			const nl = body.indexOf("\n", i);
+			const end = nl === -1 ? len : nl;
+			tokens.push({
+				type: "comment",
+				text: body.slice(i + 1, end).trim()
+			});
+			i = end + 1;
+			continue;
+		}
+		if (ch === "#" && braceDepth === 0 && buf.trim() !== "") {
+			const nl = body.indexOf("\n", i);
+			i = nl === -1 ? len : nl;
+			flush();
+			continue;
+		}
+		if (ch === "\"") {
+			const endQuote = (() => {
+				let j = i + 1;
+				while (j < len) {
+					if (body[j] === "\\") {
+						j += 2;
+						continue;
+					}
+					if (body[j] === "\"") return j;
+					j++;
+				}
+				return len - 1;
+			})();
+			buf += body.slice(i, endQuote + 1);
+			i = endQuote + 1;
+			continue;
+		}
+		if (ch === "|") {
+			const bs = readBlockString(body, i);
+			if (bs) {
+				buf += body.slice(i, bs.end);
+				i = bs.end;
+				continue;
+			}
+		}
+		if (ch === "{") {
+			if (braceDepth === 0) blockStart = buf.length;
+			braceDepth++;
+			buf += ch;
+			i++;
+			continue;
+		}
+		if (ch === "}") {
+			braceDepth = Math.max(0, braceDepth - 1);
+			buf += ch;
+			i++;
+			continue;
+		}
+		if ((ch === "\n" || ch === ";") && braceDepth === 0) {
+			flush();
+			i++;
+			continue;
+		}
+		buf += ch;
+		i++;
+	}
+	flush();
+	return tokens;
+}
+/** Find the top-level connector in a statement head, ignoring quotes/blocks. */
+function findConnector(head) {
+	let depth = 0;
+	for (let i = 0; i < head.length; i++) {
+		const ch = head[i];
+		if (ch === "\"") {
+			i = skipQuoted(head, i);
+			continue;
+		}
+		if (ch === "(") depth++;
+		else if (ch === ")") depth = Math.max(0, depth - 1);
+		else if (depth === 0) {
+			const m = head.slice(i, i + 3).match(/^(<->|->|<-|--)/);
+			if (m) {
+				const arrow = m[1];
+				return {
+					index: i,
+					arrow
+				};
+			}
+		}
+	}
+	return null;
+}
+function skipQuoted(s, i) {
+	let j = i + 1;
+	while (j < s.length) {
+		if (s[j] === "\\") {
+			j += 2;
+			continue;
+		}
+		if (s[j] === "\"") return j;
+		j++;
+	}
+	return s.length;
+}
+/** Split `key: value` at the first top-level colon. Returns null if no colon. */
+function splitKeyValue(s) {
+	let depth = 0;
+	for (let i = 0; i < s.length; i++) {
+		const ch = s[i];
+		if (ch === "\"") {
+			i = skipQuoted(s, i);
+			continue;
+		}
+		if (ch === "(" || ch === "[") depth++;
+		else if (ch === ")" || ch === "]") depth = Math.max(0, depth - 1);
+		else if (ch === ":" && depth === 0) return {
+			key: s.slice(0, i).trim(),
+			value: s.slice(i + 1).trim()
+		};
+	}
+	return null;
+}
+/**
+* Parse a dotted key path into segments, respecting quotes. Segments are
+* returned **raw** (quotes preserved) so callers can distinguish a reserved
+* keyword (`shape`) from a quoted literal node id (`"shape"`). Use
+* {@link unquotePath} to materialize node ids.
+*/
+function parseKeyPath(key) {
+	const segs = [];
+	let buf = "";
+	for (let i = 0; i < key.length; i++) {
+		const ch = key[i];
+		if (ch === "\"") {
+			const end = skipQuoted(key, i);
+			buf += key.slice(i, end + 1);
+			i = end;
+			continue;
+		}
+		if (ch === ".") {
+			segs.push(buf.trim());
+			buf = "";
+			continue;
+		}
+		buf += ch;
+	}
+	if (buf.trim() !== "") segs.push(buf.trim());
+	return segs;
+}
+/** Materialize node-id segments from raw key-path segments (strips quotes). */
+function unquotePath(segs) {
+	return segs.map((s) => unquoteD2(s));
+}
+/**
+* Whether a raw key-path segment denotes a reserved keyword. Quoted segments
+* (e.g. `"shape"`) are literal node ids and never reserved.
+*/
+function isReservedSegment(rawSeg) {
+	return RESERVED_KEYWORDS.has(rawSeg);
+}
+function parseLabelBlock(value) {
+	const trimmed = value.trim();
+	if (!trimmed.startsWith("|")) return { text: unquoteD2(trimmed) };
+	const bs = readBlockString(trimmed, 0);
+	if (!bs) return { text: unquoteD2(trimmed) };
+	let inner = trimmed.slice(bs.open.length, trimmed.length - bs.close.length);
+	let kind = "block";
+	let lang;
+	const tagMatch = inner.match(/^([A-Za-z0-9_+-]+)(\s|\n)/);
+	if (tagMatch) {
+		const tag = tagMatch[1];
+		inner = inner.slice(tagMatch[0].length);
+		if (tag === "md") kind = "md";
+		else if (tag === "tex" || tag === "latex") kind = "latex";
+		else {
+			kind = "code";
+			lang = tag;
+		}
+	}
+	return {
+		text: inner.replace(/^\n/, "").replace(/\s+$/, ""),
+		labelBlock: {
+			kind,
+			lang,
+			fence: bs.open
+		}
+	};
+}
+function coerceStyleValue(key, raw) {
+	const v = unquoteD2(raw);
+	if (BOOLEAN_STYLE_KEYS.has(key)) {
+		if (v === "true") return true;
+		if (v === "false") return false;
+	}
+	if (NUMERIC_STYLE_KEYS.has(key)) {
+		const n = Number(v);
+		if (!Number.isNaN(n)) return n;
+	}
+	return v;
+}
+function nodeId(path) {
+	return path.join(".");
+}
+function ensureNode(ctx, path, declarationForm) {
+	const id = nodeId(path);
+	let node = ctx.nodes.get(id);
+	if (!node) {
+		const parentId = path.length > 1 ? nodeId(path.slice(0, -1)) : null;
+		if (parentId) ensureNode(ctx, path.slice(0, -1), "dot");
+		node = {
+			type: "node",
+			id,
+			parentId,
+			label: null,
+			data: { declarationForm }
+		};
+		ctx.nodes.set(id, node);
+		registerChildOrder(ctx, parentId, id);
+	}
+	return node;
+}
+function registerChildOrder(ctx, parentId, childId) {
+	if (!parentId) return;
+	const parent = ctx.nodes.get(parentId);
+	if (!parent) return;
+	parent.data.order = parent.data.order ?? [];
+	if (!parent.data.order.includes(childId)) parent.data.order.push(childId);
+}
+function applyReserved(node, keyword, rest, value) {
+	switch (keyword) {
+		case "shape":
+			node.shape = unquoteD2(value);
+			break;
+		case "label": {
+			const { text, labelBlock } = parseLabelBlock(value);
+			node.label = text;
+			if (labelBlock) node.data.labelBlock = labelBlock;
+			break;
+		}
+		case "icon":
+			node.data.icon = unquoteD2(value);
+			break;
+		case "near":
+			node.data.near = unquoteD2(value);
+			break;
+		case "tooltip":
+			node.data.tooltip = unquoteD2(value);
+			break;
+		case "link":
+			node.data.link = unquoteD2(value);
+			break;
+		case "class":
+			node.data.classes = unquoteD2(value).split(/[\s;]+/).filter(Boolean);
+			break;
+		case "width":
+			node.width = Number(unquoteD2(value));
+			break;
+		case "height":
+			node.height = Number(unquoteD2(value));
+			break;
+		case "left":
+			node.x = Number(unquoteD2(value));
+			break;
+		case "top":
+			node.y = Number(unquoteD2(value));
+			break;
+		case "grid-rows":
+			node.data.grid = {
+				...node.data.grid,
+				rows: Number(unquoteD2(value))
+			};
+			break;
+		case "grid-columns":
+			node.data.grid = {
+				...node.data.grid,
+				columns: Number(unquoteD2(value))
+			};
+			break;
+		case "grid-gap":
+			node.data.grid = {
+				...node.data.grid,
+				gap: Number(unquoteD2(value))
+			};
+			break;
+		case "style":
+			if (rest.length > 0) {
+				const styleKey = rest[0];
+				node.style = node.style ?? {};
+				node.style[styleKey] = coerceStyleValue(styleKey, value);
+			}
+			break;
+		default:
+			node.data.reserved = node.data.reserved ?? {};
+			node.data.reserved[[keyword, ...rest].join(".")] = unquoteD2(value);
+	}
+}
+/** Apply a `style: { ... }` block to a node. */
+function applyStyleBlock(node, block) {
+	for (const tok of splitStatements(block)) {
+		if (tok.type !== "stmt") continue;
+		const kv = splitKeyValue(tok.head);
+		if (!kv) continue;
+		node.style = node.style ?? {};
+		node.style[kv.key] = coerceStyleValue(kv.key, kv.value);
+	}
+}
+/** Parse a sql_table / class field declaration into a port. */
+function parseFieldPort(name, value, block, classMember) {
+	const data = {};
+	if (classMember) data.classMember = true;
+	let portName = name;
+	const vis = portName.match(/^([+\-#])\s*/);
+	if (vis) {
+		data.visibility = vis[1];
+		portName = portName.slice(vis[0].length);
+	}
+	const typeName = unquoteD2(value);
+	if (typeName) data.typeName = typeName;
+	if (block) for (const tok of splitStatements(block)) {
+		if (tok.type !== "stmt") continue;
+		const kv = splitKeyValue(tok.head);
+		if (kv && kv.key === "constraint") data.constraint = unquoteD2(kv.value).replace(/^\[|\]$/g, "").split(/[\s;,]+/).filter(Boolean);
+	}
+	return {
+		name: unquoteD2(portName),
+		direction: "inout",
+		data
+	};
+}
+const STRUCTURED_SHAPES$1 = new Set(["sql_table", "class"]);
+/** Parse the body of a structured-shape (sql_table/class) node into ports. */
+function parseStructuredBody(ctx, node, block, classMember) {
+	node.ports = node.ports ?? [];
+	for (const tok of splitStatements(block)) {
+		if (tok.type !== "stmt") continue;
+		const kv = splitKeyValue(tok.head);
+		if (kv && kv.key === "shape") {
+			node.shape = unquoteD2(kv.value);
+			continue;
+		}
+		if (kv && (kv.key === "style" || kv.key.startsWith("style."))) {
+			applyStyleBlock(node, tok.block ?? kv.value);
+			continue;
+		}
+		const fieldName = kv ? kv.key : tok.head.trim();
+		const fieldType = kv ? kv.value : "";
+		node.ports.push(parseFieldPort(fieldName, fieldType, tok.block, classMember));
+	}
+}
+function makeEdge(ctx, sourcePath, targetPath, arrow, label, labelBlock) {
+	const resolve = (path) => resolveEndpoint(ctx, path);
+	const src = resolve(sourcePath);
+	const tgt = resolve(targetPath);
+	let sId = src.nodeId;
+	let tId = tgt.nodeId;
+	let sPort = src.port;
+	let tPort = tgt.port;
+	if (arrow === "<-") {
+		[sId, tId] = [tId, sId];
+		[sPort, tPort] = [tPort, sPort];
+	}
+	const key = `${sId} ${tId}`;
+	const count = ctx.edgeCounts.get(key) ?? 0;
+	ctx.edgeCounts.set(key, count + 1);
+	const id = `${sId}->${tId}#${count}`;
+	const data = { arrow };
+	if (labelBlock) data.labelBlock = labelBlock;
+	const edge = {
+		type: "edge",
+		id,
+		sourceId: sId,
+		targetId: tId,
+		label,
+		data,
+		mode: ARROW_TO_MODE[arrow]
+	};
+	if (sPort) edge.sourcePort = sPort;
+	if (tPort) edge.targetPort = tPort;
+	return edge;
+}
+function resolveEndpoint(ctx, path) {
+	if (path.length >= 2) {
+		const maybeNode = nodeId(path.slice(0, -1));
+		const node = ctx.nodes.get(maybeNode);
+		const portName = path[path.length - 1];
+		if (node?.ports?.some((p) => p.name === portName)) return {
+			nodeId: maybeNode,
+			port: portName
+		};
+	}
+	ensureNode(ctx, path, "dot");
+	return { nodeId: nodeId(path) };
+}
+function parseScope(ctx, body, scopePath, pendingComments) {
+	const tokens = splitStatements(body);
+	let comments = [...pendingComments];
+	for (const tok of tokens) {
+		if (tok.type === "comment") {
+			comments.push(tok.text);
+			continue;
+		}
+		const head = tok.head;
+		if (head.startsWith("...@") || head.startsWith("@")) {
+			const importPath = head.replace(/^\.\.\./, "").replace(/^@/, "").trim();
+			ctx.graph.data.source = ctx.graph.data.source ?? {};
+			ctx.graph.data.source.imports = ctx.graph.data.source.imports ?? [];
+			ctx.graph.data.source.imports.push(importPath);
+			comments = [];
+			continue;
+		}
+		if (findConnector(head) && scopePath.length >= 0) {
+			handleConnection(ctx, head, tok.block, scopePath, comments);
+			comments = [];
+			continue;
+		}
+		const kv = splitKeyValue(head);
+		const keyText = kv ? kv.key : head;
+		const value = kv ? kv.value : "";
+		const rawSegs = parseKeyPath(keyText);
+		if (rawSegs.length >= 1 && isReservedSegment(rawSegs[0]) && scopePath.length === 0) {
+			handleScopeReserved(ctx, rawSegs, value, tok.block, scopePath);
+			comments = [];
+			continue;
+		}
+		handleDeclaration(ctx, rawSegs, value, tok.block, scopePath, comments);
+		comments = [];
+	}
+	if (scopePath.length === 0 && comments.length > 0) ctx.graph.data.trailingComments = comments;
+}
+function handleScopeReserved(ctx, segs, value, block, scopePath) {
+	const keyword = segs[0];
+	if (keyword === "direction" && scopePath.length === 0) {
+		const dir = unquoteD2(value);
+		if ([
+			"up",
+			"down",
+			"left",
+			"right"
+		].includes(dir)) ctx.graph.direction = dir;
+		return;
+	}
+	if (keyword === "vars" && block !== void 0) {
+		ctx.graph.data.source = ctx.graph.data.source ?? {};
+		ctx.graph.data.source.vars = parseVarsBlock(block);
+		return;
+	}
+	if (keyword === "classes" && block !== void 0) {
+		ctx.graph.data.source = ctx.graph.data.source ?? {};
+		ctx.graph.data.source.classes = parseClassesBlock(block);
+		return;
+	}
+	if (keyword === "style") {
+		if (block !== void 0) for (const tok of splitStatements(block)) {
+			if (tok.type !== "stmt") continue;
+			const kv = splitKeyValue(tok.head);
+			if (!kv) continue;
+			ctx.graph.style = ctx.graph.style ?? {};
+			ctx.graph.style[kv.key] = coerceStyleValue(kv.key, kv.value);
+		}
+		else if (segs.length > 1) {
+			ctx.graph.style = ctx.graph.style ?? {};
+			ctx.graph.style[segs[1]] = coerceStyleValue(segs[1], value);
+		}
+		return;
+	}
+}
+function parseVarsBlock(block) {
+	const out = {};
+	for (const tok of splitStatements(block)) {
+		if (tok.type !== "stmt") continue;
+		const kv = splitKeyValue(tok.head);
+		if (kv) out[kv.key] = unquoteD2(kv.value);
+	}
+	return out;
+}
+function parseClassesBlock(block) {
+	const out = {};
+	for (const tok of splitStatements(block)) {
+		if (tok.type !== "stmt" || tok.block === void 0) continue;
+		const kv = splitKeyValue(tok.head);
+		const className = (kv ? kv.key : tok.head).trim();
+		const style = {};
+		for (const inner of splitStatements(tok.block)) {
+			if (inner.type !== "stmt") continue;
+			const ikv = splitKeyValue(inner.head);
+			if (!ikv) continue;
+			const segs = parseKeyPath(ikv.key);
+			const styleKey = segs[0] === "style" ? segs[1] : segs[0];
+			style[styleKey] = coerceStyleValue(styleKey, ikv.value);
+		}
+		out[className] = style;
+	}
+	return out;
+}
+function handleConnection(ctx, head, block, scopePath, comments) {
+	let working = head;
+	const kv = splitKeyValue(working);
+	let label = null;
+	let labelBlock;
+	if (kv && findConnector(kv.value) === null) {
+		working = kv.key;
+		const parsed = parseLabelBlock(kv.value);
+		label = parsed.text || null;
+		labelBlock = parsed.labelBlock;
+	}
+	const parts = [];
+	const arrows = [];
+	let rest = working.trim();
+	rest = rest.replace(/^\((.*)\)\s*(\[\d+\])?$/s, "$1");
+	let conn = findConnector(rest);
+	let lastIndex = 0;
+	while (conn) {
+		parts.push({ text: rest.slice(lastIndex, conn.index).trim() });
+		arrows.push(conn.arrow);
+		rest = rest.slice(conn.index + conn.arrow.length);
+		conn = findConnector(rest);
+		lastIndex = 0;
+	}
+	parts.push({ text: rest.trim() });
+	for (let k = 0; k < arrows.length; k++) {
+		const sourcePath = unquotePath(parseKeyPath(parts[k].text));
+		const targetPath = unquotePath(parseKeyPath(parts[k + 1].text));
+		const edge = makeEdge(ctx, [...scopePath, ...sourcePath], [...scopePath, ...targetPath], arrows[k], k === arrows.length - 1 ? label : null, k === arrows.length - 1 ? labelBlock : void 0);
+		if (comments.length > 0 && k === 0) edge.data.commentsBefore = comments;
+		ctx.edges.push(edge);
+		registerChildOrder(ctx, scopePath.length ? nodeId(scopePath) : null, edge.id);
+		if (block !== void 0 && k === arrows.length - 1) applyEdgeBlock(edge, block);
+	}
+}
+function applyEdgeBlock(edge, block) {
+	for (const tok of splitStatements(block)) {
+		if (tok.type !== "stmt") continue;
+		const kv = splitKeyValue(tok.head);
+		if (!kv) continue;
+		const segs = parseKeyPath(kv.key);
+		if (segs[0] === "style") {
+			edge.style = edge.style ?? {};
+			if (segs.length > 1) edge.style[segs[1]] = coerceStyleValue(segs[1], kv.value);
+			else if (tok.block !== void 0) for (const inner of splitStatements(tok.block)) {
+				if (inner.type !== "stmt") continue;
+				const ikv = splitKeyValue(inner.head);
+				if (ikv) edge.style[ikv.key] = coerceStyleValue(ikv.key, ikv.value);
+			}
+		} else if (segs[0] === "source-arrowhead" || segs[0] === "target-arrowhead") {
+			const side = segs[0] === "source-arrowhead" ? "sourceArrowhead" : "targetArrowhead";
+			edge.data[side] = edge.data[side] ?? {};
+			if (segs[1] === "shape") edge.data[side].shape = unquoteD2(kv.value);
+			else edge.data[side].label = unquoteD2(kv.value);
+		} else if (segs[0] === "label") edge.label = unquoteD2(kv.value);
+		else {
+			edge.data.reserved = edge.data.reserved ?? {};
+			edge.data.reserved[kv.key] = unquoteD2(kv.value);
+		}
+	}
+}
+function handleDeclaration(ctx, rawSegs, value, block, scopePath, comments) {
+	const segs = unquotePath(rawSegs);
+	const fullPath = [...scopePath, ...segs];
+	let reservedAt = -1;
+	for (let i = 0; i < rawSegs.length; i++) if (isReservedSegment(rawSegs[i])) {
+		reservedAt = i;
+		break;
+	}
+	if (reservedAt >= 0) {
+		const nodePath = [...scopePath, ...segs.slice(0, reservedAt)];
+		if (nodePath.length === 0) return;
+		const node$1 = ensureNode(ctx, nodePath, "dot");
+		if (comments.length > 0 && !node$1.data.commentsBefore) node$1.data.commentsBefore = comments;
+		applyReserved(node$1, rawSegs[reservedAt], segs.slice(reservedAt + 1), value);
+		if (rawSegs[reservedAt] === "style" && block !== void 0) applyStyleBlock(node$1, block);
+		return;
+	}
+	const node = ensureNode(ctx, fullPath, block !== void 0 ? "block" : segs.length > 1 ? "dot" : "block");
+	if (comments.length > 0 && !node.data.commentsBefore) node.data.commentsBefore = comments;
+	if (value !== "") {
+		const { text, labelBlock } = parseLabelBlock(value);
+		node.label = text;
+		if (labelBlock) node.data.labelBlock = labelBlock;
+	}
+	if (block !== void 0) {
+		const shapeFromBlock = peekShape(block);
+		if (shapeFromBlock) node.shape = shapeFromBlock;
+		if (node.shape && STRUCTURED_SHAPES$1.has(node.shape)) parseStructuredBody(ctx, node, block, node.shape === "class");
+		else parseScope(ctx, block, fullPath, []);
+	}
+}
+function peekShape(block) {
+	for (const tok of splitStatements(block)) {
+		if (tok.type !== "stmt") continue;
+		const kv = splitKeyValue(tok.head);
+		if (kv && parseKeyPath(kv.key).join(".") === "shape") return unquoteD2(kv.value);
+	}
+}
+/**
+* Resolve edge endpoints that point at a structured-shape field but were parsed
+* as child nodes because the connection appeared *before* the `sql_table`/`class`
+* declaration (forward reference). Rewrites such endpoints to `sourcePort` /
+* `targetPort` and strips the spurious empty-leaf node that was auto-created.
+*/
+function finalizePortEndpoints(ctx) {
+	const childCount = /* @__PURE__ */ new Map();
+	for (const n of ctx.nodes.values()) if (n.parentId) childCount.set(n.parentId, (childCount.get(n.parentId) ?? 0) + 1);
+	const toRemove = /* @__PURE__ */ new Set();
+	const resolve = (id, port) => {
+		if (port) return [id, port];
+		const node = ctx.nodes.get(id);
+		if (!node?.parentId) return [id, port];
+		const parent = ctx.nodes.get(node.parentId);
+		const portName = id.slice(node.parentId.length + 1);
+		if (!parent?.ports?.some((p) => p.name === portName)) return [id, port];
+		if (!((childCount.get(id) ?? 0) === 0 && !node.shape && !node.style && (node.label == null || node.label === "") && (node.ports?.length ?? 0) === 0)) return [id, port];
+		toRemove.add(id);
+		return [node.parentId, portName];
+	};
+	for (const edge of ctx.edges) {
+		[edge.sourceId, edge.sourcePort] = resolve(edge.sourceId, edge.sourcePort);
+		[edge.targetId, edge.targetPort] = resolve(edge.targetId, edge.targetPort);
+	}
+	for (const id of toRemove) {
+		const node = ctx.nodes.get(id);
+		ctx.nodes.delete(id);
+		const parent = node?.parentId ? ctx.nodes.get(node.parentId) : void 0;
+		if (parent?.data.order) parent.data.order = parent.data.order.filter((x) => x !== id);
+	}
+}
+function fromD2(input) {
+	validateD2Input(input);
+	const graph = {
+		id: "",
+		mode: "directed",
+		initialNodeId: null,
+		nodes: [],
+		edges: [],
+		data: { diagramType: "d2" }
+	};
+	const ctx = {
+		nodes: /* @__PURE__ */ new Map(),
+		edges: [],
+		edgeCounts: /* @__PURE__ */ new Map(),
+		graph
+	};
+	parseScope(ctx, input, [], []);
+	finalizePortEndpoints(ctx);
+	graph.nodes = [...ctx.nodes.values()];
+	graph.edges = ctx.edges;
+	if (graph.edges.length > 0) {
+		const modes = new Set(graph.edges.map((e) => e.mode));
+		if (modes.size === 1 && modes.has("undirected")) graph.mode = "undirected";
+	}
+	return graph;
+}
+
+//#endregion
+//#region src/formats/d2/emitter.ts
+const STRUCTURED_SHAPES = new Set(["sql_table", "class"]);
+/**
+* Parser-shaped node data, tolerating graphs not produced by `fromD2` whose
+* `data` may be `undefined`, `null`, or an arbitrary user object.
+*/
+function nodeData(node) {
+	return node.data ?? {};
+}
+/** Parser-shaped edge data; see {@link nodeData}. */
+function edgeData(edge) {
+	return edge.data ?? {};
+}
+function splitId(id) {
+	const out = [];
+	let buf = "";
+	let inQuote = false;
+	for (let i = 0; i < id.length; i++) {
+		const ch = id[i];
+		if (ch === "\"") inQuote = !inQuote;
+		if (ch === "." && !inQuote) {
+			out.push(buf);
+			buf = "";
+		} else buf += ch;
+	}
+	out.push(buf);
+	return out;
+}
+function indent(n) {
+	return "  ".repeat(n);
+}
+function emitLabelBlock(text, block) {
+	const open = block.fence;
+	const close = open.length > 1 ? open[1] + "|" : "|";
+	const tag = block.kind === "md" ? "md" : block.kind === "latex" ? "tex" : block.kind === "code" ? block.lang ?? "" : "";
+	return `${open}${tag ? `${tag} ` : ""}${text}${close}`;
+}
+function styleValueToD2(v) {
+	if (typeof v === "boolean") return v ? "true" : "false";
+	if (typeof v === "number") return String(v);
+	return escapeD2Label(v);
+}
+function emitComments(comments, ind, lines) {
+	if (!comments) return;
+	for (const c of comments) lines.push(`${indent(ind)}#${c ? " " + c.trimStart() : ""}`);
+}
+function nodeAttrLines(node, ind) {
+	const lines = [];
+	const d = nodeData(node);
+	if (node.shape) lines.push(`${indent(ind)}shape: ${escapeD2Label(node.shape)}`);
+	if (d.near) lines.push(`${indent(ind)}near: ${escapeD2Label(d.near)}`);
+	if (d.icon) lines.push(`${indent(ind)}icon: ${d.icon}`);
+	if (d.tooltip) lines.push(`${indent(ind)}tooltip: ${escapeD2Label(d.tooltip)}`);
+	if (d.link) lines.push(`${indent(ind)}link: ${escapeD2Label(d.link)}`);
+	if (d.classes?.length) lines.push(`${indent(ind)}class: ${d.classes.join(" ")}`);
+	if (node.width !== void 0) lines.push(`${indent(ind)}width: ${node.width}`);
+	if (node.height !== void 0) lines.push(`${indent(ind)}height: ${node.height}`);
+	if (node.x !== void 0) lines.push(`${indent(ind)}left: ${node.x}`);
+	if (node.y !== void 0) lines.push(`${indent(ind)}top: ${node.y}`);
+	if (d.grid) {
+		if (d.grid.rows !== void 0) lines.push(`${indent(ind)}grid-rows: ${d.grid.rows}`);
+		if (d.grid.columns !== void 0) lines.push(`${indent(ind)}grid-columns: ${d.grid.columns}`);
+		if (d.grid.gap !== void 0) lines.push(`${indent(ind)}grid-gap: ${d.grid.gap}`);
+	}
+	if (node.style) for (const [k, v] of Object.entries(node.style)) lines.push(`${indent(ind)}style.${k}: ${styleValueToD2(v)}`);
+	if (d.reserved) for (const [k, v] of Object.entries(d.reserved)) lines.push(`${indent(ind)}${k}: ${styleValueToD2(v)}`);
+	return lines;
+}
+function portLines(node, ind) {
+	const lines = [];
+	for (const port of node.ports ?? []) {
+		const pd = port.data ?? {};
+		const name = `${pd.visibility ?? ""}${escapeD2Key(port.name)}`;
+		let line = `${indent(ind)}${name}`;
+		if (pd.typeName) line += `: ${escapeD2Label(pd.typeName)}`;
+		if (pd.constraint?.length) line += ` { constraint: ${pd.constraint.length === 1 ? pd.constraint[0] : `[${pd.constraint.join("; ")}]`} }`;
+		lines.push(line);
+	}
+	return lines;
+}
+function labelHeader(node) {
+	if (node.label == null || node.label === "") return "";
+	const labelBlock = nodeData(node).labelBlock;
+	if (labelBlock) return emitLabelBlock(node.label, labelBlock);
+	return escapeD2Label(node.label);
+}
+/** Whether a node carries its own attributes/ports/label (needs a line of its own). */
+function hasOwnContent(node) {
+	return nodeAttrLines(node, 0).length > 0 || (node.ports?.length ?? 0) > 0 || node.label != null && node.label !== "";
+}
+/**
+* A node is a "pure prefix" — emitted by carrying its dotted path down to
+* descendants rather than as its own block — when it was authored in dot form,
+* has no own content, and has children.
+*/
+function isPurePrefix(ctx, node) {
+	const children = ctx.childrenOf.get(node.id) ?? [];
+	return nodeData(node).declarationForm !== "block" && children.length > 0 && !hasOwnContent(node);
+}
+/**
+* Emit the items (child nodes + owned edges) of a scope, in `data.order` when
+* present (sequence diagrams), else nodes-then-edges in insertion order.
+* `scopeSegs` is the dotted prefix already implied by enclosing blocks.
+*/
+function emitScope(ctx, container, containerId, scopeSegs, ind, lines) {
+	const children = ctx.childrenOf.get(containerId) ?? [];
+	const ownedEdges = container ? ctx.edgesByOwner.get(container.id) ?? [] : [];
+	const order = container ? nodeData(container).order : void 0;
+	if (order) {
+		const childById = new Map(children.map((c) => [c.id, c]));
+		const edgeById = new Map(ownedEdges.map((e) => [e.id, e]));
+		for (const refId of order) {
+			const child = childById.get(refId);
+			if (child) {
+				emitItem(ctx, child, scopeSegs, ind, lines);
+				continue;
+			}
+			const edge = edgeById.get(refId);
+			if (edge && !ctx.emittedEdges.has(edge.id)) emitEdge(ctx, edge, ind, lines, true);
+		}
+		for (const child of children) if (!order.includes(child.id)) emitItem(ctx, child, scopeSegs, ind, lines);
+		return;
+	}
+	for (const child of children) emitItem(ctx, child, scopeSegs, ind, lines);
+}
+/** Emit a single node within a scope, choosing dot-prefix vs block form. */
+function emitItem(ctx, node, scopeSegs, ind, lines) {
+	const rel = splitId(node.id).slice(scopeSegs.length).map(escapeD2Key).join(".");
+	if (isPurePrefix(ctx, node)) {
+		emitScope(ctx, node, node.id, scopeSegs, ind, lines);
+		return;
+	}
+	emitComments(nodeData(node).commentsBefore, ind, lines);
+	const label = labelHeader(node);
+	const structured = node.shape && STRUCTURED_SHAPES.has(node.shape);
+	const attrLines = nodeAttrLines(node, ind + 1);
+	const children = ctx.childrenOf.get(node.id) ?? [];
+	const ports = structured ? portLines(node, ind + 1) : [];
+	if (!(attrLines.length > 0 || children.length > 0 || ports.length > 0)) {
+		lines.push(`${indent(ind)}${rel}${label ? `: ${label}` : ""}`);
+		return;
+	}
+	lines.push(`${indent(ind)}${rel}: {`);
+	if (label) lines.push(`${indent(ind + 1)}label: ${label}`);
+	if (structured) {
+		lines.push(`${indent(ind + 1)}shape: ${node.shape}`);
+		lines.push(...ports);
+	} else {
+		lines.push(...attrLines);
+		emitScope(ctx, node, node.id, splitId(node.id), ind + 1, lines);
+	}
+	lines.push(`${indent(ind)}}`);
+}
+function endpointRef(nodeId$1, port, scopeSegs) {
+	let ref = splitId(nodeId$1).slice(scopeSegs.length).map(escapeD2Key).join(".");
+	if (port) ref += `.${escapeD2Key(port)}`;
+	return ref;
+}
+function emitEdge(ctx, edge, ind, lines, scoped) {
+	ctx.emittedEdges.add(edge.id);
+	const d = edgeData(edge);
+	emitComments(d.commentsBefore, ind, lines);
+	const arrow = d.arrow ?? modeToArrow(edge);
+	const owner = scoped ? ctx.ownerOfEdge.get(edge.id) : void 0;
+	const scopeSegs = owner ? splitId(owner) : [];
+	let sId = edge.sourceId;
+	let tId = edge.targetId;
+	let sPort = edge.sourcePort;
+	let tPort = edge.targetPort;
+	if (arrow === "<-") {
+		[sId, tId] = [tId, sId];
+		[sPort, tPort] = [tPort, sPort];
+	}
+	const left = endpointRef(sId, sPort, scopeSegs);
+	const right = endpointRef(tId, tPort, scopeSegs);
+	let line = `${indent(ind)}${left} ${arrow} ${right}`;
+	if (edge.label != null && edge.label !== "") {
+		const lbl = d.labelBlock ? emitLabelBlock(edge.label, d.labelBlock) : escapeD2Label(edge.label);
+		line += `: ${lbl}`;
+	}
+	const blockLines = edgeBlockLines(edge);
+	if (blockLines.length > 0) {
+		lines.push(`${line} {`);
+		lines.push(...blockLines.map((l) => `${indent(ind + 1)}${l}`));
+		lines.push(`${indent(ind)}}`);
+	} else lines.push(line);
+}
+function edgeBlockLines(edge) {
+	const out = [];
+	if (edge.style) for (const [k, v] of Object.entries(edge.style)) out.push(`style.${k}: ${styleValueToD2(v)}`);
+	const d = edgeData(edge);
+	const { sourceArrowhead, targetArrowhead } = d;
+	if (sourceArrowhead?.shape) out.push(`source-arrowhead.shape: ${sourceArrowhead.shape}`);
+	if (targetArrowhead?.shape) out.push(`target-arrowhead.shape: ${targetArrowhead.shape}`);
+	if (d.reserved) for (const [k, v] of Object.entries(d.reserved)) out.push(`${k}: ${styleValueToD2(v)}`);
+	return out;
+}
+function modeToArrow(edge) {
+	switch (edge.mode) {
+		case "undirected": return "--";
+		case "bidirectional": return "<->";
+		default: return "->";
+	}
+}
+/**
+* Single pass over container `data.order` lists, building both edge→owner and
+* owner→edges indexes. An edge "belongs" to a container when that container
+* references it in its order (sequence diagrams / scoped connections); all
+* other edges emit at root scope.
+*/
+function buildEdgeOwnership(graph) {
+	const edgesByOwner = /* @__PURE__ */ new Map();
+	const ownerOfEdge = /* @__PURE__ */ new Map();
+	const edgeById = new Map(graph.edges.map((e) => [e.id, e]));
+	for (const node of graph.nodes) {
+		const order = nodeData(node).order;
+		if (!order) continue;
+		for (const refId of order) {
+			const edge = edgeById.get(refId);
+			if (!edge) continue;
+			ownerOfEdge.set(refId, node.id);
+			const arr = edgesByOwner.get(node.id) ?? [];
+			arr.push(edge);
+			edgesByOwner.set(node.id, arr);
+		}
+	}
+	return {
+		edgesByOwner,
+		ownerOfEdge
+	};
+}
+function toD2(graph) {
+	const lines = [];
+	const data = graph.data ?? { diagramType: "d2" };
+	if (data.leadingComments) for (const c of data.leadingComments) lines.push(`#${c ? " " + c.trimStart() : ""}`);
+	if (graph.direction) lines.push(`direction: ${graph.direction}`);
+	if (data.source?.vars && Object.keys(data.source.vars).length > 0) {
+		lines.push("vars: {");
+		for (const [k, v] of Object.entries(data.source.vars)) lines.push(`  ${escapeD2Key(k)}: ${styleValueToD2(v)}`);
+		lines.push("}");
+	}
+	if (data.source?.classes && Object.keys(data.source.classes).length > 0) {
+		lines.push("classes: {");
+		for (const [name, style] of Object.entries(data.source.classes)) {
+			lines.push(`  ${escapeD2Key(name)}: {`);
+			for (const [k, v] of Object.entries(style)) lines.push(`    style.${k}: ${styleValueToD2(v)}`);
+			lines.push("  }");
+		}
+		lines.push("}");
+	}
+	if (data.source?.imports) for (const imp of data.source.imports) lines.push(`@${imp}`);
+	if (graph.style && Object.keys(graph.style).length > 0) {
+		lines.push("style: {");
+		for (const [k, v] of Object.entries(graph.style)) lines.push(`  ${k}: ${styleValueToD2(v)}`);
+		lines.push("}");
+	}
+	const childrenOf = /* @__PURE__ */ new Map();
+	const nodeById = /* @__PURE__ */ new Map();
+	for (const node of graph.nodes) {
+		nodeById.set(node.id, node);
+		const key = node.parentId ?? null;
+		const arr = childrenOf.get(key) ?? [];
+		arr.push(node);
+		childrenOf.set(key, arr);
+	}
+	const { edgesByOwner, ownerOfEdge } = buildEdgeOwnership(graph);
+	const ctx = {
+		childrenOf,
+		nodeById,
+		edgesByOwner,
+		ownerOfEdge,
+		emittedEdges: /* @__PURE__ */ new Set()
+	};
+	emitScope(ctx, null, null, [], 0, lines);
+	for (const edge of graph.edges) {
+		if (ctx.emittedEdges.has(edge.id)) continue;
+		const owner = ownerOfEdge.get(edge.id);
+		emitEdge(ctx, edge, owner ? splitId(owner).length : 0, lines, true);
+	}
+	if (data.trailingComments) for (const c of data.trailingComments) lines.push(`#${c ? " " + c.trimStart() : ""}`);
+	return lines.join("\n") + "\n";
+}
+
+//#endregion
+//#region src/formats/d2/index.ts
+/**
+* Bidirectional converter for [d2](https://d2lang.com/) diagram syntax.
+*
+* @example
+* ```ts
+* import { d2Converter } from '@statelyai/graph/d2';
+*
+* const graph = d2Converter.from('a -> b: hello');
+* const text = d2Converter.to(graph);
+* ```
+*/
+const d2Converter = createFormatConverter(toD2, fromD2);
+
+//#endregion
+export { d2Converter, fromD2, toD2 };