@grafloria/element 0.3.20 → 0.3.22

package/src/libs/engine/src/dsl/parser/Parser.js

@@ -1,725 +0,0 @@
-"use strict";
-/**
- * DSL Parser - Converts token stream into Abstract Syntax Tree
- *
- * Parses Mermaid-compatible diagram syntax into structured AST
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Parser = exports.ParseError = void 0;
-const Token_1 = require("../types/Token");
-class ParseError extends Error {
-    constructor(message, token, line, column) {
-        super(`Parse error at line ${line}, column ${column}: ${message}`);
-        this.token = token;
-        this.line = line;
-        this.column = column;
-        this.name = 'ParseError';
-    }
-}
-exports.ParseError = ParseError;
-/** Mermaid v11 `@{ shape: … }` names → our NodeShape. Unknowns fall to rect. */
-const V11_SHAPE_MAP = {
-    rect: 'rectangle', rectangle: 'rectangle', process: 'rectangle',
-    rounded: 'rounded-rectangle', 'rounded-rect': 'rounded-rectangle',
-    stadium: 'stadium', pill: 'stadium', terminal: 'stadium',
-    subroutine: 'subroutine', subprocess: 'subroutine', 'framed-rectangle': 'subroutine',
-    cylinder: 'cylindrical', database: 'cylindrical', db: 'cylindrical', 'lin-cyl': 'cylindrical',
-    circle: 'circle', circ: 'circle',
-    diamond: 'rhombus', decision: 'rhombus', rhombus: 'rhombus', question: 'rhombus',
-    hexagon: 'hexagon', hex: 'hexagon', prepare: 'hexagon',
-    trapezoid: 'trapezoid', 'trap-b': 'trapezoid', 'manual-input': 'trapezoid',
-    'trapezoid-alt': 'trapezoid-alt', 'trap-t': 'trapezoid-alt',
-};
-class Parser {
-    constructor() {
-        this.tokens = [];
-        this.current = 0;
-    }
-    /**
-     * Parse tokens into an AST
-     */
-    parse(tokens) {
-        this.tokens = tokens.filter(t => t.type !== Token_1.TokenType.WHITESPACE &&
-            // Keep ONLY the Tier-2 extension comments; ordinary %% comments still drop.
-            (t.type !== Token_1.TokenType.COMMENT || /^%%grafloria:(node|edge)\b/.test(t.value)));
-        this.current = 0;
-        return this.parseDiagram();
-    }
-    /**
-     * Parse diagram root
-     */
-    parseDiagram() {
-        const start = this.currentToken();
-        // Parse diagram type and direction
-        let diagramType = 'flowchart';
-        let direction;
-        if (this.match(Token_1.TokenType.FLOWCHART, Token_1.TokenType.GRAPH)) {
-            diagramType = 'flowchart';
-            // Parse optional direction
-            if (this.match(Token_1.TokenType.TD, Token_1.TokenType.TB, Token_1.TokenType.BT, Token_1.TokenType.RL, Token_1.TokenType.LR)) {
-                direction = this.previous().value.toUpperCase();
-            }
-            this.consumeNewlines();
-        }
-        else if (this.match(Token_1.TokenType.BPMN)) {
-            diagramType = 'bpmn';
-            this.consumeNewlines();
-        }
-        else if (this.match(Token_1.TokenType.ERD)) {
-            diagramType = 'erd';
-            this.consumeNewlines();
-        }
-        else if (this.match(Token_1.TokenType.CLASSDIAAGRAM)) {
-            diagramType = 'classDiagram';
-            this.consumeNewlines();
-        }
-        // Parse statements
-        const statements = [];
-        while (!this.isAtEnd()) {
-            // Skip empty lines
-            if (this.match(Token_1.TokenType.NEWLINE)) {
-                continue;
-            }
-            const before = this.current;
-            try {
-                const statement = this.parseStatement();
-                if (statement) {
-                    // parseStatement may yield ONE statement or a list (chains, multi-edge).
-                    if (Array.isArray(statement))
-                        statements.push(...statement);
-                    else
-                        statements.push(statement);
-                }
-            }
-            catch (error) {
-                // Line-level error recovery: one un-parseable line must not abort the
-                // whole diagram, and must not leave debris. Skip to the next newline.
-                // (docs/MERMAID-GAP-ANALYSIS.md Phase 0 — "never manufacture nodes".)
-                if (error instanceof ParseError) {
-                    this.skipLine();
-                }
-                else {
-                    throw error;
-                }
-            }
-            // Guard against a statement that consumed nothing (would loop forever).
-            if (this.current === before && !this.isAtEnd())
-                this.advance();
-            this.consumeNewlines();
-        }
-        return {
-            type: 'Diagram',
-            diagramType,
-            direction,
-            statements,
-            location: this.getLocation(start, this.previous()),
-        };
-    }
-    /**
-     * Parse a statement
-     */
-    parseStatement() {
-        // Subgraph
-        if (this.check(Token_1.TokenType.SUBGRAPH)) {
-            return this.parseSubgraph();
-        }
-        // Tier-2 extension comment (%%grafloria:node / %%grafloria:edge).
-        if (this.check(Token_1.TokenType.COMMENT)) {
-            return this.parseGrafloriaComment(this.advance().value);
-        }
-        // Tier-1 native directives — Phase 2 wires them to the model (Phase 0 only
-        // skipped them so they never threw or garbaged).
-        if (this.check(Token_1.TokenType.IDENTIFIER)) {
-            switch (this.peek().value) {
-                case 'style': return this.parseStyle();
-                case 'classDef': return this.parseClassDef();
-                case 'class': return this.parseClassApplication();
-                case 'linkStyle': return this.parseLinkStyle();
-                case 'click': return this.parseClick();
-                case 'direction':
-                    this.skipLine();
-                    return null;
-            }
-        }
-        // A statement is a NODE GROUP (one or more refs joined by `&`) optionally
-        // followed by an edge chain. `a & b --> c & d` and `a --> b --> c` both
-        // start here.
-        const start = this.currentToken();
-        const firstGroup = this.parseNodeGroup();
-        if (firstGroup.length === 0) {
-            // Not a node/edge start — skip the whole line rather than a single token,
-            // so partial debris cannot leak into the model.
-            this.skipLine();
-            return null;
-        }
-        if (this.isLinkToken()) {
-            return this.parseEdgeChain(firstGroup, start);
-        }
-        // Bare node group: one NodeDefinition per ref (usually one; `a & b` gives two).
-        const defs = firstGroup.map((ref) => ({
-            type: 'NodeDefinition',
-            id: ref.id,
-            label: ref.label || ref.id,
-            shape: ref.shape || 'rectangle',
-            location: this.getLocation(start, this.previous()),
-        }));
-        return [...defs, ...this.classApps(firstGroup, start)];
-    }
-    /**
-     * A single node reference: an id, then an optional shape (`[A]`, `([A])`, …)
-     * or a v11 metadata block (`@{ shape: rect, label: "Hi" }`).
-     */
-    parseNodeRef() {
-        const id = this.parseNodeId();
-        if (!id)
-            return null;
-        const ref = { id };
-        if (this.check(Token_1.TokenType.AT)) {
-            const meta = this.parseNodeMetadata();
-            ref.shape = meta.shape;
-            ref.label = meta.label;
-        }
-        else if (this.isNodeShapeStart()) {
-            const info = this.parseNodeShape();
-            ref.shape = info.shape;
-            ref.label = info.label;
-        }
-        // Inline class: a:::hot  (also a[Label]:::hot)
-        if (this.check(Token_1.TokenType.TRIPLE_COLON)) {
-            this.advance();
-            if (this.check(Token_1.TokenType.IDENTIFIER))
-                ref.cssClass = this.advance().value;
-        }
-        return ref;
-    }
-    /** One or more node refs joined by `&` (Mermaid multi-node syntax). */
-    parseNodeGroup() {
-        const group = [];
-        const first = this.parseNodeRef();
-        if (first)
-            group.push(first);
-        while (this.check(Token_1.TokenType.AMPERSAND)) {
-            this.advance();
-            const ref = this.parseNodeRef();
-            if (ref)
-                group.push(ref);
-        }
-        return group;
-    }
-    /** ClassApplication statements for any refs carrying an inline `:::class`. */
-    classApps(refs, start) {
-        return refs
-            .filter((r) => r.cssClass)
-            .map((r) => ({
-            type: 'ClassApplication',
-            ids: [r.id],
-            className: r.cssClass,
-            location: this.getLocation(start, this.previous()),
-        }));
-    }
-    /**
-     * An edge chain: node-group (link [label] node-group)+. Each link produces the
-     * FULL CROSS PRODUCT of the previous group and the next (so `a & b --> c & d`
-     * is four edges), and the chain continues so `a --> b --> c` is two.
-     */
-    parseEdgeChain(firstGroup, start) {
-        const edges = [];
-        const allRefs = [...firstGroup];
-        let prevGroup = firstGroup;
-        while (this.isLinkToken()) {
-            const linkToken = this.advance();
-            const linkType = this.getLinkType(linkToken.type);
-            let label;
-            if (this.match(Token_1.TokenType.PIPE)) {
-                label = this.parseTextUntil(Token_1.TokenType.PIPE);
-                this.consume(Token_1.TokenType.PIPE, 'Expected closing "|"');
-            }
-            const nextGroup = this.parseNodeGroup();
-            if (nextGroup.length === 0) {
-                throw new ParseError('Expected target node after link', this.currentToken(), this.currentToken().line, this.currentToken().column);
-            }
-            for (const source of prevGroup) {
-                for (const target of nextGroup) {
-                    edges.push({
-                        type: 'EdgeDefinition',
-                        source: source.id,
-                        target: target.id,
-                        linkType,
-                        label,
-                        sourceShape: source.shape,
-                        sourceLabel: source.label,
-                        targetShape: target.shape,
-                        targetLabel: target.label,
-                        location: this.getLocation(start, this.previous()),
-                    });
-                }
-            }
-            prevGroup = nextGroup;
-            allRefs.push(...nextGroup);
-        }
-        return [...edges, ...this.classApps(allRefs, start)];
-    }
-    /**
-     * v11 node metadata block: `@{ shape: rect, label: "Hi", icon: … }`. We read
-     * the keys we model (shape, label) and ignore the rest for forward-compat.
-     * `{`/`}` lex as RHOMBUS_OPEN/CLOSE.
-     */
-    parseNodeMetadata() {
-        var _a;
-        this.consume(Token_1.TokenType.AT, 'Expected "@"');
-        this.consume(Token_1.TokenType.RHOMBUS_OPEN, 'Expected "{" after "@"');
-        let shape;
-        let label;
-        while (!this.check(Token_1.TokenType.RHOMBUS_CLOSE) && !this.isAtEnd()) {
-            if (!this.check(Token_1.TokenType.IDENTIFIER)) {
-                this.advance(); // skip commas / stray tokens
-                continue;
-            }
-            const key = this.advance().value;
-            this.consume(Token_1.TokenType.COLON, 'Expected ":" in node metadata');
-            const value = this.advance().value.replace(/#quot;/g, '"');
-            if (key === 'label')
-                label = value;
-            else if (key === 'shape')
-                shape = (_a = V11_SHAPE_MAP[value.toLowerCase()]) !== null && _a !== void 0 ? _a : 'rectangle';
-        }
-        this.consume(Token_1.TokenType.RHOMBUS_CLOSE, 'Expected "}" to close node metadata');
-        return { shape, label };
-    }
-    /**
-     * Parse subgraph
-     */
-    parseSubgraph() {
-        const start = this.currentToken();
-        this.consume(Token_1.TokenType.SUBGRAPH, 'Expected "subgraph"');
-        // Parse optional id and label
-        let id;
-        let label;
-        let direction;
-        if (this.check(Token_1.TokenType.IDENTIFIER)) {
-            id = this.advance().value;
-        }
-        // Parse optional label in square brackets
-        if (this.match(Token_1.TokenType.SQUARE_OPEN)) {
-            label = this.parseTextUntil(Token_1.TokenType.SQUARE_CLOSE);
-            this.consume(Token_1.TokenType.SQUARE_CLOSE, 'Expected "]"');
-        }
-        this.consumeNewlines();
-        // Parse optional direction
-        if (this.match(Token_1.TokenType.TD, Token_1.TokenType.TB, Token_1.TokenType.BT, Token_1.TokenType.RL, Token_1.TokenType.LR)) {
-            direction = this.previous().value.toUpperCase();
-            this.consumeNewlines();
-        }
-        // Parse subgraph statements
-        const statements = [];
-        while (!this.check(Token_1.TokenType.END) && !this.isAtEnd()) {
-            if (this.match(Token_1.TokenType.NEWLINE)) {
-                continue;
-            }
-            const before = this.current;
-            try {
-                const statement = this.parseStatement();
-                if (statement) {
-                    if (Array.isArray(statement))
-                        statements.push(...statement);
-                    else
-                        statements.push(statement);
-                }
-            }
-            catch (error) {
-                if (error instanceof ParseError)
-                    this.skipLine();
-                else
-                    throw error;
-            }
-            if (this.current === before && !this.isAtEnd())
-                this.advance();
-            this.consumeNewlines();
-        }
-        this.consume(Token_1.TokenType.END, 'Expected "end" to close subgraph');
-        return {
-            type: 'Subgraph',
-            id,
-            label,
-            direction,
-            statements,
-            location: this.getLocation(start, this.previous()),
-        };
-    }
-    /**
-     * Parse style definition: style A fill:#f9f,stroke:#333
-     */
-    parseStyle() {
-        const start = this.currentToken();
-        this.consume(Token_1.TokenType.IDENTIFIER, 'Expected "style"'); // style keyword
-        const targetId = this.consume(Token_1.TokenType.IDENTIFIER, 'Expected node ID').value;
-        // Parse style properties
-        const properties = this.parseStyleProperties();
-        return {
-            type: 'Style',
-            targetId,
-            properties,
-            location: this.getLocation(start, this.previous()),
-        };
-    }
-    /**
-     * Parse class definition: classDef className fill:#f9f
-     */
-    parseClassDef() {
-        const start = this.currentToken();
-        this.consume(Token_1.TokenType.IDENTIFIER, 'Expected "classDef"'); // classDef keyword
-        const className = this.consume(Token_1.TokenType.IDENTIFIER, 'Expected class name').value;
-        // Parse style properties
-        const properties = this.parseStyleProperties();
-        return {
-            type: 'ClassDef',
-            className,
-            properties,
-            location: this.getLocation(start, this.previous()),
-        };
-    }
-    /**
-     * Parse `class a,b hot` — bind an existing classDef to one or more nodes.
-     */
-    parseClassApplication() {
-        const start = this.currentToken();
-        this.consume(Token_1.TokenType.IDENTIFIER, 'Expected "class"'); // class keyword
-        const ids = [this.consume(Token_1.TokenType.IDENTIFIER, 'Expected node id').value];
-        while (this.match(Token_1.TokenType.COMMA)) {
-            ids.push(this.consume(Token_1.TokenType.IDENTIFIER, 'Expected node id').value);
-        }
-        const className = this.consume(Token_1.TokenType.IDENTIFIER, 'Expected class name').value;
-        return { type: 'ClassApplication', ids, className, location: this.getLocation(start, this.previous()) };
-    }
-    /**
-     * Parse `linkStyle 0,2 stroke:#f00` — style links by index (or `default`).
-     */
-    parseLinkStyle() {
-        const start = this.currentToken();
-        this.consume(Token_1.TokenType.IDENTIFIER, 'Expected "linkStyle"'); // linkStyle keyword
-        let indices;
-        if (this.check(Token_1.TokenType.IDENTIFIER) && this.peek().value === 'default') {
-            this.advance();
-            indices = 'default';
-        }
-        else {
-            indices = [parseInt(this.consume(Token_1.TokenType.NUMBER, 'Expected link index').value, 10)];
-            while (this.match(Token_1.TokenType.COMMA)) {
-                indices.push(parseInt(this.consume(Token_1.TokenType.NUMBER, 'Expected link index').value, 10));
-            }
-        }
-        const properties = this.parseStyleProperties();
-        return { type: 'LinkStyle', indices, properties, location: this.getLocation(start, this.previous()) };
-    }
-    /**
-     * Parse `click a "https://…" "tooltip"` — a node's navigation target. The
-     * `href` keyword form and `call`/callback forms are intentionally not modeled
-     * (a callback name is not a document fact); those lines are still skipped.
-     */
-    parseClick() {
-        const start = this.currentToken();
-        this.consume(Token_1.TokenType.IDENTIFIER, 'Expected "click"'); // click keyword
-        const id = this.consume(Token_1.TokenType.IDENTIFIER, 'Expected node id').value;
-        // Optional `href` keyword, then the URL string, then an optional tooltip.
-        if (this.check(Token_1.TokenType.IDENTIFIER) && this.peek().value === 'href')
-            this.advance();
-        let href;
-        let tooltip;
-        if (this.check(Token_1.TokenType.STRING))
-            href = this.advance().value;
-        if (this.check(Token_1.TokenType.STRING))
-            tooltip = this.advance().value;
-        this.skipLine(); // ignore any trailing target token (_blank etc.)
-        return { type: 'Click', id, href, tooltip, location: this.getLocation(start, this.previous()) };
-    }
-    /**
-     * Parse a Tier-2 extension comment into a GrafloriaDirective:
-     *   %%grafloria:node <id> <k>:<v>[,<k>:<v>]*
-     *   %%grafloria:edge <source> <target> <k>:<v>...
-     * Returns null for anything that is not a well-formed grafloria directive (a
-     * malformed one is simply ignored, never garbage).
-     */
-    parseGrafloriaComment(value) {
-        const m = value.match(/^%%grafloria:(node|edge)\s+(.+)$/);
-        if (!m)
-            return null;
-        const target = m[1];
-        const parts = m[2].trim().split(/\s+/);
-        const idCount = target === 'edge' ? 2 : 1;
-        if (parts.length < idCount)
-            return null;
-        const ids = parts.slice(0, idCount);
-        const properties = {};
-        for (const pair of parts.slice(idCount).join(' ').split(',')) {
-            const idx = pair.indexOf(':');
-            if (idx <= 0)
-                continue;
-            properties[pair.slice(0, idx).trim()] = pair.slice(idx + 1).trim();
-        }
-        return { type: 'GrafloriaDirective', target, ids, properties, location: this.getLocation(this.previous(), this.previous()) };
-    }
-    /**
-     * Parse style properties: fill:#f9f,stroke:#333,stroke-width:2
-     */
-    parseStyleProperties() {
-        const properties = {};
-        do {
-            if (!this.check(Token_1.TokenType.IDENTIFIER))
-                break;
-            const propName = this.advance().value;
-            this.consume(Token_1.TokenType.COLON, 'Expected ":" after property name');
-            let propValue;
-            if (this.check(Token_1.TokenType.STRING)) {
-                propValue = this.advance().value;
-            }
-            else if (this.check(Token_1.TokenType.NUMBER)) {
-                propValue = this.advance().value;
-            }
-            else if (this.check(Token_1.TokenType.IDENTIFIER)) {
-                propValue = this.advance().value;
-            }
-            else {
-                // Try to parse color or other value
-                propValue = this.advance().value;
-            }
-            // Convert kebab-case to camelCase
-            const camelCaseName = propName.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
-            // Convert numeric strings to numbers for certain properties
-            if (camelCaseName === 'strokeWidth' || camelCaseName === 'opacity') {
-                properties[camelCaseName] = parseFloat(propValue);
-            }
-            else {
-                properties[camelCaseName] = propValue;
-            }
-        } while (this.match(Token_1.TokenType.COMMA));
-        return properties;
-    }
-    /**
-     * Parse node ID
-     */
-    parseNodeId() {
-        if (this.check(Token_1.TokenType.IDENTIFIER)) {
-            return this.advance().value;
-        }
-        return null;
-    }
-    /**
-     * Parse node shape and extract label
-     */
-    parseNodeShape() {
-        const start = this.currentToken();
-        // [text] - rectangle
-        if (this.match(Token_1.TokenType.SQUARE_OPEN)) {
-            const label = this.parseTextUntil(Token_1.TokenType.SQUARE_CLOSE);
-            this.consume(Token_1.TokenType.SQUARE_CLOSE, 'Expected "]"');
-            return { shape: 'rectangle', label };
-        }
-        // [[text]] - subroutine
-        if (this.match(Token_1.TokenType.SUBROUTINE_OPEN)) {
-            const label = this.parseTextUntil(Token_1.TokenType.SUBROUTINE_CLOSE);
-            this.consume(Token_1.TokenType.SUBROUTINE_CLOSE, 'Expected "]]"');
-            return { shape: 'subroutine', label };
-        }
-        // ([text]) - stadium
-        if (this.match(Token_1.TokenType.STADIUM_OPEN)) {
-            const label = this.parseTextUntil(Token_1.TokenType.STADIUM_CLOSE);
-            this.consume(Token_1.TokenType.STADIUM_CLOSE, 'Expected "])"');
-            return { shape: 'stadium', label };
-        }
-        // [(text)] - cylindrical
-        if (this.match(Token_1.TokenType.CYLINDRICAL_OPEN)) {
-            const label = this.parseTextUntil(Token_1.TokenType.CYLINDRICAL_CLOSE);
-            this.consume(Token_1.TokenType.CYLINDRICAL_CLOSE, 'Expected ")]"');
-            return { shape: 'cylindrical', label };
-        }
-        // ((text)) - circle
-        if (this.match(Token_1.TokenType.CIRCLE_OPEN)) {
-            const label = this.parseTextUntil(Token_1.TokenType.CIRCLE_CLOSE);
-            this.consume(Token_1.TokenType.CIRCLE_CLOSE, 'Expected "))"');
-            return { shape: 'circle', label };
-        }
-        // (text) - rounded rectangle
-        if (this.match(Token_1.TokenType.ROUND_OPEN)) {
-            const label = this.parseTextUntil(Token_1.TokenType.ROUND_CLOSE);
-            this.consume(Token_1.TokenType.ROUND_CLOSE, 'Expected ")"');
-            return { shape: 'rounded-rectangle', label };
-        }
-        // {text} - rhombus/diamond
-        if (this.match(Token_1.TokenType.RHOMBUS_OPEN)) {
-            const label = this.parseTextUntil(Token_1.TokenType.RHOMBUS_CLOSE);
-            this.consume(Token_1.TokenType.RHOMBUS_CLOSE, 'Expected "}"');
-            return { shape: 'rhombus', label };
-        }
-        // {{text}} - hexagon
-        if (this.match(Token_1.TokenType.HEXAGON_OPEN)) {
-            const label = this.parseTextUntil(Token_1.TokenType.HEXAGON_CLOSE);
-            this.consume(Token_1.TokenType.HEXAGON_CLOSE, 'Expected "}}"');
-            return { shape: 'hexagon', label };
-        }
-        // [/text/] or [\text\] - trapezoid
-        if (this.match(Token_1.TokenType.TRAPEZOID_OPEN)) {
-            const label = this.parseTextUntil(Token_1.TokenType.TRAPEZOID_CLOSE);
-            this.consume(Token_1.TokenType.TRAPEZOID_CLOSE, 'Expected trapezoid close');
-            return { shape: 'trapezoid', label };
-        }
-        // >text] - asymmetric
-        if (this.match(Token_1.TokenType.ASYMMETRIC_OPEN)) {
-            const label = this.parseTextUntil(Token_1.TokenType.SQUARE_CLOSE);
-            this.consume(Token_1.TokenType.SQUARE_CLOSE, 'Expected "]"');
-            return { shape: 'asymmetric', label };
-        }
-        // Default to rectangle if no shape found
-        return { shape: 'rectangle' };
-    }
-    /**
-     * Parse text until a specific token type
-     */
-    parseTextUntil(endType) {
-        let text = '';
-        let prevEnd = -1;
-        while (!this.check(endType) && !this.isAtEnd()) {
-            const token = this.advance();
-            // Join by SOURCE ADJACENCY, not with an unconditional space: tokens that
-            // touch in the input stay touching in the label. The unconditional join
-            // exploded any run of characters the lexer didn't recognise as one word.
-            if (prevEnd >= 0 && token.startIndex > prevEnd) {
-                text += ' ';
-            }
-            // The quoted form: a["He said #quot;hi#quot; [brackets ok]"] — the whole
-            // string is ONE token (brackets inside quotes never reach the bracket
-            // matcher), and mermaid's #quot; entity decodes back to a double quote.
-            text += token.type === Token_1.TokenType.STRING ? token.value.replace(/#quot;/g, '"') : token.value;
-            prevEnd = token.endIndex;
-        }
-        return text.trim();
-    }
-    /**
-     * Get link type from token type
-     */
-    getLinkType(tokenType) {
-        switch (tokenType) {
-            case Token_1.TokenType.ARROW:
-                return 'arrow';
-            case Token_1.TokenType.LINE:
-                return 'line';
-            case Token_1.TokenType.DOTTED_ARROW:
-                return 'dotted-arrow';
-            case Token_1.TokenType.DOTTED_LINE:
-                return 'dotted-line';
-            case Token_1.TokenType.THICK_ARROW:
-                return 'thick-arrow';
-            case Token_1.TokenType.THICK_LINE:
-                return 'thick-line';
-            case Token_1.TokenType.BIDIRECTIONAL:
-                return 'bidirectional';
-            case Token_1.TokenType.CIRCLE_EDGE:
-                return 'circle-edge';
-            case Token_1.TokenType.CROSS_EDGE:
-                return 'cross-edge';
-            default:
-                return 'arrow';
-        }
-    }
-    /**
-     * Check if current token is a link token
-     */
-    isLinkToken() {
-        return (this.check(Token_1.TokenType.ARROW) ||
-            this.check(Token_1.TokenType.LINE) ||
-            this.check(Token_1.TokenType.DOTTED_ARROW) ||
-            this.check(Token_1.TokenType.DOTTED_LINE) ||
-            this.check(Token_1.TokenType.THICK_ARROW) ||
-            this.check(Token_1.TokenType.THICK_LINE) ||
-            this.check(Token_1.TokenType.BIDIRECTIONAL) ||
-            this.check(Token_1.TokenType.CIRCLE_EDGE) ||
-            this.check(Token_1.TokenType.CROSS_EDGE));
-    }
-    /**
-     * Check if current token starts a node shape
-     */
-    isNodeShapeStart() {
-        return (this.check(Token_1.TokenType.SQUARE_OPEN) ||
-            this.check(Token_1.TokenType.ROUND_OPEN) ||
-            this.check(Token_1.TokenType.SUBROUTINE_OPEN) ||
-            this.check(Token_1.TokenType.STADIUM_OPEN) ||
-            this.check(Token_1.TokenType.CYLINDRICAL_OPEN) ||
-            this.check(Token_1.TokenType.CIRCLE_OPEN) ||
-            this.check(Token_1.TokenType.RHOMBUS_OPEN) ||
-            this.check(Token_1.TokenType.HEXAGON_OPEN) ||
-            this.check(Token_1.TokenType.TRAPEZOID_OPEN) ||
-            this.check(Token_1.TokenType.ASYMMETRIC_OPEN));
-    }
-    /**
-     * Token stream helpers
-     */
-    match(...types) {
-        for (const type of types) {
-            if (this.check(type)) {
-                this.advance();
-                return true;
-            }
-        }
-        return false;
-    }
-    check(type) {
-        if (this.isAtEnd())
-            return false;
-        return this.peek().type === type;
-    }
-    checkSequence(type) {
-        return this.check(type);
-    }
-    advance() {
-        if (!this.isAtEnd())
-            this.current++;
-        return this.previous();
-    }
-    isAtEnd() {
-        return this.peek().type === Token_1.TokenType.EOF;
-    }
-    peek() {
-        return this.tokens[this.current] || this.tokens[this.tokens.length - 1];
-    }
-    previous() {
-        return this.tokens[this.current - 1];
-    }
-    currentToken() {
-        return this.peek();
-    }
-    consume(type, message) {
-        if (this.check(type))
-            return this.advance();
-        const token = this.currentToken();
-        throw new ParseError(message, token, token.line, token.column);
-    }
-    consumeNewlines() {
-        while (this.match(Token_1.TokenType.NEWLINE)) {
-            // Keep consuming
-        }
-    }
-    /** Consume everything up to (not including) the next newline. */
-    skipLine() {
-        while (!this.isAtEnd() && !this.check(Token_1.TokenType.NEWLINE)) {
-            this.advance();
-        }
-    }
-    /**
-     * Get source location from start and end tokens
-     */
-    getLocation(start, end) {
-        return {
-            start: {
-                line: start.line,
-                column: start.column,
-                index: start.startIndex,
-            },
-            end: {
-                line: end.line,
-                column: end.column,
-                index: end.endIndex,
-            },
-        };
-    }
-}
-exports.Parser = Parser;
-//# sourceMappingURL=Parser.js.map