@coral-viz/language 0.2.3

package/dist/formats/mermaid.js

@@ -0,0 +1,1051 @@
+/**
+ * Mermaid Diagram Importer
+ *
+ * Converts Mermaid diagram syntax to Graph-IR.
+ *
+ * Supported diagram types (Mermaid v11.12.2):
+ * - flowchart/graph
+ * - sequenceDiagram
+ * - classDiagram
+ * - stateDiagram / stateDiagram-v2
+ * - erDiagram
+ * - timeline
+ * - block-beta
+ * - packet-beta
+ * - kanban
+ * - architecture-beta
+ *
+ * See SPECS.md for version tracking and feature status.
+ */
+import { finishParse, parseDiagnostic } from '../diagnostics.js';
+// Diagram type detection patterns
+const DIAGRAM_PATTERNS = {
+    flowchart: /^(flowchart|graph)\s+(TB|TD|BT|LR|RL)?/i,
+    sequence: /^sequenceDiagram/i,
+    class: /^classDiagram/i,
+    state: /^stateDiagram(-v2)?/i,
+    er: /^erDiagram/i,
+    timeline: /^timeline/i,
+    block: /^block-beta/i,
+    packet: /^packet-beta/i,
+    kanban: /^kanban/i,
+    architecture: /^architecture-beta/i,
+};
+// Unsupported diagram types (for clear error messages)
+const UNSUPPORTED_DIAGRAMS = {
+    gantt: 'Gantt charts',
+    pie: 'Pie charts',
+    quadrantChart: 'Quadrant charts',
+    requirementDiagram: 'Requirement diagrams',
+    gitGraph: 'Git graphs',
+    C4Context: 'C4 diagrams',
+    mindmap: 'Mind maps',
+    journey: 'User journey diagrams',
+    zenuml: 'ZenUML diagrams',
+    sankey: 'Sankey diagrams',
+    xychart: 'XY charts',
+    radar: 'Radar charts',
+    treemap: 'Treemaps',
+};
+/**
+ * Parse Mermaid diagram syntax into Graph-IR
+ */
+export function parseMermaid(source, options = {}) {
+    const trimmed = source.trim();
+    if (!trimmed) {
+        return finishParse([
+            parseDiagnostic({
+                severity: 'error',
+                code: 'mermaid.input.unparsed',
+                message: 'Empty input',
+                position: { line: 1, column: 0, offset: 0 },
+            }),
+        ]);
+    }
+    const lines = trimmed.split('\n');
+    const firstLine = lines[0].trim();
+    // Detect diagram type
+    const diagramType = detectDiagramType(firstLine);
+    if (!diagramType) {
+        // Check if it's an unsupported type
+        const unsupportedType = detectUnsupportedType(firstLine);
+        if (unsupportedType) {
+            return finishParse([
+                parseDiagnostic({
+                    severity: 'error',
+                    code: 'mermaid.diagram.unsupported',
+                    message: `Unsupported Mermaid diagram type: ${unsupportedType}. Supported types: flowchart, sequenceDiagram, classDiagram, stateDiagram, erDiagram, timeline, block-beta, packet-beta, kanban, architecture-beta`,
+                    position: { line: 1, column: 0, offset: 0 },
+                }),
+            ]);
+        }
+        return finishParse([
+            parseDiagnostic({
+                severity: 'error',
+                code: 'mermaid.diagram.unparsed',
+                message: 'Could not detect Mermaid diagram type. Line must start with a valid diagram keyword.',
+                position: { line: 1, column: 0, offset: 0 },
+            }),
+        ]);
+    }
+    // Parse based on diagram type
+    switch (diagramType.type) {
+        case 'flowchart':
+            return parseFlowchart(lines, diagramType.match, options);
+        case 'sequence':
+            return parseSequence(lines, options);
+        case 'class':
+            return parseClass(lines, options);
+        case 'state':
+            return parseState(lines, options);
+        case 'er':
+            return parseER(lines, options);
+        case 'timeline':
+            return parseTimeline(lines, options);
+        case 'block':
+            return parseBlock(lines, options);
+        case 'packet':
+            return parsePacket(lines, options);
+        case 'kanban':
+            return parseKanban(lines, options);
+        case 'architecture':
+            return parseArchitecture(lines, options);
+        default:
+            return finishParse([
+                parseDiagnostic({
+                    severity: 'error',
+                    code: 'mermaid.diagram.unsupported',
+                    message: `Parser not implemented for: ${diagramType.type}`,
+                    position: { line: 1, column: 0, offset: 0 },
+                }),
+            ]);
+    }
+}
+function detectDiagramType(firstLine) {
+    for (const [type, pattern] of Object.entries(DIAGRAM_PATTERNS)) {
+        const match = firstLine.match(pattern);
+        if (match) {
+            return { type, match };
+        }
+    }
+    return null;
+}
+function detectUnsupportedType(firstLine) {
+    for (const [keyword, description] of Object.entries(UNSUPPORTED_DIAGRAMS)) {
+        if (firstLine.toLowerCase().startsWith(keyword.toLowerCase())) {
+            return description;
+        }
+    }
+    return null;
+}
+function parseFlowchart(lines, headerMatch, options) {
+    const ctx = {
+        nodeMap: new Map(),
+        edges: [],
+        edgeCounter: 0,
+        diagnostics: [],
+        currentLine: 0,
+        shapeMap: new Map(),
+    };
+    const direction = headerMatch[2]?.toUpperCase();
+    const layoutOptions = {
+        direction: directionMap[direction] || 'DOWN',
+    };
+    let subgraphStack = [];
+    for (let i = 1; i < lines.length; i++) {
+        ctx.currentLine = i + 1;
+        const line = lines[i].trim();
+        if (!line || line.startsWith('%%'))
+            continue;
+        // Subgraph start
+        const subgraphMatch = line.match(/^subgraph\s+(\w+)(?:\s*\[([^\]]+)\])?\s*$/);
+        if (subgraphMatch) {
+            subgraphStack.push({
+                id: subgraphMatch[1],
+                label: subgraphMatch[2],
+                nodes: [],
+            });
+            continue;
+        }
+        // Subgraph end
+        if (line === 'end' && subgraphStack.length > 0) {
+            const subgraph = subgraphStack.pop();
+            const groupNode = {
+                id: subgraph.id,
+                type: 'group',
+                label: subgraph.label || subgraph.id,
+                children: subgraph.nodes.map(nodeId => {
+                    const node = ctx.nodeMap.get(nodeId);
+                    node.parent = subgraph.id;
+                    return node;
+                }),
+            };
+            ctx.nodeMap.set(subgraph.id, groupNode);
+            continue;
+        }
+        // Parse edges or nodes
+        const edgeParsed = parseFlowchartEdgeLine(line, ctx);
+        if (edgeParsed) {
+            if (subgraphStack.length > 0) {
+                const current = subgraphStack[subgraphStack.length - 1];
+                for (const nodeId of edgeParsed.nodeIds) {
+                    if (!current.nodes.includes(nodeId)) {
+                        current.nodes.push(nodeId);
+                    }
+                }
+            }
+            continue;
+        }
+        const nodeParsed = parseFlowchartNodeLine(line, ctx);
+        if (nodeParsed) {
+            if (subgraphStack.length > 0) {
+                const current = subgraphStack[subgraphStack.length - 1];
+                if (!current.nodes.includes(nodeParsed)) {
+                    current.nodes.push(nodeParsed);
+                }
+            }
+            continue;
+        }
+        // Nothing matched. Previously this line was skipped in silence.
+        ctx.diagnostics.push(parseDiagnostic({
+            severity: 'info',
+            code: 'mermaid.line.unparsed',
+            message: `Line not recognised by the flowchart parser: ${line}`,
+            position: { line: ctx.currentLine, column: 0, offset: 0 },
+            source: line,
+        }));
+    }
+    const nodes = [];
+    for (const node of ctx.nodeMap.values()) {
+        if (!node.parent)
+            nodes.push(node);
+    }
+    return finishParse(ctx.diagnostics, {
+        version: '1.0.0',
+        id: options.graphId || 'mermaid-flowchart',
+        name: options.graphName,
+        nodes,
+        edges: ctx.edges,
+        layoutOptions,
+    });
+}
+const directionMap = {
+    TB: 'DOWN', TD: 'DOWN', BT: 'UP', LR: 'RIGHT', RL: 'LEFT',
+};
+// Flowchart node shapes: [pattern, nodeType, mermaidShape]
+const FLOWCHART_SHAPES = [
+    [/^\[\(([^\)]*)\)\]$/, 'database', 'database'], // [(text)]
+    [/^\(\[([^\]]*)\]\)$/, 'service', 'stadium'], // ([text])
+    [/^\[\[([^\]]*)\]\]$/, 'module', 'subroutine'], // [[text]]
+    [/^\(\(\(([^\)]*)\)\)\)$/, 'actor', 'doublecircle'], // (((text)))
+    [/^\(\(([^\)]*)\)\)$/, 'service', 'circle'], // ((text))
+    [/^\(([^\)]*)\)$/, 'service', 'round'], // (text)
+    [/^\{([^\}]*)\}$/, 'module', 'diamond'], // {text}
+    [/^\{\{([^\}]*)\}\}$/, 'group', 'hexagon'], // {{text}}
+    [/^\[([^\]]*)\]$/, 'service', 'box'], // [text]
+    [/^>([^\]]*)\]$/, 'service', 'asymmetric'], // >text]
+];
+function parseFlowchartNodeLine(line, ctx) {
+    const nodePattern = /^(\w+)(.*)$/;
+    const match = line.match(nodePattern);
+    if (!match)
+        return null;
+    const id = match[1];
+    const rest = match[2].trim();
+    if (!rest || ctx.nodeMap.has(id)) {
+        if (!ctx.nodeMap.has(id)) {
+            ctx.nodeMap.set(id, { id, type: 'service', label: id });
+        }
+        return id;
+    }
+    let type = 'service';
+    let label = id;
+    let matchedShape = false;
+    for (const [pattern, nodeType, mermaidShape] of FLOWCHART_SHAPES) {
+        const shapeMatch = rest.match(pattern);
+        if (shapeMatch) {
+            type = nodeType;
+            label = shapeMatch[1] || id;
+            matchedShape = true;
+            if (mermaidShape)
+                ctx.shapeMap.set(id, mermaidShape);
+            break;
+        }
+    }
+    // A bare identifier is a node. Text following it must be a recognised
+    // Mermaid shape; otherwise accepting only the first word hides bad output.
+    if (rest && !matchedShape)
+        return null;
+    ctx.nodeMap.set(id, { id, type, label });
+    return id;
+}
+// Edge patterns for flowchart
+const EDGE_ARROWS = [
+    { pattern: /-->/, style: undefined },
+    { pattern: /---/, style: { targetArrow: 'none' } },
+    { pattern: /-\.->/, style: { lineStyle: 'dashed' } },
+    { pattern: /==>/, style: { lineStyle: 'solid' } },
+    { pattern: /--o/, style: { targetArrow: 'circle' } },
+    { pattern: /--x/, style: { targetArrow: 'none' } },
+    { pattern: /~~~/, style: { lineStyle: 'dotted' } },
+];
+// Node shape patterns for the two-pass tokenizer
+const NODE_SHAPE_PATTERNS = [
+    [/^\[\(([^\)]*)\)\]/, 'database'], // [(text)]
+    [/^\(\[([^\]]*)\]\)/, 'stadium'], // ([text])
+    [/^\[\[([^\]]*)\]\]/, 'subroutine'], // [[text]]
+    [/^\(\(\(([^\)]*)\)\)\)/, 'doublecircle'], // (((text)))
+    [/^\(\(([^\)]*)\)\)/, 'circle'], // ((text))
+    [/^\(([^\)]*)\)/, 'round'], // (text)
+    [/^\{\{([^\}]*)\}\}/, 'hexagon'], // {{text}}
+    [/^\{([^\}]*)\}/, 'diamond'], // {text}
+    [/^\[([^\]]*)\]/, 'box'], // [text]
+];
+function tokenizeNode(text) {
+    const idMatch = text.match(/^(\w+)/);
+    if (!idMatch)
+        return null;
+    const id = idMatch[1];
+    const afterId = text.slice(id.length);
+    for (const [pattern, shape] of NODE_SHAPE_PATTERNS) {
+        const shapeMatch = afterId.match(pattern);
+        if (shapeMatch) {
+            return { id, consumed: id.length + shapeMatch[0].length, label: shapeMatch[1], shape };
+        }
+    }
+    return { id, consumed: id.length };
+}
+function tokenizeArrow(text) {
+    const arrowMatch = text.match(/^(-.->|-->|===|==>|---|--o|--x|~~~)/);
+    if (!arrowMatch)
+        return null;
+    const arrowType = arrowMatch[1];
+    let consumed = arrowType.length;
+    // Check for edge label: |label text|
+    let label;
+    const rest = text.slice(consumed);
+    const labelMatch = rest.match(/^\|([^|]*)\|/);
+    if (labelMatch) {
+        label = labelMatch[1];
+        consumed += labelMatch[0].length;
+    }
+    const arrowDef = EDGE_ARROWS.find(a => a.pattern.test(arrowType));
+    return { consumed, label, style: arrowDef?.style };
+}
+function parseFlowchartEdgeLine(line, ctx) {
+    // Two-pass tokenizer: alternate node → arrow → node → arrow → ...
+    // Handles chains like: A[label] -->|text| B{shape} -.-> C
+    const parts = [];
+    const arrows = [];
+    let pos = 0;
+    const trimmed = line.trimStart();
+    pos = 0;
+    // Parse first node
+    const firstNode = tokenizeNode(trimmed);
+    if (!firstNode)
+        return null;
+    parts.push(firstNode);
+    pos = firstNode.consumed;
+    // Alternate: skip whitespace → arrow → skip whitespace → node
+    while (pos < trimmed.length) {
+        // Skip whitespace
+        while (pos < trimmed.length && /\s/.test(trimmed[pos]))
+            pos++;
+        if (pos >= trimmed.length)
+            break;
+        const arrow = tokenizeArrow(trimmed.slice(pos));
+        if (!arrow)
+            break;
+        pos += arrow.consumed;
+        // Skip whitespace
+        while (pos < trimmed.length && /\s/.test(trimmed[pos]))
+            pos++;
+        if (pos >= trimmed.length)
+            break;
+        const node = tokenizeNode(trimmed.slice(pos));
+        if (!node)
+            break;
+        parts.push(node);
+        arrows.push({ label: arrow.label, style: arrow.style });
+        pos += node.consumed;
+    }
+    if (parts.length < 2 || arrows.length === 0)
+        return null;
+    const nodeIds = [];
+    for (const part of parts) {
+        nodeIds.push(part.id);
+        if (!ctx.nodeMap.has(part.id)) {
+            ctx.nodeMap.set(part.id, {
+                id: part.id,
+                type: shapeToType(part.shape),
+                label: part.label || part.id,
+            });
+        }
+        else if (part.label) {
+            const existing = ctx.nodeMap.get(part.id);
+            existing.label = part.label;
+            if (part.shape)
+                existing.type = shapeToType(part.shape);
+        }
+        // Track shape from tokenizeNode path
+        if (part.shape)
+            ctx.shapeMap.set(part.id, part.shape);
+    }
+    for (let i = 0; i < arrows.length && i < parts.length - 1; i++) {
+        const sourceId = parts[i].id;
+        const targetId = parts[i + 1].id;
+        const edge = {
+            id: `edge_${++ctx.edgeCounter}`,
+            source: sourceId,
+            target: targetId,
+        };
+        if (arrows[i].label)
+            edge.label = arrows[i].label;
+        if (arrows[i].style)
+            edge.style = arrows[i].style;
+        // Map edge labels to ports when source is a diamond (decision)
+        if (ctx.shapeMap.get(sourceId) === 'diamond' && edge.label) {
+            const normalizedLabel = edge.label.toLowerCase().trim();
+            if (['yes', 'y', 'true'].includes(normalizedLabel)) {
+                edge.sourcePort = 'yes';
+            }
+            else if (['no', 'n', 'false'].includes(normalizedLabel)) {
+                edge.sourcePort = 'no';
+            }
+            else {
+                edge.sourcePort = 'alt';
+            }
+        }
+        // Set targetPort for non-diamond targets
+        if (ctx.shapeMap.get(sourceId) === 'diamond' && edge.label) {
+            if (ctx.shapeMap.get(targetId) !== 'diamond') {
+                edge.targetPort = 'in';
+            }
+        }
+        ctx.edges.push(edge);
+    }
+    return { nodeIds };
+}
+function shapeToType(shape) {
+    switch (shape) {
+        case 'database': return 'database';
+        case 'doublecircle':
+        case 'circle': return 'actor';
+        case 'diamond':
+        case 'subroutine': return 'module';
+        case 'hexagon': return 'group';
+        default: return 'service';
+    }
+}
+// ============================================================================
+// Sequence Diagram Parser
+// ============================================================================
+function parseSequence(lines, options) {
+    const nodes = [];
+    const edges = [];
+    const nodeMap = new Map();
+    let edgeCounter = 0;
+    for (let i = 1; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (!line || line.startsWith('%%'))
+            continue;
+        // Participant/Actor declaration
+        const participantMatch = line.match(/^(participant|actor)\s+(\w+)(?:\s+as\s+(.+))?$/i);
+        if (participantMatch) {
+            const type = participantMatch[1].toLowerCase() === 'actor' ? 'actor' : 'service';
+            const id = participantMatch[2];
+            const label = participantMatch[3] || id;
+            if (!nodeMap.has(id)) {
+                const node = { id, type, label };
+                nodeMap.set(id, node);
+                nodes.push(node);
+            }
+            continue;
+        }
+        // Message: A->>B: text or A-->>B: text etc
+        const messageMatch = line.match(/^(\w+)\s*(--?>?>|--?>>|<<--?>>?|-x|--x|-\)|--\))\s*(\w+)\s*:\s*(.*)$/);
+        if (messageMatch) {
+            const [, source, arrow, target, label] = messageMatch;
+            // Ensure nodes exist
+            for (const id of [source, target]) {
+                if (!nodeMap.has(id)) {
+                    const node = { id, type: 'service', label: id };
+                    nodeMap.set(id, node);
+                    nodes.push(node);
+                }
+            }
+            const edge = {
+                id: `msg_${++edgeCounter}`,
+                source,
+                target,
+                label,
+                type: 'message',
+            };
+            // Set style based on arrow
+            if (arrow.includes('--')) {
+                edge.style = { lineStyle: 'dashed' };
+            }
+            if (arrow.includes('x')) {
+                edge.style = { ...edge.style, targetArrow: 'none' };
+            }
+            edges.push(edge);
+        }
+    }
+    return finishParse([], {
+        version: '1.0.0',
+        id: options.graphId || 'mermaid-sequence',
+        name: options.graphName,
+        nodes,
+        edges,
+        metadata: { custom: { diagramType: 'sequence' } },
+    });
+}
+// ============================================================================
+// Class Diagram Parser
+// ============================================================================
+function parseClass(lines, options) {
+    const nodes = [];
+    const edges = [];
+    const nodeMap = new Map();
+    let edgeCounter = 0;
+    let currentClass = null;
+    let inClassBody = false;
+    for (let i = 1; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (!line || line.startsWith('%%'))
+            continue;
+        // Class with body start
+        const classBodyMatch = line.match(/^class\s+(\w+)(?:\["([^"]+)"\])?\s*\{$/);
+        if (classBodyMatch) {
+            const id = classBodyMatch[1];
+            const label = classBodyMatch[2] || id;
+            currentClass = { id, type: 'module', label, properties: { members: [] } };
+            nodeMap.set(id, currentClass);
+            nodes.push(currentClass);
+            inClassBody = true;
+            continue;
+        }
+        // End of class body
+        if (line === '}' && inClassBody) {
+            currentClass = null;
+            inClassBody = false;
+            continue;
+        }
+        // Member inside class body
+        if (inClassBody && currentClass) {
+            currentClass.properties.members.push(line);
+            continue;
+        }
+        // Simple class declaration
+        const simpleClassMatch = line.match(/^class\s+(\w+)(?:\["([^"]+)"\])?$/);
+        if (simpleClassMatch) {
+            const id = simpleClassMatch[1];
+            const label = simpleClassMatch[2] || id;
+            if (!nodeMap.has(id)) {
+                const node = { id, type: 'module', label };
+                nodeMap.set(id, node);
+                nodes.push(node);
+            }
+            continue;
+        }
+        // Relationship: ClassA <|-- ClassB, ClassA *-- ClassB, etc.
+        const relationMatch = line.match(/^(\w+)\s*(<\|--|<\|\.\.|\*--|o--|-->|--|\.\.\>|\.\.\|>|\.\.)\s*(\w+)(?:\s*:\s*(.+))?$/);
+        if (relationMatch) {
+            const [, classA, rel, classB, label] = relationMatch;
+            for (const id of [classA, classB]) {
+                if (!nodeMap.has(id)) {
+                    const node = { id, type: 'module', label: id };
+                    nodeMap.set(id, node);
+                    nodes.push(node);
+                }
+            }
+            const relTypes = {
+                '<|--': 'inheritance',
+                '<|..': 'realization',
+                '*--': 'composition',
+                'o--': 'aggregation',
+                '-->': 'association',
+                '--': 'link',
+                '..>': 'dependency',
+                '..|>': 'realization',
+                '..': 'dashed_link',
+            };
+            const edge = {
+                id: `rel_${++edgeCounter}`,
+                source: classB,
+                target: classA,
+                type: relTypes[rel] || 'association',
+            };
+            if (label)
+                edge.label = label;
+            if (rel.includes('..'))
+                edge.style = { lineStyle: 'dashed' };
+            edges.push(edge);
+        }
+    }
+    return finishParse([], {
+        version: '1.0.0',
+        id: options.graphId || 'mermaid-class',
+        name: options.graphName,
+        nodes,
+        edges,
+        metadata: { custom: { diagramType: 'class' } },
+    });
+}
+// ============================================================================
+// State Diagram Parser
+// ============================================================================
+function parseState(lines, options) {
+    const nodes = [];
+    const edges = [];
+    const nodeMap = new Map();
+    let edgeCounter = 0;
+    for (let i = 1; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (!line || line.startsWith('%%') || line.startsWith('direction'))
+            continue;
+        // State declaration with description
+        const stateMatch = line.match(/^state\s+"?(\w+)"?(?:\s*:\s*(.+))?$/);
+        if (stateMatch) {
+            const id = stateMatch[1];
+            const description = stateMatch[2];
+            if (!nodeMap.has(id)) {
+                const node = { id, type: 'module', label: id };
+                if (description)
+                    node.description = description;
+                nodeMap.set(id, node);
+                nodes.push(node);
+            }
+            continue;
+        }
+        // Transition: State1 --> State2 : label
+        const transitionMatch = line.match(/^(\[\*\]|\w+)\s*-->\s*(\[\*\]|\w+)(?:\s*:\s*(.+))?$/);
+        if (transitionMatch) {
+            const [, source, target, label] = transitionMatch;
+            const sourceId = source === '[*]' ? '_start_' : source;
+            const targetId = target === '[*]' ? '_end_' : target;
+            for (const [id, type] of [[sourceId, source === '[*]' ? 'actor' : 'module'], [targetId, target === '[*]' ? 'actor' : 'module']]) {
+                if (!nodeMap.has(id)) {
+                    const node = {
+                        id,
+                        type: type,
+                        label: id === '_start_' ? 'Start' : id === '_end_' ? 'End' : id,
+                    };
+                    nodeMap.set(id, node);
+                    nodes.push(node);
+                }
+            }
+            const edge = {
+                id: `trans_${++edgeCounter}`,
+                source: sourceId,
+                target: targetId,
+                type: 'transition',
+            };
+            if (label)
+                edge.label = label;
+            edges.push(edge);
+        }
+    }
+    return finishParse([], {
+        version: '1.0.0',
+        id: options.graphId || 'mermaid-state',
+        name: options.graphName,
+        nodes,
+        edges,
+        metadata: { custom: { diagramType: 'state' } },
+    });
+}
+// ============================================================================
+// ER Diagram Parser
+// ============================================================================
+function parseER(lines, options) {
+    const nodes = [];
+    const edges = [];
+    const nodeMap = new Map();
+    let edgeCounter = 0;
+    let currentEntity = null;
+    for (let i = 1; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (!line || line.startsWith('%%'))
+            continue;
+        // Entity with attributes block start
+        const entityBlockMatch = line.match(/^(\w+)\s*\{$/);
+        if (entityBlockMatch) {
+            const id = entityBlockMatch[1];
+            currentEntity = { id, type: 'database', label: id, properties: { attributes: [] } };
+            nodeMap.set(id, currentEntity);
+            nodes.push(currentEntity);
+            continue;
+        }
+        // End of entity block
+        if (line === '}' && currentEntity) {
+            currentEntity = null;
+            continue;
+        }
+        // Attribute inside entity
+        if (currentEntity && !line.includes('||') && !line.includes('}')) {
+            currentEntity.properties.attributes.push(line);
+            continue;
+        }
+        // Relationship: ENTITY1 ||--o{ ENTITY2 : "label"
+        const relMatch = line.match(/^(\w+)\s*(\|o|\|\||o\{|\}\||\|{|}o|o\|)\s*--\s*(\|o|\|\||o\{|\}\||\|{|}o|o\|)\s*(\w+)\s*:\s*"?([^"]+)"?$/);
+        if (relMatch) {
+            const [, entity1, card1, card2, entity2, label] = relMatch;
+            for (const id of [entity1, entity2]) {
+                if (!nodeMap.has(id)) {
+                    const node = { id, type: 'database', label: id };
+                    nodeMap.set(id, node);
+                    nodes.push(node);
+                }
+            }
+            const edge = {
+                id: `rel_${++edgeCounter}`,
+                source: entity1,
+                target: entity2,
+                type: 'relationship',
+                label,
+                properties: {
+                    sourceCardinality: card1,
+                    targetCardinality: card2,
+                },
+            };
+            edges.push(edge);
+        }
+    }
+    return finishParse([], {
+        version: '1.0.0',
+        id: options.graphId || 'mermaid-er',
+        name: options.graphName,
+        nodes,
+        edges,
+        metadata: { custom: { diagramType: 'er' } },
+    });
+}
+// ============================================================================
+// Timeline Parser
+// ============================================================================
+function parseTimeline(lines, options) {
+    const nodes = [];
+    const edges = [];
+    let nodeCounter = 0;
+    let currentSection = null;
+    let previousPeriod = null;
+    for (let i = 1; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (!line || line.startsWith('%%'))
+            continue;
+        // Title
+        if (line.startsWith('title '))
+            continue;
+        // Section
+        const sectionMatch = line.match(/^section\s+(.+)$/);
+        if (sectionMatch) {
+            currentSection = {
+                id: `section_${++nodeCounter}`,
+                type: 'group',
+                label: sectionMatch[1],
+                children: [],
+            };
+            nodes.push(currentSection);
+            continue;
+        }
+        // Time period with events
+        const periodMatch = line.match(/^([^:]+)\s*:\s*(.+)$/);
+        if (periodMatch) {
+            const period = periodMatch[1].trim();
+            const events = periodMatch[2].split(':').map(e => e.trim());
+            const periodNode = {
+                id: `period_${++nodeCounter}`,
+                type: 'module',
+                label: period,
+                properties: { events },
+            };
+            if (currentSection) {
+                periodNode.parent = currentSection.id;
+                currentSection.children.push(periodNode);
+            }
+            else {
+                nodes.push(periodNode);
+            }
+            if (previousPeriod) {
+                edges.push({
+                    id: `seq_${nodeCounter}`,
+                    source: previousPeriod,
+                    target: periodNode.id,
+                    type: 'sequence',
+                });
+            }
+            previousPeriod = periodNode.id;
+        }
+    }
+    return finishParse([], {
+        version: '1.0.0',
+        id: options.graphId || 'mermaid-timeline',
+        name: options.graphName,
+        nodes,
+        edges,
+        metadata: { custom: { diagramType: 'timeline' } },
+    });
+}
+// ============================================================================
+// Block Diagram Parser
+// ============================================================================
+function parseBlock(lines, options) {
+    const nodes = [];
+    const edges = [];
+    const nodeMap = new Map();
+    let edgeCounter = 0;
+    for (let i = 1; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (!line || line.startsWith('%%') || line.startsWith('columns'))
+            continue;
+        // Block with edge
+        const edgeMatch = line.match(/^(\w+)(?:\["([^"]+)"\])?\s*(-->|---)\s*(?:\|"([^"]+)"\|)?\s*(\w+)(?:\["([^"]+)"\])?$/);
+        if (edgeMatch) {
+            const [, id1, label1, arrow, edgeLabel, id2, label2] = edgeMatch;
+            for (const [id, label] of [[id1, label1], [id2, label2]]) {
+                if (!nodeMap.has(id)) {
+                    const node = { id: id, type: 'service', label: (label || id) };
+                    nodeMap.set(id, node);
+                    nodes.push(node);
+                }
+            }
+            const edge = {
+                id: `edge_${++edgeCounter}`,
+                source: id1,
+                target: id2,
+            };
+            if (edgeLabel)
+                edge.label = edgeLabel;
+            if (arrow === '---')
+                edge.style = { targetArrow: 'none' };
+            edges.push(edge);
+            continue;
+        }
+        // Simple block
+        const blockMatch = line.match(/^(\w+)(?:\["([^"]+)"\])?(?::(\d+))?$/);
+        if (blockMatch) {
+            const [, id, label, span] = blockMatch;
+            if (!nodeMap.has(id)) {
+                const node = { id, type: 'service', label: label || id };
+                if (span)
+                    node.properties = { columnSpan: parseInt(span) };
+                nodeMap.set(id, node);
+                nodes.push(node);
+            }
+        }
+    }
+    return finishParse([], {
+        version: '1.0.0',
+        id: options.graphId || 'mermaid-block',
+        name: options.graphName,
+        nodes,
+        edges,
+        metadata: { custom: { diagramType: 'block' } },
+    });
+}
+// ============================================================================
+// Packet Diagram Parser
+// ============================================================================
+function parsePacket(lines, options) {
+    const nodes = [];
+    let fieldCounter = 0;
+    let currentBit = 0;
+    for (let i = 1; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (!line || line.startsWith('%%'))
+            continue;
+        // Range syntax: 0-15: "Header"
+        const rangeMatch = line.match(/^(\d+)-(\d+)\s*:\s*"([^"]+)"$/);
+        if (rangeMatch) {
+            const [, start, end, label] = rangeMatch;
+            const node = {
+                id: `field_${++fieldCounter}`,
+                type: 'module',
+                label,
+                properties: {
+                    bitStart: parseInt(start),
+                    bitEnd: parseInt(end),
+                    bitWidth: parseInt(end) - parseInt(start) + 1,
+                },
+            };
+            nodes.push(node);
+            continue;
+        }
+        // Relative syntax: +8: "Field"
+        const relativeMatch = line.match(/^\+(\d+)\s*:\s*"([^"]+)"$/);
+        if (relativeMatch) {
+            const [, width, label] = relativeMatch;
+            const bitWidth = parseInt(width);
+            const node = {
+                id: `field_${++fieldCounter}`,
+                type: 'module',
+                label,
+                properties: {
+                    bitStart: currentBit,
+                    bitEnd: currentBit + bitWidth - 1,
+                    bitWidth,
+                },
+            };
+            nodes.push(node);
+            currentBit += bitWidth;
+        }
+    }
+    return finishParse([], {
+        version: '1.0.0',
+        id: options.graphId || 'mermaid-packet',
+        name: options.graphName,
+        nodes,
+        edges: [],
+        metadata: { custom: { diagramType: 'packet' } },
+    });
+}
+// ============================================================================
+// Kanban Parser
+// ============================================================================
+function parseKanban(lines, options) {
+    const nodes = [];
+    let currentColumn = null;
+    for (let i = 1; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('%%'))
+            continue;
+        const indent = line.search(/\S/);
+        // Column (less indented than tasks)
+        const columnMatch = trimmed.match(/^(\w+)\[([^\]]+)\]$/);
+        if (columnMatch && indent <= 4) {
+            currentColumn = {
+                id: columnMatch[1],
+                type: 'group',
+                label: columnMatch[2],
+                children: [],
+            };
+            nodes.push(currentColumn);
+            continue;
+        }
+        // Task (more indented than column)
+        const taskMatch = trimmed.match(/^(\w+)\[([^\]]+)\](?:@\{([^}]+)\})?$/);
+        if (taskMatch && currentColumn && indent > 4) {
+            const [, id, label, metaStr] = taskMatch;
+            const task = {
+                id,
+                type: 'service',
+                label,
+                parent: currentColumn.id,
+            };
+            if (metaStr) {
+                const metadata = {};
+                const pairs = metaStr.split(',');
+                for (const pair of pairs) {
+                    const [key, value] = pair.split(':').map(s => s.trim().replace(/"/g, ''));
+                    if (key && value)
+                        metadata[key] = value;
+                }
+                task.properties = { metadata };
+            }
+            currentColumn.children.push(task);
+        }
+    }
+    return finishParse([], {
+        version: '1.0.0',
+        id: options.graphId || 'mermaid-kanban',
+        name: options.graphName,
+        nodes,
+        edges: [],
+        metadata: { custom: { diagramType: 'kanban' } },
+    });
+}
+// ============================================================================
+// Architecture Diagram Parser
+// ============================================================================
+function parseArchitecture(lines, options) {
+    const nodes = [];
+    const edges = [];
+    const nodeMap = new Map();
+    let edgeCounter = 0;
+    for (let i = 1; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (!line || line.startsWith('%%'))
+            continue;
+        // Group: group id(icon)[title] in parent
+        const groupMatch = line.match(/^group\s+(\w+)(?:\(([^)]*)\))?\[([^\]]+)\](?:\s+in\s+(\w+))?$/);
+        if (groupMatch) {
+            const [, id, icon, label, parentId] = groupMatch;
+            const node = { id, type: 'group', label, children: [] };
+            if (icon)
+                node.properties = { icon };
+            if (parentId)
+                node.parent = parentId;
+            nodeMap.set(id, node);
+            if (!parentId)
+                nodes.push(node);
+            else {
+                const parent = nodeMap.get(parentId);
+                if (parent?.children)
+                    parent.children.push(node);
+            }
+            continue;
+        }
+        // Service: service id(icon)[title] in parent
+        const serviceMatch = line.match(/^service\s+(\w+)(?:\(([^)]*)\))?\[([^\]]+)\](?:\s+in\s+(\w+))?$/);
+        if (serviceMatch) {
+            const [, id, icon, label, parentId] = serviceMatch;
+            const node = { id, type: 'service', label };
+            if (icon)
+                node.properties = { icon };
+            if (parentId)
+                node.parent = parentId;
+            nodeMap.set(id, node);
+            if (!parentId)
+                nodes.push(node);
+            else {
+                const parent = nodeMap.get(parentId);
+                if (parent?.children)
+                    parent.children.push(node);
+            }
+            continue;
+        }
+        // Junction: junction id in parent
+        const junctionMatch = line.match(/^junction\s+(\w+)(?:\s+in\s+(\w+))?$/);
+        if (junctionMatch) {
+            const [, id, parentId] = junctionMatch;
+            const node = { id, type: 'module', label: id };
+            if (parentId)
+                node.parent = parentId;
+            nodeMap.set(id, node);
+            if (!parentId)
+                nodes.push(node);
+            continue;
+        }
+        // Edge: id:T <--> B:id or id:L --> R:id
+        const edgeMatch = line.match(/^(\w+)(?:\{(\w+)\})?:([TBLR])\s*(<)?--?(>)?\s*([TBLR]):(\w+)(?:\{(\w+)\})?$/);
+        if (edgeMatch) {
+            const [, src, srcGroup, srcSide, leftArrow, rightArrow, tgtSide, tgt, tgtGroup] = edgeMatch;
+            const edge = {
+                id: `edge_${++edgeCounter}`,
+                source: src,
+                target: tgt,
+                properties: {
+                    sourceSide: srcSide,
+                    targetSide: tgtSide,
+                    bidirectional: !!leftArrow && !!rightArrow,
+                },
+            };
+            if (srcGroup)
+                edge.properties.sourceGroup = srcGroup;
+            if (tgtGroup)
+                edge.properties.targetGroup = tgtGroup;
+            edges.push(edge);
+        }
+    }
+    return finishParse([], {
+        version: '1.0.0',
+        id: options.graphId || 'mermaid-architecture',
+        name: options.graphName,
+        nodes,
+        edges,
+        metadata: { custom: { diagramType: 'architecture' } },
+    });
+}
+//# sourceMappingURL=mermaid.js.map