lsh-framework 1.2.0 → 1.3.0

package/dist/lib/shell-parser.js

@@ -1,958 +0,0 @@
-/**
- * POSIX Shell Grammar Parser
- * Implements lexical analysis and syntax parsing for POSIX shell commands
- */
-export var TokenType;
-(function (TokenType) {
-    // Literals and identifiers
-    TokenType["WORD"] = "WORD";
-    TokenType["NUMBER"] = "NUMBER";
-    // Operators
-    TokenType["PIPE"] = "PIPE";
-    TokenType["AND_IF"] = "AND_IF";
-    TokenType["OR_IF"] = "OR_IF";
-    TokenType["SEMICOLON"] = "SEMICOLON";
-    TokenType["DSEMI"] = "DSEMI";
-    TokenType["AMPERSAND"] = "AMPERSAND";
-    // Redirection
-    TokenType["GREAT"] = "GREAT";
-    TokenType["DGREAT"] = "DGREAT";
-    TokenType["LESS"] = "LESS";
-    TokenType["DLESS"] = "DLESS";
-    TokenType["LESSGREAT"] = "LESSGREAT";
-    TokenType["DLESSDASH"] = "DLESSDASH";
-    // Process substitution
-    TokenType["PROC_SUB_IN"] = "PROC_SUB_IN";
-    TokenType["PROC_SUB_OUT"] = "PROC_SUB_OUT";
-    // Grouping
-    TokenType["LPAREN"] = "LPAREN";
-    TokenType["RPAREN"] = "RPAREN";
-    TokenType["LBRACE"] = "LBRACE";
-    TokenType["RBRACE"] = "RBRACE";
-    // Special
-    TokenType["NEWLINE"] = "NEWLINE";
-    TokenType["EOF"] = "EOF";
-    // Quotes
-    TokenType["SINGLE_QUOTE"] = "SINGLE_QUOTE";
-    TokenType["DOUBLE_QUOTE"] = "DOUBLE_QUOTE";
-    TokenType["ANSI_C_QUOTE"] = "ANSI_C_QUOTE";
-    TokenType["LOCALE_QUOTE"] = "LOCALE_QUOTE";
-    TokenType["BACKSLASH"] = "BACKSLASH";
-    // Control structure keywords
-    TokenType["IF"] = "IF";
-    TokenType["THEN"] = "THEN";
-    TokenType["ELSE"] = "ELSE";
-    TokenType["ELIF"] = "ELIF";
-    TokenType["FI"] = "FI";
-    TokenType["FOR"] = "FOR";
-    TokenType["IN"] = "IN";
-    TokenType["DO"] = "DO";
-    TokenType["DONE"] = "DONE";
-    TokenType["WHILE"] = "WHILE";
-    TokenType["UNTIL"] = "UNTIL";
-    TokenType["CASE"] = "CASE";
-    TokenType["ESAC"] = "ESAC";
-    TokenType["FUNCTION"] = "FUNCTION";
-})(TokenType || (TokenType = {}));
-export class ShellLexer {
-    input;
-    position = 0;
-    line = 1;
-    column = 1;
-    constructor(input) {
-        this.input = input;
-    }
-    peek(offset = 0) {
-        const pos = this.position + offset;
-        return pos >= this.input.length ? '\0' : this.input[pos];
-    }
-    advance() {
-        if (this.position >= this.input.length)
-            return '\0';
-        const char = this.input[this.position];
-        this.position++;
-        if (char === '\n') {
-            this.line++;
-            this.column = 1;
-        }
-        else {
-            this.column++;
-        }
-        return char;
-    }
-    skipWhitespace() {
-        while (this.position < this.input.length) {
-            const char = this.peek();
-            if (char === ' ' || char === '\t' || char === '\r') {
-                this.advance();
-            }
-            else {
-                break;
-            }
-        }
-    }
-    readWord() {
-        let word = '';
-        let inBraces = false;
-        while (this.position < this.input.length) {
-            const char = this.peek();
-            if (char === '{') {
-                inBraces = true;
-                word += this.advance();
-            }
-            else if (char === '}' && inBraces) {
-                inBraces = false;
-                word += this.advance();
-            }
-            else if (inBraces) {
-                // Inside braces, allow more characters for parameter expansion
-                if (char.match(/[a-zA-Z0-9_\-./~:+=?#%*@!$]/)) {
-                    word += this.advance();
-                }
-                else {
-                    break;
-                }
-            }
-            else {
-                // Word characters (including $ for variables, = for assignments, and glob characters)
-                if (char.match(/[a-zA-Z0-9_\-./~$=*?[\]]/)) {
-                    word += this.advance();
-                }
-                else {
-                    break;
-                }
-            }
-        }
-        return word;
-    }
-    readQuotedString(quote) {
-        let result = '';
-        this.advance(); // consume opening quote
-        while (this.position < this.input.length) {
-            const char = this.peek();
-            if (char === quote) {
-                this.advance(); // consume closing quote
-                break;
-            }
-            else if (char === '\\' && quote === '"') {
-                // Handle escape sequences in double quotes
-                this.advance(); // consume backslash
-                const escaped = this.advance();
-                result += this.processEscape(escaped);
-            }
-            else {
-                result += this.advance();
-            }
-        }
-        return result;
-    }
-    processEscape(char) {
-        switch (char) {
-            case 'n': return '\n';
-            case 't': return '\t';
-            case 'r': return '\r';
-            case 'b': return '\b';
-            case 'f': return '\f';
-            case 'v': return '\v';
-            case '\\': return '\\';
-            case '"': return '"';
-            case "'": return "'";
-            default: return char;
-        }
-    }
-    readAnsiCQuotedString() {
-        let result = '';
-        this.advance(); // consume opening quote '
-        while (this.position < this.input.length) {
-            const char = this.peek();
-            if (char === "'") {
-                this.advance(); // consume closing quote
-                break;
-            }
-            else if (char === '\\') {
-                // Handle ANSI-C escape sequences
-                this.advance(); // consume backslash
-                const escaped = this.advance();
-                result += this.processAnsiCEscape(escaped);
-            }
-            else {
-                result += this.advance();
-            }
-        }
-        return result;
-    }
-    readLocaleQuotedString() {
-        let result = '';
-        this.advance(); // consume opening quote "
-        while (this.position < this.input.length) {
-            const char = this.peek();
-            if (char === '"') {
-                this.advance(); // consume closing quote
-                break;
-            }
-            else if (char === '\\') {
-                // Handle escape sequences like double quotes
-                this.advance(); // consume backslash
-                const escaped = this.advance();
-                result += this.processEscape(escaped);
-            }
-            else {
-                result += this.advance();
-            }
-        }
-        return result;
-    }
-    readProcessSubstitution() {
-        let result = '';
-        let parenCount = 1; // We already consumed the opening (
-        while (this.position < this.input.length && parenCount > 0) {
-            const char = this.peek();
-            if (char === '(') {
-                parenCount++;
-            }
-            else if (char === ')') {
-                parenCount--;
-            }
-            if (parenCount > 0) { // Don't include the closing )
-                result += this.advance();
-            }
-            else {
-                this.advance(); // consume closing )
-            }
-        }
-        return result;
-    }
-    processAnsiCEscape(char) {
-        switch (char) {
-            case 'a': return '\u0007'; // Alert (bell)
-            case 'b': return '\b'; // Backspace
-            case 'e': return '\u001B'; // Escape character
-            case 'f': return '\f'; // Form feed
-            case 'n': return '\n'; // Newline
-            case 'r': return '\r'; // Carriage return
-            case 't': return '\t'; // Horizontal tab
-            case 'v': return '\v'; // Vertical tab
-            case '\\': return '\\'; // Backslash
-            case "'": return "'"; // Single quote
-            case '"': return '"'; // Double quote
-            case '?': return '?'; // Question mark
-            case '0': return '\0'; // Null character
-            // Octal sequences \nnn
-            case '1':
-            case '2':
-            case '3':
-            case '4':
-            case '5':
-            case '6':
-            case '7':
-                // For simplicity, just return the character for now
-                // Full implementation would parse \nnn octal sequences
-                return char;
-            // Hex sequences \xhh
-            case 'x':
-                // For simplicity, just return 'x' for now
-                // Full implementation would parse \xhh hex sequences
-                return 'x';
-            default:
-                return char;
-        }
-    }
-    createToken(type, value) {
-        return {
-            type,
-            value,
-            position: this.position,
-            line: this.line,
-            column: this.column,
-        };
-    }
-    tokenize() {
-        const tokens = [];
-        while (this.position < this.input.length) {
-            this.skipWhitespace();
-            if (this.position >= this.input.length)
-                break;
-            const char = this.peek();
-            const nextChar = this.peek(1);
-            // Two-character operators
-            if (char === '&' && nextChar === '&') {
-                this.advance();
-                this.advance();
-                tokens.push(this.createToken(TokenType.AND_IF, '&&'));
-            }
-            else if (char === '|' && nextChar === '|') {
-                this.advance();
-                this.advance();
-                tokens.push(this.createToken(TokenType.OR_IF, '||'));
-            }
-            else if (char === '>' && nextChar === '>') {
-                this.advance();
-                this.advance();
-                tokens.push(this.createToken(TokenType.DGREAT, '>>'));
-            }
-            else if (char === '<' && nextChar === '<') {
-                this.advance();
-                this.advance();
-                if (this.peek() === '-') {
-                    this.advance();
-                    tokens.push(this.createToken(TokenType.DLESSDASH, '<<-'));
-                }
-                else {
-                    tokens.push(this.createToken(TokenType.DLESS, '<<'));
-                }
-            }
-            else if (char === '<' && nextChar === '>') {
-                this.advance();
-                this.advance();
-                tokens.push(this.createToken(TokenType.LESSGREAT, '<>'));
-            }
-            // Process substitution
-            else if (char === '<' && nextChar === '(') {
-                this.advance(); // consume <
-                this.advance(); // consume (
-                const command = this.readProcessSubstitution();
-                tokens.push(this.createToken(TokenType.PROC_SUB_IN, '<(' + command + ')'));
-            }
-            else if (char === '>' && nextChar === '(') {
-                this.advance(); // consume >
-                this.advance(); // consume (
-                const command = this.readProcessSubstitution();
-                tokens.push(this.createToken(TokenType.PROC_SUB_OUT, '>(' + command + ')'));
-            }
-            // Single-character operators
-            else if (char === '|') {
-                this.advance();
-                tokens.push(this.createToken(TokenType.PIPE, '|'));
-            }
-            else if (char === '&') {
-                this.advance();
-                tokens.push(this.createToken(TokenType.AMPERSAND, '&'));
-            }
-            else if (char === ';') {
-                const nextChar = this.peek(1);
-                if (nextChar === ';') {
-                    this.advance();
-                    this.advance();
-                    tokens.push(this.createToken(TokenType.DSEMI, ';;'));
-                }
-                else {
-                    this.advance();
-                    tokens.push(this.createToken(TokenType.SEMICOLON, ';'));
-                }
-            }
-            else if (char === '>') {
-                this.advance();
-                tokens.push(this.createToken(TokenType.GREAT, '>'));
-            }
-            else if (char === '<') {
-                this.advance();
-                tokens.push(this.createToken(TokenType.LESS, '<'));
-            }
-            else if (char === '(') {
-                this.advance();
-                tokens.push(this.createToken(TokenType.LPAREN, '('));
-            }
-            else if (char === ')') {
-                this.advance();
-                tokens.push(this.createToken(TokenType.RPAREN, ')'));
-            }
-            else if (char === '{') {
-                this.advance();
-                tokens.push(this.createToken(TokenType.LBRACE, '{'));
-            }
-            else if (char === '}') {
-                this.advance();
-                tokens.push(this.createToken(TokenType.RBRACE, '}'));
-            }
-            else if (char === '\n') {
-                this.advance();
-                tokens.push(this.createToken(TokenType.NEWLINE, '\n'));
-            }
-            // Quoted strings
-            else if (char === '$' && (this.peek(1) === "'" || this.peek(1) === '"')) {
-                // Handle ANSI-C quoting $'...' and locale quoting $"..."
-                this.advance(); // consume $
-                const quoteChar = this.peek();
-                if (quoteChar === "'") {
-                    const value = this.readAnsiCQuotedString();
-                    tokens.push(this.createToken(TokenType.ANSI_C_QUOTE, value));
-                }
-                else if (quoteChar === '"') {
-                    const value = this.readLocaleQuotedString();
-                    tokens.push(this.createToken(TokenType.LOCALE_QUOTE, value));
-                }
-            }
-            else if (char === '"') {
-                const value = this.readQuotedString('"');
-                tokens.push(this.createToken(TokenType.DOUBLE_QUOTE, value));
-            }
-            else if (char === "'") {
-                const value = this.readQuotedString("'");
-                tokens.push(this.createToken(TokenType.SINGLE_QUOTE, value));
-            }
-            // Words and numbers
-            else if (char.match(/[a-zA-Z_$*?[\].]/)) {
-                const word = this.readWord();
-                const tokenType = this.getKeywordType(word);
-                tokens.push(this.createToken(tokenType, word));
-            }
-            else if (char.match(/[0-9]/)) {
-                const number = this.readWord(); // Numbers can contain dots, etc.
-                tokens.push(this.createToken(TokenType.NUMBER, number));
-            }
-            else {
-                // Unknown character, treat as word
-                const word = this.readWord() || this.advance();
-                const tokenType = this.getKeywordType(word);
-                tokens.push(this.createToken(tokenType, word));
-            }
-        }
-        tokens.push(this.createToken(TokenType.EOF, ''));
-        return tokens;
-    }
-    getKeywordType(word) {
-        const keywords = {
-            'if': TokenType.IF,
-            'then': TokenType.THEN,
-            'else': TokenType.ELSE,
-            'elif': TokenType.ELIF,
-            'fi': TokenType.FI,
-            'for': TokenType.FOR,
-            'in': TokenType.IN,
-            'do': TokenType.DO,
-            'done': TokenType.DONE,
-            'while': TokenType.WHILE,
-            'until': TokenType.UNTIL,
-            'case': TokenType.CASE,
-            'esac': TokenType.ESAC,
-            'function': TokenType.FUNCTION,
-        };
-        return keywords[word] || TokenType.WORD;
-    }
-}
-export class ShellParser {
-    tokens;
-    position = 0;
-    constructor(tokens) {
-        this.tokens = tokens;
-    }
-    peek(offset = 0) {
-        const pos = this.position + offset;
-        return pos >= this.tokens.length
-            ? { type: TokenType.EOF, value: '', position: 0, line: 0, column: 0 }
-            : this.tokens[pos];
-    }
-    advance() {
-        return this.position < this.tokens.length ? this.tokens[this.position++] : this.peek();
-    }
-    expect(type) {
-        const token = this.advance();
-        if (token.type !== type) {
-            throw new Error(`Expected ${type}, got ${token.type} at line ${token.line}`);
-        }
-        return token;
-    }
-    parseSimpleCommand() {
-        const name = this.expect(TokenType.WORD).value;
-        const args = [];
-        const redirections = [];
-        while (this.peek().type === TokenType.WORD ||
-            this.peek().type === TokenType.NUMBER ||
-            this.peek().type === TokenType.SINGLE_QUOTE ||
-            this.peek().type === TokenType.DOUBLE_QUOTE ||
-            this.peek().type === TokenType.ANSI_C_QUOTE ||
-            this.peek().type === TokenType.LOCALE_QUOTE ||
-            this.peek().type === TokenType.LBRACE ||
-            this.peek().type === TokenType.PROC_SUB_IN ||
-            this.peek().type === TokenType.PROC_SUB_OUT ||
-            this.isRedirection(this.peek().type)) {
-            const token = this.peek();
-            if (this.isRedirection(token.type)) {
-                redirections.push(this.parseRedirection());
-            }
-            else if (token.type === TokenType.LBRACE) {
-                // Parse brace expression as a single argument
-                args.push(this.parseBraceExpression());
-            }
-            else if (token.type === TokenType.PROC_SUB_IN || token.type === TokenType.PROC_SUB_OUT) {
-                // Process substitution will be handled during execution - just store token
-                args.push(this.advance().value);
-            }
-            else {
-                args.push(this.advance().value);
-            }
-        }
-        return { type: 'SimpleCommand', name, args, redirections };
-    }
-    parseBraceExpression() {
-        let braceExpression = '';
-        // Consume opening brace
-        braceExpression += this.expect(TokenType.LBRACE).value;
-        // Parse content until closing brace
-        while (this.peek().type !== TokenType.RBRACE && this.peek().type !== TokenType.EOF) {
-            braceExpression += this.advance().value;
-        }
-        // Consume closing brace
-        if (this.peek().type === TokenType.RBRACE) {
-            braceExpression += this.advance().value;
-        }
-        return braceExpression;
-    }
-    isRedirection(type) {
-        return type === TokenType.GREAT || type === TokenType.DGREAT ||
-            type === TokenType.LESS || type === TokenType.DLESS ||
-            type === TokenType.LESSGREAT || type === TokenType.DLESSDASH;
-    }
-    parseRedirection() {
-        const token = this.advance();
-        const target = this.expect(TokenType.WORD).value;
-        switch (token.type) {
-            case TokenType.GREAT:
-                return { type: 'output', target };
-            case TokenType.DGREAT:
-                return { type: 'append', target };
-            case TokenType.LESS:
-                return { type: 'input', target };
-            case TokenType.DLESS:
-            case TokenType.DLESSDASH:
-                return { type: 'heredoc', target };
-            default:
-                throw new Error(`Unknown redirection type: ${token.type}`);
-        }
-    }
-    parsePipelineElement() {
-        const token = this.peek();
-        switch (token.type) {
-            case TokenType.LPAREN:
-                return this.parseSubshell();
-            case TokenType.LBRACE:
-                return this.parseCommandGroup();
-            case TokenType.IF:
-                return this.parseIfStatement();
-            case TokenType.FOR:
-                return this.parseForStatement();
-            case TokenType.WHILE:
-                return this.parseWhileStatement();
-            case TokenType.CASE:
-                return this.parseCaseStatement();
-            case TokenType.FUNCTION:
-                return this.parseFunctionDefinition();
-            default:
-                // Check if this might be a function definition (name followed by ())
-                if (token.type === TokenType.WORD) {
-                    const nextToken = this.peek(1);
-                    if (nextToken.type === TokenType.LPAREN) {
-                        const afterParen = this.peek(2);
-                        if (afterParen.type === TokenType.RPAREN) {
-                            return this.parseFunctionDefinition();
-                        }
-                    }
-                }
-                return this.parseSimpleCommand();
-        }
-    }
-    parsePipeline() {
-        const left = this.parsePipelineElement();
-        if (this.peek().type === TokenType.PIPE) {
-            const commands = [left];
-            while (this.peek().type === TokenType.PIPE) {
-                this.advance(); // consume pipe
-                commands.push(this.parsePipelineElement());
-            }
-            return { type: 'Pipeline', commands };
-        }
-        return left;
-    }
-    parseCommandList() {
-        let left = this.parsePipeline();
-        while (this.peek().type === TokenType.AND_IF ||
-            this.peek().type === TokenType.OR_IF ||
-            this.peek().type === TokenType.SEMICOLON ||
-            this.peek().type === TokenType.AMPERSAND) {
-            const operator = this.advance();
-            let op;
-            switch (operator.type) {
-                case TokenType.AND_IF:
-                    op = '&&';
-                    break;
-                case TokenType.OR_IF:
-                    op = '||';
-                    break;
-                case TokenType.SEMICOLON:
-                    op = ';';
-                    break;
-                case TokenType.AMPERSAND:
-                    op = '&';
-                    break;
-                default: throw new Error(`Unknown operator: ${operator.type}`);
-            }
-            // For background (&), right side is optional (can be at end of line)
-            let right;
-            if (op === '&' && (this.peek().type === TokenType.EOF || this.peek().type === TokenType.NEWLINE)) {
-                right = undefined;
-            }
-            else {
-                right = this.parsePipeline();
-            }
-            left = { type: 'CommandList', left, operator: op, right };
-        }
-        return left;
-    }
-    parseIfStatement() {
-        this.expect(TokenType.IF);
-        // Skip newlines
-        while (this.peek().type === TokenType.NEWLINE) {
-            this.advance();
-        }
-        const condition = this.parseConditionalCommand();
-        // Skip newlines
-        while (this.peek().type === TokenType.NEWLINE) {
-            this.advance();
-        }
-        this.expect(TokenType.THEN);
-        // Skip newlines
-        while (this.peek().type === TokenType.NEWLINE) {
-            this.advance();
-        }
-        const thenClause = this.parseCompoundList();
-        let elseClause;
-        // Skip newlines
-        while (this.peek().type === TokenType.NEWLINE) {
-            this.advance();
-        }
-        if (this.peek().type === TokenType.ELSE) {
-            this.advance();
-            // Skip newlines
-            while (this.peek().type === TokenType.NEWLINE) {
-                this.advance();
-            }
-            elseClause = this.parseCompoundList();
-            // Skip newlines
-            while (this.peek().type === TokenType.NEWLINE) {
-                this.advance();
-            }
-        }
-        this.expect(TokenType.FI);
-        return {
-            type: 'IfStatement',
-            condition,
-            thenClause,
-            elseClause,
-        };
-    }
-    parseForStatement() {
-        this.expect(TokenType.FOR);
-        const variable = this.expect(TokenType.WORD).value;
-        // Skip newlines
-        while (this.peek().type === TokenType.NEWLINE) {
-            this.advance();
-        }
-        const words = [];
-        if (this.peek().type === TokenType.IN) {
-            this.advance();
-            // Read word list (including numbers which are treated as words in for loops)
-            while (this.peek().type === TokenType.WORD || this.peek().type === TokenType.NUMBER || this.peek().type === TokenType.SINGLE_QUOTE || this.peek().type === TokenType.DOUBLE_QUOTE || this.peek().type === TokenType.ANSI_C_QUOTE || this.peek().type === TokenType.LOCALE_QUOTE) {
-                words.push(this.advance().value);
-            }
-        }
-        // Skip newlines and optional semicolon
-        while (this.peek().type === TokenType.NEWLINE) {
-            this.advance();
-        }
-        // Optional semicolon before DO
-        if (this.peek().type === TokenType.SEMICOLON) {
-            this.advance();
-        }
-        // Skip newlines after semicolon
-        while (this.peek().type === TokenType.NEWLINE) {
-            this.advance();
-        }
-        this.expect(TokenType.DO);
-        // Skip newlines
-        while (this.peek().type === TokenType.NEWLINE) {
-            this.advance();
-        }
-        const body = this.parseCompoundList();
-        // Skip newlines
-        while (this.peek().type === TokenType.NEWLINE) {
-            this.advance();
-        }
-        this.expect(TokenType.DONE);
-        return {
-            type: 'ForStatement',
-            variable,
-            words,
-            body,
-        };
-    }
-    parseWhileStatement() {
-        this.expect(TokenType.WHILE);
-        // Skip newlines
-        while (this.peek().type === TokenType.NEWLINE) {
-            this.advance();
-        }
-        const condition = this.parseConditionalCommand();
-        // Skip newlines
-        while (this.peek().type === TokenType.NEWLINE) {
-            this.advance();
-        }
-        this.expect(TokenType.DO);
-        // Skip newlines
-        while (this.peek().type === TokenType.NEWLINE) {
-            this.advance();
-        }
-        const body = this.parseCompoundList();
-        // Skip newlines
-        while (this.peek().type === TokenType.NEWLINE) {
-            this.advance();
-        }
-        this.expect(TokenType.DONE);
-        return {
-            type: 'WhileStatement',
-            condition,
-            body,
-        };
-    }
-    parseCaseStatement() {
-        this.expect(TokenType.CASE);
-        const word = this.expect(TokenType.WORD).value;
-        // Skip newlines
-        while (this.peek().type === TokenType.NEWLINE) {
-            this.advance();
-        }
-        this.expect(TokenType.IN);
-        // Skip newlines
-        while (this.peek().type === TokenType.NEWLINE) {
-            this.advance();
-        }
-        const items = [];
-        while (this.peek().type !== TokenType.ESAC && this.peek().type !== TokenType.EOF) {
-            const patterns = [];
-            // Parse patterns separated by |
-            patterns.push(this.expect(TokenType.WORD).value);
-            while (this.peek().type === TokenType.PIPE) {
-                this.advance(); // consume |
-                patterns.push(this.expect(TokenType.WORD).value);
-            }
-            this.advance(); // expect ')' - would need to add to lexer
-            // Skip newlines
-            while (this.peek().type === TokenType.NEWLINE) {
-                this.advance();
-            }
-            let command;
-            if (this.peek().type !== TokenType.ESAC) {
-                command = this.parseCommandList();
-            }
-            items.push({ patterns, command });
-            // Skip newlines
-            while (this.peek().type === TokenType.NEWLINE) {
-                this.advance();
-            }
-            // Skip ;; if present
-            if (this.peek().type === TokenType.DSEMI) {
-                this.advance();
-            }
-            // Skip newlines after ;;
-            while (this.peek().type === TokenType.NEWLINE) {
-                this.advance();
-            }
-        }
-        this.expect(TokenType.ESAC);
-        return {
-            type: 'CaseStatement',
-            word,
-            items,
-        };
-    }
-    parseCompoundList() {
-        // Parse a sequence of commands until we hit a closing keyword
-        const commands = [];
-        while (this.peek().type !== TokenType.FI &&
-            this.peek().type !== TokenType.DONE &&
-            this.peek().type !== TokenType.ESAC &&
-            this.peek().type !== TokenType.ELSE &&
-            this.peek().type !== TokenType.RBRACE &&
-            this.peek().type !== TokenType.EOF) {
-            // Skip newlines
-            while (this.peek().type === TokenType.NEWLINE) {
-                this.advance();
-            }
-            if (this.peek().type === TokenType.FI ||
-                this.peek().type === TokenType.DONE ||
-                this.peek().type === TokenType.ESAC ||
-                this.peek().type === TokenType.ELSE ||
-                this.peek().type === TokenType.RBRACE ||
-                this.peek().type === TokenType.EOF) {
-                break;
-            }
-            // Parse individual commands or pipelines
-            commands.push(this.parsePipeline());
-            // Skip optional semicolon or newline
-            if (this.peek().type === TokenType.SEMICOLON) {
-                this.advance();
-            }
-        }
-        if (commands.length === 0) {
-            return { type: 'SimpleCommand', name: '', args: [], redirections: [] };
-        }
-        else if (commands.length === 1) {
-            return commands[0];
-        }
-        else {
-            // Create a command list
-            let result = commands[0];
-            for (let i = 1; i < commands.length; i++) {
-                result = {
-                    type: 'CommandList',
-                    left: result,
-                    operator: ';',
-                    right: commands[i],
-                };
-            }
-            return result;
-        }
-    }
-    parseConditionalCommand() {
-        // Parse a command list until we hit a control structure keyword
-        const commands = [];
-        while (this.peek().type !== TokenType.THEN &&
-            this.peek().type !== TokenType.DO &&
-            this.peek().type !== TokenType.NEWLINE &&
-            this.peek().type !== TokenType.EOF) {
-            commands.push(this.parsePipeline());
-            // Check for command separators
-            if (this.peek().type === TokenType.SEMICOLON) {
-                this.advance();
-            }
-            else if (this.peek().type === TokenType.AND_IF || this.peek().type === TokenType.OR_IF) {
-                const operator = this.advance();
-                const right = this.parsePipeline();
-                const op = operator.type === TokenType.AND_IF ? '&&' : '||';
-                const lastCmd = commands.pop();
-                commands.push({ type: 'CommandList', left: lastCmd, operator: op, right });
-            }
-            else {
-                break;
-            }
-        }
-        if (commands.length === 0) {
-            throw new Error('Expected command in conditional');
-        }
-        else if (commands.length === 1) {
-            return commands[0];
-        }
-        else {
-            // Create a command list
-            let result = commands[0];
-            for (let i = 1; i < commands.length; i++) {
-                result = {
-                    type: 'CommandList',
-                    left: result,
-                    operator: ';',
-                    right: commands[i],
-                };
-            }
-            return result;
-        }
-    }
-    parseFunctionDefinition() {
-        let name;
-        // Handle both syntaxes: "function name { ... }" and "name() { ... }"
-        if (this.peek().type === TokenType.FUNCTION) {
-            this.advance(); // consume 'function'
-            name = this.expect(TokenType.WORD).value;
-        }
-        else {
-            // name() syntax
-            name = this.expect(TokenType.WORD).value;
-            this.expect(TokenType.LPAREN);
-            this.expect(TokenType.RPAREN);
-        }
-        // Skip newlines before body
-        while (this.peek().type === TokenType.NEWLINE) {
-            this.advance();
-        }
-        // Parse function body - expect { ... }
-        this.expect(TokenType.LBRACE);
-        // Skip newlines after opening brace
-        while (this.peek().type === TokenType.NEWLINE) {
-            this.advance();
-        }
-        // Parse the body as a compound list
-        const body = this.parseCompoundList();
-        // Skip newlines before closing brace
-        while (this.peek().type === TokenType.NEWLINE) {
-            this.advance();
-        }
-        this.expect(TokenType.RBRACE);
-        return {
-            type: 'FunctionDefinition',
-            name,
-            body,
-        };
-    }
-    parseSubshell() {
-        this.expect(TokenType.LPAREN);
-        // Skip newlines after opening paren
-        while (this.peek().type === TokenType.NEWLINE) {
-            this.advance();
-        }
-        const command = this.parseCommandList();
-        // Skip newlines before closing paren
-        while (this.peek().type === TokenType.NEWLINE) {
-            this.advance();
-        }
-        this.expect(TokenType.RPAREN);
-        // Parse redirections after subshell
-        const redirections = [];
-        while (this.isRedirection(this.peek().type)) {
-            redirections.push(this.parseRedirection());
-        }
-        return {
-            type: 'Subshell',
-            command,
-            redirections,
-        };
-    }
-    parseCommandGroup() {
-        this.expect(TokenType.LBRACE);
-        // Skip newlines after opening brace
-        while (this.peek().type === TokenType.NEWLINE) {
-            this.advance();
-        }
-        const command = this.parseCompoundList();
-        // Skip newlines before closing brace
-        while (this.peek().type === TokenType.NEWLINE) {
-            this.advance();
-        }
-        this.expect(TokenType.RBRACE);
-        // Parse redirections after command group
-        const redirections = [];
-        while (this.isRedirection(this.peek().type)) {
-            redirections.push(this.parseRedirection());
-        }
-        return {
-            type: 'CommandGroup',
-            command,
-            redirections,
-        };
-    }
-    parse() {
-        // Skip leading newlines
-        while (this.peek().type === TokenType.NEWLINE) {
-            this.advance();
-        }
-        if (this.peek().type === TokenType.EOF) {
-            return { type: 'SimpleCommand', name: '', args: [], redirections: [] };
-        }
-        // Always use parseCommandList to handle all commands and operators
-        return this.parseCommandList();
-    }
-}
-// Convenience function for parsing shell commands
-export function parseShellCommand(input) {
-    const lexer = new ShellLexer(input);
-    const tokens = lexer.tokenize();
-    const parser = new ShellParser(tokens);
-    return parser.parse();
-}