callman-core 1.28.1 → 1.29.0

package/dist/diagram/mermaid/parse.js

@@ -0,0 +1,672 @@
+// A tolerant parser for the Mermaid FLOWCHART dialect that produces a
+// concrete syntax tree WITH SOURCE RANGES. The ranges are the point: the
+// patcher (patch.ts) edits exactly the statement an operation concerns and
+// leaves every other byte — comments, formatting, constructs we do not model
+// — untouched. Lines the parser does not understand become `unknown`
+// statements that are preserved verbatim and reported as diagnostics.
+//
+// Covered: `flowchart|graph <DIR>`, frontmatter (`---` blocks), `%%`
+// comments and `%%{init}%%` directives, node declarations with every
+// classic bracket and `@{ shape, label, … }`, `:::class`, chains
+// (`A --> B --> C`), fans (`A & B --> C`), all link forms (`-->`, `---`,
+// `-.->`, `==>`, `<-->`, `--o`, `--x`, `~~~`, extra length, `|label|`,
+// `-- label -->`), edge ids (`e1@-->`) and edge attributes (`e1@{ curve }`),
+// nested `subgraph id [title] … end` with `direction`, and the statement
+// kinds classDef/class/style/linkStyle/click, kept as opaque text.
+import { BRACKET_SHAPE, canonicalMermaidShape } from "./shapes.js";
+// --- helpers ------------------------------------------------------------------
+const ID_START = /[A-Za-z0-9_]/;
+const isIdChar = (text, i) => {
+    const ch = text[i];
+    if (ch === undefined)
+        return false;
+    if (/[A-Za-z0-9_.]/.test(ch))
+        return true;
+    // A dash belongs to the id unless it starts a link (`-->`, `--`, `-.`).
+    if (ch === "-") {
+        const next = text[i + 1];
+        return next !== undefined && next !== ">" && next !== "-" && next !== "." && next !== "=" && /[A-Za-z0-9_]/.test(next);
+    }
+    return false;
+};
+const RESERVED = new Set(["end", "subgraph", "graph", "flowchart", "style", "classDef", "class", "click", "linkStyle", "direction"]);
+export const unescapeLabel = (raw) => raw
+    .replace(/<br\s*\/?>/gi, "\n")
+    .replace(/#quot;/g, '"')
+    .replace(/#(\d+);/g, (_m, code) => String.fromCharCode(Number(code)))
+    .replace(/&quot;/g, '"')
+    .replace(/&amp;/g, "&")
+    .trim();
+// Parses `key: value, key2: "v 2"` (the inside of `@{ … }`).
+export const parseAttrs = (inner) => {
+    const out = {};
+    let i = 0;
+    while (i < inner.length) {
+        while (i < inner.length && /[\s,]/.test(inner[i]))
+            i += 1;
+        const keyStart = i;
+        while (i < inner.length && /[A-Za-z0-9_-]/.test(inner[i]))
+            i += 1;
+        const key = inner.slice(keyStart, i).trim();
+        if (!key)
+            break;
+        while (i < inner.length && /\s/.test(inner[i]))
+            i += 1;
+        if (inner[i] !== ":") {
+            out[key] = "true";
+            continue;
+        }
+        i += 1;
+        while (i < inner.length && /\s/.test(inner[i]))
+            i += 1;
+        let value = "";
+        if (inner[i] === '"' || inner[i] === "'") {
+            const quote = inner[i];
+            i += 1;
+            const start = i;
+            while (i < inner.length && inner[i] !== quote)
+                i += 1;
+            value = inner.slice(start, i);
+            i += 1;
+        }
+        else {
+            const start = i;
+            while (i < inner.length && inner[i] !== ",")
+                i += 1;
+            value = inner.slice(start, i).trim();
+        }
+        out[key] = value;
+    }
+    return out;
+};
+const splitLines = (text) => {
+    const lines = [];
+    let offset = 0;
+    let line = 1;
+    for (const part of text.split("\n")) {
+        const body = part.endsWith("\r") ? part.slice(0, -1) : part;
+        lines.push({ text: body, start: offset, line });
+        offset += part.length + 1;
+        line += 1;
+    }
+    return lines;
+};
+// --- the chain scanner ---------------------------------------------------------------
+class Scanner {
+    text;
+    base; // offset of text[0] in the document
+    pos = 0;
+    constructor(text, base) {
+        this.text = text;
+        this.base = base;
+    }
+    get done() {
+        return this.pos >= this.text.length;
+    }
+    peek(offset = 0) {
+        return this.text[this.pos + offset] ?? "";
+    }
+    skipSpaces() {
+        while (!this.done && /\s/.test(this.peek()))
+            this.pos += 1;
+    }
+    startsWith(s) {
+        return this.text.startsWith(s, this.pos);
+    }
+    span(start, end) {
+        return { start: this.base + start, end: this.base + end };
+    }
+}
+const readBalanced = (scanner, open, close) => {
+    // scanner.pos is at `open`. Quotes protect the closer.
+    if (!scanner.startsWith(open))
+        return null;
+    let i = scanner.pos + open.length;
+    const innerStart = i;
+    let quote = null;
+    let depth = 0;
+    while (i < scanner.text.length) {
+        const ch = scanner.text[i];
+        if (quote) {
+            if (ch === quote)
+                quote = null;
+            i += 1;
+            continue;
+        }
+        if (ch === '"' || (ch === "'" && open === "@{")) {
+            quote = ch;
+            i += 1;
+            continue;
+        }
+        if (open === "@{") {
+            if (ch === "{")
+                depth += 1;
+            if (ch === "}") {
+                if (depth === 0)
+                    return { inner: scanner.text.slice(innerStart, i), innerStart, end: i + 1 };
+                depth -= 1;
+            }
+            i += 1;
+            continue;
+        }
+        if (scanner.text.startsWith(close, i))
+            return { inner: scanner.text.slice(innerStart, i), innerStart, end: i + close.length };
+        i += 1;
+    }
+    return null;
+};
+// Bracket kinds ordered so longer openers win.
+const BRACKETS = [
+    ["((()))", "(((", ")))"],
+    ["(())", "((", "))"],
+    ["([])", "([", "])"],
+    ["[[]]", "[[", "]]"],
+    ["[()]", "[(", ")]"],
+    ["[//]", "[/", "/]"],
+    ["[\\\\]", "[\\", "\\]"],
+    ["[/\\]", "[/", "\\]"],
+    ["[\\/]", "[\\", "/]"],
+    ["{{}}", "{{", "}}"],
+    ["{}", "{", "}"],
+    ["()", "(", ")"],
+    ["[]", "[", "]"],
+    [">]", ">", "]"],
+];
+const readLabelText = (raw) => {
+    const trimmed = raw.trim();
+    if (trimmed.length >= 2 && trimmed.startsWith('"') && trimmed.endsWith('"')) {
+        return { label: unescapeLabel(trimmed.slice(1, -1)), quoted: true };
+    }
+    return { label: unescapeLabel(trimmed), quoted: false };
+};
+const readNodeRef = (scanner, diagnostics, line) => {
+    scanner.skipSpaces();
+    const start = scanner.pos;
+    if (!ID_START.test(scanner.peek()))
+        return null;
+    let i = scanner.pos;
+    while (isIdChar(scanner.text, i))
+        i += 1;
+    const id = scanner.text.slice(scanner.pos, i);
+    if (RESERVED.has(id))
+        return null;
+    const idSpan = scanner.span(scanner.pos, i);
+    scanner.pos = i;
+    const ref = { id, span: scanner.span(start, i), idSpan, classes: [] };
+    // `@{ … }` attributes.
+    if (scanner.startsWith("@{")) {
+        const block = readBalanced(scanner, "@{", "}");
+        if (!block) {
+            diagnostics.push({ line, column: scanner.pos - 0 + 1, message: "Unterminated @{ … } block", severity: "error" });
+            return null;
+        }
+        ref.attrs = parseAttrs(block.inner);
+        ref.attrsSpan = scanner.span(scanner.pos, block.end);
+        if (ref.attrs.label !== undefined) {
+            ref.label = unescapeLabel(ref.attrs.label);
+            const labelIndex = block.inner.indexOf(ref.attrs.label);
+            if (labelIndex >= 0)
+                ref.labelSpan = scanner.span(block.innerStart + labelIndex, block.innerStart + labelIndex + ref.attrs.label.length);
+        }
+        if (ref.attrs.shape !== undefined)
+            ref.shape = canonicalMermaidShape(ref.attrs.shape) ?? ref.attrs.shape;
+        scanner.pos = block.end;
+    }
+    else {
+        // Classic bracket label. Some openers belong to several kinds (`[/` opens
+        // `[/ … /]` and `[/ … \]`, `[\` opens `[\ … \]` and `[\ … /]`): the
+        // NEAREST closer decides, so a closer of a later node never wins.
+        let unterminated = null;
+        let best = null;
+        for (const [kind, open, close] of BRACKETS) {
+            if (!scanner.startsWith(open))
+                continue;
+            if (best && open.length < best.open.length)
+                break; // longer openers already matched
+            const block = readBalanced(scanner, open, close);
+            if (!block) {
+                unterminated ??= `Unterminated ${open} … ${close} label`;
+                continue;
+            }
+            if (!best || block.end < best.block.end)
+                best = { kind, open, block };
+        }
+        if (best) {
+            unterminated = null;
+            const { kind, block } = best;
+            const { label, quoted } = readLabelText(block.inner);
+            ref.label = label;
+            const trimmedStart = block.inner.indexOf(block.inner.trim());
+            const innerStart = block.innerStart + trimmedStart + (quoted ? 1 : 0);
+            ref.labelSpan = scanner.span(innerStart, innerStart + block.inner.trim().length - (quoted ? 2 : 0));
+            ref.bracket = kind;
+            ref.bracketSpan = scanner.span(scanner.pos, block.end);
+            ref.shape = BRACKET_SHAPE[kind];
+            scanner.pos = block.end;
+        }
+        if (unterminated) {
+            diagnostics.push({ line, column: scanner.pos + 1, message: unterminated, severity: "error" });
+            return null;
+        }
+    }
+    // `:::class1:::class2`
+    const classStart = scanner.pos;
+    while (scanner.startsWith(":::")) {
+        let j = scanner.pos + 3;
+        while (j < scanner.text.length && /[A-Za-z0-9_-]/.test(scanner.text[j]))
+            j += 1;
+        ref.classes.push(scanner.text.slice(scanner.pos + 3, j));
+        scanner.pos = j;
+    }
+    if (scanner.pos > classStart)
+        ref.classSpan = scanner.span(classStart, scanner.pos);
+    ref.span = scanner.span(start, scanner.pos);
+    return ref;
+};
+// `-.` alone (followed by a space) opens an inline-labelled dotted link.
+const LINK_BODY = /^(?:-{2,}|={2,}|-\.+-|-\.(?=\s)|~{3,})/;
+const readLink = (scanner) => {
+    scanner.skipSpaces();
+    const start = scanner.pos;
+    const token = { labelStyle: "none" };
+    // Optional `id@` prefix.
+    const idMatch = /^([A-Za-z0-9_-]+)@(?=[<ox]?(?:-|=|~))/.exec(scanner.text.slice(scanner.pos));
+    if (idMatch) {
+        token.id = idMatch[1];
+        token.idSpan = scanner.span(scanner.pos, scanner.pos + idMatch[1].length);
+        scanner.pos += idMatch[0].length;
+    }
+    // Optional start marker.
+    const startCh = scanner.peek();
+    if ((startCh === "<" || startCh === "o" || startCh === "x") && /[-=.]/.test(scanner.peek(1))) {
+        token.startMarker = startCh;
+        scanner.pos += 1;
+    }
+    const bodyMatch = LINK_BODY.exec(scanner.text.slice(scanner.pos));
+    if (!bodyMatch) {
+        scanner.pos = start;
+        return null;
+    }
+    let body = bodyMatch[0];
+    scanner.pos += body.length;
+    const strokeOf = (b) => (b.startsWith("~") ? "invisible" : b.startsWith("=") ? "thick" : b.includes(".") ? "dotted" : "normal");
+    token.stroke = strokeOf(body);
+    token.length = body.startsWith("~") ? 1 : Math.max(1, body.replace(/[^-=.]/g, "").length - 2);
+    // Inline label: `-- text -->`, `-. text .->`, `== text ==>`.
+    const inlineOpener = body === "--" || body === "==" || body === "-.";
+    if (inlineOpener && /\s/.test(scanner.peek())) {
+        const rest = scanner.text.slice(scanner.pos);
+        const closer = /\s(-{2,}|={2,}|\.-+|\.{1,}-)([>ox])?/.exec(rest);
+        if (closer && closer.index >= 0) {
+            const labelRaw = rest.slice(0, closer.index);
+            const labelStart = scanner.pos + (labelRaw.length - labelRaw.trimStart().length);
+            token.label = unescapeLabel(labelRaw);
+            token.labelSpan = scanner.span(labelStart, labelStart + labelRaw.trim().length);
+            token.labelStyle = "inline";
+            scanner.pos += closer.index + closer[0].length;
+            body = closer[1];
+            if (closer[2])
+                token.endMarker = closer[2];
+            token.stroke = body.includes("=") ? "thick" : body.includes(".") || token.stroke === "dotted" ? "dotted" : "normal";
+        }
+    }
+    if (token.endMarker === undefined) {
+        const endCh = scanner.peek();
+        if (endCh === ">" || endCh === "o" || endCh === "x") {
+            // `o`/`x` are markers only when followed by a space/pipe (else they start a node id).
+            const after = scanner.peek(1);
+            if (endCh === ">" || after === "" || /[\s|;]/.test(after)) {
+                token.endMarker = endCh;
+                scanner.pos += 1;
+            }
+        }
+    }
+    // Pipe label `|text|` (the span grows only when one is found).
+    const beforeSpaces = scanner.pos;
+    scanner.skipSpaces();
+    if (scanner.peek() === "|") {
+        const close = scanner.text.indexOf("|", scanner.pos + 1);
+        if (close > scanner.pos) {
+            const raw = scanner.text.slice(scanner.pos + 1, close);
+            token.label = readLabelText(raw).label;
+            token.labelSpan = scanner.span(scanner.pos + 1, close);
+            token.labelStyle = "pipe";
+            scanner.pos = close + 1;
+        }
+    }
+    else {
+        scanner.pos = beforeSpaces;
+    }
+    token.span = scanner.span(start, scanner.pos);
+    return token;
+};
+// Mermaid lets an edge take attributes on its own line (`e1@{ curve: linear }`)
+// once it was declared with an id (`a e1@--> b`). Such a line reads as a lone
+// node reference with attributes; when its id is an edge id anywhere in the
+// text it is an edge-attribute statement instead. Runs after the whole text
+// was read because the declaration may come later.
+const reclassifyEdgeAttrs = (statements, text) => {
+    const edgeIds = new Set();
+    const collect = (list) => {
+        for (const statement of list) {
+            if (statement.kind === "chain") {
+                for (const link of statement.links)
+                    if (link.id)
+                        edgeIds.add(link.id);
+            }
+            else if (statement.kind === "subgraph") {
+                collect(statement.statements);
+            }
+        }
+    };
+    collect(statements);
+    if (edgeIds.size === 0)
+        return;
+    const rewrite = (list) => {
+        for (let index = 0; index < list.length; index += 1) {
+            const statement = list[index];
+            if (statement.kind === "subgraph") {
+                rewrite(statement.statements);
+                continue;
+            }
+            if (statement.kind !== "chain" || statement.links.length > 0 || statement.groups.length !== 1 || statement.groups[0].length !== 1)
+                continue;
+            const ref = statement.groups[0][0];
+            if (!ref.attrs || !edgeIds.has(ref.id) || ref.bracket || ref.classes.length > 0)
+                continue;
+            list[index] = {
+                kind: "edgeAttrs",
+                span: statement.span,
+                line: statement.line,
+                indent: statement.indent,
+                text: text.slice(statement.span.start, statement.span.end),
+                edgeId: ref.id,
+                attrs: ref.attrs,
+            };
+        }
+    };
+    rewrite(statements);
+};
+const parseChain = (raw, base, line, diagnostics) => {
+    const scanner = new Scanner(raw, base);
+    const groups = [];
+    const links = [];
+    let group = [];
+    const indent = raw.match(/^\s*/)?.[0] ?? "";
+    for (;;) {
+        const ref = readNodeRef(scanner, diagnostics, line);
+        if (!ref) {
+            if (group.length === 0)
+                return null;
+            break;
+        }
+        group.push(ref);
+        scanner.skipSpaces();
+        if (scanner.peek() === "&") {
+            scanner.pos += 1;
+            continue;
+        }
+        const link = readLink(scanner);
+        if (!link)
+            break;
+        groups.push(group);
+        group = [];
+        links.push(link);
+    }
+    if (group.length > 0)
+        groups.push(group);
+    scanner.skipSpaces();
+    if (!scanner.done) {
+        // Trailing junk we did not understand: this line is not ours to edit.
+        return null;
+    }
+    if (links.length !== groups.length - 1)
+        return null;
+    return { kind: "chain", span: { start: base + indent.length, end: base + raw.length }, line, indent, groups, links };
+};
+// --- top level ----------------------------------------------------------------------------
+const HEADER = /^\s*(flowchart|graph)\b\s*([A-Za-z]{2})?\s*;?\s*$/;
+export const parseMermaidFlowchart = (text) => {
+    const diagnostics = [];
+    const cst = { text, diagramType: null, direction: "TB", statements: [], diagnostics };
+    const lines = splitLines(text);
+    const stack = [{ statements: cst.statements }];
+    let index = 0;
+    // Frontmatter: `---` … `---` at the very top.
+    if (lines[0]?.text.trim() === "---") {
+        let close = 1;
+        while (close < lines.length && lines[close].text.trim() !== "---")
+            close += 1;
+        if (close < lines.length) {
+            const block = lines.slice(0, close + 1);
+            const raw = block.map((l) => l.text).join("\n");
+            const titleLine = block.find((l) => /^\s*title\s*:/.test(l.text));
+            const fm = { span: { start: block[0].start, end: block[close].start + block[close].text.length }, raw };
+            if (titleLine) {
+                const match = /^(\s*title\s*:\s*)(.*)$/.exec(titleLine.text);
+                if (match) {
+                    fm.title = match[2].trim().replace(/^["']|["']$/g, "");
+                    fm.titleSpan = { start: titleLine.start + match[1].length, end: titleLine.start + titleLine.text.length };
+                }
+            }
+            cst.frontmatter = fm;
+            cst.statements.push({ kind: "frontmatter", span: fm.span, line: 1, indent: "", text: raw });
+            index = close + 1;
+        }
+    }
+    const pushOther = (kind, rawLine) => {
+        const indent = rawLine.text.match(/^\s*/)?.[0] ?? "";
+        stack[stack.length - 1].statements.push({
+            kind,
+            span: { start: rawLine.start, end: rawLine.start + rawLine.text.length },
+            line: rawLine.line,
+            indent,
+            text: rawLine.text,
+        });
+    };
+    for (; index < lines.length; index += 1) {
+        const rawLine = lines[index];
+        const trimmed = rawLine.text.trim();
+        const current = stack[stack.length - 1];
+        if (trimmed === "") {
+            // Trailing empty line after the final newline is not a statement.
+            if (index === lines.length - 1 && rawLine.text === "")
+                break;
+            pushOther("blank", rawLine);
+            continue;
+        }
+        if (trimmed.startsWith("%%{")) {
+            pushOther("directive", rawLine);
+            continue;
+        }
+        if (trimmed.startsWith("%%")) {
+            pushOther("comment", rawLine);
+            continue;
+        }
+        if (cst.diagramType === null) {
+            const header = HEADER.exec(rawLine.text);
+            if (header) {
+                cst.diagramType = "flowchart";
+                cst.direction = (header[2] ?? "TB").toUpperCase();
+                cst.headerSpan = { start: rawLine.start, end: rawLine.start + rawLine.text.length };
+                pushOther("header", rawLine);
+                continue;
+            }
+            const otherType = /^\s*([A-Za-z]+(?:-beta)?)\b/.exec(rawLine.text);
+            if (otherType) {
+                cst.diagramType = otherType[1];
+                cst.headerSpan = { start: rawLine.start, end: rawLine.start + rawLine.text.length };
+                diagnostics.push({ line: rawLine.line, column: 1, message: `"${otherType[1]}" diagrams are previewed only — the canvas and diagram operations need a flowchart`, severity: "warning" });
+                pushOther("header", rawLine);
+                // Everything below belongs to a dialect we do not model.
+                for (index += 1; index < lines.length; index += 1) {
+                    if (lines[index].text.trim() === "" && index === lines.length - 1)
+                        break;
+                    pushOther("unknown", lines[index]);
+                }
+                break;
+            }
+        }
+        const subgraph = /^(\s*)subgraph\s+(.*)$/.exec(rawLine.text);
+        if (subgraph) {
+            const indent = subgraph[1];
+            const rest = subgraph[2].trim();
+            let id = "";
+            let title;
+            let titleSpan;
+            let attrs;
+            const restStart = rawLine.start + rawLine.text.indexOf(rest, indent.length + "subgraph".length);
+            const attrMatch = /^([A-Za-z0-9_-]+)\s*@\{(.*)\}\s*$/.exec(rest);
+            const titled = /^([A-Za-z0-9_-]+)\s*\[(.*)\]\s*$/.exec(rest);
+            if (attrMatch) {
+                id = attrMatch[1];
+                attrs = parseAttrs(attrMatch[2]);
+                if (attrs.label !== undefined)
+                    title = unescapeLabel(attrs.label);
+            }
+            else if (titled) {
+                id = titled[1];
+                const inner = readLabelText(titled[2]);
+                title = inner.label;
+                const bracketAt = rest.indexOf("[");
+                titleSpan = { start: restStart + bracketAt + 1 + (inner.quoted ? 1 : 0), end: restStart + rest.lastIndexOf("]") - (inner.quoted ? 1 : 0) };
+            }
+            else {
+                const quoted = /^"(.*)"$/.exec(rest);
+                if (quoted) {
+                    title = unescapeLabel(quoted[1]);
+                    id = title.replace(/[^A-Za-z0-9_]+/g, "_");
+                    titleSpan = { start: restStart + 1, end: restStart + rest.length - 1 };
+                }
+                else {
+                    id = rest;
+                    title = rest.includes(" ") ? rest : undefined;
+                    if (rest.includes(" ")) {
+                        id = rest.replace(/[^A-Za-z0-9_]+/g, "_");
+                        titleSpan = { start: restStart, end: restStart + rest.length };
+                    }
+                }
+            }
+            const idSpanStart = rawLine.start + rawLine.text.indexOf(rest);
+            const statement = {
+                kind: "subgraph",
+                span: { start: rawLine.start, end: rawLine.start + rawLine.text.length },
+                line: rawLine.line,
+                indent,
+                id,
+                idSpan: { start: idSpanStart, end: idSpanStart + id.length },
+                title,
+                titleSpan,
+                headerSpan: { start: rawLine.start, end: rawLine.start + rawLine.text.length },
+                endSpan: { start: rawLine.start + rawLine.text.length, end: rawLine.start + rawLine.text.length },
+                attrs,
+                statements: [],
+            };
+            current.statements.push(statement);
+            stack.push({ statements: statement.statements, subgraph: statement });
+            continue;
+        }
+        if (/^\s*end\s*;?\s*$/.test(rawLine.text)) {
+            if (stack.length > 1) {
+                const frame = stack.pop();
+                const sg = frame.subgraph;
+                sg.endSpan = { start: rawLine.start, end: rawLine.start + rawLine.text.length };
+                sg.span = { start: sg.span.start, end: sg.endSpan.end };
+            }
+            else {
+                diagnostics.push({ line: rawLine.line, column: 1, message: "`end` without a matching `subgraph`", severity: "error" });
+                pushOther("unknown", rawLine);
+            }
+            continue;
+        }
+        const directionMatch = /^\s*direction\s+([A-Za-z]{2})\s*$/.exec(rawLine.text);
+        if (directionMatch) {
+            if (current.subgraph)
+                current.subgraph.direction = directionMatch[1].toUpperCase();
+            pushOther("direction", rawLine);
+            continue;
+        }
+        const keyword = /^\s*(classDef|class|style|linkStyle|click)\b/.exec(rawLine.text);
+        if (keyword) {
+            pushOther(keyword[1], rawLine);
+            continue;
+        }
+        // Statements separated by `;` on one line — only split outside quotes/brackets.
+        const pieces = splitStatements(rawLine.text);
+        let anyChain = false;
+        for (const piece of pieces) {
+            const chain = parseChain(piece.text, rawLine.start + piece.offset, rawLine.line, diagnostics);
+            if (chain) {
+                current.statements.push(chain);
+                anyChain = true;
+            }
+            else if (piece.text.trim() !== "") {
+                diagnostics.push({ line: rawLine.line, column: piece.offset + 1, message: `Not understood: "${piece.text.trim().slice(0, 60)}" (kept as is)`, severity: "warning" });
+                current.statements.push({
+                    kind: "unknown",
+                    span: { start: rawLine.start + piece.offset, end: rawLine.start + piece.offset + piece.text.length },
+                    line: rawLine.line,
+                    indent: piece.text.match(/^\s*/)?.[0] ?? "",
+                    text: piece.text,
+                });
+            }
+        }
+        if (!anyChain && pieces.length === 0)
+            pushOther("unknown", rawLine);
+    }
+    while (stack.length > 1) {
+        const frame = stack.pop();
+        diagnostics.push({ line: frame.subgraph?.line ?? 1, column: 1, message: `subgraph "${frame.subgraph?.id}" is missing its \`end\``, severity: "error" });
+    }
+    reclassifyEdgeAttrs(cst.statements, cst.text);
+    if (cst.diagramType === null) {
+        diagnostics.push({ line: 1, column: 1, message: "Missing `flowchart <direction>` header", severity: "error" });
+    }
+    return cst;
+};
+const splitStatements = (line) => {
+    const out = [];
+    let depth = 0;
+    let quote = null;
+    let start = 0;
+    for (let i = 0; i < line.length; i += 1) {
+        const ch = line[i];
+        if (quote) {
+            if (ch === quote)
+                quote = null;
+            continue;
+        }
+        if (ch === '"') {
+            quote = ch;
+            continue;
+        }
+        if ("[({".includes(ch))
+            depth += 1;
+        else if ("])}".includes(ch))
+            depth = Math.max(0, depth - 1);
+        else if (ch === ";" && depth === 0) {
+            out.push({ text: line.slice(start, i), offset: start });
+            start = i + 1;
+        }
+    }
+    out.push({ text: line.slice(start), offset: start });
+    return out;
+};
+// Walk every statement (depth first) — subgraph bodies included.
+export const walkStatements = (statements, visit, parent = null) => {
+    for (const statement of statements) {
+        visit(statement, parent);
+        if (statement.kind === "subgraph")
+            walkStatements(statement.statements, visit, statement);
+    }
+};
+export const isMermaidFlowchart = (text) => {
+    const withoutFrontmatter = text.replace(/^---[\s\S]*?\n---\s*\n/, "");
+    const firstMeaningful = withoutFrontmatter.split("\n").map((l) => l.trim()).find((l) => l !== "" && !l.startsWith("%%"));
+    return Boolean(firstMeaningful && /^(flowchart|graph)\b/.test(firstMeaningful));
+};
+export const looksLikeMermaid = (text) => {
+    const first = text.replace(/^---[\s\S]*?\n---\s*\n/, "").split("\n").map((l) => l.trim()).find((l) => l !== "" && !l.startsWith("%%"));
+    return Boolean(first && /^(flowchart|graph|sequenceDiagram|classDiagram|stateDiagram(-v2)?|erDiagram|gantt|pie|mindmap|timeline|journey|gitGraph|quadrantChart|requirementDiagram|C4Context|sankey-beta|xychart-beta|block-beta|packet-beta|kanban|architecture-beta|radar-beta|treemap-beta|agentflow-beta)\b/.test(first));
+};
+//# sourceMappingURL=parse.js.map