@aexol/spectral 0.9.221 → 0.9.222

package/dist/generated/parser/parser.js

@@ -0,0 +1,754 @@
+// GENERATED by cli-node/scripts/vendor-parser.mjs — do not edit; regenerate with `node scripts/vendor-parser.mjs`; source: packages/parser/
+/**
+ * Aexol Language Parser
+ *
+ * Builds an Abstract Syntax Tree (AST) from a token stream.
+ * Supports the full Aexol language grammar for capability definitions,
+ * workflows, and agent structures.
+ */
+import { Tokenizer } from "./tokenizer.js";
+import { TokenType } from "./lexer.js";
+export class Parser {
+    tokenizer;
+    currentToken;
+    constructor(source) {
+        this.tokenizer = new Tokenizer(source);
+        this.currentToken = this.tokenizer.current();
+    }
+    advance() {
+        const token = this.currentToken;
+        this.tokenizer.advance();
+        this.currentToken = this.tokenizer.current();
+        return token;
+    }
+    check(type) {
+        return this.currentToken.type === type;
+    }
+    checkAny(...types) {
+        return types.includes(this.currentToken.type);
+    }
+    consume(type, message) {
+        if (!this.check(type)) {
+            throw new SyntaxError(message ||
+                `Expected ${type} but got ${this.currentToken.type} at line ${this.currentToken.location.line}:${this.currentToken.location.column}`);
+        }
+        return this.advance();
+    }
+    match(...types) {
+        if (this.checkAny(...types)) {
+            return this.advance();
+        }
+        return null;
+    }
+    // Keywords that can be used as identifiers in certain contexts (like field names, enum values)
+    consumeIdentifierOrKeyword(message) {
+        // Allow any token that has a string value - this includes IDENTIFIER and most keywords
+        if (this.currentToken.value && typeof this.currentToken.value === "string") {
+            return this.advance();
+        }
+        throw new SyntaxError(message ||
+            `Expected identifier but got ${this.currentToken.type} at line ${this.currentToken.location.line}:${this.currentToken.location.column}`);
+    }
+    /**
+     * Check if the current token is a keyword being used as an identifier in a
+     * capability context. Many common English words (import, from, context, etc.)
+     * are reserved keywords in the lexer but should be accepted as-is when they
+     * appear as unquoted capability names (e.g. "can import catalog").
+     */
+    isKeywordUsedAsIdentifier() {
+        // Structural / top-level keywords that should NOT be treated as identifiers
+        const STRUCTURAL_KEYWORDS = new Set([
+            TokenType.VISITOR,
+            TokenType.TYPE,
+            TokenType.ENUM,
+            TokenType.INTERFACE,
+            TokenType.AGENT,
+            TokenType.WORKFLOW,
+            TokenType.ROLE,
+            TokenType.PERMISSION,
+            TokenType.STATE,
+            TokenType.EXECUTION_PLAN,
+            TokenType.EXECUTION_GRAPH,
+            // Structural punctuation / control flow that signal block end
+            // are not TokenType keywords, so no need to list them here.
+        ]);
+        const t = this.currentToken.type;
+        // Must be a keyword-type token (not IDENTIFIER/STRING/NUMBER/punctuation)
+        // and not a structural top-level keyword.
+        return (t !== TokenType.IDENTIFIER &&
+            t !== TokenType.STRING &&
+            t !== TokenType.NUMBER &&
+            t !== TokenType.EOF &&
+            t !== TokenType.LBRACE &&
+            t !== TokenType.RBRACE &&
+            t !== TokenType.NEWLINE &&
+            t !== TokenType.INDENT &&
+            t !== TokenType.DEDENT &&
+            t !== TokenType.COMMA &&
+            !STRUCTURAL_KEYWORDS.has(t) &&
+            // Ensure the token has an actual word value
+            this.currentToken.value.length > 0);
+    }
+    skipNewlines() {
+        while (this.checkAny(TokenType.NEWLINE, TokenType.INDENT, TokenType.DEDENT, TokenType.COMMENT)) {
+            this.advance();
+        }
+    }
+    isAtEnd() {
+        return this.check(TokenType.EOF);
+    }
+    /**
+     * Check for and consume a description (PROMPT token with triple single-quotes) if present
+     */
+    parseDescriptionIfPresent() {
+        if (this.check(TokenType.PROMPT)) {
+            const description = this.advance().value;
+            this.skipNewlines();
+            return description;
+        }
+        return undefined;
+    }
+    throwUnexpectedTopLevelToken(description) {
+        const token = this.currentToken;
+        const tokenValue = token.value ? ` '${token.value}'` : "";
+        const descriptionHint = description ? " after a description block" : "";
+        throw new SyntaxError(`Unexpected top-level token ${token.type}${tokenValue}${descriptionHint} at line ${token.location.line}:${token.location.column}. ` +
+            "Expected one of: visitor, role, workflow, agent, type, enum, interface.");
+    }
+    /**
+     * Parse the entire program
+     */
+    parse() {
+        const body = [];
+        const startLocation = this.currentToken.location;
+        this.skipNewlines();
+        while (!this.isAtEnd()) {
+            // Check for description before any definition
+            const description = this.parseDescriptionIfPresent();
+            if (this.check(TokenType.VISITOR)) {
+                body.push(this.parseVisitor(description));
+            }
+            else if (this.check(TokenType.ROLE)) {
+                body.push(this.parseRole(description));
+            }
+            else if (this.check(TokenType.WORKFLOW)) {
+                body.push(this.parseWorkflow(description));
+            }
+            else if (this.check(TokenType.AGENT)) {
+                body.push(this.parseAgent(description));
+            }
+            else if (this.check(TokenType.TYPE) || this.check(TokenType.ENUM) ||
+                this.check(TokenType.INTERFACE)) {
+                body.push(this.parseTypeDefinition(description));
+            }
+            else {
+                this.throwUnexpectedTopLevelToken(description);
+            }
+            this.skipNewlines();
+        }
+        return {
+            type: "Program",
+            body,
+            location: {
+                start: startLocation.offset,
+                end: this.currentToken.location.offset,
+                line: startLocation.line,
+                column: startLocation.column,
+            },
+        };
+    }
+    parseVisitor(description) {
+        const startToken = this.consume(TokenType.VISITOR);
+        let name;
+        if (this.check(TokenType.IDENTIFIER)) {
+            name = this.advance().value;
+        }
+        this.skipNewlines();
+        this.consume(TokenType.LBRACE, "Expected '{' after visitor");
+        this.skipNewlines();
+        const capabilities = [];
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            capabilities.push(this.parseCapability());
+            this.skipNewlines();
+        }
+        this.consume(TokenType.RBRACE, "Expected '}' after visitor body");
+        return {
+            type: "VisitorDefinition",
+            name,
+            description,
+            capabilities,
+            location: {
+                start: startToken.location.offset,
+                end: this.currentToken.location.offset,
+                line: startToken.location.line,
+                column: startToken.location.column,
+            },
+        };
+    }
+    parseCapability() {
+        // Check for description before capability
+        const description = this.parseDescriptionIfPresent();
+        const startToken = this.currentToken;
+        // Accept STRING token (quoted), IDENTIFIER token (unquoted), or any
+        // keyword token used as an identifier (e.g. "import", "from", "context").
+        // Keywords are context-sensitive: inside a capability list, any word-like
+        // token should be treated as a plain identifier.
+        let action;
+        if (this.check(TokenType.STRING)) {
+            action = this.advance().value;
+        }
+        else if (this.check(TokenType.IDENTIFIER) || this.isKeywordUsedAsIdentifier()) {
+            // Single identifier for unquoted capability
+            // For multi-word capabilities, use quotes: "browse products"
+            action = this.advance().value;
+        }
+        else {
+            throw new SyntaxError(`Expected capability (string or identifier) at line ${this.currentToken.location.line}, got token type ${this.currentToken.type} with value '${this.currentToken.value}'`);
+        }
+        this.skipNewlines();
+        const nested = [];
+        const conditions = [];
+        // Check for nested capabilities
+        if (this.check(TokenType.LBRACE)) {
+            this.advance();
+            this.skipNewlines();
+            while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+                const loopStartPos = this.currentToken.location.offset;
+                nested.push(this.parseCapability());
+                // Allow optional comma separator
+                if (this.check(TokenType.COMMA)) {
+                    this.advance();
+                }
+                this.skipNewlines();
+                // Safety: ensure outer loop is advancing
+                if (this.currentToken.location.offset === loopStartPos &&
+                    !this.check(TokenType.RBRACE)) {
+                    throw new SyntaxError(`Parser stuck at line ${this.currentToken.location.line}: unexpected token '${this.currentToken.value}' in nested capabilities`);
+                }
+            }
+            this.consume(TokenType.RBRACE, "Expected '}' after nested capabilities");
+            this.skipNewlines();
+        }
+        // Allow optional comma after capability
+        if (this.check(TokenType.COMMA)) {
+            this.advance();
+        }
+        // Check for inline conditions
+        if (this.check(TokenType.IF) || this.check(TokenType.WHEN)) {
+            this.advance();
+            conditions.push(this.parseCondition());
+        }
+        return {
+            type: "Capability",
+            verb: undefined,
+            action,
+            description,
+            nested: nested.length > 0 ? nested : undefined,
+            conditions: conditions.length > 0 ? conditions : undefined,
+            location: {
+                start: startToken.location.offset,
+                end: this.currentToken.location.offset,
+                line: startToken.location.line,
+                column: startToken.location.column,
+            },
+        };
+    }
+    parseCondition() {
+        const startToken = this.currentToken;
+        const expression = this.parseExpression();
+        return {
+            type: "Condition",
+            expression,
+            location: {
+                start: startToken.location.offset,
+                end: this.currentToken.location.offset,
+                line: startToken.location.line,
+                column: startToken.location.column,
+            },
+        };
+    }
+    parseExpression() {
+        return this.parseOrExpression();
+    }
+    parseOrExpression() {
+        const startToken = this.currentToken;
+        let left = this.parseAndExpression();
+        while (this.check(TokenType.OR)) {
+            this.advance();
+            const right = this.parseAndExpression();
+            left = {
+                type: "Expression",
+                operator: "or",
+                left,
+                right,
+                location: {
+                    start: startToken.location.offset,
+                    end: this.currentToken.location.offset,
+                    line: startToken.location.line,
+                    column: startToken.location.column,
+                },
+            };
+        }
+        return left;
+    }
+    parseAndExpression() {
+        const startToken = this.currentToken;
+        let left = this.parseComparisonExpression();
+        while (this.check(TokenType.AND)) {
+            this.advance();
+            const right = this.parseComparisonExpression();
+            left = {
+                type: "Expression",
+                operator: "and",
+                left,
+                right,
+                location: {
+                    start: startToken.location.offset,
+                    end: this.currentToken.location.offset,
+                    line: startToken.location.line,
+                    column: startToken.location.column,
+                },
+            };
+        }
+        return left;
+    }
+    parseComparisonExpression() {
+        const startToken = this.currentToken;
+        let left = this.parsePrimaryExpression();
+        while (this.checkAny(TokenType.EQ, TokenType.NEQ, TokenType.LT, TokenType.LTE, TokenType.GT, TokenType.GTE)) {
+            const op = this.advance().value;
+            const right = this.parsePrimaryExpression();
+            left = {
+                type: "Expression",
+                operator: op,
+                left,
+                right,
+                location: {
+                    start: startToken.location.offset,
+                    end: this.currentToken.location.offset,
+                    line: startToken.location.line,
+                    column: startToken.location.column,
+                },
+            };
+        }
+        return left;
+    }
+    parsePrimaryExpression() {
+        const startToken = this.currentToken;
+        if (this.check(TokenType.TRUE)) {
+            this.advance();
+            return {
+                type: "Expression",
+                value: true,
+                location: {
+                    start: startToken.location.offset,
+                    end: this.currentToken.location.offset,
+                    line: startToken.location.line,
+                    column: startToken.location.column,
+                },
+            };
+        }
+        if (this.check(TokenType.FALSE)) {
+            this.advance();
+            return {
+                type: "Expression",
+                value: false,
+                location: {
+                    start: startToken.location.offset,
+                    end: this.currentToken.location.offset,
+                    line: startToken.location.line,
+                    column: startToken.location.column,
+                },
+            };
+        }
+        if (this.check(TokenType.NUMBER)) {
+            const value = Number(this.advance().value);
+            return {
+                type: "Expression",
+                value,
+                location: {
+                    start: startToken.location.offset,
+                    end: this.currentToken.location.offset,
+                    line: startToken.location.line,
+                    column: startToken.location.column,
+                },
+            };
+        }
+        if (this.check(TokenType.STRING)) {
+            const value = this.advance().value;
+            return {
+                type: "Expression",
+                value,
+                location: {
+                    start: startToken.location.offset,
+                    end: this.currentToken.location.offset,
+                    line: startToken.location.line,
+                    column: startToken.location.column,
+                },
+            };
+        }
+        if (this.check(TokenType.IDENTIFIER)) {
+            const value = this.advance().value;
+            return {
+                type: "Expression",
+                value,
+                location: {
+                    start: startToken.location.offset,
+                    end: this.currentToken.location.offset,
+                    line: startToken.location.line,
+                    column: startToken.location.column,
+                },
+            };
+        }
+        if (this.check(TokenType.LPAREN)) {
+            this.advance();
+            const expr = this.parseExpression();
+            this.consume(TokenType.RPAREN, "Expected ')' after expression");
+            return expr;
+        }
+        throw new SyntaxError(`Unexpected token in expression: ${this.currentToken.type}`);
+    }
+    parseRole(description) {
+        const startToken = this.consume(TokenType.ROLE);
+        const name = this.consume(TokenType.IDENTIFIER, "Expected role name").value;
+        this.skipNewlines();
+        this.consume(TokenType.LBRACE, "Expected '{' after role name");
+        this.skipNewlines();
+        const permissions = [];
+        const inherits = [];
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            const loopStart = this.currentToken.location.offset;
+            // Check for description before permission
+            const permissionDescription = this.parseDescriptionIfPresent();
+            if (this.check(TokenType.PERMISSION)) {
+                this.advance();
+                const resource = this.consume(TokenType.IDENTIFIER, "Expected resource name").value;
+                const actions = [];
+                if (this.check(TokenType.LBRACE)) {
+                    this.advance();
+                    this.skipNewlines();
+                    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+                        actions.push(this.consume(TokenType.IDENTIFIER, "Expected action name").value);
+                        if (this.check(TokenType.COMMA)) {
+                            this.advance();
+                            this.skipNewlines();
+                        }
+                        this.skipNewlines();
+                    }
+                    this.consume(TokenType.RBRACE, "Expected '}' after actions");
+                }
+                permissions.push({
+                    type: "Permission",
+                    resource,
+                    description: permissionDescription,
+                    actions,
+                    location: {
+                        start: startToken.location.offset,
+                        end: this.currentToken.location.offset,
+                        line: startToken.location.line,
+                        column: startToken.location.column,
+                    },
+                });
+            }
+            else {
+                // If we hit an unexpected token, throw an error instead of hanging
+                throw new SyntaxError(`Unexpected token '${this.currentToken.value}' (type: ${this.currentToken.type}) at line ${this.currentToken.location.line}. ` +
+                    `Expected 'permission' keyword or '}' to close role definition. ` +
+                    `Note: Role definitions use 'permission resource { actions }' syntax, not field syntax with colons.`);
+            }
+            this.skipNewlines();
+            // Safety: ensure we're advancing
+            if (this.currentToken.location.offset === loopStart &&
+                !this.check(TokenType.RBRACE)) {
+                throw new SyntaxError(`Parser stuck in role definition at line ${this.currentToken.location.line}`);
+            }
+        }
+        this.consume(TokenType.RBRACE, "Expected '}' after role body");
+        return {
+            type: "RoleDefinition",
+            name,
+            description,
+            permissions,
+            inherits: inherits.length > 0 ? inherits : undefined,
+            location: {
+                start: startToken.location.offset,
+                end: this.currentToken.location.offset,
+                line: startToken.location.line,
+                column: startToken.location.column,
+            },
+        };
+    }
+    parseWorkflow(description) {
+        const startToken = this.consume(TokenType.WORKFLOW);
+        const name = this.consume(TokenType.IDENTIFIER, "Expected workflow name").value;
+        this.skipNewlines();
+        this.consume(TokenType.LBRACE, "Expected '{' after workflow name");
+        this.skipNewlines();
+        const steps = [];
+        let initialState = "";
+        const finalStates = [];
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            // Check for description before state
+            const stepDescription = this.parseDescriptionIfPresent();
+            // Handle 'initial <stateName>' to set the initial state
+            if (this.check(TokenType.INITIAL)) {
+                this.advance();
+                initialState = this.consume(TokenType.IDENTIFIER, "Expected state name after 'initial'").value;
+                this.skipNewlines();
+                continue;
+            }
+            if (this.check(TokenType.STATE)) {
+                this.advance();
+                const stateName = this.consume(TokenType.IDENTIFIER, "Expected state name").value;
+                if (this.match(TokenType.ARROW)) {
+                    const transitions = [];
+                    while (!this.check(TokenType.NEWLINE) && !this.check(TokenType.RBRACE) &&
+                        !this.isAtEnd()) {
+                        const toState = this.consume(TokenType.IDENTIFIER, "Expected target state").value;
+                        transitions.push({
+                            type: "Transition",
+                            from: stateName,
+                            to: toState,
+                            location: {
+                                start: startToken.location.offset,
+                                end: this.currentToken.location.offset,
+                                line: startToken.location.line,
+                                column: startToken.location.column,
+                            },
+                        });
+                        if (this.match(TokenType.COMMA)) {
+                            // Continue parsing transitions
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                    steps.push({
+                        type: "WorkflowStep",
+                        name: stateName,
+                        description: stepDescription,
+                        action: "transition",
+                        transitions,
+                        location: {
+                            start: startToken.location.offset,
+                            end: this.currentToken.location.offset,
+                            line: startToken.location.line,
+                            column: startToken.location.column,
+                        },
+                    });
+                }
+                this.skipNewlines();
+                continue;
+            }
+            // If we reach here, we have an unexpected token in the workflow body
+            throw new SyntaxError(`Unexpected token '${this.currentToken.type}' in workflow definition at line ${this.currentToken.location.line}:${this.currentToken.location.column}. ` +
+                `Workflows should contain 'initial <state>' or 'state <name> -> <transitions>' declarations. ` +
+                `Note: Workflows use state machine syntax, not method declarations.`);
+        }
+        this.consume(TokenType.RBRACE, "Expected '}' after workflow body");
+        return {
+            type: "WorkflowDefinition",
+            name,
+            description,
+            steps,
+            initialState,
+            finalStates,
+            location: {
+                start: startToken.location.offset,
+                end: this.currentToken.location.offset,
+                line: startToken.location.line,
+                column: startToken.location.column,
+            },
+        };
+    }
+    parseAgent(description) {
+        const startToken = this.consume(TokenType.AGENT);
+        const name = this.consume(TokenType.IDENTIFIER, "Expected agent name").value;
+        let role = "";
+        if (this.match(TokenType.COLON)) {
+            role = this.consume(TokenType.IDENTIFIER, "Expected role name").value;
+        }
+        this.skipNewlines();
+        this.consume(TokenType.LBRACE, "Expected '{' after agent name");
+        this.skipNewlines();
+        const capabilities = [];
+        const responsibilities = [];
+        let skills;
+        let model;
+        let maxConcurrent;
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            if (this.check(TokenType.CAPABILITIES)) {
+                this.advance();
+                this.consume(TokenType.COLON, "Expected ':' after capabilities");
+                const capList = this.parseStringArray();
+                // Convert to capability nodes
+                for (const cap of capList) {
+                    capabilities.push({
+                        type: "Capability",
+                        verb: "can",
+                        action: cap,
+                        location: {
+                            start: startToken.location.offset,
+                            end: this.currentToken.location.offset,
+                            line: startToken.location.line,
+                            column: startToken.location.column,
+                        },
+                    });
+                }
+            }
+            else if (this.check(TokenType.SKILLS)) {
+                this.advance();
+                this.consume(TokenType.COLON, "Expected ':' after skills");
+                skills = this.parseStringArray();
+            }
+            else if (this.check(TokenType.MODEL)) {
+                this.advance();
+                this.consume(TokenType.COLON, "Expected ':' after model");
+                model = this.consume(TokenType.STRING, "Expected string value").value;
+            }
+            else if (this.check(TokenType.MAX_CONCURRENT)) {
+                this.advance();
+                this.consume(TokenType.COLON, "Expected ':' after max_concurrent");
+                maxConcurrent = parseInt(this.consume(TokenType.NUMBER, "Expected number value").value);
+            }
+            else if (this.check(TokenType.STRING) || this.check(TokenType.IDENTIFIER) ||
+                this.check(TokenType.PROMPT)) {
+                // Parse the full capability with nested capabilities support (including descriptions)
+                capabilities.push(this.parseCapability());
+            }
+            else {
+                this.advance();
+            }
+            this.skipNewlines();
+        }
+        this.consume(TokenType.RBRACE, "Expected '}' after agent body");
+        // Determine agent kind based on properties
+        // Builder agents have skills, model, or maxConcurrent properties
+        // Domain agents have business logic capabilities and may have roles
+        const agentKind = (skills !== undefined || model !== undefined ||
+            maxConcurrent !== undefined)
+            ? "builder"
+            : "domain";
+        return {
+            type: "AgentDefinition",
+            name,
+            description,
+            agentKind,
+            role,
+            responsibilities,
+            capabilities,
+            skills,
+            model,
+            maxConcurrent,
+            location: {
+                start: startToken.location.offset,
+                end: this.currentToken.location.offset,
+                line: startToken.location.line,
+                column: startToken.location.column,
+            },
+        };
+    }
+    parseTypeDefinition(description) {
+        const startToken = this.currentToken;
+        let kind = "type";
+        if (this.check(TokenType.TYPE)) {
+            kind = "type";
+            this.advance();
+        }
+        else if (this.check(TokenType.ENUM)) {
+            kind = "enum";
+            this.advance();
+        }
+        else if (this.check(TokenType.INTERFACE)) {
+            kind = "interface";
+            this.advance();
+        }
+        this.skipNewlines();
+        const name = this.consumeIdentifierOrKeyword(`Expected type name after '${kind}' keyword at line ${this.currentToken.location.line}:${this.currentToken.location.column}. Got '${this.currentToken.value || this.currentToken.type}' instead.`).value;
+        this.skipNewlines();
+        this.consume(TokenType.LBRACE, "Expected '{' after type name");
+        this.skipNewlines();
+        const fields = [];
+        const values = [];
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            if (kind === "enum") {
+                // Enum values remain plain strings (no descriptions)
+                values.push(this.consumeIdentifierOrKeyword("Expected enum value").value);
+            }
+            else {
+                // Check for description before field
+                const fieldDescription = this.parseDescriptionIfPresent();
+                const fieldName = this.consumeIdentifierOrKeyword("Expected field name").value;
+                this.consume(TokenType.COLON, "Expected ':' after field name");
+                // Parse field type with optional array syntax
+                let fieldType = this.consumeIdentifierOrKeyword("Expected field type").value;
+                // Handle array syntax: string[], TypeName[], TypeName[][]
+                while (this.check(TokenType.LBRACKET)) {
+                    this.advance(); // consume '['
+                    this.consume(TokenType.RBRACKET, "Expected ']' after '['");
+                    fieldType += "[]";
+                }
+                fields.push({
+                    type: "TypeField",
+                    name: fieldName,
+                    description: fieldDescription,
+                    fieldType,
+                    required: true,
+                    location: {
+                        start: startToken.location.offset,
+                        end: this.currentToken.location.offset,
+                        line: startToken.location.line,
+                        column: startToken.location.column,
+                    },
+                });
+            }
+            if (this.check(TokenType.COMMA)) {
+                this.advance();
+            }
+            this.skipNewlines();
+        }
+        this.consume(TokenType.RBRACE, "Expected '}' after type body");
+        return {
+            type: "TypeDefinition",
+            name,
+            description,
+            kind,
+            fields: fields.length > 0 ? fields : undefined,
+            values: values.length > 0 ? values : undefined,
+            location: {
+                start: startToken.location.offset,
+                end: this.currentToken.location.offset,
+                line: startToken.location.line,
+                column: startToken.location.column,
+            },
+        };
+    }
+    /**
+     * Parse string array: [item1, item2, item3]
+     */
+    parseStringArray() {
+        const items = [];
+        this.consume(TokenType.LBRACKET, "Expected '['");
+        this.skipNewlines();
+        while (!this.check(TokenType.RBRACKET) && !this.isAtEnd()) {
+            if (this.check(TokenType.IDENTIFIER)) {
+                items.push(this.advance().value);
+            }
+            else if (this.check(TokenType.STRING)) {
+                items.push(this.advance().value);
+            }
+            else {
+                throw new SyntaxError(`Expected identifier or string but got ${this.currentToken.type} at line ${this.currentToken.location.line}:${this.currentToken.location.column}`);
+            }
+            if (this.check(TokenType.COMMA)) {
+                this.advance();
+                this.skipNewlines();
+            }
+            else {
+                break;
+            }
+        }
+        this.consume(TokenType.RBRACKET, "Expected ']'");
+        return items;
+    }
+}