mermaid-ast 0.1.0 → 0.2.0

package/README.md

@@ -1,5 +1,6 @@
 # mermaid-ast
 
+[![npm version](https://img.shields.io/npm/v/mermaid-ast)](https://www.npmjs.com/package/mermaid-ast)
 [![Built with Slate](https://img.shields.io/badge/Built%20with-Slate-blue)](https://randomlabs.ai)
 
 Parse and render Mermaid diagrams to/from AST (Abstract Syntax Tree).
@@ -18,6 +19,7 @@ This library provides a way to programmatically work with Mermaid diagrams by pa
 
 - **Flowchart** (`flowchart`, `graph`)
 - **Sequence Diagram** (`sequenceDiagram`)
+- **Class Diagram** (`classDiagram`)
 
 ## Installation
 
@@ -91,6 +93,33 @@ console.log(ast.statements.length); // 2
 const output = renderSequence(ast);
 ```
 
+### Class Diagrams
+
+```typescript
+import { parseClassDiagram, renderClassDiagram } from "mermaid-ast";
+
+const ast = parseClassDiagram(`classDiagram
+    class Animal {
+        +String name
+        +int age
+        +eat()
+        +sleep()
+    }
+    class Duck {
+        +String beakColor
+        +swim()
+        +quack()
+    }
+    Animal <|-- Duck`);
+
+// Access AST properties
+console.log(ast.classes.size); // 2
+console.log(ast.relations.length); // 1
+
+// Render back
+const output = renderClassDiagram(ast);
+```
+
 ### Diagram Type Detection
 
 ```typescript
@@ -98,6 +127,7 @@ import { detectDiagramType } from "mermaid-ast";
 
 detectDiagramType("flowchart LR\n  A --> B"); // "flowchart"
 detectDiagramType("sequenceDiagram\n  A->>B: Hi"); // "sequence"
+detectDiagramType("classDiagram\n  class Animal"); // "class"
 detectDiagramType("unknown diagram"); // null
 ```
 
@@ -127,6 +157,14 @@ detectDiagramType("unknown diagram"); // null
 | `renderSequence(ast: SequenceAST): string` | Render sequence AST |
 | `isSequenceDiagram(input: string): boolean` | Check if input is sequence |
 
+### Class Diagram Functions
+
+| Function | Description |
+|----------|-------------|
+| `parseClassDiagram(input: string): ClassDiagramAST` | Parse class diagram |
+| `renderClassDiagram(ast: ClassDiagramAST): string` | Render class diagram AST |
+| `isClassDiagram(input: string): boolean` | Check if input is class diagram |
+
 ## Supported Flowchart Features
 
 - **Directions**: LR, RL, TB, TD, BT
@@ -148,6 +186,21 @@ detectDiagramType("unknown diagram"); // null
 - **Notes**: `note left of`, `note right of`, `note over`
 - **Actor lifecycle**: `create`, `destroy`
 
+## Supported Class Diagram Features
+
+- **Classes**: With labels, members (attributes and methods)
+- **Visibility modifiers**: `+` (public), `-` (private), `#` (protected), `~` (package)
+- **Relationships**: Inheritance (`<|--`), composition (`*--`), aggregation (`o--`), dependency (`<--`), lollipop (`()--`)
+- **Line types**: Solid (`--`), dotted (`..`)
+- **Cardinality**: `"1" --> "*"` relationship labels
+- **Annotations**: `<<interface>>`, `<<abstract>>`, `<<service>>`, etc.
+- **Namespaces**: Group related classes
+- **Notes**: `note for Class "text"`
+- **Direction**: `direction LR`, `direction TB`, etc.
+- **Styling**: `cssClass`, `classDef`
+- **Interactions**: `callback`, `link`
+- **Generic types**: `class List~T~`
+
 ## Development
 
 ### Prerequisites

package/dist/index.d.ts

@@ -17,6 +17,6 @@
  * ```
  */
 export * from "./types/index.js";
-export { parse, parseFlowchart, parseSequence, detectDiagramType, isFlowchartDiagram, isSequenceDiagram, } from "./parser/index.js";
-export { render, renderFlowchart, renderSequence, } from "./renderer/index.js";
+export { parse, parseFlowchart, parseSequence, parseClassDiagram, detectDiagramType, isFlowchartDiagram, isSequenceDiagram, isClassDiagram, } from "./parser/index.js";
+export { render, renderFlowchart, renderSequence, renderClassDiagram, } from "./renderer/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,cAAc,kBAAkB,CAAC;AAGjC,OAAO,EACL,KAAK,EACL,cAAc,EACd,aAAa,EACb,iBAAiB,EACjB,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EACL,MAAM,EACN,eAAe,EACf,cAAc,GACf,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,cAAc,kBAAkB,CAAC;AAGjC,OAAO,EACL,KAAK,EACL,cAAc,EACd,aAAa,EACb,iBAAiB,EACjB,iBAAiB,EACjB,kBAAkB,EAClB,iBAAiB,EACjB,cAAc,GACf,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EACL,MAAM,EACN,eAAe,EACf,cAAc,EACd,kBAAkB,GACnB,MAAM,qBAAqB,CAAC"}

package/dist/index.js

@@ -19,6 +19,6 @@
 // Export types
 export * from "./types/index.js";
 // Export parser functions
-export { parse, parseFlowchart, parseSequence, detectDiagramType, isFlowchartDiagram, isSequenceDiagram, } from "./parser/index.js";
-// Export renderer functions (to be implemented)
-export { render, renderFlowchart, renderSequence, } from "./renderer/index.js";
+export { parse, parseFlowchart, parseSequence, parseClassDiagram, detectDiagramType, isFlowchartDiagram, isSequenceDiagram, isClassDiagram, } from "./parser/index.js";
+// Export renderer functions
+export { render, renderFlowchart, renderSequence, renderClassDiagram, } from "./renderer/index.js";

package/dist/parser/class-parser.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Class Diagram Parser
+ *
+ * Parses Mermaid class diagram syntax into an AST using the vendored JISON parser.
+ */
+import { type ClassDiagramAST } from "../types/class.js";
+/**
+ * Parse a class diagram string into an AST
+ */
+export declare function parseClassDiagram(input: string): ClassDiagramAST;
+/**
+ * Detect if input is a class diagram
+ */
+export declare function isClassDiagram(input: string): boolean;
+//# sourceMappingURL=class-parser.d.ts.map

package/dist/parser/class-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"class-parser.d.ts","sourceRoot":"","sources":["../../src/parser/class-parser.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,KAAK,eAAe,EASrB,MAAM,mBAAmB,CAAC;AAwS3B;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe,CAsBhE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAOrD"}

package/dist/parser/class-parser.js

@@ -0,0 +1,295 @@
+/**
+ * Class Diagram Parser
+ *
+ * Parses Mermaid class diagram syntax into an AST using the vendored JISON parser.
+ */
+import { createClassDiagramAST, } from "../types/class.js";
+// Import the vendored parser
+// @ts-ignore - Generated JS file without types
+import classParser from "../vendored/parsers/class.js";
+/**
+ * Parse a member string to extract visibility and type
+ */
+function parseMember(memberStr) {
+    const trimmed = memberStr.trim();
+    let visibility;
+    let text = trimmed;
+    // Check for visibility prefix
+    if (trimmed.startsWith("+")) {
+        visibility = "+";
+        text = trimmed.slice(1).trim();
+    }
+    else if (trimmed.startsWith("-")) {
+        visibility = "-";
+        text = trimmed.slice(1).trim();
+    }
+    else if (trimmed.startsWith("#")) {
+        visibility = "#";
+        text = trimmed.slice(1).trim();
+    }
+    else if (trimmed.startsWith("~")) {
+        visibility = "~";
+        text = trimmed.slice(1).trim();
+    }
+    // Determine if method or attribute
+    const isMethod = text.includes("(") && text.includes(")");
+    return {
+        text,
+        visibility,
+        type: isMethod ? "method" : "attribute",
+    };
+}
+/**
+ * Map relation type number to string
+ */
+function mapRelationType(type) {
+    if (typeof type === "string")
+        return type;
+    switch (type) {
+        case 0:
+            return "aggregation";
+        case 1:
+            return "extension";
+        case 2:
+            return "composition";
+        case 3:
+            return "dependency";
+        case 4:
+            return "lollipop";
+        default:
+            return "none";
+    }
+}
+/**
+ * Map line type number to string
+ */
+function mapLineType(type) {
+    if (typeof type === "string")
+        return type;
+    return type === 0 ? "solid" : "dotted";
+}
+/**
+ * Create the yy object that the JISON parser uses
+ */
+function createClassYY(ast) {
+    // Helper to get or create a class
+    function getOrCreateClass(id) {
+        let cls = ast.classes.get(id);
+        if (!cls) {
+            cls = {
+                id,
+                members: [],
+                annotations: [],
+                cssClasses: [],
+                styles: [],
+            };
+            ast.classes.set(id, cls);
+        }
+        return cls;
+    }
+    return {
+        // Relation type constants (used by the parser)
+        relationType: {
+            AGGREGATION: 0,
+            EXTENSION: 1,
+            COMPOSITION: 2,
+            DEPENDENCY: 3,
+            LOLLIPOP: 4,
+        },
+        // Line type constants
+        lineType: {
+            LINE: 0,
+            DOTTED_LINE: 1,
+        },
+        // Set diagram direction
+        setDirection(dir) {
+            ast.direction = dir;
+        },
+        // Add a class
+        addClass(id) {
+            getOrCreateClass(id);
+        },
+        // Set class label
+        setClassLabel(id, label) {
+            const cls = getOrCreateClass(id);
+            cls.label = label;
+        },
+        // Add members to a class
+        addMembers(id, members) {
+            const cls = getOrCreateClass(id);
+            for (const member of members) {
+                const trimmed = member.trim();
+                if (trimmed) { // Skip empty members
+                    cls.members.push(parseMember(member));
+                }
+            }
+        },
+        // Add a single member (called from memberStatement)
+        addMember(id, member) {
+            const cls = getOrCreateClass(id);
+            const trimmed = member.trim();
+            if (trimmed) { // Skip empty members
+                cls.members.push(parseMember(member));
+            }
+        },
+        // Add a relation
+        addRelation(relation) {
+            // Ensure both classes exist
+            getOrCreateClass(relation.id1);
+            getOrCreateClass(relation.id2);
+            const rel = {
+                id1: relation.id1,
+                id2: relation.id2,
+                relation: {
+                    type1: mapRelationType(relation.relation.type1),
+                    type2: mapRelationType(relation.relation.type2),
+                    lineType: mapLineType(relation.relation.lineType),
+                },
+            };
+            if (relation.relationTitle1 && relation.relationTitle1 !== "none") {
+                rel.relationTitle1 = relation.relationTitle1;
+            }
+            if (relation.relationTitle2 && relation.relationTitle2 !== "none") {
+                rel.relationTitle2 = relation.relationTitle2;
+            }
+            if (relation.title) {
+                rel.title = relation.title;
+            }
+            ast.relations.push(rel);
+        },
+        // Add annotation (like <<interface>>)
+        addAnnotation(className, annotation) {
+            const cls = getOrCreateClass(className);
+            cls.annotations.push(annotation);
+        },
+        // Add namespace
+        addNamespace(name) {
+            if (!ast.namespaces.has(name)) {
+                ast.namespaces.set(name, { name, classes: [] });
+            }
+        },
+        // Add classes to namespace
+        addClassesToNamespace(namespaceName, classIds) {
+            let ns = ast.namespaces.get(namespaceName);
+            if (!ns) {
+                ns = { name: namespaceName, classes: [] };
+                ast.namespaces.set(namespaceName, ns);
+            }
+            for (const classId of classIds) {
+                if (!ns.classes.includes(classId)) {
+                    ns.classes.push(classId);
+                }
+            }
+        },
+        // Add note
+        addNote(text, forClass) {
+            const note = { text };
+            if (forClass) {
+                note.forClass = forClass;
+            }
+            ast.notes.push(note);
+        },
+        // Set CSS class on a class (id can be comma-separated list like "C1,C2")
+        setCssClass(id, className) {
+            // Split by comma to handle "cssClass C1,C2 styleClass" syntax
+            const classIds = id.split(",").map(s => s.trim()).filter(s => s.length > 0);
+            for (const classId of classIds) {
+                const cls = getOrCreateClass(classId);
+                if (!cls.cssClasses.includes(className)) {
+                    cls.cssClasses.push(className);
+                }
+            }
+        },
+        // Set inline CSS style
+        setCssStyle(id, styles) {
+            const cls = getOrCreateClass(id);
+            cls.styles.push(...styles);
+        },
+        // Define a CSS class (classDef)
+        defineClass(classList, styles) {
+            for (const className of classList) {
+                ast.classDefs.set(className, { name: className, styles });
+            }
+        },
+        // Set click event
+        setClickEvent(id, callback, callbackArgs) {
+            const cls = getOrCreateClass(id);
+            cls.callback = callback;
+            if (callbackArgs) {
+                cls.callbackArgs = callbackArgs;
+            }
+        },
+        // Set link
+        setLink(id, href, target) {
+            const cls = getOrCreateClass(id);
+            cls.link = href;
+            if (target) {
+                cls.linkTarget = target;
+            }
+        },
+        // Set tooltip
+        setTooltip(id, tooltip) {
+            const cls = getOrCreateClass(id);
+            cls.tooltip = tooltip;
+        },
+        // Clean up label (remove surrounding quotes, colons)
+        cleanupLabel(label) {
+            let result = label;
+            if (result.startsWith(":")) {
+                result = result.slice(1);
+            }
+            result = result.trim();
+            if ((result.startsWith('"') && result.endsWith('"')) ||
+                (result.startsWith("'") && result.endsWith("'"))) {
+                result = result.slice(1, -1);
+            }
+            return result;
+        },
+        // Accessibility
+        setAccTitle(title) {
+            ast.accTitle = title;
+        },
+        setAccDescription(description) {
+            ast.accDescription = description;
+        },
+        // These are called but we don't need to do anything special
+        getTooltip: () => undefined,
+        lookUpDomId: (id) => id,
+        setDiagramTitle: () => { },
+        getDiagramTitle: () => "",
+        getConfig: () => ({}),
+        clear: () => { },
+    };
+}
+/**
+ * Parse a class diagram string into an AST
+ */
+export function parseClassDiagram(input) {
+    const ast = createClassDiagramAST();
+    const yy = createClassYY(ast);
+    // Set up the parser with our yy object
+    classParser.yy = yy;
+    try {
+        classParser.parse(input);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to parse class diagram: ${error.message}`);
+        }
+        throw error;
+    }
+    // Reverse members to maintain source order (JISON grammar processes bottom-up)
+    for (const [, cls] of ast.classes) {
+        cls.members.reverse();
+    }
+    return ast;
+}
+/**
+ * Detect if input is a class diagram
+ */
+export function isClassDiagram(input) {
+    const trimmed = input.trim();
+    const firstLine = trimmed.split("\n")[0].trim().toLowerCase();
+    return (firstLine.startsWith("classdiagram") ||
+        firstLine.startsWith("classdiagram-v2"));
+}

