shell-lite 0.4.2__py3-none-any.whl → 0.4.4__py3-none-any.whl

shell_lite/interpreter.py

@@ -128,7 +128,23 @@ class WebBuilder:
             pass
 class Interpreter:
     def __init__(self):
+        print('DEBUG: ShellLite v0.04.4')
         self.global_env = Environment()
+        self.global_env.set('str', str)
+        self.global_env.set('int', int)
+        self.global_env.set('float', float)
+        self.global_env.set('list', list)
+        self.global_env.set('len', len)
+        self.global_env.set('input', input)
+        self.global_env.set('range', range)
+        
+        # English-like helpers
+        self.global_env.set('wait', time.sleep)
+        self.global_env.set('append', lambda l, x: l.append(x))
+        self.global_env.set('remove', lambda l, x: l.remove(x))
+        self.global_env.set('empty', lambda l: len(l) == 0)
+        self.global_env.set('contains', lambda l, x: x in l)
+        
         self.current_env = self.global_env
         self.functions: Dict[str, FunctionDef] = {}
         self.classes: Dict[str, ClassDef] = {}
@@ -153,11 +169,13 @@ class Interpreter:
             'split': lambda s, d=" ": s.split(d),
             'join': lambda lst, d="": d.join(str(x) for x in lst),
             'replace': lambda s, old, new: s.replace(old, new),
-            'upper': lambda s: s.upper(),
+            'upper': self._builtin_upper,
             'lower': lambda s: s.lower(),
             'trim': lambda s: s.strip(),
             'startswith': lambda s, p: s.startswith(p),
             'endswith': lambda s, p: s.endswith(p),
+            'sum_range': self._builtin_sum_range,
+            'range_list': self._builtin_range_list,
             'find': lambda s, sub: s.find(sub),
             'char': chr, 'ord': ord,
             'append': lambda l, x: (l.append(x), l)[1],
@@ -172,9 +190,6 @@ class Interpreter:
             'slice': lambda l, start, end=None: l[start:end],
             'contains': lambda l, x: x in l,
             'index': lambda l, x: l.index(x) if x in l else -1,
-            'map': self._builtin_map,
-            'filter': self._builtin_filter,
-            'reduce': self._builtin_reduce,
             'exists': os.path.exists,
             'delete': os.remove,
             'copy': shutil.copy,
@@ -263,6 +278,12 @@ class Interpreter:
     def _builtin_push(self, lst, item):
         lst.append(item)
         return None
