shell-lite 0.4.3__py3-none-any.whl → 0.4.5__py3-none-any.whl

shell_lite/parser_new.py

@@ -1,2229 +0,0 @@
-from typing import List, Optional
-from .lexer_new import Token, Lexer
-from .ast_nodes import *
-import re
-class Parser:
-    def __init__(self, tokens: List[Token]):
-        self.tokens = [t for t in tokens if t.type != 'COMMENT']
-        self.pos = 0
-    def peek(self, offset: int = 0) -> Token:
-        if self.pos + offset < len(self.tokens):
-            return self.tokens[self.pos + offset]
-        return self.tokens[-1]
-    def consume(self, expected_type: str = None) -> Token:
-        token = self.peek()
-        if expected_type and token.type != expected_type:
-            raise SyntaxError(f"Expected {expected_type} but got {token.type} on line {token.line}")
-        self.pos += 1
-        return token
-    def check(self, token_type: str) -> bool:
-        return self.peek().type == token_type
-    def parse(self) -> List[Node]:
-        statements = []
-        while not self.check('EOF'):
-            while self.check('NEWLINE'):
-                self.consume()
-                if self.check('EOF'): break
-            if self.check('EOF'): break
-            stmt = self.parse_statement()
-            if stmt:
-                statements.append(stmt)
-        return statements
-    def parse_statement(self) -> Node:
-        if self.check('USE'):
-            return self.parse_import()
-        elif self.check('APP'):
-            return self.parse_app()
-        elif self.check('ON'):
-            return self.parse_on()
-        elif self.check('CONST'):
-            return self.parse_const()
-        elif self.check('PRINT') or self.check('SAY'):
-            return self.parse_print()
-        elif self.check('ALERT'):
-            return self.parse_alert()
-        elif self.check('IF'):
-            return self.parse_if()
-        elif self.check('UNLESS'):
-            return self.parse_unless()
-        elif self.check('WHILE'):
-            return self.parse_while()
-        elif self.check('UNTIL'):
-            return self.parse_until()
-        elif self.check('FOREVER'):
-            return self.parse_forever()
-        elif self.check('TRY'):
-            return self.parse_try()
-        elif self.check('FOR') or self.check('LOOP'):
-            return self.parse_for()
-        elif self.check('REPEAT'):
-            return self.parse_repeat()
-        elif self.check('WHEN'):
-            return self.parse_when()
-        elif self.check('TO'):
-            return self.parse_function_def()
-        elif self.check('STRUCTURE'):
-            return self.parse_class_def()
-        elif self.check('RETURN'):
-            return self.parse_return()
-        elif self.check('STOP'):
-            return self.parse_stop()
-        elif self.check('SKIP'):
-            return self.parse_skip()
-        elif self.check('EXIT'):
-            return self.parse_exit()
-        elif self.check('ERROR'):
-            return self.parse_error()
-        elif self.check('EXECUTE'):
-            return self.parse_execute()
-        elif self.check('MAKE'):
-            return self.parse_make()
-        elif self.check('INPUT'):
-            next_t = self.peek(1)
-            if next_t.type in ('ID', 'TYPE', 'STRING', 'NAME', 'VALUE', 'CLASS', 'STYLE', 'ONCLICK', 'SRC', 'HREF', 'ACTION', 'METHOD'):
-                input_token = self.consume()
-                return self.parse_id_start_statement(passed_name_token=input_token)
-            return self.parse_expression_stmt()
-        elif self.check('ID'):
-            return self.parse_id_start_statement()
-        elif self.check('SPAWN'):
-             expr = self.parse_expression()
-             self.consume('NEWLINE')
-             return Print(expr) 
-             pass
-        elif self.check('WAIT'):
-            return self.parse_wait()
-        elif self.check('EVERY'):
-            return self.parse_every()
-        elif self.check('IN'):
-             return self.parse_after()
-        elif self.check('LISTEN'):
-            return self.parse_listen()
-        elif self.check('SERVE'):
-            return self.parse_serve()
-        elif self.check('DOWNLOAD'):
-             return self.parse_download()
-        elif self.check('COMPRESS') or self.check('EXTRACT'):
-             return self.parse_archive()
-        elif self.check('LOAD') or self.check('SAVE'):
-             if self.check('LOAD') and self.peek(1).type == 'CSV':
-                 return self.parse_csv_load()
-             if self.check('SAVE'):
-                 return self.parse_csv_save() 
-             return self.parse_expression_stmt() 
-        elif self.check('COPY') or self.check('PASTE'):
-             return self.parse_clipboard()
-        elif self.check('WRITE'):
-             return self.parse_write()
-        elif self.check('APPEND'):
-             return self.parse_append()
-        elif self.check('DB'):
-             return self.parse_db_op()
-        elif self.check('PRESS') or self.check('TYPE') or self.check('CLICK') or self.check('NOTIFY'):
-             return self.parse_automation()
-        elif self.check('BEFORE'):
-             return self.parse_middleware()
-        elif self.check('DEFINE'):
-            if self.peek(1).type == 'FUNCTION':
-                 return self.parse_function_def()
-            return self.parse_define_page()
-        elif self.check('ADD'):
-            if self.peek(1).type == 'ID' or self.peek(1).type == 'NUMBER' or self.peek(1).type == 'STRING':
-                 # Heuristic: "Add X to Y" (List) vs "Add Component" (UI) maybe?
-                 # Assuming UI "add" uses 'ADD' keyword?
-                 # Lexer maps 'add' to 'ADD'.
-                 # parse_add_to -> UI.
-                 # parse_add_to_list -> List.
-                 # Let's check parse_add_to signature.
-                 pass
-            # For now prioritize List if 'TO' is present later? 
-            # Or assume parse_add_to handles UI.
-            # Let's peek(1). If it's an expression -> List op. If it's a Component?
-            # Creating a unified parse_add dispatcher might be better.
-            return self.parse_add_distinguish()
-
-        elif self.check('START'):
-            return self.parse_start_server()
-        elif self.check('HEADING'):
-            return self.parse_heading()
-        elif self.check('PARAGRAPH'):
-            return self.parse_paragraph()
-        
-        # English List/Time Ops
-        if self.check('ADD'):
-            return self.parse_add_to_list()
-        if self.check('REMOVE'):
-            return self.parse_remove_from_list()
-        if self.check('WAIT'):
-            return self.parse_wait()
-            
-        if self.check('INCREMENT'):
-            return self.parse_increment()
-        elif self.check('DECREMENT'):
-            return self.parse_decrement()
-        elif self.check('MULTIPLY'):
-            return self.parse_multiply()
-        elif self.check('DIVIDE'):
-            return self.parse_divide()
-        elif self.check('MAKE'):
-            return self.parse_make_assignment()
-        elif self.check('AS'):
-            return self.parse_as_long_as()
-        elif self.check('ASK'):
-            # Standalone ask statement? e.g. ask "Questions?"
-            # Or ask is expression. If statement, maybe just expression statement.
-            return self.parse_expression_statement()
-        elif self.check('SET'):
-            return self.parse_set()
-        else:
-            return self.parse_expression_stmt()
-    def parse_alert(self) -> Alert:
-        token = self.consume('ALERT')
-        message = self.parse_expression()
-        self.consume('NEWLINE')
-        node = Alert(message)
-        node.line = token.line
-        return node
-    def parse_const(self) -> ConstAssign:
-        token = self.consume('CONST')
-        name = self.consume('ID').value
-        self.consume('ASSIGN')
-        value = self.parse_expression()
-        self.consume('NEWLINE')
-        node = ConstAssign(name, value)
-        node.line = token.line
-        return node
-    def parse_on(self) -> Node:
-        token = self.consume('ON')
-        if self.check('REQUEST') or (self.check('ID') and self.peek().value == 'request'):
-            self.consume()
-            if self.check('TO'): self.consume('TO')
-            path = self.parse_expression() 
-            self.consume('NEWLINE')
-            self.consume('INDENT')
-            body = []
-            while not self.check('DEDENT') and not self.check('EOF'):
-                while self.check('NEWLINE'): self.consume()
-                if self.check('DEDENT'): break
-                body.append(self.parse_statement())
-            self.consume('DEDENT')
-            node = OnRequest(path, body)
-            node.line = token.line
-            return node
-        event_type = self.consume('ID').value
-        path = self.parse_expression()
-        self.consume('NEWLINE')
-        self.consume('INDENT')
-        body = []
-        while not self.check('DEDENT') and not self.check('EOF'):
-            while self.check('NEWLINE'): self.consume()
-            if self.check('DEDENT'): break
-            body.append(self.parse_statement())
-        self.consume('DEDENT')
-        return FileWatcher(path, body)
-    def _parse_natural_list(self) -> ListVal:
-        self.consume('ID') 
-        self.consume('LIST')
-        self.consume('OF')
-        elements = []
-        if not self.check('NEWLINE') and not self.check('EOF'):
-            elements.append(self.parse_expression())
-            while self.check('COMMA'):
-                self.consume('COMMA')
-                if self.check('NEWLINE'): break 
-                elements.append(self.parse_expression())
-        node = ListVal(elements)
-        return node
-    def _parse_natural_set(self) -> Node:
-        self.consume('ID') 
-        self.consume('UNIQUE')
-        self.consume('SET')
-        self.consume('OF')
-        elements = []
-        if not self.check('NEWLINE') and not self.check('EOF'):
-            elements.append(self.parse_expression())
-            while self.check('COMMA'):
-                self.consume('COMMA')
-                if self.check('NEWLINE'): break
-                elements.append(self.parse_expression())
-        list_node = ListVal(elements)
-        return Call('Set', [list_node])
-    def parse_wait(self) -> Node:
-        token = self.consume('WAIT')
-        if self.check('FOR'):
-            self.consume('FOR')
-        time_expr = self.parse_expression()
-        if self.check('SECOND'):
-            self.consume()
-        self.consume('NEWLINE')
-        return Call('wait', [time_expr])
-    def parse_stop(self) -> Stop:
-        token = self.consume('STOP')
-        self.consume('NEWLINE')
-        node = Stop()
-        node.line = token.line
-        return node
-    def parse_skip(self) -> Skip:
-        token = self.consume('SKIP')
-        self.consume('NEWLINE')
-        node = Skip()
-        node.line = token.line
-        return node
-    def parse_error(self) -> Throw:
-        token = self.consume('ERROR')
-        message = self.parse_expression()
-        self.consume('NEWLINE')
-        node = Throw(message)
-        node.line = token.line
-        return node
-    def parse_execute(self) -> Execute:
-        token = self.consume('EXECUTE')
-        code = self.parse_expression()
-        self.consume('NEWLINE')
-        node = Execute(code)
-        node.line = token.line
-        return node
-    def parse_unless(self) -> Unless:
-        token = self.consume('UNLESS')
-        condition = self.parse_expression()
-        self.consume('NEWLINE')
-        self.consume('INDENT')
-        body = []
-        while not self.check('DEDENT') and not self.check('EOF'):
-            while self.check('NEWLINE'): self.consume()
-            if self.check('DEDENT'): break
-            body.append(self.parse_statement())
-        self.consume('DEDENT')
-        else_body = None
-        if self.check('ELSE'):
-            self.consume('ELSE')
-            self.consume('NEWLINE')
-            self.consume('INDENT')
-            else_body = []
-            while not self.check('DEDENT') and not self.check('EOF'):
-                while self.check('NEWLINE'): self.consume()
-                if self.check('DEDENT'): break
-                else_body.append(self.parse_statement())
-            self.consume('DEDENT')
-        node = Unless(condition, body, else_body)
-        node.line = token.line
-        return node
-    def parse_until(self) -> Until:
-        token = self.consume('UNTIL')
-        condition = self.parse_expression()
-        self.consume('NEWLINE')
-        self.consume('INDENT')
-        body = []
-        while not self.check('DEDENT') and not self.check('EOF'):
-            while self.check('NEWLINE'): self.consume()
-            if self.check('DEDENT'): break
-            body.append(self.parse_statement())
-        self.consume('DEDENT')
-        node = Until(condition, body)
-        node.line = token.line
-        return node
-    def parse_forever(self) -> Forever:
-        token = self.consume('FOREVER')
-        self.consume('NEWLINE')
-        self.consume('INDENT')
-        body = []
-        while not self.check('DEDENT') and not self.check('EOF'):
-            while self.check('NEWLINE'): self.consume()
-            if self.check('DEDENT'): break
-            body.append(self.parse_statement())
-        self.consume('DEDENT')
-        node = Forever(body)
-        node.line = token.line
-        return node
-    def parse_exit(self) -> Exit:
-        token = self.consume('EXIT')
-        code = None
-        if not self.check('NEWLINE'):
-            code = self.parse_expression()
-        self.consume('NEWLINE')
-        node = Exit(code)
-        node.line = token.line
-        return node
-    def parse_make(self) -> Node:
-        node = self.parse_make_expr()
-        self.consume('NEWLINE')
-        return node
-
-    def parse_make_expr(self) -> Node:
-        token = self.consume('MAKE')
-        class_name = self.consume('ID').value
-        
-        if self.check('BE'):
-            self.consume('BE')
-            value = self.parse_expression()
-            node = Assign(class_name, value) # class_name is actually variable name here
-            node.line = token.line
-            return node
-
-        args = []
-        if self.check('LPAREN'):
-            self.consume('LPAREN')
-            if not self.check('RPAREN'):
-                args.append(self.parse_expression())
-                while self.check('COMMA'):
-                    self.consume('COMMA')
-                    args.append(self.parse_expression())
-            self.consume('RPAREN')
-        else:
-            while not self.check('NEWLINE') and not self.check('EOF'):
-                args.append(self.parse_expression())
-        node = Make(class_name, args)
-        node.line = token.line
-        return node
-        return node
-    def parse_db_op(self) -> DatabaseOp:
-        token = self.consume('DB')
-        op = 'open' 
-        if self.check('OPEN'): op = 'open'; self.consume()
-        elif self.check('QUERY'): op = 'query'; self.consume()
-        elif self.check('EXEC'): op = 'exec'; self.consume()
-        elif self.check('CLOSE'): op = 'close'; self.consume()
-        else:
-             if self.check('STRING'):
-                 op = 'open'
-             else:
-                 raise SyntaxError(f"Unknown db operation at line {token.line}")
-        args = []
-        if op != 'close' and not self.check('NEWLINE'):
-             args.append(self.parse_expression())
-             while not self.check('NEWLINE'):
-                 args.append(self.parse_expression())
-        node = DatabaseOp(op, args)
-        node.line = token.line
-        return node
-    def parse_middleware(self) -> Node:
-        token = self.consume('BEFORE')
-        self.consume('REQUEST')
-        self.consume('NEWLINE')
-        self.consume('INDENT')
-        body = []
-        while not self.check('DEDENT') and not self.check('EOF'):
-            while self.check('NEWLINE'): self.consume()
-            if self.check('DEDENT'): break
-            body.append(self.parse_statement())
-        self.consume('DEDENT')
-        return OnRequest(String('__middleware__'), body)
-    def parse_when(self) -> Node:
-        token = self.consume('WHEN')
-        if self.check('SOMEONE'):
-            self.consume('SOMEONE')
-            if self.check('VISITS'):
-                self.consume('VISITS')
-                path = String(self.consume('STRING').value)
-                self.consume('NEWLINE')
-                self.consume('INDENT')
-                body = []
-                while not self.check('DEDENT') and not self.check('EOF'):
-                    while self.check('NEWLINE'): self.consume()
-                    if self.check('DEDENT'): break
-                    body.append(self.parse_statement())
-                self.consume('DEDENT')
-                node = OnRequest(path, body)
-                node.line = token.line
-                return node
-            elif self.check('SUBMITS'):
-                self.consume('SUBMITS')
-                if self.check('TO'):
-                    self.consume('TO')
-                path = String(self.consume('STRING').value)
-                self.consume('NEWLINE')
-                self.consume('INDENT')
-                body = []
-                while not self.check('DEDENT') and not self.check('EOF'):
-                    while self.check('NEWLINE'): self.consume()
-                    if self.check('DEDENT'): break
-                    body.append(self.parse_statement())
-                self.consume('DEDENT')
-                node = OnRequest(path, body)
-                node.line = token.line
-                return node
-        condition_or_value = self.parse_expression()
-        self.consume('NEWLINE')
-        self.consume('INDENT')
-        if self.check('IS'):
-            cases = []
-            otherwise = None
-            while not self.check('DEDENT') and not self.check('EOF'):
-                if self.check('IS'):
-                    self.consume('IS')
-                    match_val = self.parse_expression()
-                    self.consume('NEWLINE')
-                    self.consume('INDENT')
-                    case_body = []
-                    while not self.check('DEDENT') and not self.check('EOF'):
-                        while self.check('NEWLINE'): self.consume()
-                        if self.check('DEDENT'): break
-                        case_body.append(self.parse_statement())
-                    self.consume('DEDENT')
-                    cases.append((match_val, case_body))
-                elif self.check('OTHERWISE'):
-                    self.consume('OTHERWISE')
-                    self.consume('NEWLINE')
-                    self.consume('INDENT')
-                    otherwise = []
-                    while not self.check('DEDENT') and not self.check('EOF'):
-                        while self.check('NEWLINE'): self.consume()
-                        if self.check('DEDENT'): break
-                        otherwise.append(self.parse_statement())
-                    self.consume('DEDENT')
-                elif self.check('NEWLINE'):
-                    self.consume('NEWLINE')
-                else:
-                    break
-            self.consume('DEDENT')
-            node = When(condition_or_value, cases, otherwise)
-            node.line = token.line
-            return node
-        else:
-            body = []
-            while not self.check('DEDENT') and not self.check('EOF'):
-                while self.check('NEWLINE'): self.consume()
-                if self.check('DEDENT'): break
-                body.append(self.parse_statement())
-            self.consume('DEDENT')
-            else_body = None
-            if self.check('ELSE'):
-                self.consume('ELSE')
-                self.consume('NEWLINE')
-                self.consume('INDENT')
-                else_body = []
-                while not self.check('DEDENT') and not self.check('EOF'):
-                    while self.check('NEWLINE'): self.consume()
-                    if self.check('DEDENT'): break
-                    else_body.append(self.parse_statement())
-                self.consume('DEDENT')
-            node = If(condition_or_value, body, else_body)
-            node.line = token.line
-            return node
-    def parse_return(self) -> Return:
-        token = self.consume('RETURN')
-        expr = self.parse_expression()
-        self.consume('NEWLINE')
-        node = Return(expr)
-        node.line = token.line
-        return node
-    def parse_function_def(self) -> FunctionDef:
-        start_token = None
-        if self.check('DEFINE'):
-            start_token = self.consume('DEFINE')
-            self.consume('FUNCTION')
-        else:
-            start_token = self.consume('TO') # Fallback to existing 'TO' if not 'DEFINE'
-            
-        name = self.consume('ID').value
-        args = []
-        while self.check('ID'):
-            arg_name = self.consume('ID').value
-            type_hint = None
-            if self.check('COLON'):
-                if self.peek(1).type == 'NEWLINE':
-                    pass 
-                else:
-                    self.consume('COLON')
-                    if self.check('ID'):
-                        type_hint = self.consume('ID').value
-                    elif self.check('STRING'): 
-                        type_hint = "str"
-                        self.consume()
-                    else: 
-                         type_hint = self.consume().value 
-            default_val = None
-            if self.check('ASSIGN'):
-                self.consume('ASSIGN')
-                default_val = self.parse_expression()
-            args.append((arg_name, default_val, type_hint))
-        if self.check('DOING'): self.consume('DOING')
-        if self.check('COLON'):
-            self.consume('COLON')
-        self.consume('NEWLINE')
-        self.consume('INDENT')
-        body = []
-        while not self.check('DEDENT') and not self.check('EOF'):
-            while self.check('NEWLINE'): self.consume()
-            if self.check('DEDENT'): break
-            body.append(self.parse_statement())
-        self.consume('DEDENT')
-        node = FunctionDef(name, args, body)
-        node.line = start_token.line
-        return node
-    def parse_class_def(self) -> ClassDef:
-        start_token = self.consume('STRUCTURE')
-        name = self.consume('ID').value
-        parent = None
-        if self.check('EXTENDS'):
-            self.consume('EXTENDS')
-            parent = self.consume('ID').value
-        elif self.check('LPAREN'):
-            self.consume('LPAREN')
-            parent = self.consume('ID').value
-            self.consume('RPAREN')
-        self.consume('NEWLINE')
-        self.consume('INDENT')
-        properties = []
-        methods = []
-        while not self.check('DEDENT') and not self.check('EOF'):
-            if self.check('HAS'):
-                self.consume()
-                prop_name = None
-                if self.check('MAKE'):
-                    prop_name = self.consume().value
-                else:
-                    prop_name = self.consume('ID').value
-                
-                default_val = None
-                if self.check('ASSIGN'):
-                    self.consume('ASSIGN')
-                    default_val = self.parse_expression()
-                
-                properties.append((prop_name, default_val))
-                self.consume('NEWLINE')
-            elif self.check('TO'):
-                methods.append(self.parse_function_def())
-            elif self.check('ID'):
-                prop_name = self.consume('ID').value
-                default_val = None
-                if self.check('ASSIGN'):
-                    self.consume('ASSIGN')
-                    default_val = self.parse_expression()
-                properties.append((prop_name, default_val))
-                self.consume('NEWLINE')
-            elif self.check('NEWLINE'):
-                self.consume()
-            else:
-                self.consume('DEDENT') 
-                break
-        self.consume('DEDENT')
-        node = ClassDef(name, properties, methods, parent)
-        node.line = start_token.line
-        return node
-    def parse_id_start_statement(self, passed_name_token=None) -> Node:
-        if passed_name_token:
-            name_token = passed_name_token
-        else:
-            name_token = self.consume('ID')
-        name = name_token.value
-        if self.check('ASSIGN'):
-            self.consume('ASSIGN')
-            value = self.parse_expression()
-            self.consume('NEWLINE')
-            node = Assign(name, value)
-            node.line = name_token.line
-            return node
-        elif self.check('PLUSEQ'):
-            self.consume('PLUSEQ')
-            value = self.parse_expression()
-            self.consume('NEWLINE')
-            node = Assign(name, BinOp(VarAccess(name), '+', value))
-            node.line = name_token.line
-            return node
-        elif self.check('MINUSEQ'):
-            self.consume('MINUSEQ')
-            value = self.parse_expression()
-            self.consume('NEWLINE')
-            node = Assign(name, BinOp(VarAccess(name), '-', value))
-            node.line = name_token.line
-            return node
-        elif self.check('MULEQ'):
-            self.consume('MULEQ')
-            value = self.parse_expression()
-            self.consume('NEWLINE')
-            node = Assign(name, BinOp(VarAccess(name), '*', value))
-            node.line = name_token.line
-            return node
-        elif self.check('DIVEQ'):
-            self.consume('DIVEQ')
-            value = self.parse_expression()
-            self.consume('NEWLINE')
-            node = Assign(name, BinOp(VarAccess(name), '/', value))
-            node.line = name_token.line
-            return node
-        elif self.check('IS'):
-            token_is = self.consume('IS')
-            if self.check('ID') and self.peek().value == 'a':
-                self.consume()
-            if self.check('LIST'):
-                self.consume('LIST')
-                self.consume('NEWLINE')
-                node = Assign(name, ListVal([]))
-                node.line = token_is.line
-                return node
-            if self.check('ID') and self.peek().value in ('dictionary', 'map', 'dict'):
-                self.consume()
-                self.consume('NEWLINE')
-                node = Assign(name, Dictionary([]))
-                node.line = token_is.line
-                return node
-            if self.check('ID') and not self.peek().value in ('{', '['): 
-                class_name = self.consume('ID').value
-                args = []
-                while not self.check('NEWLINE') and not self.check('EOF'):
-                    args.append(self.parse_expression()) 
-                self.consume('NEWLINE')
-                node = Instantiation(name, class_name, args)
-                node.line = token_is.line
-                return node
-            else:
-                value = self.parse_expression()
-                self.consume('NEWLINE')
-                node = Assign(name, value)
-                node.line = token_is.line
-                return node
-        elif self.check('LBRACKET'):
-             self.consume('LBRACKET')
-             index = self.parse_expression()
-             self.consume('RBRACKET')
-             self.consume('ASSIGN')
-             val = self.parse_expression()
-             self.consume('NEWLINE')
-             # Convert simple assignment to PropertyAssign-like or specific set call?
-             # interpreter.visit_IndexAccess handles get.
-             # We need a node for IndexAssign. parser snippet doesn't show one.
-             # But visit_PropertyAssign handles dict keys. 
-             # Let's map d[k] = v to PropertyAssign(d, k, v)? 
-             # No, PropertyAssign takes member name as string. Here index handles expressions.
-             # I need to check if there is a node for this. 
-             # If not, I'll return Call('set', [VarAccess(name), index, val])
-             return Call('set', [VarAccess(name), index, val])
-        elif self.check('DOT'):
-            self.consume('DOT')
-            member_token = self.consume()
-            member = member_token.value
-            if self.check('ASSIGN'):
-                self.consume('ASSIGN')
-                value = self.parse_expression()
-                self.consume('NEWLINE')
-                return PropertyAssign(name, member, value)
-            
-            args = []
-            if self.check('LPAREN'):
-                 self.consume('LPAREN')
-                 if not self.check('RPAREN'):
-                     args.append(self.parse_expression())
-                     while self.check('COMMA'):
-                         self.consume('COMMA')
-                         args.append(self.parse_expression())
-                 self.consume('RPAREN')
-                 self.consume('NEWLINE')
-                 node = MethodCall(name, member, args)
-                 node.line = name_token.line
-                 return node
-
-            while not self.check('NEWLINE') and not self.check('EOF'):
-                args.append(self.parse_expression())
-            self.consume('NEWLINE')
-            node = MethodCall(name, member, args)
-            node.line = name_token.line
-            return node
-        elif self.check('LPAREN'):
-             self.consume('LPAREN')
-             args = []
-             if not self.check('RPAREN'):
-                 args.append(self.parse_expression())
-                 while self.check('COMMA'):
-                     self.consume('COMMA')
-                     args.append(self.parse_expression())
-             self.consume('RPAREN')
-             self.consume('NEWLINE')
-             node = Call(name, args)
-             node.line = name_token.line
-             return node
-        else:
-            if not self.check('NEWLINE') and not self.check('EOF') and not self.check('EQ') and not self.check('IS'):
-                args = []
-                while not self.check('NEWLINE') and not self.check('EOF') and not self.check('IS'): 
-                     is_named_arg = False
-                     if self.peek(1).type == 'ASSIGN':
-                         t_type = self.peek().type
-                         if t_type in ('ID', 'STRUCTURE', 'TYPE', 'FOR', 'IN', 'WHILE', 'IF', 'ELSE', 'FROM', 'TO', 'STRING', 'EXTENDS', 'WITH', 'PLACEHOLDER', 'NAME', 'VALUE', 'ACTION', 'METHOD', 'HREF', 'SRC', 'CLASS', 'STYLE'):
-                             is_named_arg = True
-                     if is_named_arg:
-                         key_token = self.consume()
-                         key = key_token.value
-                         self.consume('ASSIGN')
-                         val = self.parse_expression()
-                         args.append(Dictionary([ (String(key), val) ]))
-                     else:
-                         if self.check('USING'):
-                             self.consume('USING')
-                         args.append(self.parse_expression())
-                if self.check('NEWLINE'):
-                    self.consume('NEWLINE')
-                elif self.check('INDENT'):
-                    pass
-                else:
-                    self.consume('NEWLINE')
-                body = None
-                if self.check('INDENT'):
-                    self.consume('INDENT')
-                    body = []
-                    while not self.check('DEDENT') and not self.check('EOF'):
-                        while self.check('NEWLINE'): self.consume()
-                        if self.check('DEDENT'): break
-                        body.append(self.parse_statement())
-                    self.consume('DEDENT')
-                node = Call(name, args, body)
-                node.line = name_token.line
-                return node
-                node = Call(name, args, body)
-                node.line = name_token.line
-                return node
-            if self.check('NEWLINE'):
-                self.consume('NEWLINE')
-            elif self.check('INDENT'):
-                pass
-            else:
-                 self.consume('NEWLINE')
-            if self.check('INDENT'):
-                self.consume('INDENT')
-                body = []
-                while not self.check('DEDENT') and not self.check('EOF'):
-                    while self.check('NEWLINE'): self.consume()
-                    if self.check('DEDENT'): break
-                    body.append(self.parse_statement())
-                self.consume('DEDENT')
-                node = Call(name, [], body)
-                node.line = name_token.line
-                return node
-            node = VarAccess(name)
-            node.line = name_token.line
-            return node
-    def parse_print(self) -> Node:
-        if self.check('PRINT'):
-            token = self.consume('PRINT')
-        else:
-            token = self.consume('SAY')
-        if self.check('PROGRESS'):
-            return self.parse_progress_loop(token)
-        style = None
-        color = None
-        if self.check('IN'):
-            self.consume('IN')
-            if self.peek().type in ('RED', 'GREEN', 'BLUE', 'YELLOW', 'CYAN', 'MAGENTA'):
-                color = self.consume().value
-        if self.check('BOLD'):
-            self.consume('BOLD')
-            style = 'bold'
-        if self.peek().type in ('RED', 'GREEN', 'BLUE', 'YELLOW', 'CYAN', 'MAGENTA'):
-            color = self.consume().value
-        expr = self.parse_expression()
-        self.consume('NEWLINE')
-        node = Print(expression=expr, style=style, color=color)
-        node.line = token.line
-        return node
-    def parse_progress_loop(self, start_token: Token) -> ProgressLoop:
-        self.consume('PROGRESS')
-        if not (self.check('FOR') or self.check('REPEAT') or self.check('LOOP')):
-             raise SyntaxError(f"Expected loop after 'show progress' on line {start_token.line}")
-        if self.check('FOR') or self.check('LOOP'):
-            loop_node = self.parse_for()
-        else:
-            loop_node = self.parse_repeat()
-        node = ProgressLoop(loop_node)
-        node.line = start_token.line
-        return node
-    def parse_serve(self) -> ServeStatic:
-        token = self.consume('SERVE')
-        if self.check('FILES'):
-            self.consume('FILES')
-            if self.check('FROM'):
-                self.consume('FROM')
-            folder = self.parse_expression()
-            url = String('/static')
-            if self.check('AT'):
-                self.consume('AT')
-                url = self.parse_expression()
-            if self.check('FOLDER'):
-                self.consume('FOLDER')
-            self.consume('NEWLINE')
-            node = ServeStatic(folder, url)
-            node.line = token.line
-            return node
-        self.consume('STATIC')
-        folder = self.parse_expression()
-        self.consume('AT')
-        url = self.parse_expression()
-        self.consume('NEWLINE')
-        node = ServeStatic(folder, url)
-        node.line = token.line
-        return node
-    def parse_listen(self) -> Listen:
-        token = self.consume('LISTEN')
-        if self.check('ON'): self.consume('ON')
-        if self.check('PORT'): self.consume('PORT')
-        port_num = self.parse_expression()
-        self.consume('NEWLINE')
-        node = Listen(port_num)
-        node.line = token.line
-        return node
-    def parse_every(self) -> Every:
-        token = self.consume('EVERY')
-        interval = self.parse_expression()
-        unit = 'seconds'
-        if self.check('MINUTE'): 
-            self.consume()
-            unit = 'minutes'
-        elif self.check('SECOND'):
-            self.consume()
-            unit = 'seconds'
-        self.consume('NEWLINE')
-        self.consume('INDENT')
-        body = []
-        while not self.check('DEDENT') and not self.check('EOF'):
-            while self.check('NEWLINE'): self.consume()
-            if self.check('DEDENT'): break
-            body.append(self.parse_statement())
-        self.consume('DEDENT')
-        node = Every(interval, unit, body)
-        node.line = token.line
-        return node
-    def parse_after(self) -> After:
-        token = self.consume('IN')
-        delay = self.parse_expression()
-        unit = 'seconds'
-        if self.check('MINUTE'):
-            self.consume()
-            unit = 'minutes'
-        elif self.check('SECOND'):
-            self.consume()
-            unit = 'seconds'
-        self.consume('NEWLINE')
-        self.consume('INDENT')
-        body = []
-        while not self.check('DEDENT') and not self.check('EOF'):
-            while self.check('NEWLINE'): self.consume()
-            if self.check('DEDENT'): break
-            body.append(self.parse_statement())
-        self.consume('DEDENT')
-        node = After(delay, unit, body)
-        node.line = token.line
-        return node
-    def parse_define_page(self) -> Node:
-        token = self.consume('DEFINE')
-        if self.check('PAGE'):
-            self.consume('PAGE')
-        name = self.consume('ID').value
-        args = []
-        if self.check('USING'):
-            self.consume('USING')
-            args.append((self.consume('ID').value, None, None))
-            while self.check('COMMA'):
-                self.consume('COMMA')
-                args.append((self.consume('ID').value, None, None))
-        self.consume('NEWLINE')
-        self.consume('INDENT')
-        body = []
-        while not self.check('DEDENT') and not self.check('EOF'):
-            while self.check('NEWLINE'): self.consume()
-            if self.check('DEDENT'): break
-            body.append(self.parse_statement())
-        self.consume('DEDENT')
-        node = FunctionDef(name, args, body)
-        node.line = token.line
-        return node
-    def parse_add_to(self) -> Node:
-        token = self.consume('ADD')
-        item_expr = self.parse_factor_simple()
-        if self.check('TO') or self.check('INTO'):
-            self.consume()
-        list_name = self.consume('ID').value
-        self.consume('NEWLINE')
-        list_access = VarAccess(list_name)
-        item_list = ListVal([item_expr])
-        concat = BinOp(list_access, '+', item_list)
-        node = Assign(list_name, concat)
-        node.line = token.line
-        return node
-    def parse_start_server(self) -> Node:
-        token = self.consume('START')
-        if self.check('SERVER'):
-            self.consume('SERVER')
-        port = Number(8080)
-        if self.check('ON'):
-            self.consume('ON')
-            if self.check('PORT'):
-                self.consume('PORT')
-            port = self.parse_expression()
-        self.consume('NEWLINE')
-        node = Listen(port)
-        node.line = token.line
-        return node
-    def parse_heading(self) -> Node:
-        token = self.consume('HEADING')
-        text = self.parse_expression()
-        self.consume('NEWLINE')
-        node = Call('h1', [text])
-        node.line = token.line
-        return node
-    def parse_paragraph(self) -> Node:
-        token = self.consume('PARAGRAPH')
-        text = self.parse_expression()
-        self.consume('NEWLINE')
-        node = Call('p', [text])
-        node.line = token.line
-        return node
-    def parse_assign(self) -> Assign:
-        name = self.consume('ID').value
-        self.consume('ASSIGN')
-        value = self.parse_expression()
-        self.consume('NEWLINE')
-        return Assign(name, value)
-    def parse_import(self) -> Node:
-        token = self.consume('USE')
-        
-        # Check for Python Import: use python "numpy" as np
-        if self.check('ID') and self.peek().value == 'python':
-             self.consume('ID') # consume 'python'
-             if self.check('STRING'):
-                 module_name = self.consume('STRING').value
-                 alias = None
-                 if self.check('AS'):
-                     self.consume('AS')
-                     alias = self.consume('ID').value
-                 self.consume('NEWLINE')
-                 node = PythonImport(module_name, alias)
-                 node.line = token.line
-                 return node
-             else:
-                 raise SyntaxError(f"Expected module name string after 'use python' at line {token.line}")
-
-        if self.check('STRING'):
-            path = self.consume('STRING').value
-        else:
-             path = self.consume('ID').value
-        if self.check('AS'):
-            self.consume('AS')
-            alias = self.consume('ID').value
-            self.consume('NEWLINE')
-            node = ImportAs(path, alias)
-        else:
-            self.consume('NEWLINE')
-            node = Import(path)
-        node.line = token.line
-        return node
-    def parse_if(self) -> If:
-        self.consume('IF')
-        condition = self.parse_expression()
-        if self.check('COLON'): self.consume('COLON')
-        self.consume('NEWLINE')
-        self.consume('INDENT')
-        body = []
-        while not self.check('DEDENT') and not self.check('EOF'):
-            while self.check('NEWLINE'): self.consume()
-            if self.check('DEDENT'): break
-            body.append(self.parse_statement())
-        self.consume('DEDENT')
-        else_body = None
-        if self.check('ELIF'):
-            else_body = [self.parse_elif()]
-        elif self.check('ELSE') or self.check('OTHERWISE'):
-            if self.check('ELSE'): self.consume('ELSE')
-            else: self.consume('OTHERWISE')
-            
-            if self.check('COLON'): self.consume('COLON')
-            self.consume('NEWLINE')
-            self.consume('INDENT')
-            else_body = []
-            while not self.check('DEDENT') and not self.check('EOF'):
-                while self.check('NEWLINE'): self.consume()
-                if self.check('DEDENT'): break
-                else_body.append(self.parse_statement())
-            self.consume('DEDENT')
-        return If(condition, body, else_body)
-
-    def parse_elif(self) -> If:
-        token = self.consume('ELIF')
-        condition = self.parse_expression()
-        if self.check('COLON'): self.consume('COLON')
-        self.consume('NEWLINE')
-        self.consume('INDENT')
-        body = []
-        while not self.check('DEDENT') and not self.check('EOF'):
-            while self.check('NEWLINE'): self.consume()
-            if self.check('DEDENT'): break
-            body.append(self.parse_statement())
-        self.consume('DEDENT')
-        else_body = None
-        if self.check('ELIF'):
-            else_body = [self.parse_elif()]
-        elif self.check('ELSE'):
-            self.consume('ELSE')
-            if self.check('COLON'): self.consume('COLON')
-            self.consume('NEWLINE')
-            self.consume('INDENT')
-            else_body = []
-            while not self.check('DEDENT') and not self.check('EOF'):
-                while self.check('NEWLINE'): self.consume()
-                if self.check('DEDENT'): break
-                else_body.append(self.parse_statement())
-            self.consume('DEDENT')
-        return If(condition, body, else_body)
-
-    def parse_while(self) -> While:
-        start_token = self.consume('WHILE')
-        condition = self.parse_expression()
-        if self.check('COLON'): self.consume('COLON')
-        self.consume('NEWLINE')
-        self.consume('INDENT')
-        body = []
-        while not self.check('DEDENT') and not self.check('EOF'):
-            while self.check('NEWLINE'): self.consume()
-            if self.check('DEDENT'): break
-            body.append(self.parse_statement())
-        self.consume('DEDENT')
-        node = While(condition, body)
-        node.line = start_token.line
-        return node
-    
-    def parse_repeat(self) -> Repeat:
-        start_token = self.consume('REPEAT')
-        count = self.parse_expression()
-        self.consume('TIMES')
-        if self.check('COLON'): self.consume('COLON')
-        self.consume('NEWLINE')
-        self.consume('INDENT')
-        body = []
-        while not self.check('DEDENT') and not self.check('EOF'):
-            while self.check('NEWLINE'): self.consume()
-            if self.check('DEDENT'): break
-            body.append(self.parse_statement())
-        self.consume('DEDENT')
-        node = Repeat(count, body)
-        node.line = start_token.line
-        return node
-    
-    def parse_try(self) -> Try:
-        start_token = self.consume('TRY')
-        if self.check('COLON'):
-            self.consume('COLON')
-        self.consume('NEWLINE')
-        self.consume('INDENT')
-        try_body = []
-        while not self.check('DEDENT') and not self.check('EOF'):
-            while self.check('NEWLINE'): self.consume()
-            if self.check('DEDENT'): break
-            try_body.append(self.parse_statement())
-        self.consume('DEDENT')
-        self.consume('CATCH')
-        catch_var = self.consume('ID').value
-        if self.check('COLON'):
-            self.consume('COLON')
-        self.consume('NEWLINE')
-        self.consume('INDENT')
-        catch_body = []
-        while not self.check('DEDENT') and not self.check('EOF'):
-            while self.check('NEWLINE'): self.consume()
-            if self.check('DEDENT'): break
-            catch_body.append(self.parse_statement())
-        self.consume('DEDENT')
-        always_body = []
-        if self.check('ALWAYS'):
-            self.consume('ALWAYS')
-            self.consume('NEWLINE')
-            self.consume('INDENT')
-            while not self.check('DEDENT') and not self.check('EOF'):
-                while self.check('NEWLINE'): self.consume()
-                if self.check('DEDENT'): break
-                always_body.append(self.parse_statement())
-            self.consume('DEDENT')
-        if always_body:
-            node = TryAlways(try_body, catch_var, catch_body, always_body)
-        else:
-            node = Try(try_body, catch_var, catch_body)
-        node.line = start_token.line
-        return node
-    def parse_list(self) -> Node:
-        token = self.consume('LBRACKET')
-        def skip_formatted():
-            while self.check('NEWLINE') or self.check('INDENT') or self.check('DEDENT'):
-                self.consume()
-        skip_formatted()
-        if self.check('RBRACKET'):
-            self.consume('RBRACKET')
-            node = ListVal([])
-            node.line = token.line
-            return node
-        if self.check('DOTDOTDOT'):
-             node = self._parse_list_with_spread(token)
-             skip_formatted()
-             return node
-        first_expr = self.parse_expression()
-        skip_formatted()
-        
-        if self.check('TO'):
-            self.consume('TO')
-            end_val = self.parse_expression()
-            skip_formatted()
-            self.consume('RBRACKET')
-            node = Call('range', [first_expr, end_val])
-            node.line = token.line
-            return node
-
-        if self.check('FOR'):
-            self.consume('FOR')
-            var_name = self.consume('ID').value
-            self.consume('IN')
-            iterable = self.parse_expression()
-            condition = None
-            if self.check('IF'):
-                self.consume('IF')
-                condition = self.parse_expression()
-            self.consume('RBRACKET')
-            node = ListComprehension(first_expr, var_name, iterable, condition)
-            node.line = token.line
-            return node
-        elements = [first_expr]
-        while self.check('COMMA'):
-            self.consume('COMMA')
-            skip_formatted()
-            if self.check('RBRACKET'):
-                break  
-            if self.check('DOTDOTDOT'):
-                self.consume('DOTDOTDOT')
-                spread_val = self.parse_expression()
-                spread_node = Spread(spread_val)
-                spread_node.line = token.line
-                elements.append(spread_node)
-            else:
-                elements.append(self.parse_expression())
-            skip_formatted()
-        skip_formatted()
-        self.consume('RBRACKET')
-        node = ListVal(elements)
-        node.line = token.line
-        return node
-    def _parse_list_with_spread(self, token: Token) -> ListVal:
-        elements = []
-        self.consume('DOTDOTDOT')
-        spread_val = self.parse_expression()
-        spread_node = Spread(spread_val)
-        spread_node.line = token.line
-        elements.append(spread_node)
-        while self.check('COMMA'):
-            self.consume('COMMA')
-            if self.check('RBRACKET'):
-                break
-            if self.check('DOTDOTDOT'):
-                self.consume('DOTDOTDOT')
-                spread_val = self.parse_expression()
-                spread_node = Spread(spread_val)
-                spread_node.line = token.line
-                elements.append(spread_node)
-            else:
-                elements.append(self.parse_expression())
-        self.consume('RBRACKET')
-        node = ListVal(elements)
-        node.line = token.line
-        return node
-    def parse_dict(self) -> Dictionary:
-        token = self.consume('LBRACE')
-        def skip_formatted():
-            while self.check('NEWLINE') or self.check('INDENT') or self.check('DEDENT'):
-                self.consume()
-        skip_formatted()
-        pairs = []
-        if not self.check('RBRACE'):
-            if self.check('ID') and self.peek(1).type == 'COLON':
-                key_token = self.consume('ID')
-                key = String(key_token.value)
-                key.line = key_token.line
-            else:
-                key = self.parse_expression()
-            self.consume('COLON')
-            skip_formatted()
-            value = self.parse_expression()
-            pairs.append((key, value))
-            skip_formatted()
-            while self.check('COMMA'):
-                self.consume('COMMA')
-                skip_formatted()
-                if self.check('RBRACE'): break
-                if self.check('ID') and self.peek(1).type == 'COLON':
-                    key_token = self.consume('ID')
-                    key = String(key_token.value)
-                    key.line = key_token.line
-                else:
-                    key = self.parse_expression()
-                self.consume('COLON')
-                skip_formatted()
-                value = self.parse_expression()
-                pairs.append((key, value))
-                skip_formatted()
-        skip_formatted()
-        self.consume('RBRACE')
-        node = Dictionary(pairs)
-        node.line = token.line
-        return node
-    def parse_app(self) -> Node:
-        token = self.consume('APP')
-        title = self.consume('STRING').value
-        
-        width = 500
-        height = 400
-        if self.check('SIZE'):
-            self.consume('SIZE')
-            width = int(self.consume('NUMBER').value)
-            height = int(self.consume('NUMBER').value)
-        
-        self.consume('COLON')
-        self.consume('NEWLINE')
-        self.consume('INDENT')
-        
-        body = []
-        while not self.check('DEDENT'):
-            body.append(self.parse_ui_block())
-            if self.check('NEWLINE'):
-                self.consume('NEWLINE')
-        
-        self.consume('DEDENT')
-        return App(title, width, height, body)
-
-    def parse_ui_block(self) -> Node:
-        token = self.peek()
-        
-        if token.type in ('COLUMN', 'ROW'):
-            layout_type = self.consume().value # column or row
-            self.consume('COLON')
-            self.consume('NEWLINE')
-            self.consume('INDENT')
-            children = []
-            while not self.check('DEDENT'):
-               children.append(self.parse_ui_block())
-               if self.check('NEWLINE'): self.consume('NEWLINE')
-            self.consume('DEDENT')
-            return Layout(layout_type, children)
-            
-        elif (token.type in ('BUTTON', 'INPUT', 'HEADING') or 
-              (token.type == 'ID' and token.value == 'text')):
-            if token.type == 'ID' and token.value == 'text':
-                widget_type = 'TEXT'
-                self.consume() # consume 'text' ID
-            else:
-                widget_type = self.consume().value
-            label = self.consume('STRING').value
-            
-            var_name = None
-            if self.check('AS'):
-                self.consume('AS')
-                var_name = self.consume('ID').value
-                
-            event_handler = None
-            if token.type == 'BUTTON' and self.check('DO'):
-                self.consume('DO')
-                self.consume('COLON')
-                self.consume('NEWLINE')
-                self.consume('INDENT')
-                event_handler = []
-                while not self.check('DEDENT'):
-                    event_handler.append(self.parse_statement())
-                self.consume('DEDENT')
-            
-            return Widget(widget_type, label, var_name, event_handler)
-            
-        else:
-            raise SyntaxError(f"Unexpected token in UI block: {token.type} at line {token.line}")
-
-    def parse_factor_simple(self) -> Node:
-        token = self.peek()
-        if token.type == 'ASK':
-            self.consume('ASK')
-            prompt = self.parse_expression()
-            node = Call('input', [prompt]) # Alias to input
-            node.line = token.line
-            return node
-        elif token.type == 'NUMBER':
-            self.consume()
-            val = token.value
-            if '.' in val:
-                node = Number(float(val))
-            else:
-                node = Number(int(val))
-            node.line = token.line
-            return node
-        elif token.type == 'STRING':
-            self.consume()
-            val = token.value
-            if '{' in val and '}' in val:
-                parts = re.split(r'\{([^}]+)\}', val)
-                if len(parts) == 1:
-                     node = String(val)
-                     node.line = token.line
-                     return node
-                current_node = None
-                for i, part in enumerate(parts):
-                    if i % 2 == 0:
-                        if not part: continue 
-                        expr = String(part)
-                        expr.line = token.line
-                    else:
-                        snippet = part.strip()
-                        if snippet:
-                            sub_lexer = Lexer(snippet)
-                            sub_tokens = sub_lexer.tokenize() 
-                            sub_parser = Parser(sub_tokens)
-                            try:
-                                expr = sub_parser.parse_expression()
-                                expr.line = token.line
-                            except Exception as e:
-                                raise SyntaxError(f"Invalid interpolation expression: '{snippet}' on line {token.line}")
-                        else:
-                            continue
-                    if current_node is None:
-                        current_node = expr
-                    else:
-                        current_node = BinOp(current_node, '+', expr)
-                        current_node.line = token.line
-                return current_node if current_node else String("")
-            node = String(token.value)
-            node.line = token.line
-            return node
-        elif token.type == 'YES':
-            self.consume()
-            node = Boolean(True)
-            node.line = token.line
-            return node
-        elif token.type == 'NO':
-            self.consume()
-            node = Boolean(False)
-            node.line = token.line
-            return node
-        elif token.type == 'LBRACKET':
-            return self.parse_list()
-        elif token.type == 'LBRACE':
-            return self.parse_dict()
-        elif token.type == 'ID':
-            self.consume()
-            if self.check('DOT'):
-                self.consume('DOT')
-                prop_token = self.consume()
-                prop = prop_token.value
-                node = PropertyAccess(token.value, prop)
-                node.line = token.line
-                return node
-            node = VarAccess(token.value)
-            node.line = token.line
-            return node
-        elif token.type == 'LPAREN':
-            self.consume()
-            expr = self.parse_expression()
-            self.consume('RPAREN')
-            return expr
-        elif token.type == 'INPUT':
-            is_tag = False
-            next_t = self.peek(1)
-            if next_t.type in ('ID', 'TYPE', 'STRING', 'NAME', 'VALUE', 'CLASS', 'STYLE', 'ONCLICK', 'SRC', 'HREF', 'ACTION', 'METHOD'):
-                is_tag = True
-            if is_tag:
-                 return self.parse_id_start_statement(passed_name_token=token)
-            self.consume()
-            prompt = None
-            if self.check('STRING'):
-                prompt = self.consume('STRING').value
-            node = Input(prompt)
-            node.line = token.line
-            return node
-        raise SyntaxError(f"Unexpected argument token {token.type} at line {token.line}")
-    def parse_factor(self) -> Node:
-        token = self.peek()
-        if token.type == 'MINUS':
-            op = self.consume()
-            right = self.parse_factor()
-            node = UnaryOp('-', right)
-            node.line = op.line
-            return node
-        elif token.type == 'NOT':
-             op = self.consume()
-             right = self.parse_factor()
-             node = UnaryOp('not', right)
-             node.line = op.line
-             return node
-        elif token.type == 'ASK':
-             return self.parse_factor_simple()
-        elif token.type == 'LPAREN':
-             self.consume('LPAREN')
-             node = self.parse_expression()
-             self.consume('RPAREN')
-             return node
-        elif token.type == 'DB':
-            return self.parse_db_op()
-        elif token.type == 'SPAWN':
-            op = self.consume()
-            right = self.parse_factor()
-            node = Spawn(right)
-            node.line = op.line
-            return node
-        elif token.type == 'EXECUTE':
-            op = self.consume()
-            right = self.parse_expression()
-            node = Call('run', [right])
-            node.line = op.line
-            return node
-        elif token.type == 'COUNT' or token.type == 'HOW':
-            token = self.consume()
-            if token.type == 'HOW':
-                self.consume('MANY')
-            if self.check('OF'):
-                self.consume('OF')
-            expr = self.parse_expression()
-            node = Call('len', [expr])
-            node.line = token.line
-            return node
-        elif token.type == 'AWAIT':
-            op = self.consume()
-            right = self.parse_factor()
-            node = Await(right)
-            node.line = op.line
-            return node
-        elif token.type == 'CONVERT':
-            return self.parse_convert()
-        elif token.type == 'LOAD' and self.peek(1).type == 'CSV':
-             self.consume('LOAD')
-             self.consume('CSV')
-             path = self.parse_factor() 
-             node = CsvOp('load', None, path)
-             node.line = token.line
-             return node
-        elif token.type == 'PASTE':
-             token = self.consume('PASTE')
-             self.consume('FROM')
-             self.consume('CLIPBOARD')
-             node = ClipboardOp('paste', None)
-             node.line = token.line
-             return node
-        elif token.type == 'READ':
-             token = self.consume('READ')
-             if self.check('FILE'):
-                 self.consume('FILE')
-             path = self.parse_factor()
-             node = FileRead(path)
-             node.line = token.line
-             return node
-        elif token.type == 'SUM':
-            return self.parse_sum()
-        elif token.type == 'UPPER':
-            return self.parse_upper()
-        elif token.type == 'DATE':
-             token = self.consume('DATE')
-             s = self.consume('STRING').value
-             node = DateOp(s)
-             node.line = token.line
-             return node
-        elif token.type == 'TODAY':
-             token = self.consume('TODAY')
-             node = DateOp('today')
-             node.line = token.line
-             return node
-        if token.type == 'NUMBER':
-            self.consume()
-            val = token.value
-            if '.' in val:
-                node = Number(float(val))
-            else:
-                node = Number(int(val))
-            node.line = token.line
-            return node
-        elif token.type == 'REGEX':
-            self.consume()
-            node = Regex(token.value)
-            node.line = token.line
-            return node
-        elif token.type == 'STRING':
-            return self.parse_factor_simple()
-        elif token.type == 'YES':
-            self.consume()
-            node = Boolean(True)
-            node.line = token.line
-            return node
-        elif token.type == 'NO':
-            self.consume()
-            node = Boolean(False)
-            node.line = token.line
-            return node
-        elif token.type == 'LBRACKET':
-            return self.parse_list()
-        elif token.type == 'LBRACE':
-            return self.parse_dict()
-        elif token.type == 'ID':
-            if token.value == 'a':
-                if self.peek(1).type == 'LIST' and self.peek(2).type == 'OF':
-                    return self._parse_natural_list()
-                elif self.peek(1).type == 'UNIQUE' and self.peek(2).type == 'SET' and self.peek(3).type == 'OF':
-                    return self._parse_natural_set()
-            if token.value == 'numbers' and self.peek(1).type == 'FROM':
-                return self.parse_numbers_range()
-            self.consume()
-            instance_name = token.value
-            method_name = None
-            if self.check('DOT'):
-                self.consume('DOT')
-                method_name = self.consume().value
-            
-            args = []
-            # Check for C-style function call: func(arg1, arg2)
-            if self.check('LPAREN'):
-                self.consume('LPAREN')
-                if not self.check('RPAREN'):
-                    args.append(self.parse_expression())
-                    while self.check('COMMA'):
-                        self.consume('COMMA')
-                        args.append(self.parse_expression())
-                self.consume('RPAREN')
-                if method_name:
-                    node = MethodCall(instance_name, method_name, args)
-                else:
-                    node = Call(instance_name, args)
-                node.line = token.line
-                return node
-
-            # Fallback to command-style arguments: func arg1 arg2
-            # But only if NOT a property access (method_name w/o args is property access, 
-            # but if it was method call it would use parens ideally, or spaces?)
-            # Existing logic supported 'func arg1 arg2'.
-            # We keep it for backward compatibility e.g. 'echo 123'.
-            
-            force_call = False
-            while True:
-                next_t = self.peek()
-                # If we see LPAREN now, it's ambiguous if we didn't handle it above.
-                # But 'func (1)' is func called with 1 arg which is (1).
-                # 'func (1, 2)' would fail in old logic too.
-                # So the above block handles the explicit invocation.
-                # This loop is for 'func 1 2'.
-                
-                # Check for keywords or invalid start tokens
-                if next_t.type not in ('NUMBER', 'STRING', 'REGEX', 'ID', 'LPAREN', 'INPUT', 'ASK', 'YES', 'NO', 'LBRACKET', 'LBRACE'):
-                    break
-                
-                # Special case: if we see LPAREN, is it part of command args?
-                # e.g. 'func (1+2)' -> args=[(1+2)].
-                args.append(self.parse_factor_simple())
-
-            if method_name:
-                if args:
-                    node = MethodCall(instance_name, method_name, args)
-                else:
-                    node = PropertyAccess(instance_name, method_name)
-                node.line = token.line
-                return node
-            
-            if args:
-                node = Call(instance_name, args)
-                node.line = token.line
-                return node
-
-            node = VarAccess(instance_name)
-            node.line = token.line
-            return node
-        elif token.type == 'LPAREN':
-            self.consume()
-            expr = self.parse_expression()
-            self.consume('RPAREN')
-            return expr
-        elif token.type == 'INPUT' or token.type == 'ASK':
-            next_t = self.peek(1)
-            if next_t.type in ('ID', 'TYPE', 'STRING', 'NAME', 'VALUE', 'CLASS', 'STYLE', 'ONCLICK', 'SRC', 'HREF', 'ACTION', 'METHOD'):
-                self.consume() 
-                return self.parse_id_start_statement(passed_name_token=token)
-            self.consume()
-            prompt = None
-            if self.check('STRING'):
-                prompt = self.consume('STRING').value
-            node = Input(prompt)
-            node.line = token.line
-            return node
-        elif token.type == 'PROMPT':
-            self.consume()
-            prompt_expr = self.parse_factor() 
-            node = Prompt(prompt_expr)
-            node.line = token.line
-            return node
-        elif token.type == 'CONFIRM':
-            self.consume()
-            prompt_expr = self.parse_factor()
-            node = Confirm(prompt_expr)
-            node.line = token.line
-            return node
-        elif token.type == 'MAKE':
-            return self.parse_make_expr()
-        raise SyntaxError(f"Unexpected token {token.type} at line {token.line}")
-    def parse_for(self) -> Node:
-        if self.check('LOOP'):
-            start_token = self.consume('LOOP')
-            count_expr = self.parse_expression()
-            self.consume('TIMES')
-            self.consume('NEWLINE')
-            self.consume('INDENT')
-            body = []
-            while not self.check('DEDENT') and not self.check('EOF'):
-                while self.check('NEWLINE'): self.consume()
-                if self.check('DEDENT'): break
-                body.append(self.parse_statement())
-            self.consume('DEDENT')
-            node = For(count_expr, body)
-            node.line = start_token.line
-            return node
-        start_token = self.consume('FOR')
-        if self.check('ID') and self.peek(1).type == 'IN':
-            var_name = self.consume('ID').value
-            self.consume('IN')
-            if self.check('RANGE'):
-                self.consume('RANGE')
-                start_val = self.parse_expression()
-                end_val = self.parse_expression()
-                self.consume('NEWLINE')
-                self.consume('INDENT')
-                body = []
-                while not self.check('DEDENT') and not self.check('EOF'):
-                    while self.check('NEWLINE'): self.consume()
-                    if self.check('DEDENT'): break
-                    body.append(self.parse_statement())
-                self.consume('DEDENT')
-                iterable = Call('range', [start_val, end_val])
-                node = ForIn(var_name, iterable, body)
-                node.line = start_token.line
-                return node
-            else:
-                iterable = self.parse_expression()
-                self.consume('NEWLINE')
-                self.consume('INDENT')
-                body = []
-                while not self.check('DEDENT') and not self.check('EOF'):
-                    while self.check('NEWLINE'): self.consume()
-                    if self.check('DEDENT'): break
-                    body.append(self.parse_statement())
-                self.consume('DEDENT')
-                node = ForIn(var_name, iterable, body)
-                node.line = start_token.line
-                return node
-        else:
-            count_expr = self.parse_expression()
-            self.consume('IN')
-            self.consume('RANGE')
-            if self.check('COLON'):
-                self.consume('COLON')
-            self.consume('NEWLINE')
-            self.consume('INDENT')
-            body = []
-            while not self.check('DEDENT') and not self.check('EOF'):
-                while self.check('NEWLINE'): self.consume()
-                if self.check('DEDENT'): break
-                body.append(self.parse_statement())
-            self.consume('DEDENT')
-            node = For(count_expr, body)
-            node.line = start_token.line
-            return node
-    def parse_expression_stmt(self) -> Node:
-        expr = self.parse_expression()
-        self.consume('NEWLINE')
-        node = Print(expression=expr)
-        node.line = expr.line
-        return node
-    def parse_expression(self) -> Node:
-        if self.check('FN'):
-            return self.parse_lambda()
-        return self.parse_ternary()
-    def parse_lambda(self) -> Lambda:
-        token = self.consume('FN')
-        params = []
-        while self.check('ID'):
-            params.append(self.consume('ID').value)
-        self.consume('ARROW')
-        body = self.parse_expression()
-        node = Lambda(params, body)
-        node.line = token.line
-        return node
-    def parse_ternary(self) -> Node:
-        condition = self.parse_logic_or()
-        if self.check('QUESTION'):
-            self.consume('QUESTION')
-            true_expr = self.parse_expression()
-            self.consume('COLON')
-            false_expr = self.parse_expression()
-            node = Ternary(condition, true_expr, false_expr)
-            node.line = condition.line
-            return node
-        return condition
-    def parse_logic_or(self) -> Node:
-        left = self.parse_logic_and()
-        while self.check('OR'):
-            op_token = self.consume()
-            right = self.parse_logic_and()
-            new_node = BinOp(left, op_token.value, right)
-            new_node.line = op_token.line
-            left = new_node
-        return left
-    def parse_logic_and(self) -> Node:
-        left = self.parse_comparison()
-        while self.check('AND'):
-            op_token = self.consume()
-            right = self.parse_comparison()
-            new_node = BinOp(left, op_token.value, right)
-            new_node.line = op_token.line
-            left = new_node
-        return left
-    def parse_comparison(self) -> Node:
-        left = self.parse_arithmetic()
-        if self.peek().type in ('EQ', 'NEQ', 'GT', 'LT', 'GE', 'LE', 'IS', 'MATCHES', 'GREATER', 'LESS', 'EQUAL', 'CONTAINS', 'EMPTY'):
-            op_token = self.consume()
-            op_val = op_token.value
-            
-            # Handle "is greater/less/equal"
-            if op_token.type == 'IS':
-                if self.check('GREATER'):
-                    self.consume('GREATER'); self.consume('THAN')
-                    op_val = '>'
-                elif self.check('LESS'):
-                    self.consume('LESS'); self.consume('THAN')
-                    op_val = '<'
-                elif self.check('EQUAL'):
-                    self.consume('EQUAL'); self.consume('TO')
-                    op_val = '=='
-                elif self.check('NOT'):
-                    self.consume('NOT'); self.consume('EQUAL'); self.consume('TO')
-                    op_val = '!='
-                elif self.check('EMPTY'):
-                    self.consume('EMPTY')
-                    # is empty -> Call('empty', [left])
-                    node = Call('empty', [left])
-                    node.line = op_token.line
-                    return node
-                else:
-                    op_val = '=='
-            elif op_token.type == 'CONTAINS':
-                # list contains item -> Call('contains', [list, item])
-                right = self.parse_arithmetic()
-                node = Call('contains', [left, right])
-                node.line = op_token.line
-                return node
-
-            right = self.parse_arithmetic()
-            node = BinOp(left, op_val, right)
-            node.line = op_token.line
-            return node
-        return left
-    def parse_arithmetic(self) -> Node:
-        left = self.parse_term()
-        while self.peek().type in ('PLUS', 'MINUS'):
-            op_token = self.consume()
-            op_val = op_token.value
-            # Normalize to symbols
-            if op_token.type == 'PLUS': op_val = '+'
-            if op_token.type == 'MINUS': op_val = '-'
-            
-            right = self.parse_term()
-            new_node = BinOp(left, op_val, right)
-            new_node.line = op_token.line
-            left = new_node
-        return left
-    def parse_term(self) -> Node:
-        left = self.parse_factor()
-        while self.peek().type in ('MUL', 'DIV', 'MOD', 'TIMES'):
-            # Disambiguate "repeat 3 TIMES" vs "3 TIMES 4"
-            if self.peek().type == 'TIMES':
-                next_tok = self.peek(1)
-                if next_tok.type in ('COLON', 'NEWLINE'):
-                    break
-            
-            op_token = self.consume()
-            op_val = op_token.value
-            
-            # Normalize
-            if op_token.type == 'MUL': op_val = '*'
-            if op_token.type == 'TIMES': op_val = '*'
-            if op_token.type == 'DIV': 
-                op_val = '/'
-                if self.check('BY'): self.consume('BY') # Handle "divided by"
-
-            if op_token.type == 'MOD': op_val = '%'
-
-            right = self.parse_factor()
-            new_node = BinOp(left, op_val, right)
-            new_node.line = op_token.line
-            left = new_node
-        return left
-    def parse_convert(self) -> Convert:
-        token = self.consume('CONVERT')
-        expr = self.parse_factor() 
-        self.consume('TO')
-        target_format = 'json'
-        if self.check('JSON'):
-             self.consume('JSON')
-        elif self.check('ID'):
-             target_format = self.consume('ID').value
-        node = Convert(expr, target_format)
-        node.line = token.line
-        return node
-    def parse_download(self) -> Download:
-        token = self.consume('DOWNLOAD')
-        url = self.parse_expression()
-        self.consume('NEWLINE')
-        node = Download(url)
-        node.line = token.line
-        return node
-    def parse_archive(self) -> ArchiveOp:
-        op = None
-        token = None
-        if self.check('COMPRESS'):
-            token = self.consume('COMPRESS')
-            op = 'compress'
-            if self.check('FOLDER'): self.consume('FOLDER')
-        else:
-            token = self.consume('EXTRACT')
-            op = 'extract'
-        source = self.parse_expression()
-        self.consume('TO')
-        target = self.parse_expression()
-        self.consume('NEWLINE')
-        node = ArchiveOp(op, source, target)
-        node.line = token.line
-        return node
-    def parse_csv_load(self) -> CsvOp:
-        token = self.consume('LOAD')
-        self.consume('CSV')
-        path = self.parse_expression()
-        self.consume('NEWLINE')
-        node = CsvOp('load', None, path)
-        node.line = token.line
-        return node
-    def parse_csv_save(self) -> CsvOp:
-         token = self.consume('SAVE')
-         data = self.parse_expression()
-         self.consume('TO')
-         self.consume('CSV')
-         path = self.parse_expression()
-         self.consume('NEWLINE')
-         node = CsvOp('save', data, path)
-         node.line = token.line
-         return node
-    def parse_clipboard(self) -> Node:
-        if self.check('COPY'):
-            token = self.consume('COPY')
-            content = self.parse_expression()
-            self.consume('TO')
-            self.consume('CLIPBOARD')
-            self.consume('NEWLINE')
-            node = ClipboardOp('copy', content)
-            node.line = token.line
-            return node
-        else:
-             token = self.consume('PASTE')
-             self.consume('FROM')
-             self.consume('CLIPBOARD')
-             self.consume('NEWLINE')
-             node = ClipboardOp('paste', None)
-             node.line = token.line
-             return node
-    def parse_automation(self) -> AutomationOp:
-         if self.check('PRESS'):
-             token = self.consume('PRESS')
-             keys = self.parse_expression()
-             self.consume('NEWLINE')
-             return AutomationOp('press', [keys])
-         elif self.check('TYPE'):
-             token = self.consume('TYPE')
-             text = self.parse_expression()
-             self.consume('NEWLINE')
-             return AutomationOp('type', [text])
-         elif self.check('CLICK'):
-             token = self.consume('CLICK')
-             self.consume('AT')
-             x = self.parse_expression()
-             if self.check('COMMA'): self.consume('COMMA') 
-             y = self.parse_expression()
-             self.consume('NEWLINE')
-             return AutomationOp('click', [x, y])
-         elif self.check('NOTIFY'):
-             token = self.consume('NOTIFY')
-             title = self.parse_expression()
-             msg = self.parse_expression()
-             self.consume('NEWLINE')
-             return AutomationOp('notify', [title, msg])
-    def parse_write(self) -> FileWrite:
-        token = self.consume('WRITE')
-        content = self.parse_expression()
-        self.consume('TO')
-        self.consume('FILE')
-        path = self.parse_expression()
-        self.consume('NEWLINE')
-        node = FileWrite(path, content, 'w')
-        node.line = token.line
-        return node
-    def parse_append(self) -> FileWrite:
-        token = self.consume('APPEND')
-        content = self.parse_expression()
-        self.consume('TO')
-        self.consume('FILE')
-        path = self.parse_expression()
-        self.consume('NEWLINE')
-        node = FileWrite(path, content, 'a')
-        node.line = token.line
-        return node
-
-
-    def parse_increment(self) -> Assign:
-
-        token = self.consume('INCREMENT')
-
-        name = self.consume('ID').value
-
-        amount = Number(1)
-
-        if self.check('BY'):
-
-            self.consume('BY')
-
-            amount = self.parse_expression()
-
-        self.consume('NEWLINE')
-
-        node = Assign(name, BinOp(VarAccess(name), '+', amount))
-
-        node.line = token.line
-
-        return node
-
-
-
-    def parse_decrement(self) -> Assign:
-
-        token = self.consume('DECREMENT')
-
-        name = self.consume('ID').value
-
-        amount = Number(1)
-
-        if self.check('BY'):
-
-            self.consume('BY')
-
-            amount = self.parse_expression()
-
-        self.consume('NEWLINE')
-
-        node = Assign(name, BinOp(VarAccess(name), '-', amount))
-
-        node.line = token.line
-
-        return node
-
-
-
-    def parse_multiply(self) -> Assign:
-
-        token = self.consume('MULTIPLY')
-
-        name = self.consume('ID').value
-
-        self.consume('BY')
-
-        amount = self.parse_expression()
-
-        self.consume('NEWLINE')
-
-        node = Assign(name, BinOp(VarAccess(name), '*', amount))
-
-        node.line = token.line
-
-        return node
-
-
-
-    def parse_divide(self) -> Assign:
-
-        token = self.consume('DIVIDE')
-
-        name = self.consume('ID').value
-
-        self.consume('BY')
-
-        amount = self.parse_expression()
-
-        self.consume('NEWLINE')
-
-        node = Assign(name, BinOp(VarAccess(name), '/', amount))
-
-        node.line = token.line
-
-        return node
-
-
-
-    def parse_set(self) -> Assign:
-
-        token = self.consume('SET')
-
-        name = self.consume('ID').value
-
-        self.consume('TO')
-
-        value = self.parse_expression()
-
-        self.consume('NEWLINE')
-
-        node = Assign(name, value)
-
-        node.line = token.line
-
-        return node
-
-
-
-    def parse_sum(self) -> Node:
-        token = self.consume('SUM')
-        self.consume('OF')
-        
-        # Check for 'numbers from ...' (contextual keyword 'numbers')
-        if self.check('ID') and self.peek().value == 'numbers':
-             range_node = self.parse_numbers_range()
-             # range_node is Call('range_list', ...)
-             # We want Call('sum', [range_node])
-             node = Call('sum', [range_node])
-             node.line = token.line
-             return node
-             
-        expr = self.parse_expression()
-        node = Call('sum', [expr])
-        node.line = token.line
-        return node
-
-
-
-    def parse_upper(self) -> Node:
-        token = self.consume('UPPER')
-        expr = self.parse_expression()
-        only_letters = Boolean(False)
-
-        if self.check('ID') and self.peek().value == 'only':
-            self.consume() # consume 'only'
-            if self.check('ID') and self.peek().value == 'letters':
-                self.consume() # consume 'letters'
-            only_letters = Boolean(True)
-        node = Call('upper', [expr, only_letters])
-        node.line = token.line
-        return node
-
-
-
-    def parse_numbers_range(self) -> Node:
-        # Expect 'numbers' as ID
-        token = self.peek()
-        if self.check('ID') and self.peek().value == 'numbers':
-             self.consume()
-        else:
-             # Should be 'numbers' but if called from parse_sum we assume check passed.
-             # If called from Factor loop...
-             pass 
-        
-        self.consume('FROM')
-        start = self.parse_expression()
-        self.consume('TO')
-        end = self.parse_expression()
-        
-        condition = None
-        if self.check('ID') and self.peek().value == 'that':
-            self.consume() # that
-            if self.check('ID') and self.peek().value == 'are':
-                 self.consume() # are
-            
-            if self.check('ID') and self.peek().value == 'prime':
-                self.consume() # prime
-                condition = String('prime')
-            elif self.check('ID') and self.peek().value == 'digits':
-                self.consume() # digits
-                condition = String('digits')
-                
-        elif self.check('WHEN'):
-             self.consume('WHEN')
-             # 'when even' -> check for ID 'even' or expression?
-             # User example: 'when even'. Implicit variable?
-             # Let's verify repro: 'when even'
-             if self.check('ID') and self.peek().value == 'even':
-                 self.consume()
-                 condition = String('even')
-             elif self.check('ID') and self.peek().value == 'odd':
-                 self.consume()
-                 condition = String('odd')
-             else:
-                 # TODO: handle generic expression filter if needed
-                 pass
-                 
-        node = Call('range_list', [start, end, condition if condition else Boolean(False)])
-        node.line = token.line
-        return node
-    def parse_add_to_list(self) -> Node:
-        token = self.consume('ADD')
-        item = self.parse_expression()
-        self.consume('TO')
-        list_expr = self.parse_expression()
-        self.consume('NEWLINE')
-        node = Call('append', [list_expr, item])
-        node.line = token.line
-        return node
-
-    def parse_remove_from_list(self) -> Node:
-        token = self.consume('REMOVE')
-        item = self.parse_expression()
-        self.consume('FROM')
-        list_expr = self.parse_expression()
-        self.consume('NEWLINE')
-        node = Call('remove', [list_expr, item])
-        node.line = token.line
-        return node
-        
-    def parse_wait(self) -> Node:
-        token = self.consume('WAIT')
-        value = self.parse_expression()
-        if self.check('SECOND'): self.consume('SECOND')
-        elif self.check('SECONDS'): self.consume('SECONDS') # Assuming 'SECONDS' token maps to SECOND?
-        # Actually I need to check lexer mapping for MINUTES/SECONDS.
-        # Lexer has: 'minute': 'MINUTE', 'minutes': 'MINUTE', 'second': 'SECOND', 'seconds': 'SECOND'
-        
-        elif self.check('MINUTE'): 
-            self.consume('MINUTE')
-            value = BinOp(value, '*', Number(60))
-        
-        self.consume('NEWLINE')
-        node = Call('wait', [value])
-        node.line = token.line
-        return node
-
-    def parse_add_distinguish(self) -> Node:
-        # Distinguish "ADD <expr> TO <list>" vs "ADD <component> ..."
-        tok = self.peek(1)
-        if tok.type in ('BUTTON', 'HEADING', 'PARAGRAPH', 'IMAGE', 'APP', 'PAGE', 'Use', 'INPUT', 'TEXT'):
-             return self.parse_add_to()
-        else:
-             return self.parse_add_to_list()
-
-    def parse_make_assignment(self) -> Node:
-        token = self.consume('MAKE')
-        name = self.consume('ID').value
-        if self.check('BE'): self.consume('BE')
-        value = self.parse_expression()
-        self.consume('NEWLINE')
-        node = Assign(name, value)
-        node.line = token.line
-        return node
-
-    def parse_as_long_as(self) -> While:
-        start_token = self.consume('AS')
-        self.consume('LONG')
-        self.consume('AS')
-        condition = self.parse_expression()
-        if self.check('COLON'): self.consume('COLON')
-        self.consume('NEWLINE')
-        self.consume('INDENT')
-        body = []
-        while not self.check('DEDENT') and not self.check('EOF'):
-            while self.check('NEWLINE'): self.consume()
-            if self.check('DEDENT'): break
-            body.append(self.parse_statement())
-        self.consume('DEDENT')
-        node = While(condition, body)
-        node.line = start_token.line
-        return node
-