package/dist/parser/flowchart-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flowchart-parser.d.ts","sourceRoot":"","sources":["../../src/parser/flowchart-parser.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,KAAK,YAAY,EAalB,MAAM,uBAAuB,CAAC;AA+Z/B;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,CAkB1D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAQzD"}
+{"version":3,"file":"flowchart-parser.d.ts","sourceRoot":"","sources":["../../src/parser/flowchart-parser.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,KAAK,YAAY,EAalB,MAAM,uBAAuB,CAAC;AAyb/B;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,CAkB1D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAQzD"}

package/dist/parser/flowchart-parser.js

@@ -205,10 +205,10 @@ function createFlowchartYY(ast) {
                 subgraphId = `subGraph${subgraphIdCounter++}`;
             }
             else if (typeof id === "object" && "text" in id) {
-                subgraphId = id.text;
+                subgraphId = id.text.trim();
             }
             else {
-                subgraphId = id;
+                subgraphId = id.trim();
             }
             // Collect node IDs from the nodeList and look for direction statements
             const nodes = [];
@@ -216,10 +216,21 @@ function createFlowchartYY(ast) {
             if (Array.isArray(nodeList)) {
                 for (const item of nodeList) {
                     if (typeof item === "string") {
-                        nodes.push(item);
+                        // Trim and filter empty strings
+                        const trimmed = item.trim();
+                        if (trimmed) {
+                            nodes.push(trimmed);
+                        }
                     }
                     else if (Array.isArray(item)) {
-                        nodes.push(...item.filter((x) => typeof x === "string"));
+                        for (const x of item) {
+                            if (typeof x === "string") {
+                                const trimmed = x.trim();
+                                if (trimmed) {
+                                    nodes.push(trimmed);
+                                }
+                            }
+                        }
                     }
                     else if (item && typeof item === "object") {
                         // Check for direction statement: {stmt: 'dir', value: 'TB'}
@@ -229,12 +240,28 @@ function createFlowchartYY(ast) {
                         else if ("nodes" in item) {
                             const itemNodes = item.nodes;
                             if (Array.isArray(itemNodes)) {
-                                nodes.push(...itemNodes);
+                                for (const x of itemNodes) {
+                                    if (typeof x === "string") {
+                                        const trimmed = x.trim();
+                                        if (trimmed) {
+                                            nodes.push(trimmed);
+                                        }
+                                    }
+                                }
                             }
                         }
                     }
                 }
             }
+            else if (typeof nodeList === "string") {
+                // Handle case where nodeList is a string (might be space-separated node IDs)
+                const trimmed = nodeList.trim();
+                if (trimmed) {
+                    // Split by whitespace and filter empty strings
+                    const parts = trimmed.split(/\s+/).filter(p => p.length > 0);
+                    nodes.push(...parts);
+                }
+            }
             const subgraph = {
                 id: subgraphId,
                 nodes,

package/dist/parser/index.d.ts

@@ -5,6 +5,7 @@
  */
 export { parseFlowchart, isFlowchartDiagram } from "./flowchart-parser.js";
 export { parseSequence, isSequenceDiagram } from "./sequence-parser.js";
+export { parseClassDiagram, isClassDiagram } from "./class-parser.js";
 import type { MermaidAST, DiagramType } from "../types/index.js";
 /**
  * Detect the diagram type from input text

package/dist/parser/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/parser/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3E,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAExE,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIjE;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAInE;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAiB/C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/parser/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3E,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACxE,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEtE,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAKjE;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAKnE;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAmB/C"}

package/dist/parser/index.js

@@ -5,8 +5,10 @@
  */
 export { parseFlowchart, isFlowchartDiagram } from "./flowchart-parser.js";
 export { parseSequence, isSequenceDiagram } from "./sequence-parser.js";
+export { parseClassDiagram, isClassDiagram } from "./class-parser.js";
 import { parseFlowchart, isFlowchartDiagram } from "./flowchart-parser.js";
 import { parseSequence, isSequenceDiagram } from "./sequence-parser.js";
+import { parseClassDiagram, isClassDiagram } from "./class-parser.js";
 /**
  * Detect the diagram type from input text
  */
@@ -15,6 +17,8 @@ export function detectDiagramType(input) {
         return "flowchart";
     if (isSequenceDiagram(input))
         return "sequence";
+    if (isClassDiagram(input))
+        return "class";
     return null;
 }
 /**
@@ -23,13 +27,15 @@ export function detectDiagramType(input) {
 export function parse(input) {
     const type = detectDiagramType(input);
     if (!type) {
-        throw new Error("Unable to detect diagram type. Supported types: flowchart, sequence");
+        throw new Error("Unable to detect diagram type. Supported types: flowchart, sequence, class");
     }
     switch (type) {
         case "flowchart":
             return parseFlowchart(input);
         case "sequence":
             return parseSequence(input);
+        case "class":
+            return parseClassDiagram(input);
         default:
             throw new Error(`Unsupported diagram type: ${type}`);
     }

package/dist/parser/sequence-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sequence-parser.d.ts","sourceRoot":"","sources":["../../src/parser/sequence-parser.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,KAAK,WAAW,EAiBjB,MAAM,sBAAsB,CAAC;AAygB9B;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAmBxD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAIxD"}
+{"version":3,"file":"sequence-parser.d.ts","sourceRoot":"","sources":["../../src/parser/sequence-parser.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,KAAK,WAAW,EAiBjB,MAAM,sBAAsB,CAAC;AAkkB9B;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAsBxD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAIxD"}

package/dist/parser/sequence-parser.js

@@ -471,6 +471,59 @@ function ensureActor(ast, id) {
         });
     }
 }
+/**
+ * Post-process statements to normalize activate/deactivate shortcut syntax.
+ *
+ * Mermaid's parser handles + and - shortcuts inconsistently:
+ * - For +: Sets activate:true on message AND creates activeStart statement
+ * - For -: Only creates activeEnd statement (doesn't set deactivate on message)
+ *
+ * This function normalizes the AST by setting deactivate:true on messages
+ * that are immediately followed by a deactivate for the message's from actor.
+ */
+function normalizeActivationShortcuts(statements) {
+    for (let i = 0; i < statements.length - 1; i++) {
+        const current = statements[i];
+        const next = statements[i + 1];
+        // Check if current is a message and next is a deactivate for the same actor
+        if (current.type === "message" && next.type === "deactivate") {
+            const msg = current;
+            const deactivation = next;
+            // The - shortcut deactivates the sender (from), not the receiver
+            if (msg.from === deactivation.actor && !msg.deactivate) {
+                msg.deactivate = true;
+            }
+        }
+        // Recursively process nested statements (loops, alt, etc.)
+        // Using type narrowing based on statement type
+        switch (current.type) {
+            case "loop":
+            case "opt":
+            case "break":
+            case "rect": {
+                const stmt = current;
+                normalizeActivationShortcuts(stmt.statements);
+                break;
+            }
+            case "alt":
+            case "par": {
+                const stmt = current;
+                for (const section of stmt.sections) {
+                    normalizeActivationShortcuts(section.statements);
+                }
+                break;
+            }
+            case "critical": {
+                const stmt = current;
+                normalizeActivationShortcuts(stmt.statements);
+                for (const option of stmt.options) {
+                    normalizeActivationShortcuts(option.statements);
+                }
+                break;
+            }
+        }
+    }
+}
 /**
  * Parse a sequence diagram string into an AST
  */
@@ -490,6 +543,8 @@ export function parseSequence(input) {
         }
         throw error;
     }
+    // Normalize activation shortcuts to handle inconsistent parser behavior
+    normalizeActivationShortcuts(ast.statements);
     return ast;
 }
 /**

package/dist/parser/state-parser.d.ts

@@ -0,0 +1,17 @@
+/**
+ * State Diagram Parser
+ *
+ * Parses Mermaid state diagram syntax into an AST using the vendored JISON parser.
+ * The JISON parser calls methods on a `yy` object - we provide our own implementation
+ * that builds an AST instead of mermaid's internal db structure.
+ */
+import { type StateDiagramAST } from "../types/state.js";
+/**
+ * Parse a state diagram string into an AST
+ */
+export declare function parseStateDiagram(input: string): StateDiagramAST;
+/**
+ * Detect if input is a state diagram
+ */
+export declare function isStateDiagram(input: string): boolean;
+//# sourceMappingURL=state-parser.d.ts.map

package/dist/parser/state-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-parser.d.ts","sourceRoot":"","sources":["../../src/parser/state-parser.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,KAAK,eAAe,EAQrB,MAAM,mBAAmB,CAAC;AA6M3B;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe,CAuBhE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAOrD"}