mermaid-ast 0.1.1 → 0.3.0

package/README.md

@@ -19,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
 
@@ -92,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
@@ -99,9 +127,59 @@ 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
 ```
 
+### Render Options (Pretty-Print)
+
+All render functions accept an optional `RenderOptions` object to customize output formatting:
+
+```typescript
+import { renderFlowchart, parseFlowchart } from "mermaid-ast";
+import type { RenderOptions } from "mermaid-ast";
+
+const ast = parseFlowchart(`flowchart LR
+    A[Start] --> B[Middle] --> C[End]
+    classDef highlight fill:#f9f
+    class A highlight`);
+
+// Default output (4-space indent)
+renderFlowchart(ast);
+
+// Custom indent (2 spaces)
+renderFlowchart(ast, { indent: 2 });
+
+// Tab indent
+renderFlowchart(ast, { indent: "tab" });
+
+// Sort nodes alphabetically
+renderFlowchart(ast, { sortNodes: true });
+
+// Flowchart-specific: inline classes (A:::highlight instead of separate class statement)
+renderFlowchart(ast, { inlineClasses: true });
+
+// Flowchart-specific: chain links (A --> B --> C on one line)
+renderFlowchart(ast, { compactLinks: true });
+
+// Combine options
+renderFlowchart(ast, {
+  indent: 2,
+  sortNodes: true,
+  inlineClasses: true,
+  compactLinks: true,
+});
+```
+
+#### Available Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `indent` | `number \| "tab"` | `4` | Number of spaces for indentation, or `"tab"` for tabs |
+| `sortNodes` | `boolean` | `false` | Sort node/actor/class declarations alphabetically |
+| `inlineClasses` | `boolean` | `false` | (Flowchart only) Use `A:::className` instead of separate `class` statements |
+| `compactLinks` | `boolean` | `false` | (Flowchart only) Chain consecutive links: `A --> B --> C` |
+
 ## API Reference
 
 ### Core Functions
@@ -109,7 +187,7 @@ detectDiagramType("unknown diagram"); // null
 | Function | Description |
 |----------|-------------|
 | `parse(input: string): MermaidAST` | Parse any supported diagram |
-| `render(ast: MermaidAST): string` | Render any supported AST |
+| `render(ast: MermaidAST, options?: RenderOptions): string` | Render any supported AST |
 | `detectDiagramType(input: string): DiagramType \| null` | Detect diagram type |
 
 ### Flowchart Functions
@@ -117,7 +195,7 @@ detectDiagramType("unknown diagram"); // null
 | Function | Description |
 |----------|-------------|
 | `parseFlowchart(input: string): FlowchartAST` | Parse flowchart diagram |
-| `renderFlowchart(ast: FlowchartAST): string` | Render flowchart AST |
+| `renderFlowchart(ast: FlowchartAST, options?: RenderOptions): string` | Render flowchart AST |
 | `isFlowchartDiagram(input: string): boolean` | Check if input is flowchart |
 
 ### Sequence Diagram Functions
@@ -125,9 +203,17 @@ detectDiagramType("unknown diagram"); // null
 | Function | Description |
 |----------|-------------|
 | `parseSequence(input: string): SequenceAST` | Parse sequence diagram |
-| `renderSequence(ast: SequenceAST): string` | Render sequence AST |
+| `renderSequence(ast: SequenceAST, options?: RenderOptions): 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, options?: RenderOptions): string` | Render class diagram AST |
+| `isClassDiagram(input: string): boolean` | Check if input is class diagram |
+
 ## Supported Flowchart Features
 
 - **Directions**: LR, RL, TB, TD, BT
@@ -149,6 +235,40 @@ detectDiagramType("unknown diagram"); // null
 - **Notes**: `note left of`, `note right of`, `note over`
 - **Actor lifecycle**: `create`, `destroy`
 
+## Limitations
+
+### Comments Not Preserved
+
+Mermaid supports `%%` line comments, but **comments are not preserved** during parsing. The JISON parsers discard comments during lexing, so they are not included in the AST and will not appear in rendered output.
+
+```mermaid
+flowchart LR
+    %% This comment will be lost
+    A --> B
+```
+
+After round-trip, the comment is gone:
+
+```mermaid
+flowchart LR
+    A --> B
+```
+
+## 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
@@ -244,6 +364,8 @@ mermaid-ast/
 
 MIT
 
+This project includes JISON parsers from [mermaid.js](https://github.com/mermaid-js/mermaid) (MIT License, Copyright (c) 2014 - 2022 Knut Sveidqvist). See [THIRD-PARTY-NOTICES.md](./THIRD-PARTY-NOTICES.md) for details.
+
 ---
 
 ## How This Library Was Built

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"}