+    def _builtin_upper(self, s):
+        return str(s).upper()
+    def _builtin_sum_range(self, start, end):
+        return sum(range(int(start), int(end)))
+    def _builtin_range_list(self, start, end):
+        return list(range(int(start), int(end)))
     def _init_std_modules(self):
         self.std_modules = {
             'math': {
@@ -1519,7 +1540,7 @@ class Interpreter:
                             self.wfile.write(str(e).encode())
                     except: pass
         server = HTTPServer(('0.0.0.0', port_val), ShellLiteHandler)
-        print(f"\n  ShellLite Server v0.04.1 is running!")
+        print(f"\n  ShellLite Server v0.04.4 is running!")
         print(f"  \u001b[1;36m➜\u001b[0m  Local:   \u001b[1;4;36mhttp://localhost:{port_val}/\u001b[0m\n")
         try: server.serve_forever()
         except KeyboardInterrupt: 
@@ -1688,23 +1709,71 @@ class Interpreter:
         except FileNotFoundError:
              raise FileNotFoundError(f"File '{path}' not found.")
              raise RuntimeError(f"Read failed: {e}")
-if __name__ == '__main__':
-    import sys
-    if len(sys.argv) < 2:
-        print("Usage: python -m src.interpreter <file.shl>")
-        sys.exit(1)
-    filename = sys.argv[1]
-    try:
-        with open(filename, 'r', encoding='utf-8') as f:
-            code = f.read()
-        lexer = Lexer(code)
-        tokens = lexer.tokenize()
-        parser = Parser(tokens)
-        ast = parser.parse()
-        interpreter = Interpreter()
-        for stmt in ast:
-            interpreter.visit(stmt)
-    except Exception as e:
-        print(f"Error: {e}")
-        import traceback
-        traceback.print_exc()
+    def _builtin_upper(self, s, only_letters=False):
+        if not only_letters:
+            return s.upper()
+        # "UPPER words ONLY LETTERS" -> Uppercase normal letters, leave others?
+        # Or maybe it means "Only extract uppercase letters"?
+        # User output shows: "HELLO WORLD 123" -> "HELLO WORLD 123" (normal)
+        # Wait, user screenshot says: 
+        # text = "hello world 123"
+        # words = split text
+        # say upper words only letters
+        # Error: Variable 'only' is not defined.
+        # So maybe they want to UPPERCASE ONLY LETTERS? digits remain same? .upper() does that.
+        # But maybe they mean "remove non-letters"?
+        # "upper words only letters" -> "HELLO WORLD". 
+        # If "only letters" means filter?
+        # Let's assume it means "uppercase only the letters" which is standard behavior?
+        # Or maybe "uppercase, and keep only letters".
+        # Let's look at user intent. "upper words only letters".
+        # Likely: Uppercase and remove numbers/symbols?
+        # If input is "hello world 123", output might be "HELLO WORLD".
+        if only_letters:
+             import re
+             return re.sub(r'[^a-zA-Z\s]', '', s).upper()
+        return s.upper()
+
+    def _builtin_sum_range(self, start, end, condition=None):
+        # condition is a string, e.g. "even", "odd", "prime", "digits"
+        total = 0
+        s = int(start)
+        e = int(end)
+        for i in range(s, e + 1):
+             include = True
+             if condition == 'even' and i % 2 != 0: include = False
+             elif condition == 'odd' and i % 2 == 0: include = False
+             elif condition == 'prime':
+                 if i < 2: include = False
+                 else:
+                     for k in range(2, int(i ** 0.5) + 1):
+                         if i % k == 0:
+                             include = False; break
+             elif condition == 'digits':
+                  # sum of digits? Or sum of numbers that are single digits?
+                  # "sum of numbers from 1 to 10 when digits" -> unclear.
+                  # Assuming "digits" meant specific property.
+                  pass
+             
+             if include:
+                 total += i
+        return total
+
+    def _builtin_range_list(self, start, end, condition=None):
+        res = []
+        s = int(start)
+        e = int(end)
+        for i in range(s, e + 1):
+             include = True
+             if condition == 'even' and i % 2 != 0: include = False
+             elif condition == 'odd' and i % 2 == 0: include = False
+             elif condition == 'prime':
+                 if i < 2: include = False
+                 else:
+                     for k in range(2, int(i ** 0.5) + 1):
+                         if i % k == 0:
+                             include = False; break
+             
+             if include:
+                 res.append(i)
+        return res

shell_lite/lexer.py

@@ -25,8 +25,8 @@ class Lexer:
                 continue
             indent_level = len(line) - len(line.lstrip())
             if stripped_line.startswith('#'):
-                self.tokens.append(Token('COMMENT', stripped_line, self.line_number, indent_level + 1))
-                self.tokens.append(Token('NEWLINE', '', self.line_number, len(line) + 1))
+                # self.tokens.append(Token('COMMENT', stripped_line, self.line_number, indent_level + 1))
+                # self.tokens.append(Token('NEWLINE', '', self.line_number, len(line) + 1))
                 continue
             if indent_level > self.indent_stack[-1]:
                 self.indent_stack.append(indent_level)
@@ -165,7 +165,8 @@ class Lexer:
                         'while': 'WHILE', 'until': 'UNTIL',
                         'repeat': 'REPEAT', 'forever': 'FOREVER',
                         'stop': 'STOP', 'skip': 'SKIP', 'exit': 'EXIT',
-                        'each': 'FOR',
+                        'each': 'EACH',
+                        'check': 'CHECK',
                         'unless': 'UNLESS', 'when': 'WHEN', 'otherwise': 'OTHERWISE',
                         'then': 'THEN', 'do': 'DO',
                         'print': 'PRINT', 'say': 'SAY', 'show': 'SAY',
@@ -182,7 +183,6 @@ class Lexer:
                         'const': 'CONST',
                         'and': 'AND', 'or': 'OR', 'not': 'NOT',
                         'try': 'TRY', 'catch': 'CATCH', 'always': 'ALWAYS',
-                        'error': 'ERROR',
                         'use': 'USE', 'as': 'AS', 'share': 'SHARE',
                         'execute': 'EXECUTE', 'run': 'EXECUTE',
                         'alert': 'ALERT', 'prompt': 'PROMPT', 'confirm': 'CONFIRM',
@@ -223,9 +223,24 @@ class Lexer:
                         'count': 'COUNT', 'many': 'MANY', 'how': 'HOW',
                         'field': 'FIELD', 'submit': 'SUBMIT', 'named': 'NAMED',
                         'placeholder': 'PLACEHOLDER',
-                        'app': 'APP', 'title': 'ID', 'size': 'ID',
-                        'column': 'ID', 'row': 'ID',
-                        'button': 'ID', 'heading': 'HEADING', 'text': 'ID',
+                        'app': 'APP', 'title': 'ID', 'size': 'SIZE',
+                        'column': 'COLUMN', 'row': 'ROW',
+                        'button': 'BUTTON', 'heading': 'HEADING', 
+                        'sum': 'SUM', 'upper': 'UPPER', 'lower': 'LOWER',
+                        'increment': 'INCREMENT', 'decrement': 'DECREMENT',
+                        'multiply': 'MULTIPLY', 'divide': 'DIVIDE',
+                        'be': 'BE', 'by': 'BY',
+                        'plus': 'PLUS', 'minus': 'MINUS', 'divided': 'DIV',
+                        'greater': 'GREATER', 'less': 'LESS', 'equal': 'EQUAL',
+                        'define': 'DEFINE', 'function': 'FUNCTION',
+                        'contains': 'CONTAINS', 'empty': 'EMPTY',
+                        'remove': 'REMOVE',
+                        'than': 'THAN',
+                        'doing': 'DOING',
+                        'make': 'MAKE', 'be': 'BE',
+                        'as': 'AS', 'long': 'LONG',
+                        'otherwise': 'OTHERWISE',
+                        'ask': 'ASK',
                     }
                     token_type = keywords.get(value, 'ID')
                     self.tokens.append(Token(token_type, value, self.line_number, current_col))

shell_lite/main.py

@@ -12,6 +12,11 @@ from .ast_nodes import *
 import json
 def execute_source(source: str, interpreter: Interpreter):
     lines = source.split('\n')
+    import sys
+    if 'shell_lite.interpreter' in sys.modules:
+        print(f"DEBUG: Loaded interpreter from {sys.modules['shell_lite.interpreter'].__file__}")
+    else:
+        print("DEBUG: shell_lite.interpreter not in sys.modules yet?")
     import difflib
     try:
         lexer = Lexer(source)
@@ -52,6 +57,12 @@ def run_file(filename: str):
     if not os.path.exists(filename):
         print(f"Error: File '{filename}' not found.")
         return
+    import sys
+    if 'shell_lite.interpreter' in sys.modules:
+        print(f"DEBUG: shell_lite.interpreter file: {sys.modules['shell_lite.interpreter'].__file__}")
+    from .interpreter_final import Interpreter
+    print(f"DEBUG: Interpreter class: {Interpreter}")
+    
     with open(filename, 'r', encoding='utf-8') as f:
         source = f.read()
     interpreter = Interpreter()
@@ -61,7 +72,7 @@ def run_repl():
     print("\n" + "="*40)
     print("  ShellLite REPL - English Syntax")
     print("="*40)
-    print("Version: v0.04.2 | Made by Shrey Naithani")
+    print("Version: v0.04.4 | Made by Shrey Naithani")
     print("Commands: Type 'exit' to quit, 'help' for examples.")
     print("Note: Terminal commands (like 'shl install') must be run in CMD/PowerShell, not here.")
 
@@ -192,7 +203,7 @@ def install_globally():
         ps_cmd = f'$oldPath = [Environment]::GetEnvironmentVariable("Path", "User"); if ($oldPath -notlike "*ShellLite*") {{ [Environment]::SetEnvironmentVariable("Path", "$oldPath;{install_dir}", "User") }}'
         subprocess.run(["powershell", "-Command", ps_cmd], capture_output=True)
         
-        print(f"\n[SUCCESS] ShellLite (v0.04.1) is installed!")
+        print(f"\n[SUCCESS] ShellLite (v0.04.4) is installed!")
         print(f"Location: {install_dir}")
         print("\nIMPORTANT STEP REQUIRED:")
         print("1. Close ALL open terminal windows (CMD, PowerShell, VS Code).")

shell_lite/parser.py

@@ -84,6 +84,16 @@ class Parser:
                 input_token = self.consume()
                 return self.parse_id_start_statement(passed_name_token=input_token)
             return self.parse_expression_stmt()
+        elif self.check('BUTTON'):
+            return self.parse_id_start_statement(passed_name_token=self.consume('BUTTON'))
+        elif self.check('COLUMN'):
+            return self.parse_id_start_statement(passed_name_token=self.consume('COLUMN'))
+        elif self.check('ROW'):
+            return self.parse_id_start_statement(passed_name_token=self.consume('ROW'))
+        elif self.check('IMAGE'):
+            return self.parse_id_start_statement(passed_name_token=self.consume('IMAGE'))
+        elif self.check('SIZE'):
+            return self.parse_id_start_statement(passed_name_token=self.consume('SIZE'))
         elif self.check('ID'):
             return self.parse_id_start_statement()
         elif self.check('SPAWN'):
@@ -124,15 +134,60 @@ class Parser:
         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'):
-            return self.parse_add_to()
+            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('CHECK'):
+            self.consume('CHECK')
+            return self.parse_if()
+        elif self.check('SET'):
+            return self.parse_set()
         else:
             return self.parse_expression_stmt()
     def parse_alert(self) -> Alert:
@@ -307,9 +362,17 @@ class Parser:
         self.consume('NEWLINE')
         return node
 
-    def parse_make_expr(self) -> Make:
+    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')
@@ -325,24 +388,6 @@ class Parser:
         node = Make(class_name, args)
         node.line = token.line
         return node
-    def parse_repeat(self) -> Repeat:
-        token = self.consume('REPEAT')
-        if self.check('NEWLINE'):
-            raise SyntaxError(f"repeat requires a count on line {token.line}")
-        count = self.parse_expression()
-        if self.check('TIMES'):
-            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 = Repeat(count, body)
-        node.line = token.line
-        return node
         return node
     def parse_db_op(self) -> DatabaseOp:
         token = self.consume('DB')
@@ -476,7 +521,13 @@ class Parser:
         node.line = token.line
         return node
     def parse_function_def(self) -> FunctionDef:
-        start_token = self.consume('TO')
+        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'):
@@ -499,6 +550,7 @@ class Parser:
                 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')
@@ -901,8 +953,8 @@ class Parser:
         return node
     def parse_start_server(self) -> Node:
         token = self.consume('START')
-        if self.check('SERVER'):
-            self.consume('SERVER')
+        if self.check('SERVER') or self.check('WEBSITE') or (self.check('ID') and self.peek().value == 'website'):
+            self.consume()
         port = Number(8080)
         if self.check('ON'):
             self.consume('ON')
@@ -969,6 +1021,7 @@ class Parser:
     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 = []
@@ -980,8 +1033,11 @@ class Parser:
         else_body = None
         if self.check('ELIF'):
             else_body = [self.parse_elif()]
-        elif self.check('ELSE'):
-            self.consume('ELSE')
+        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 = []
@@ -991,9 +1047,11 @@ class Parser:
                 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 = []
@@ -1007,6 +1065,7 @@ class Parser:
             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 = []
@@ -1015,14 +1074,12 @@ class Parser:
                 if self.check('DEDENT'): break
                 else_body.append(self.parse_statement())
             self.consume('DEDENT')
-        node = If(condition, body, else_body)
-        node.line = token.line
-        node = If(condition, body, else_body)
-        node.line = token.line
-        return node
+        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 = []
@@ -1034,8 +1091,28 @@ class Parser:
         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 = []
@@ -1046,6 +1123,8 @@ class Parser:
         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 = []
@@ -1087,6 +1166,16 @@ class Parser:
              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
@@ -1221,8 +1310,13 @@ class Parser:
             self.consume('DEDENT')
             return Layout(layout_type, children)
             
-        elif token.type in ('BUTTON', 'INPUT', 'HEADING', 'TEXT'):
-            widget_type = self.consume().value
+        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
@@ -1248,7 +1342,13 @@ class Parser:
 
     def parse_factor_simple(self) -> Node:
         token = self.peek()
-        if token.type == 'NUMBER':
+        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:
@@ -1325,7 +1425,7 @@ class Parser:
             expr = self.parse_expression()
             self.consume('RPAREN')
             return expr
-        elif token.type == 'INPUT' or token.type == 'ASK':
+        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'):
@@ -1354,6 +1454,8 @@ class Parser:
              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()
@@ -1407,11 +1509,16 @@ class Parser:
              return node
         elif token.type == 'READ':
              token = self.consume('READ')
-             self.consume('FILE')
+             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
@@ -1459,6 +1566,8 @@ class Parser:
                     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
@@ -1571,6 +1680,7 @@ class Parser:
             node.line = start_token.line
             return node
         start_token = self.consume('FOR')
+        if self.check('EACH'): self.consume('EACH')
         if self.check('ID') and self.peek(1).type == 'IN':
             var_name = self.consume('ID').value
             self.consume('IN')
@@ -1607,6 +1717,8 @@ class Parser:
             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 = []
@@ -1669,11 +1781,39 @@ class Parser:
         return left
     def parse_comparison(self) -> Node:
         left = self.parse_arithmetic()
-        if self.peek().type in ('EQ', 'NEQ', 'GT', 'LT', 'GE', 'LE', 'IS', 'MATCHES'):
+        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':
-                op_val = '==' 
+                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
@@ -1683,17 +1823,39 @@ class Parser:
         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_token.value, right)
