hispano-lang 1.1.7 → 2.1.0

package/dist/parser.js

@@ -20,7 +20,7 @@ class Parser {
       statements.push(this.declaration());
 
       // Consume semicolon if present between statements
-      if (this.match('SEMICOLON')) {
+      if (this.match("SEMICOLON")) {
         // Semicolon consumed
       }
     }
@@ -34,47 +34,67 @@ class Parser {
    */
   declaration() {
     try {
-      if (this.match('VARIABLE')) {
+      if (this.match("VARIABLE")) {
         return this.variableDeclaration();
       }
 
-      if (this.match('FUNCION')) {
+      if (this.match("CONSTANTE")) {
+        return this.constantDeclaration();
+      }
+
+      if (this.match("FUNCION")) {
         return this.functionDeclaration();
       }
 
-      if (this.match('MOSTRAR')) {
+      if (this.match("CLASE")) {
+        return this.classDeclaration();
+      }
+
+      if (this.match("MOSTRAR")) {
         return this.mostrarStatement();
       }
 
-      if (this.match('LEER')) {
+      if (this.match("LEER")) {
         return this.leerStatement();
       }
 
-      if (this.match('SI')) {
+      if (this.match("SI")) {
         return this.ifStatement();
       }
 
-      if (this.match('MIENTRAS')) {
+      if (this.match("MIENTRAS")) {
         return this.whileStatement();
       }
 
-      if (this.match('PARA')) {
+      if (this.match("PARA")) {
+        // Check if it's "para cada" (for-each) or regular "para" (for)
+        if (this.match("CADA")) {
+          return this.forEachStatement();
+        }
         return this.forStatement();
       }
 
-      if (this.match('RETORNAR')) {
+      if (this.match("ELEGIR")) {
+        return this.elegirStatement();
+      }
+
+      if (this.match("HACER")) {
+        return this.hacerMientrasStatement();
+      }
+
+      if (this.match("RETORNAR")) {
         return this.returnStatement();
       }
 
-      if (this.match('ROMPER')) {
+      if (this.match("ROMPER")) {
         return this.breakStatement();
       }
 
-      if (this.match('CONTINUAR')) {
+      if (this.match("CONTINUAR")) {
         return this.continueStatement();
       }
 
-      if (this.match('INTENTAR')) {
+      if (this.match("INTENTAR")) {
         return this.tryStatement();
       }
 
@@ -91,21 +111,46 @@ class Parser {
    */
   variableDeclaration() {
     let name;
-    if (this.match('IDENTIFIER')) {
+    if (this.match("IDENTIFIER")) {
       name = this.previous();
-    } else if (this.match('AND')) {
+    } else if (this.match("AND")) {
       name = this.previous();
     } else {
-      throw new Error('Se esperaba un nombre de variable');
+      throw new Error("Se esperaba un nombre de variable");
     }
 
     let initializer = null;
-    if (this.match('EQUAL')) {
+    if (this.match("EQUAL")) {
       initializer = this.expression();
     }
 
     return {
-      type: 'VariableDeclaration',
+      type: "VariableDeclaration",
+      name: name.lexeme,
+      initializer,
+    };
+  }
+
+  /**
+   * Parses a constant declaration
+   * @returns {Object} Constant declaration
+   */
+  constantDeclaration() {
+    let name;
+    if (this.match("IDENTIFIER")) {
+      name = this.previous();
+    } else {
+      throw new Error("Se esperaba un nombre de constante");
+    }
+
+    if (!this.match("EQUAL")) {
+      throw new Error("Las constantes deben ser inicializadas");
+    }
+
+    const initializer = this.expression();
+
+    return {
+      type: "ConstantDeclaration",
       name: name.lexeme,
       initializer,
     };
@@ -116,40 +161,143 @@ class Parser {
    * @returns {Object} Function declaration
    */
   functionDeclaration() {
-    const name = this.consume('IDENTIFIER', 'Expected function name');
-    this.consume('LEFT_PAREN', 'Expected ( after function name');
+    const name = this.consume("IDENTIFIER", "Expected function name");
+    this.consume("LEFT_PAREN", "Expected ( after function name");
 
     const parameters = [];
-    if (!this.check('RIGHT_PAREN')) {
+    if (!this.check("RIGHT_PAREN")) {
       do {
         if (parameters.length >= 255) {
-          throw new Error('No se pueden tener más de 255 parámetros');
+          throw new Error("No se pueden tener más de 255 parámetros");
         }
         let param;
-        if (this.match('IDENTIFIER')) {
+        if (this.match("IDENTIFIER")) {
           param = this.previous();
-        } else if (this.match('AND')) {
+        } else if (this.match("AND")) {
           param = this.previous();
         } else {
-          throw new Error('Se esperaba un nombre de parámetro');
+          throw new Error("Se esperaba un nombre de parámetro");
         }
         parameters.push(param.lexeme);
-      } while (this.match('COMMA'));
+      } while (this.match("COMMA"));
     }
 
-    this.consume('RIGHT_PAREN', 'Expected ) after parameters');
-    this.consume('LEFT_BRACE', 'Expected { before function body');
+    this.consume("RIGHT_PAREN", "Expected ) after parameters");
+    this.consume("LEFT_BRACE", "Expected { before function body");
     const body = this.block();
-    this.consume('RIGHT_BRACE', 'Expected } after function body');
+    this.consume("RIGHT_BRACE", "Expected } after function body");
 
     return {
-      type: 'FunctionDeclaration',
+      type: "FunctionDeclaration",
       name: name.lexeme,
       parameters,
       body,
     };
   }
 
+  /**
+   * Parses a class declaration
+   * @returns {Object} Class declaration
+   */
+  classDeclaration() {
+    const name = this.consume("IDENTIFIER", "Se esperaba un nombre de clase");
+
+    // Check for inheritance
+    let superclass = null;
+    if (this.match("EXTIENDE")) {
+      this.consume("IDENTIFIER", "Se esperaba el nombre de la clase padre");
+      superclass = this.previous().lexeme;
+    }
+
+    this.consume("LEFT_BRACE", "Se esperaba { después del nombre de clase");
+
+    // Parse class body (constructor and methods)
+    let constructor = null;
+    const methods = [];
+
+    while (!this.check("RIGHT_BRACE") && !this.isAtEnd()) {
+      if (this.match("CONSTRUCTOR")) {
+        // Parse constructor
+        this.consume("LEFT_PAREN", "Se esperaba ( después de constructor");
+        const parameters = [];
+        if (!this.check("RIGHT_PAREN")) {
+          do {
+            if (parameters.length >= 255) {
+              throw new Error("No se pueden tener más de 255 parámetros");
+            }
+            const param = this.consume(
+              "IDENTIFIER",
+              "Se esperaba nombre de parámetro",
+            );
+            parameters.push(param.lexeme);
+          } while (this.match("COMMA"));
+        }
+        this.consume("RIGHT_PAREN", "Se esperaba ) después de parámetros");
+        this.consume(
+          "LEFT_BRACE",
+          "Se esperaba { antes del cuerpo del constructor",
+        );
+        const body = this.block();
+        this.consume(
+          "RIGHT_BRACE",
+          "Se esperaba } después del cuerpo del constructor",
+        );
+
+        constructor = {
+          parameters,
+          body,
+        };
+      } else if (this.match("IDENTIFIER")) {
+        // Parse method
+        const methodName = this.previous().lexeme;
+        this.consume(
+          "LEFT_PAREN",
+          "Se esperaba ( después del nombre del método",
+        );
+        const parameters = [];
+        if (!this.check("RIGHT_PAREN")) {
+          do {
+            if (parameters.length >= 255) {
+              throw new Error("No se pueden tener más de 255 parámetros");
+            }
+            const param = this.consume(
+              "IDENTIFIER",
+              "Se esperaba nombre de parámetro",
+            );
+            parameters.push(param.lexeme);
+          } while (this.match("COMMA"));
+        }
+        this.consume("RIGHT_PAREN", "Se esperaba ) después de parámetros");
+        this.consume("LEFT_BRACE", "Se esperaba { antes del cuerpo del método");
+        const body = this.block();
+        this.consume(
+          "RIGHT_BRACE",
+          "Se esperaba } después del cuerpo del método",
+        );
+
+        methods.push({
+          name: methodName,
+          parameters,
+          body,
+        });
+      } else {
+        throw new Error(
+          "Se esperaba constructor o método en el cuerpo de la clase",
+        );
+      }
+    }
+
+    this.consume("RIGHT_BRACE", "Se esperaba } después del cuerpo de la clase");
+
+    return {
+      type: "ClassDeclaration",
+      name: name.lexeme,
+      superclass,
+      constructor,
+      methods,
+    };
+  }
+
   /**
    * Parses a show statement
    * @returns {Object} Show statement
@@ -158,7 +306,7 @@ class Parser {
     const value = this.expression();
 
     return {
-      type: 'MostrarStatement',
+      type: "MostrarStatement",
       expression: value,
     };
   }
@@ -170,18 +318,18 @@ class Parser {
   leerStatement() {
     // Parse the variable name to store the input
     const variableName = this.consume(
-      'IDENTIFIER',
-      'Expected variable name after leer'
+      "IDENTIFIER",
+      "Expected variable name after leer",
     );
 
     // Optional prompt message
     let prompt = null;
-    if (this.match('STRING')) {
+    if (this.match("STRING")) {
       prompt = this.previous().literal;
     }
 
     return {
-      type: 'LeerStatement',
+      type: "LeerStatement",
       variable: variableName.lexeme,
       prompt: prompt,
     };
@@ -193,19 +341,19 @@ class Parser {
    */
   ifStatement() {
     const condition = this.expression();
-    this.consume('LEFT_BRACE', 'Expected { after condition');
+    this.consume("LEFT_BRACE", "Expected { after condition");
     const thenBranch = this.block();
-    this.consume('RIGHT_BRACE', 'Expected } after block');
+    this.consume("RIGHT_BRACE", "Expected } after block");
     let elseBranch = null;
 
-    if (this.match('SINO')) {
-      this.consume('LEFT_BRACE', 'Expected { after else');
+    if (this.match("SINO")) {
+      this.consume("LEFT_BRACE", "Expected { after else");
       elseBranch = this.block();
-      this.consume('RIGHT_BRACE', 'Expected } after else block');
+      this.consume("RIGHT_BRACE", "Expected } after else block");
     }
 
     return {
-      type: 'IfStatement',
+      type: "IfStatement",
       condition,
       thenBranch,
       elseBranch,
@@ -218,12 +366,12 @@ class Parser {
    */
   whileStatement() {
     const condition = this.expression();
-    this.consume('LEFT_BRACE', 'Expected { after condition');
+    this.consume("LEFT_BRACE", "Expected { after condition");
     const body = this.block();
-    this.consume('RIGHT_BRACE', 'Expected } after block');
+    this.consume("RIGHT_BRACE", "Expected } after block");
 
     return {
-      type: 'WhileStatement',
+      type: "WhileStatement",
       condition,
       body,
     };
@@ -234,18 +382,18 @@ class Parser {
    * @returns {Object} For statement
    */
   forStatement() {
-    this.consume('LEFT_PAREN', 'Expected ( after para');
+    this.consume("LEFT_PAREN", "Expected ( after para");
 
     // Initializer (optional)
     let initializer = null;
-    if (!this.check('SEMICOLON')) {
-      if (this.match('VARIABLE')) {
+    if (!this.check("SEMICOLON")) {
+      if (this.match("VARIABLE")) {
         initializer = this.variableDeclaration();
       } else {
         initializer = this.expressionStatement();
       }
       // Consume the semicolon after initializer
-      this.consume('SEMICOLON', 'Expected ; after for initializer');
+      this.consume("SEMICOLON", "Expected ; after for initializer");
     } else {
       // Skip the first semicolon if no initializer
       this.advance();
@@ -253,24 +401,24 @@ class Parser {
 
     // Condition (optional)
     let condition = null;
-    if (!this.check('SEMICOLON')) {
+    if (!this.check("SEMICOLON")) {
       condition = this.expression();
     }
-    this.consume('SEMICOLON', 'Expected ; after condition');
+    this.consume("SEMICOLON", "Expected ; after condition");
 
     // Increment (optional)
     let increment = null;
-    if (!this.check('RIGHT_PAREN')) {
+    if (!this.check("RIGHT_PAREN")) {
       increment = this.expression();
     }
-    this.consume('RIGHT_PAREN', 'Expected ) after for clause');
+    this.consume("RIGHT_PAREN", "Expected ) after for clause");
 
-    this.consume('LEFT_BRACE', 'Expected { after for clause');
+    this.consume("LEFT_BRACE", "Expected { after for clause");
     const body = this.block();
-    this.consume('RIGHT_BRACE', 'Expected } after block');
+    this.consume("RIGHT_BRACE", "Expected } after block");
 
     return {
-      type: 'ForStatement',
+      type: "ForStatement",
       initializer,
       condition,
       increment,
@@ -285,12 +433,12 @@ class Parser {
   returnStatement() {
     const keyword = this.previous();
     let value = null;
-    if (!this.check('RIGHT_BRACE')) {
+    if (!this.check("RIGHT_BRACE")) {
       value = this.expression();
     }
 
     return {
-      type: 'ReturnStatement',
+      type: "ReturnStatement",
       keyword,
       value,
     };
@@ -303,7 +451,7 @@ class Parser {
   breakStatement() {
     const keyword = this.previous();
     return {
-      type: 'BreakStatement',
+      type: "BreakStatement",
       keyword,
     };
   }
@@ -315,7 +463,7 @@ class Parser {
   continueStatement() {
     const keyword = this.previous();
     return {
-      type: 'ContinueStatement',
+      type: "ContinueStatement",
       keyword,
     };
   }
@@ -327,7 +475,7 @@ class Parser {
   block() {
     const statements = [];
 
-    while (!this.check('RIGHT_BRACE') && !this.isAtEnd()) {
+    while (!this.check("RIGHT_BRACE") && !this.isAtEnd()) {
       statements.push(this.declaration());
     }
 
@@ -341,7 +489,7 @@ class Parser {
   expressionStatement() {
     const expr = this.expression();
     return {
-      type: 'ExpressionStatement',
+      type: "ExpressionStatement",
       expression: expr,
     };
   }
@@ -361,7 +509,7 @@ class Parser {
   parseExpression() {
     let expr = this.equality();
 
-    while (this.match('LEFT_BRACKET')) {
+    while (this.match("LEFT_BRACKET")) {
       expr = this.finishArrayAccess(expr);
     }
 
@@ -373,68 +521,76 @@ class Parser {
    * @returns {Object} Parsed assignment
    */
   assignment() {
-    let expr = this.logicalOr();
+    const expr = this.logicalOr();
 
-    if (this.match('EQUAL')) {
+    if (this.match("EQUAL")) {
       const equals = this.previous();
       const value = this.logicalOr();
 
-      if (expr.type === 'Variable') {
+      if (expr.type === "Variable") {
         const name = expr.name;
         return {
-          type: 'Assign',
+          type: "Assign",
           name,
           value,
         };
       }
 
-      if (expr.type === 'ArrayAccess') {
+      if (expr.type === "ArrayAccess") {
         return {
-          type: 'ArrayAssign',
+          type: "ArrayAssign",
           array: expr.array,
           index: expr.index,
           value,
         };
       }
 
-      if (expr.type === 'PropertyAccess') {
+      if (expr.type === "PropertyAccess") {
         return {
-          type: 'PropertyAssign',
+          type: "PropertyAssign",
           object: expr.object,
           name: expr.name,
           value,
         };
       }
 
-      throw new Error('Objetivo de asignación inválido');
+      if (expr.type === "ThisPropertyAccess") {
+        return {
+          type: "ThisPropertyAssign",
+          property: expr.property,
+          value,
+        };
+      }
+
+      throw new Error("Objetivo de asignación inválido");
     }
 
     // Handle compound assignment operators
     if (
       this.match(
-        'PLUS_EQUAL',
-        'MINUS_EQUAL',
-        'STAR_EQUAL',
-        'SLASH_EQUAL',
-        'PERCENT_EQUAL'
+        "PLUS_EQUAL",
+        "MINUS_EQUAL",
+        "STAR_EQUAL",
+        "SLASH_EQUAL",
+        "PERCENT_EQUAL",
       )
     ) {
       const operator = this.previous();
       const value = this.logicalOr();
 
-      if (expr.type === 'Variable') {
+      if (expr.type === "Variable") {
         const name = expr.name;
         return {
-          type: 'CompoundAssign',
+          type: "CompoundAssign",
           name,
           operator: operator.type,
           value,
         };
       }
 
-      if (expr.type === 'ArrayAccess') {
+      if (expr.type === "ArrayAccess") {
         return {
-          type: 'CompoundArrayAssign',
+          type: "CompoundArrayAssign",
           array: expr.array,
           index: expr.index,
           operator: operator.type,
@@ -442,9 +598,9 @@ class Parser {
         };
       }
 
-      if (expr.type === 'PropertyAccess') {
+      if (expr.type === "PropertyAccess") {
         return {
-          type: 'CompoundPropertyAssign',
+          type: "CompoundPropertyAssign",
           object: expr.object,
           name: expr.name,
           operator: operator.type,
@@ -452,7 +608,7 @@ class Parser {
         };
       }
 
-      throw new Error('Objetivo de asignación compuesta inválido');
+      throw new Error("Objetivo de asignación compuesta inválido");
     }
 
     return expr;
@@ -465,11 +621,11 @@ class Parser {
   equality() {
     let expr = this.comparison();
 
-    while (this.match('EQUAL_EQUAL', 'BANG_EQUAL')) {
+    while (this.match("EQUAL_EQUAL", "BANG_EQUAL")) {
       const operator = this.previous();
       const right = this.comparison();
       expr = {
-        type: 'Binary',
+        type: "Binary",
         left: expr,
         operator: operator.type,
         right,
@@ -486,11 +642,11 @@ class Parser {
   logicalAnd() {
     let expr = this.equality();
 
-    while (this.match('AND')) {
+    while (this.match("AND")) {
       const operator = this.previous();
       const right = this.equality();
       expr = {
-        type: 'Logical',
+        type: "Logical",
         left: expr,
         operator: operator.type,
         right,
@@ -507,11 +663,11 @@ class Parser {
   logicalOr() {
     let expr = this.logicalAnd();
 
-    while (this.match('OR')) {
+    while (this.match("OR")) {
       const operator = this.previous();
       const right = this.logicalAnd();
       expr = {
-        type: 'Logical',
+        type: "Logical",
         left: expr,
         operator: operator.type,
         right,
@@ -528,11 +684,11 @@ class Parser {
   comparison() {
     let expr = this.term();
 
-    while (this.match('GREATER', 'GREATER_EQUAL', 'LESS', 'LESS_EQUAL')) {
+    while (this.match("GREATER", "GREATER_EQUAL", "LESS", "LESS_EQUAL")) {
       const operator = this.previous();
       const right = this.term();
       expr = {
-        type: 'Binary',
+        type: "Binary",
         left: expr,
         operator: operator.type,
         right,
@@ -549,11 +705,11 @@ class Parser {
   term() {
     let expr = this.factor();
 
-    while (this.match('MINUS', 'PLUS')) {
+    while (this.match("MINUS", "PLUS")) {
       const operator = this.previous();
       const right = this.factor();
       expr = {
-        type: 'Binary',
+        type: "Binary",
         left: expr,
         operator: operator.type,
         right,
@@ -570,11 +726,11 @@ class Parser {
   factor() {
     let expr = this.unary();
 
-    while (this.match('SLASH', 'STAR', 'PERCENT')) {
+    while (this.match("SLASH", "STAR", "PERCENT")) {
       const operator = this.previous();
       const right = this.unary();
       expr = {
-        type: 'Binary',
+        type: "Binary",
         left: expr,
         operator: operator.type,
         right,
@@ -589,11 +745,11 @@ class Parser {
    * @returns {Object} Unary expression
    */
   unary() {
-    if (this.match('BANG', 'MINUS')) {
+    if (this.match("BANG", "MINUS")) {
       const operator = this.previous();
       const right = this.unary();
       return {
-        type: 'Unary',
+        type: "Unary",
         operator: operator.type,
         right,
       };
@@ -609,10 +765,10 @@ class Parser {
   postfix() {
     let expr = this.call();
 
-    while (this.match('PLUS_PLUS', 'MINUS_MINUS')) {
+    while (this.match("PLUS_PLUS", "MINUS_MINUS")) {
       const operator = this.previous();
       expr = {
-        type: 'Postfix',
+        type: "Postfix",
         operator: operator.type,
         operand: expr,
       };
@@ -629,10 +785,44 @@ class Parser {
     let expr = this.primary();
 
     while (true) {
-      if (this.match('LEFT_BRACKET')) {
+      if (this.match("LEFT_BRACKET")) {
         expr = this.finishArrayAccess(expr);
-      } else if (this.match('DOT')) {
+      } else if (this.match("DOT")) {
         expr = this.finishPropertyAccess(expr);
+      } else if (this.match("LEFT_PAREN")) {
+        // Handle method/function calls on PropertyAccess or ThisPropertyAccess
+        if (expr.type === "PropertyAccess") {
+          const args = [];
+          if (!this.check("RIGHT_PAREN")) {
+            do {
+              args.push(this.expression());
+            } while (this.match("COMMA"));
+          }
+          this.consume("RIGHT_PAREN", "Expected ) after method arguments");
+          expr = {
+            type: "MethodCall",
+            object: expr.object,
+            method: expr.name,
+            arguments: args,
+          };
+        } else if (expr.type === "ThisPropertyAccess") {
+          const args = [];
+          if (!this.check("RIGHT_PAREN")) {
+            do {
+              args.push(this.expression());
+            } while (this.match("COMMA"));
+          }
+          this.consume("RIGHT_PAREN", "Expected ) after method arguments");
+          expr = {
+            type: "ThisMethodCall",
+            method: expr.property,
+            arguments: args,
+          };
+        } else {
+          // Put back the LEFT_PAREN for other handlers
+          this.current--;
+          break;
+        }
       } else {
         break;
       }
@@ -646,60 +836,182 @@ class Parser {
    * @returns {Object} Primary expression
    */
   primary() {
-    if (this.match('FALSE')) return { type: 'Literal', value: false };
-    if (this.match('TRUE')) return { type: 'Literal', value: true };
-    if (this.match('NULL')) return { type: 'Literal', value: null };
-    if (this.match('UNDEFINED')) return { type: 'Literal', value: undefined };
-    if (this.match('NUMBER', 'STRING')) {
+    if (this.match("FALSE")) return { type: "Literal", value: false };
+    if (this.match("TRUE")) return { type: "Literal", value: true };
+    if (this.match("NULL")) return { type: "Literal", value: null };
+    if (this.match("UNDEFINED")) return { type: "Literal", value: undefined };
+    if (this.match("NUMBER", "STRING")) {
       return {
-        type: 'Literal',
+        type: "Literal",
         value: this.previous().literal,
       };
     }
 
-    if (this.match('IDENTIFIER')) {
+    if (this.match("TEMPLATE_STRING")) {
+      return this.templateStringExpression();
+    }
+
+    if (this.match("IDENTIFIER")) {
       const identifier = this.previous();
-      if (this.check('LEFT_PAREN')) {
+      // Check for single-param arrow function: x => ...
+      if (this.check("ARROW")) {
+        this.advance(); // Consume the ARROW
+        return this.arrowFunctionBody([identifier.lexeme]);
+      }
+      if (this.check("LEFT_PAREN")) {
         this.advance(); // Consume the LEFT_PAREN
         return this.finishCall(identifier);
       }
       return {
-        type: 'Variable',
+        type: "Variable",
         name: identifier.lexeme,
       };
     }
 
-    if (this.match('AND')) {
+    if (this.match("AND")) {
       const identifier = this.previous();
-      if (this.check('LEFT_PAREN')) {
+      if (this.check("LEFT_PAREN")) {
         this.advance(); // Consume the LEFT_PAREN
         return this.finishCall(identifier);
       }
       return {
-        type: 'Variable',
+        type: "Variable",
         name: identifier.lexeme,
       };
     }
 
-    if (this.match('LEFT_PAREN')) {
+    if (this.match("LEFT_PAREN")) {
+      // Check if this could be arrow function params
+      if (this.isArrowFunctionParams()) {
+        return this.arrowFunctionWithParams();
+      }
       const expr = this.expression();
-      this.consume('RIGHT_PAREN', 'Expected ) after expression');
+      this.consume("RIGHT_PAREN", "Expected ) after expression");
       return expr;
     }
 
-    if (this.match('LEFT_BRACKET')) {
+    if (this.match("LEFT_BRACKET")) {
       return this.arrayLiteral();
     }
 
-    if (this.match('LEFT_BRACE')) {
+    if (this.match("LEFT_BRACE")) {
       return this.objectLiteral();
     }
 
-    if (this.match('FUNCION')) {
+    if (this.match("FUNCION")) {
       return this.anonymousFunction();
     }
 
-    throw new Error('Se esperaba una expresión');
+    if (this.match("NUEVO")) {
+      return this.newExpression();
+    }
+
+    if (this.match("ESTE")) {
+      return this.thisExpression();
+    }
+
+    if (this.match("SUPER")) {
+      return this.superExpression();
+    }
+
+    throw new Error("Se esperaba una expresión");
+  }
+
+  /**
+   * Parses a new expression for class instantiation
+   * @returns {Object} New expression
+   */
+  newExpression() {
+    const className = this.consume(
+      "IDENTIFIER",
+      "Se esperaba el nombre de la clase después de 'nuevo'",
+    );
+    this.consume("LEFT_PAREN", "Se esperaba ( después del nombre de la clase");
+
+    const args = [];
+    if (!this.check("RIGHT_PAREN")) {
+      do {
+        args.push(this.expression());
+      } while (this.match("COMMA"));
+    }
+
+    this.consume("RIGHT_PAREN", "Se esperaba ) después de los argumentos");
+
+    return {
+      type: "NewExpression",
+      className: className.lexeme,
+      arguments: args,
+    };
+  }
+
+  /**
+   * Parses 'este' (this) expression
+   * @returns {Object} This expression
+   */
+  thisExpression() {
+    // Check if accessing a property
+    if (this.match("DOT")) {
+      const property = this.consume(
+        "IDENTIFIER",
+        "Se esperaba el nombre de la propiedad después de 'este.'",
+      );
+      return {
+        type: "ThisPropertyAccess",
+        property: property.lexeme,
+      };
+    }
+    return {
+      type: "This",
+    };
+  }
+
+  /**
+   * Parses 'super' expression for parent class calls
+   * @returns {Object} Super expression
+   */
+  superExpression() {
+    this.consume("LEFT_PAREN", "Se esperaba ( después de 'super'");
+
+    const args = [];
+    if (!this.check("RIGHT_PAREN")) {
+      do {
+        args.push(this.expression());
+      } while (this.match("COMMA"));
+    }
+
+    this.consume(
+      "RIGHT_PAREN",
+      "Se esperaba ) después de los argumentos de super",
+    );
+
+    return {
+      type: "SuperCall",
+      arguments: args,
+    };
+  }
+
+  /**
+   * Parses a template string expression
+   * @returns {Object} Template string expression with parsed expressions
+   */
+  templateStringExpression() {
+    const token = this.previous();
+    const { parts, expressions } = token.literal;
+    const Tokenizer = require("./tokenizer.js");
+
+    // Parse each expression string into an AST
+    const parsedExpressions = expressions.map((exprSource) => {
+      const tokenizer = new Tokenizer();
+      const exprTokens = tokenizer.tokenize(exprSource);
+      const exprParser = new Parser(exprTokens);
+      return exprParser.expression();
+    });
+
+    return {
+      type: "TemplateString",
+      parts,
+      expressions: parsedExpressions,
+    };
   }
 
   /**
@@ -707,38 +1019,141 @@ class Parser {
    * @returns {Object} Anonymous function expression
    */
   anonymousFunction() {
-    this.consume('LEFT_PAREN', 'Expected ( after funcion');
+    this.consume("LEFT_PAREN", "Expected ( after funcion");
 
     const parameters = [];
-    if (!this.check('RIGHT_PAREN')) {
+    if (!this.check("RIGHT_PAREN")) {
       do {
         if (parameters.length >= 255) {
-          throw new Error('No se pueden tener más de 255 parámetros');
+          throw new Error("No se pueden tener más de 255 parámetros");
         }
         let param;
-        if (this.match('IDENTIFIER')) {
+        if (this.match("IDENTIFIER")) {
           param = this.previous();
-        } else if (this.match('AND')) {
+        } else if (this.match("AND")) {
           param = this.previous();
         } else {
-          throw new Error('Se esperaba un nombre de parámetro');
+          throw new Error("Se esperaba un nombre de parámetro");
         }
         parameters.push(param.lexeme);
-      } while (this.match('COMMA'));
+      } while (this.match("COMMA"));
     }
 
-    this.consume('RIGHT_PAREN', 'Expected ) after parameters');
-    this.consume('LEFT_BRACE', 'Expected { before function body');
+    this.consume("RIGHT_PAREN", "Expected ) after parameters");
+    this.consume("LEFT_BRACE", "Expected { before function body");
     const body = this.block();
-    this.consume('RIGHT_BRACE', 'Expected } after function body');
+    this.consume("RIGHT_BRACE", "Expected } after function body");
 
     return {
-      type: 'AnonymousFunction',
+      type: "AnonymousFunction",
       parameters,
       body,
     };
   }
 
+  /**
+   * Checks if current position looks like arrow function parameters
+   * Looks ahead to find matching ) and checks for =>
+   * @returns {boolean} True if this looks like arrow function params
+   */
+  isArrowFunctionParams() {
+    // Save current position
+    const startPos = this.current;
+
+    // Empty params: () =>
+    if (this.check("RIGHT_PAREN")) {
+      // Check if next is =>
+      if (
+        this.tokens[this.current + 1] &&
+        this.tokens[this.current + 1].type === "ARROW"
+      ) {
+        return true;
+      }
+      return false;
+    }
+
+    // Try to match params pattern: identifier (comma identifier)*
+    let parenDepth = 1;
+    let pos = this.current;
+
+    while (pos < this.tokens.length && parenDepth > 0) {
+      const token = this.tokens[pos];
+      if (token.type === "LEFT_PAREN") {
+        parenDepth++;
+      } else if (token.type === "RIGHT_PAREN") {
+        parenDepth--;
+      }
+      pos++;
+    }
+
+    // pos is now after the matching )
+    // Check if next token is =>
+    if (pos < this.tokens.length && this.tokens[pos].type === "ARROW") {
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Parses arrow function with parenthesized parameters
+   * Called after LEFT_PAREN has been consumed
+   * @returns {Object} Arrow function expression
+   */
+  arrowFunctionWithParams() {
+    const parameters = [];
+
+    // Parse parameters
+    if (!this.check("RIGHT_PAREN")) {
+      do {
+        if (parameters.length >= 255) {
+          throw new Error("No se pueden tener más de 255 parámetros");
+        }
+        const param = this.consume(
+          "IDENTIFIER",
+          "Se esperaba un nombre de parámetro",
+        );
+        parameters.push(param.lexeme);
+      } while (this.match("COMMA"));
+    }
+
+    this.consume("RIGHT_PAREN", "Se esperaba ) después de los parámetros");
+    this.consume("ARROW", "Se esperaba => después de los parámetros");
+
+    return this.arrowFunctionBody(parameters);
+  }
+
+  /**
+   * Parses arrow function body (expression or block)
+   * @param {Array} parameters - Function parameters
+   * @returns {Object} Arrow function expression
+   */
+  arrowFunctionBody(parameters) {
+    // Check if body is a block
+    if (this.match("LEFT_BRACE")) {
+      const body = this.block();
+      this.consume(
+        "RIGHT_BRACE",
+        "Se esperaba } después del cuerpo de la función",
+      );
+      return {
+        type: "ArrowFunction",
+        parameters,
+        body,
+        isExpression: false,
+      };
+    }
+
+    // Body is a single expression (implicit return)
+    const expression = this.expression();
+    return {
+      type: "ArrowFunction",
+      parameters,
+      body: expression,
+      isExpression: true,
+    };
+  }
+
   /**
    * Finishes parsing an array access
    * @param {Object} array - The array being accessed
@@ -746,10 +1161,10 @@ class Parser {
    */
   finishArrayAccess(array) {
     const index = this.expression();
-    this.consume('RIGHT_BRACKET', 'Expected ] after array index');
+    this.consume("RIGHT_BRACKET", "Expected ] after array index");
 
     return {
-      type: 'ArrayAccess',
+      type: "ArrayAccess",
       array,
       index,
     };
@@ -761,63 +1176,101 @@ class Parser {
    * @returns {Object} Property access expression
    */
   finishPropertyAccess(object) {
-    this.consume('IDENTIFIER', 'Expected property name after .');
+    this.consume("IDENTIFIER", "Expected property name after .");
     const name = this.previous();
 
-    // Check if this is a method call (array or string)
+    // Check if this is a method call (array, string, or number)
     if (
-      name.lexeme === 'longitud' ||
-      name.lexeme === 'primero' ||
-      name.lexeme === 'ultimo' ||
-      name.lexeme === 'agregar' ||
-      name.lexeme === 'remover' ||
-      name.lexeme === 'contiene' ||
-      name.lexeme === 'recorrer' ||
-      name.lexeme === 'mayusculas' ||
-      name.lexeme === 'minusculas'
+      name.lexeme === "longitud" ||
+      name.lexeme === "primero" ||
+      name.lexeme === "ultimo" ||
+      name.lexeme === "agregar" ||
+      name.lexeme === "remover" ||
+      name.lexeme === "contiene" ||
+      name.lexeme === "recorrer" ||
+      name.lexeme === "mayusculas" ||
+      name.lexeme === "minusculas" ||
+      name.lexeme === "dividir" ||
+      name.lexeme === "reemplazar" ||
+      name.lexeme === "recortar" ||
+      name.lexeme === "incluye" ||
+      name.lexeme === "empiezaCon" ||
+      name.lexeme === "terminaCon" ||
+      name.lexeme === "caracter" ||
+      name.lexeme === "subcadena" ||
+      name.lexeme === "invertir" ||
+      name.lexeme === "filtrar" ||
+      name.lexeme === "mapear" ||
+      name.lexeme === "reducir" ||
+      name.lexeme === "ordenar" ||
+      name.lexeme === "buscar" ||
+      name.lexeme === "algunos" ||
+      name.lexeme === "todos" ||
+      name.lexeme === "unir" ||
+      name.lexeme === "cortar" ||
+      name.lexeme === "insertar" ||
+      name.lexeme === "esPar" ||
+      name.lexeme === "esImpar" ||
+      name.lexeme === "esPositivo" ||
+      name.lexeme === "esNegativo" ||
+      name.lexeme === "aTexto"
     ) {
       // Check if there are parentheses (method call syntax)
-      if (this.match('LEFT_PAREN')) {
+      if (this.match("LEFT_PAREN")) {
         // Consume the opening parenthesis
         // Check if there are arguments
-        if (!this.check('RIGHT_PAREN')) {
-          // Handle methods that accept arguments (like agregar, contiene, recorrer)
+        if (!this.check("RIGHT_PAREN")) {
+          // Handle methods that accept arguments
           if (
-            name.lexeme === 'agregar' ||
-            name.lexeme === 'contiene' ||
-            name.lexeme === 'recorrer'
+            name.lexeme === "agregar" ||
+            name.lexeme === "contiene" ||
+            name.lexeme === "recorrer" ||
+            name.lexeme === "dividir" ||
+            name.lexeme === "reemplazar" ||
+            name.lexeme === "incluye" ||
+            name.lexeme === "empiezaCon" ||
+            name.lexeme === "terminaCon" ||
+            name.lexeme === "caracter" ||
+            name.lexeme === "subcadena" ||
+            name.lexeme === "filtrar" ||
+            name.lexeme === "mapear" ||
+            name.lexeme === "reducir" ||
+            name.lexeme === "buscar" ||
+            name.lexeme === "algunos" ||
+            name.lexeme === "todos" ||
+            name.lexeme === "unir" ||
+            name.lexeme === "cortar" ||
+            name.lexeme === "insertar"
           ) {
             const args = [];
             do {
               args.push(this.expression());
-            } while (this.match('COMMA'));
-            this.consume('RIGHT_PAREN', 'Expected ) after method call');
+            } while (this.match("COMMA"));
+            this.consume("RIGHT_PAREN", "Expected ) after method call");
 
             return {
-              type: 'MethodCall',
+              type: "MethodCall",
               object,
               method: name.lexeme,
               arguments: args,
             };
           } else {
-            throw new Error(
-              `El método ${name.lexeme}() no acepta argumentos`
-            );
+            throw new Error(`El método ${name.lexeme}() no acepta argumentos`);
           }
         }
         // Consume the closing parenthesis
-        this.consume('RIGHT_PAREN', 'Expected ) after method call');
+        this.consume("RIGHT_PAREN", "Expected ) after method call");
       }
 
       return {
-        type: 'MethodCall',
+        type: "MethodCall",
         object,
         method: name.lexeme,
       };
     }
 
     return {
-      type: 'PropertyAccess',
+      type: "PropertyAccess",
       object,
       name: name.lexeme,
     };
@@ -831,21 +1284,21 @@ class Parser {
   finishCall(callee) {
     const args = [];
 
-    if (!this.check('RIGHT_PAREN')) {
+    if (!this.check("RIGHT_PAREN")) {
       do {
         if (args.length >= 255) {
-          throw new Error('Cannot have more than 255 arguments');
+          throw new Error("Cannot have more than 255 arguments");
         }
         args.push(this.expression());
-      } while (this.match('COMMA'));
+      } while (this.match("COMMA"));
     }
 
-    const paren = this.consume('RIGHT_PAREN', 'Expected ) after arguments');
+    const paren = this.consume("RIGHT_PAREN", "Expected ) after arguments");
 
     return {
-      type: 'Call',
+      type: "Call",
       callee: {
-        type: 'Variable',
+        type: "Variable",
         name: callee.lexeme,
       },
       arguments: args,
@@ -859,16 +1312,16 @@ class Parser {
   arrayLiteral() {
     const elements = [];
 
-    if (!this.check('RIGHT_BRACKET')) {
+    if (!this.check("RIGHT_BRACKET")) {
       do {
         elements.push(this.expression());
-      } while (this.match('COMMA'));
+      } while (this.match("COMMA"));
     }
 
-    this.consume('RIGHT_BRACKET', 'Expected ] after array elements');
+    this.consume("RIGHT_BRACKET", "Expected ] after array elements");
 
     return {
-      type: 'ArrayLiteral',
+      type: "ArrayLiteral",
       elements,
     };
   }
@@ -880,33 +1333,33 @@ class Parser {
   objectLiteral() {
     const properties = [];
 
-    if (!this.check('RIGHT_BRACE')) {
+    if (!this.check("RIGHT_BRACE")) {
       do {
         // Parse property name (identifier or string)
         let name;
-        if (this.match('IDENTIFIER')) {
+        if (this.match("IDENTIFIER")) {
           name = this.previous().lexeme;
-        } else if (this.match('STRING')) {
+        } else if (this.match("STRING")) {
           name = this.previous().literal;
         } else {
-          throw new Error('Se esperaba un nombre de propiedad');
+          throw new Error("Se esperaba un nombre de propiedad");
         }
 
-        this.consume('COLON', 'Expected : after property name');
+        this.consume("COLON", "Expected : after property name");
         const value = this.expression();
 
         properties.push({
-          type: 'Property',
+          type: "Property",
           name,
           value,
         });
-      } while (this.match('COMMA'));
+      } while (this.match("COMMA"));
     }
 
-    this.consume('RIGHT_BRACE', 'Expected } after object properties');
+    this.consume("RIGHT_BRACE", "Expected } after object properties");
 
     return {
-      type: 'ObjectLiteral',
+      type: "ObjectLiteral",
       properties,
     };
   }
@@ -950,7 +1403,7 @@ class Parser {
    * @returns {boolean} True if we reached the end
    */
   isAtEnd() {
-    return this.peek().type === 'EOF';
+    return this.peek().type === "EOF";
   }
 
   /**
@@ -988,21 +1441,23 @@ class Parser {
     this.advance();
 
     while (!this.isAtEnd()) {
-      if (this.previous().type === 'EOF') return;
+      if (this.previous().type === "EOF") return;
 
       switch (this.peek().type) {
-        case 'VARIABLE':
-        case 'FUNCION':
-        case 'MOSTRAR':
-        case 'LEER':
-        case 'SI':
-        case 'MIENTRAS':
-        case 'PARA':
-        case 'RETORNAR':
-        case 'ROMPER':
-        case 'CONTINUAR':
-        case 'INTENTAR':
-        case 'CAPTURAR':
+        case "VARIABLE":
+        case "CONSTANTE":
+        case "FUNCION":
+        case "CLASE":
+        case "MOSTRAR":
+        case "LEER":
+        case "SI":
+        case "MIENTRAS":
+        case "PARA":
+        case "RETORNAR":
+        case "ROMPER":
+        case "CONTINUAR":
+        case "INTENTAR":
+        case "CAPTURAR":
           return;
       }
 
@@ -1016,35 +1471,137 @@ class Parser {
    */
   tryStatement() {
     // Parse the try block
-    this.consume('LEFT_BRACE', 'Expected { after intentar');
+    this.consume("LEFT_BRACE", "Expected { after intentar");
     const tryBlock = this.block();
-    this.consume('RIGHT_BRACE', 'Expected } after intentar block');
+    this.consume("RIGHT_BRACE", "Expected } after intentar block");
 
     // Look for catch block
-    if (this.match('CAPTURAR')) {
+    if (this.match("CAPTURAR")) {
       // Parse catch parameter (error variable name)
-      this.consume('LEFT_PAREN', 'Expected ( after capturar');
+      this.consume("LEFT_PAREN", "Expected ( after capturar");
       const errorVariable = this.consume(
-        'IDENTIFIER',
-        'Expected error variable name'
+        "IDENTIFIER",
+        "Expected error variable name",
       );
-      this.consume('RIGHT_PAREN', 'Expected ) after error variable');
+      this.consume("RIGHT_PAREN", "Expected ) after error variable");
 
       // Parse catch block
-      this.consume('LEFT_BRACE', 'Expected { after capturar');
+      this.consume("LEFT_BRACE", "Expected { after capturar");
       const catchBlock = this.block();
-      this.consume('RIGHT_BRACE', 'Expected } after capturar block');
+      this.consume("RIGHT_BRACE", "Expected } after capturar block");
 
       return {
-        type: 'TryCatch',
+        type: "TryCatch",
         tryBlock,
         catchBlock,
         errorVariable: errorVariable.lexeme,
       };
     } else {
-      throw new Error('Se esperaba capturar después del bloque intentar');
+      throw new Error("Se esperaba capturar después del bloque intentar");
     }
   }
+
+  /**
+   * Parses an elegir (switch) statement
+   * @returns {Object} Elegir statement
+   */
+  elegirStatement() {
+    const discriminant = this.expression();
+    this.consume("LEFT_BRACE", "Expected { after elegir expression");
+
+    const cases = [];
+    let defaultCase = null;
+
+    while (!this.check("RIGHT_BRACE") && !this.isAtEnd()) {
+      if (this.match("CASO")) {
+        const testValue = this.expression();
+        this.consume("COLON", "Expected : after caso value");
+
+        let consequent;
+        if (this.check("LEFT_BRACE")) {
+          this.advance();
+          consequent = this.block();
+          this.consume("RIGHT_BRACE", "Expected } after caso block");
+        } else {
+          consequent = [this.declaration()];
+        }
+
+        cases.push({
+          test: testValue,
+          consequent,
+        });
+      } else if (this.match("PORDEFECTO")) {
+        this.consume("COLON", "Expected : after pordefecto");
+
+        let consequent;
+        if (this.check("LEFT_BRACE")) {
+          this.advance();
+          consequent = this.block();
+          this.consume("RIGHT_BRACE", "Expected } after pordefecto block");
+        } else {
+          consequent = [this.declaration()];
+        }
+
+        defaultCase = {
+          consequent,
+        };
+      } else {
+        throw new Error("Se esperaba caso o pordefecto dentro de elegir");
+      }
+    }
+
+    this.consume("RIGHT_BRACE", "Expected } after elegir block");
+
+    return {
+      type: "ElegirStatement",
+      discriminant,
+      cases,
+      defaultCase,
+    };
+  }
+
+  /**
+   * Parses a hacer/mientras (do-while) statement
+   * @returns {Object} HacerMientras statement
+   */
+  hacerMientrasStatement() {
+    this.consume("LEFT_BRACE", "Expected { after hacer");
+    const body = this.block();
+    this.consume("RIGHT_BRACE", "Expected } after hacer block");
+
+    this.consume("MIENTRAS", "Expected mientras after hacer block");
+    const condition = this.expression();
+
+    return {
+      type: "HacerMientrasStatement",
+      body,
+      condition,
+    };
+  }
+
+  /**
+   * Parses a para cada (for-each) statement
+   * @returns {Object} ForEach statement
+   */
+  forEachStatement() {
+    const iteratorName = this.consume(
+      "IDENTIFIER",
+      "Expected iterator variable name after cada",
+    );
+    this.consume("EN", "Expected en after iterator variable");
+    const iterable = this.expression();
+
+    this.consume("LEFT_BRACE", "Expected { after iterable");
+    const body = this.block();
+    this.consume("RIGHT_BRACE", "Expected } after para cada block");
+
+    return {
+      type: "ForEachStatement",
+      iterator: iteratorName.lexeme,
+      iterable,
+      body,
+    };
+  }
 }
 
 module.exports = Parser;