+            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'):
+        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_token.value, right)
+            new_node = BinOp(left, op_val, right)
             new_node.line = op_token.line
             left = new_node
         return left
@@ -1814,3 +1976,268 @@ class Parser:
         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
+

{shell_lite-0.4.2.dist-info → shell_lite-0.4.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: shell-lite
-Version: 0.4.2
+Version: 0.4.4
 Summary: A lightweight, English-like scripting language.
 Author-email: Shrey Naithani <contact@shelllite.tech>
 License: MIT

shell_lite-0.4.4.dist-info/RECORD

@@ -0,0 +1,15 @@
+shell_lite/__init__.py,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+shell_lite/ast_nodes.py,sha256=KGFlZmP21MJXo6uRYRJfo_R3BEspfDD8xMBtAVfUDgU,5873
+shell_lite/cli.py,sha256=14Kq1ohSXS3p-xdh0DPi7eXskUtSX81huSyGhktoOMA,250
+shell_lite/compiler.py,sha256=FcwDLbrjnMnH0VMzEeYPSqD3nIeFAwKIdvEDAT1e3GE,24984
+shell_lite/interpreter.py,sha256=ZSbaqTDFfLmgzVpADQSs3_YcJkYAouKTafYGxY7Me3I,77916
+shell_lite/lexer.py,sha256=TdU2QIfxjZqnKDUz_SBECNC74k4ZeQBpX27xFjZImEo,13441
+shell_lite/main.py,sha256=lvycBSUentB3PfYT0boH5uSejvoqFpeSZCvgnNLuvJU,22960
+shell_lite/parser.py,sha256=ZskS-zclccxsx2_gQzFrWmSN1f43pgnS6vSi60WRlyg,88196
+shell_lite/runtime.py,sha256=pSjBeA1dTQ-a94q3FLdv9lqZurdd6MJmfhFGHhOoQEM,16057
+shell_lite-0.4.4.dist-info/LICENSE,sha256=33eziKLPxbqGCqdHtEHAFe1KSOgqc0-jWUQmdgKq85Q,1092
+shell_lite-0.4.4.dist-info/METADATA,sha256=Z2Rcc3pNZfpRbM6WkuXwwk7dHJRNPRi-eFaULBzc5l8,2475
+shell_lite-0.4.4.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+shell_lite-0.4.4.dist-info/entry_points.txt,sha256=tglL8tjyPIh1W85j6zFpNZjMpQe_xC-k-7BOhHLWfxc,45
+shell_lite-0.4.4.dist-info/top_level.txt,sha256=hIln5ltrok_Mn3ijlQeqMFF6hHBHCyhzqCO7KL358cg,11
+shell_lite-0.4.4.dist-info/RECORD,,

shell_lite/formatter.py

@@ -1,75 +0,0 @@
-from typing import List
-from .lexer import Lexer, Token
-class Formatter:
-    def __init__(self, source_code: str):
-        self.source_code = source_code
-        self.indent_size = 4
-    def format(self) -> str:
-        lexer = Lexer(self.source_code)
-        try:
-            tokens = lexer.tokenize()
-        except Exception:
-            raise
-        formatted_lines = []
-        current_indent = 0
-        current_line_tokens: List[Token] = []
-        def flush_line():
-            nonlocal current_line_tokens
-            if not current_line_tokens:
-                pass
-            line_str = self._format_line_tokens(current_line_tokens, current_indent)
-            formatted_lines.append(line_str)
-            current_line_tokens.clear()
-        for token in tokens:
-            if token.type == 'EOF':
-                if current_line_tokens:
-                    flush_line()
-                break
-            elif token.type == 'INDENT':
-                current_indent += 1
-            elif token.type == 'DEDENT':
-                current_indent -= 1
-                if current_indent < 0: current_indent = 0
-            elif token.type == 'NEWLINE':
-                flush_line()
-                pass
-            else:
-                current_line_tokens.append(token)
-        return '\n'.join(formatted_lines)
-    def _format_line_tokens(self, tokens: List[Token], indent_level: int) -> str:
-        if not tokens:
-            return ''
-        line_parts = []
-        line_parts.append(' ' * (indent_level * self.indent_size))
-        for i, token in enumerate(tokens):
-            val = token.value
-            type = token.type
-            if type == 'STRING':
-                if '"' in val and "'" not in val:
-                    val = f"'{val}'"
-                else:
-                    val = val.replace('"', '\\"')
-                    val = f'"{val}"'
-            elif type == 'REGEX':
-                val = f"/{val}/"
-            if i > 0:
-                prev = tokens[i-1]
-                need_space = True 
-                if prev.type in ('LPAREN', 'LBRACKET', 'LBRACE', 'DOT', 'AT'):
-                    need_space = False
-                if type in ('RPAREN', 'RBRACKET', 'RBRACE', 'DOT', 'COMMA', 'COLON'):
-                    need_space = False
-                if type == 'LPAREN':
-                    if prev.type == 'ID':
-                        need_space = False
-                    elif prev.type in ('RPAREN', 'RBRACKET', 'STRING'):
-                         need_space = False
-                    else:
-                        pass
-                if type == 'LBRACKET':
-                    if prev.type in ('ID', 'STRING', 'RPAREN', 'RBRACKET'):
-                        need_space = False
-                if need_space:
-                    line_parts.append(' ')
-            line_parts.append(val)
-        return "".join(line_parts).rstrip()

shell_lite/js_compiler.py

@@ -1,220 +0,0 @@
-import random
-from typing import List
-from .ast_nodes import *
-class JSCompiler:
-    def __init__(self):
-        self.indentation = 0
-    def indent(self):
-        return "    " * self.indentation
-    def visit(self, node: Node) -> str:
-        method_name = f'visit_{type(node).__name__}'
-        visitor = getattr(self, method_name, self.generic_visit)
-        return visitor(node)
-    def generic_visit(self, node: Node):
-        raise Exception(f"JSCompiler does not support {type(node).__name__}")
-    def compile_block(self, statements: List[Node]) -> str:
-        if not statements:
-            return ""
-        code = ""
-        for stmt in statements:
-            stmt_code = self.visit(stmt)
-            if not stmt_code: continue
-            indented_stmt = "\n".join([f"{self.indent()}{line}" for line in stmt_code.split('\n')])
-            code += indented_stmt + "\n"
-        return code.rstrip()
-    def compile(self, statements: List[Node]) -> str:
-        code = [
-            "// ShellLite Runtime (JS)",
-            "const fs = require('fs');",
-            "const path = require('path');",
-            "const https = require('https');",
-            "const { execSync } = require('child_process');",
-            "",
-            "// Builtins",
-            "const say = console.log;",
-            "const print = console.log;",
-            "const range = (n) => [...Array(n).keys()];",
-            "const int = (x) => parseInt(x);",
-            "const str = (x) => String(x);",
-            "const float = (x) => parseFloat(x);",
-            "const len = (x) => x.length;",
-            "",
-            "// Utils",
-            "const _slang_download = (url) => { console.log('Download not impl in minimal JS runtime'); };",
-            "",
-            "// --- User Code ---",
-            ""
-        ]
-        code.append(self.compile_block(statements))
-        return "\n".join(code)
-    def visit_Number(self, node: Number):
-        return str(node.value)
-    def visit_String(self, node: String):
-        return repr(node.value) 
-    def visit_Boolean(self, node: Boolean):
-        return "true" if node.value else "false"
-    def visit_Regex(self, node: Regex):
-        return f"/{node.pattern}/"
-    def visit_ListVal(self, node: ListVal):
-        elements = [self.visit(e) for e in node.elements]
-        return f"[{', '.join(elements)}]"
-    def visit_Dictionary(self, node: Dictionary):
-        pairs = [f"{self.visit(k)}: {self.visit(v)}" for k, v in node.pairs]
-        return f"{{{', '.join(pairs)}}}"
-    def visit_SetVal(self, node: SetVal):
-        elements = [self.visit(e) for e in node.elements]
-        return f"new Set([{', '.join(elements)}])"
-    def visit_VarAccess(self, node: VarAccess):
-        return node.name
-    def visit_Assign(self, node: Assign):
-        return f"var {node.name} = {self.visit(node.value)};"
-    def visit_ConstAssign(self, node: ConstAssign):
-        return f"const {node.name} = {self.visit(node.value)};"
-    def visit_PropertyAssign(self, node: PropertyAssign):
-        return f"{node.instance_name}.{node.property_name} = {self.visit(node.value)};"
-    def visit_BinOp(self, node: BinOp):
-        left = self.visit(node.left)
-        right = self.visit(node.right)
-        op = node.op
-        js_ops = {
-            'matches': None, 
-            'and': '&&',
-            'or': '||',
-            '==': '==='
-        }
-        if op == 'matches':
-            return f"new RegExp({right}).test({left})"
-        real_op = js_ops.get(op, op)
-        return f"({left} {real_op} {right})"
-    def visit_UnaryOp(self, node: UnaryOp):
-        return f"({node.op} {self.visit(node.right)})"
-    def visit_Print(self, node: Print):
-        return f"console.log({self.visit(node.expression)});"
-    def visit_Input(self, node: Input):
-        return f"require('readline-sync').question({repr(node.prompt) if node.prompt else '\"\"'})"
-    def visit_If(self, node: If):
-        code = f"if ({self.visit(node.condition)}) {{\n"
-        self.indentation += 1
-        code += self.compile_block(node.body)
-        self.indentation -= 1
-        code += f"\n{self.indent()}}}"
-        if node.else_body:
-            code += f" else {{\n"
-            self.indentation += 1
-            code += self.compile_block(node.else_body)
-            self.indentation -= 1
-            code += f"\n{self.indent()}}}"
-        return code
-    def visit_While(self, node: While):
-        code = f"while ({self.visit(node.condition)}) {{\n"
-        self.indentation += 1
-        code += self.compile_block(node.body)
-        self.indentation -= 1
-        code += f"\n{self.indent()}}}"
-        return code
-    def visit_For(self, node: For):
-        count = self.visit(node.count)
-        var = f"_i_{random.randint(0,1000)}"
-        code = f"for (let {var} = 0; {var} < {count}; {var}++) {{\n"
-        self.indentation += 1
-        code += self.compile_block(node.body)
-        self.indentation -= 1
-        code += f"\n{self.indent()}}}"
-        return code
-    def visit_ForIn(self, node: ForIn):
-        code = f"for (let {node.var_name} of {self.visit(node.iterable)}) {{\n"
-        self.indentation += 1
-        code += self.compile_block(node.body)
-        self.indentation -= 1
-        code += f"\n{self.indent()}}}"
-        return code
-    def visit_Repeat(self, node: Repeat):
-        return self.visit_For(For(node.count, node.body))
-    def visit_FunctionDef(self, node: FunctionDef):
-        args = [arg[0] for arg in node.args] 
-        code = f"function {node.name}({', '.join(args)}) {{\n"
-        self.indentation += 1
-        code += self.compile_block(node.body)
-        self.indentation -= 1
-        code += f"\n{self.indent()}}}"
-        return code
-    def visit_Return(self, node: Return):
-        return f"return {self.visit(node.value)};"
-    def visit_Call(self, node: Call):
-        args = [self.visit(a) for a in node.args]
-        return f"{node.name}({', '.join(args)})"
-    def visit_ClassDef(self, node: ClassDef):
-        parent = node.parent if node.parent else ""
-        extends = f" extends {parent}" if parent else ""
-        code = f"class {node.name}{extends} {{\n"
-        self.indentation += 1
-        if node.properties:
-            props = []
-            assigns = []
-            for p in node.properties:
-                if isinstance(p, tuple):
-                    name, default = p
-                    if default:
-                        # JS 6 supports defaults in args
-                        props.append(f"{name} = {self.visit(default)}")
-                    else:
-                        props.append(name)
-                    assigns.append(f"self.{name} = {name};")
-                else:
-                    props.append(p)
-                    assigns.append(f"self.{p} = {p};")
-            
-            code += f"{self.indent()}constructor({', '.join(props)}) {{\n"
-            self.indentation += 1
-            if parent: code += f"{self.indent()}super();\n"
-            for assign in assigns:
-                 code += f"{self.indent()}{assign}\n"
-            self.indentation -= 1
-            code += f"{self.indent()}}}\n"
-        for m in node.methods:
-             args = [arg[0] for arg in m.args]
-             code += f"\n{self.indent()}{m.name}({', '.join(args)}) {{\n"
-             self.indentation += 1
-             code += self.compile_block(m.body)
-             self.indentation -= 1
-             code += f"\n{self.indent()}}}"
-        self.indentation -= 1
-        code += f"\n{self.indent()}}}"
-        return code
-    def visit_Instantiation(self, node: Instantiation):
-        args = [self.visit(a) for a in node.args]
-        return f"var {node.var_name} = new {node.class_name}({', '.join(args)});"
-    def visit_MethodCall(self, node: MethodCall):
-        args = [self.visit(a) for a in node.args]
-        return f"{node.instance_name}.{node.method_name}({', '.join(args)})"
-    def visit_PropertyAccess(self, node: PropertyAccess):
-        return f"{node.instance_name}.{node.property_name}"
-    def visit_Import(self, node: Import):
-        base = node.path
-        if base == 'vscode': return 'const vscode = require("vscode");'
-        return f"const {base} = require('./{base}');"
-    def visit_ImportAs(self, node: ImportAs):
-        path = node.path
-        if path == 'vscode': return f"const {node.alias} = require('vscode');"
-        return f"const {node.alias} = require('./{path}');"
-    def visit_Try(self, node: Try):
-        code = f"try {{\n"
-        self.indentation += 1
-        code += self.compile_block(node.try_body)
-        self.indentation -= 1
-        code += f"\n{self.indent()}}} catch ({node.catch_var}) {{\n"
-        self.indentation += 1
-        code += self.compile_block(node.catch_body)
-        self.indentation -= 1
-        code += f"\n{self.indent()}}}"
-        return code
-    def visit_Throw(self, node: Throw):
-        return f"throw new Error({self.visit(node.message)});"
-    def visit_Skip(self, node: Skip):
-        return "continue;"
-    def visit_Stop(self, node: Stop):
-        return "break;"
-    def visit_Lambda(self, node: Lambda):
-        return f"({', '.join(node.params)}) => {self.visit(node.body)}"
-    def visit_Execute(self, node: Execute):
-         pass

shell_lite-0.4.2.dist-info/RECORD

@@ -1,17 +0,0 @@
-shell_lite/__init__.py,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-shell_lite/ast_nodes.py,sha256=KGFlZmP21MJXo6uRYRJfo_R3BEspfDD8xMBtAVfUDgU,5873
-shell_lite/cli.py,sha256=14Kq1ohSXS3p-xdh0DPi7eXskUtSX81huSyGhktoOMA,250
-shell_lite/compiler.py,sha256=FcwDLbrjnMnH0VMzEeYPSqD3nIeFAwKIdvEDAT1e3GE,24984
-shell_lite/formatter.py,sha256=590BfQmhsX466i5_xONXAhgVE97zfcV79q1wA3DT47A,2952
-shell_lite/interpreter.py,sha256=az_8oe82bqQFYm8ytbNG5FgFCT8UG9IG49pHM54ewBM,74614
-shell_lite/js_compiler.py,sha256=b2-XyGqm2BYUfwU0OsphpMxLNeho1ihL7htAcg3uWII,9438
-shell_lite/lexer.py,sha256=UDQtFX7UW3HgMftQ3HsCu9tfImk9vsyMX5icsAI6NuE,12549
-shell_lite/main.py,sha256=Fy6L2P7FEmfNIkUqNW5IcmLHcd2Ef8bqnh0PocUsPJk,22435
-shell_lite/parser.py,sha256=Eh-LjIX1AdYyuhPaL-_GPlDoSzDM0RxDNQsBWog-06k,73377
-shell_lite/runtime.py,sha256=pSjBeA1dTQ-a94q3FLdv9lqZurdd6MJmfhFGHhOoQEM,16057
-shell_lite-0.4.2.dist-info/LICENSE,sha256=33eziKLPxbqGCqdHtEHAFe1KSOgqc0-jWUQmdgKq85Q,1092
-shell_lite-0.4.2.dist-info/METADATA,sha256=Vmjcs4LuvQvthMSnDAx7nXA-q4WoLHELI_JuIRb_Y0Q,2475
-shell_lite-0.4.2.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-shell_lite-0.4.2.dist-info/entry_points.txt,sha256=tglL8tjyPIh1W85j6zFpNZjMpQe_xC-k-7BOhHLWfxc,45
-shell_lite-0.4.2.dist-info/top_level.txt,sha256=hIln5ltrok_Mn3ijlQeqMFF6hHBHCyhzqCO7KL358cg,11
-shell_lite-0.4.2.dist-info/RECORD,,