hispano-lang 1.0.8 → 2.0.0

package/dist/evaluator.js

@@ -7,6 +7,7 @@ class Evaluator {
   constructor() {
     this.environment = new Environment();
     this.output = [];
+    this.currentInstance = null; // For tracking 'este' (this)
   }
 
   /**
@@ -34,31 +35,41 @@ class Evaluator {
    */
   execute(statement) {
     switch (statement.type) {
-      case 'VariableDeclaration':
+      case "VariableDeclaration":
         return this.executeVariableDeclaration(statement);
-      case 'FunctionDeclaration':
+      case "ConstantDeclaration":
+        return this.executeConstantDeclaration(statement);
+      case "FunctionDeclaration":
         return this.executeFunctionDeclaration(statement);
-      case 'MostrarStatement':
+      case "ClassDeclaration":
+        return this.executeClassDeclaration(statement);
+      case "MostrarStatement":
         return this.executeMostrarStatement(statement);
-      case 'LeerStatement':
+      case "LeerStatement":
         return this.executeLeerStatement(statement);
-      case 'IfStatement':
+      case "IfStatement":
         return this.executeIfStatement(statement);
-      case 'WhileStatement':
+      case "WhileStatement":
         return this.executeWhileStatement(statement);
-      case 'ForStatement':
+      case "ForStatement":
         return this.executeForStatement(statement);
-      case 'ReturnStatement':
+      case "ReturnStatement":
         return this.executeReturnStatement(statement);
-      case 'BreakStatement':
+      case "BreakStatement":
         return this.executeBreakStatement(statement);
-      case 'ContinueStatement':
+      case "ContinueStatement":
         return this.executeContinueStatement(statement);
-      case 'TryCatch':
+      case "TryCatch":
         return this.executeTryCatch(statement);
-      case 'ExpressionStatement':
+      case "ElegirStatement":
+        return this.executeElegirStatement(statement);
+      case "HacerMientrasStatement":
+        return this.executeHacerMientrasStatement(statement);
+      case "ForEachStatement":
+        return this.executeForEachStatement(statement);
+      case "ExpressionStatement":
         return this.executeExpressionStatement(statement);
-      case 'Block':
+      case "Block":
         return this.executeBlock(statement);
     }
   }
@@ -76,13 +87,22 @@ class Evaluator {
     this.environment.define(statement.name, value);
   }
 
+  /**
+   * Executes a constant declaration
+   * @param {Object} statement - Constant declaration
+   */
+  executeConstantDeclaration(statement) {
+    const value = this.evaluateExpression(statement.initializer);
+    this.environment.defineConstant(statement.name, value);
+  }
+
   /**
    * Executes a function declaration
    * @param {Object} statement - Function declaration
    */
   executeFunctionDeclaration(statement) {
     const functionObj = {
-      type: 'Function',
+      type: "Function",
       name: statement.name,
       parameters: statement.parameters,
       body: statement.body,
@@ -91,6 +111,22 @@ class Evaluator {
     this.environment.define(statement.name, functionObj);
   }
 
+  /**
+   * Executes a class declaration
+   * @param {Object} statement - Class declaration
+   */
+  executeClassDeclaration(statement) {
+    const classObj = {
+      type: "Class",
+      name: statement.name,
+      superclass: statement.superclass,
+      constructor: statement.constructor,
+      methods: statement.methods,
+    };
+
+    this.environment.define(statement.name, classObj);
+  }
+
   /**
    * Executes a show statement
    * @param {Object} statement - Show statement
@@ -113,21 +149,21 @@ class Evaluator {
     }
 
     // Try different methods for input
-    let input = '';
+    let input = "";
 
     try {
       // Method 1: Try readline-sync
-      const readlineSync = require('readline-sync');
-      input = readlineSync.question('');
+      const readlineSync = require("readline-sync");
+      input = readlineSync.question("");
     } catch (error1) {
       try {
         // Method 2: Try fs.readFileSync with stdin
-        const fs = require('fs');
-        input = fs.readFileSync(0, 'utf8').trim();
+        const fs = require("fs");
+        input = fs.readFileSync(0, "utf8").trim();
       } catch (error2) {
         try {
           // Method 3: Try process.stdin
-          const readline = require('readline');
+          const readline = require("readline");
           const rl = readline.createInterface({
             input: process.stdin,
             output: process.stdout,
@@ -135,18 +171,18 @@ class Evaluator {
 
           // This is a simplified approach - in a real implementation
           // you'd need to handle this asynchronously
-          input = '';
+          input = "";
         } catch (error3) {
           // Fallback: use empty string
-          input = '';
-          console.log('(Entrada no disponible en este entorno)');
+          input = "";
+          console.log("(Entrada no disponible en este entorno)");
         }
       }
     }
 
     // Try to parse as number first, then as string
     let value = input;
-    if (!isNaN(input) && input.trim() !== '') {
+    if (!isNaN(input) && input.trim() !== "") {
       value = parseFloat(input);
     }
 
@@ -286,75 +322,101 @@ class Evaluator {
    */
   evaluateExpression(expression) {
     switch (expression.type) {
-      case 'Literal':
+      case "Literal":
         return expression.value;
 
-      case 'Variable':
+      case "TemplateString":
+        return this.evaluateTemplateString(expression);
+
+      case "Variable":
         return this.environment.get(expression.name);
 
-      case 'AnonymousFunction':
+      case "AnonymousFunction":
         return {
-          type: 'Function',
+          type: "Function",
           name: null,
           parameters: expression.parameters,
           body: expression.body,
         };
 
-      case 'Assign':
+      case "Assign":
         const value = this.evaluateExpression(expression.value);
         this.environment.assign(expression.name, value);
         return value;
 
-      case 'ArrayLiteral':
+      case "ArrayLiteral":
         return this.evaluateArrayLiteral(expression);
 
-      case 'ArrayAccess':
+      case "ArrayAccess":
         return this.evaluateArrayAccess(expression);
 
-      case 'ArrayAssign':
+      case "ArrayAssign":
         return this.evaluateArrayAssign(expression);
 
-      case 'ObjectLiteral':
+      case "ObjectLiteral":
         return this.evaluateObjectLiteral(expression);
 
-      case 'PropertyAccess':
+      case "PropertyAccess":
         return this.evaluatePropertyAccess(expression);
 
-      case 'PropertyAssign':
+      case "PropertyAssign":
         return this.evaluatePropertyAssign(expression);
 
-      case 'CompoundAssign':
+      case "CompoundAssign":
         return this.evaluateCompoundAssign(expression);
 
-      case 'CompoundArrayAssign':
+      case "CompoundArrayAssign":
         return this.evaluateCompoundArrayAssign(expression);
 
-      case 'CompoundPropertyAssign':
+      case "CompoundPropertyAssign":
         return this.evaluateCompoundPropertyAssign(expression);
 
-      case 'Logical':
+      case "Logical":
         return this.evaluateLogicalExpression(expression);
 
-      case 'Postfix':
+      case "Postfix":
         return this.evaluatePostfixExpression(expression);
 
-      case 'Call':
+      case "Call":
         return this.evaluateCallExpression(expression);
 
-      case 'MethodCall':
+      case "MethodCall":
         return this.evaluateMethodCall(expression);
 
-      case 'Unary':
+      case "NewExpression":
+        return this.evaluateNewExpression(expression);
+
+      case "This":
+        if (this.currentInstance === null) {
+          throw new Error(
+            "'este' solo se puede usar dentro de un método de clase",
+          );
+        }
+        return this.currentInstance;
+
+      case "ThisPropertyAccess":
+        return this.evaluateThisPropertyAccess(expression);
+
+      case "ThisPropertyAssign":
+        return this.evaluateThisPropertyAssign(expression);
+
+      case "ThisMethodCall":
+        return this.evaluateThisMethodCall(expression);
+
+      case "SuperCall":
+        return this.evaluateSuperCall(expression);
+
+      case "Unary":
         const right = this.evaluateExpression(expression.right);
         return this.evaluateUnaryExpression(expression.operator, right);
 
-      case 'Binary':
+      case "Binary":
         const left = this.evaluateExpression(expression.left);
         const rightOperand = this.evaluateExpression(expression.right);
         return this.evaluateBinaryExpression(
           left,
           expression.operator,
-          rightOperand
+          rightOperand,
         );
 
       default:
@@ -370,11 +432,11 @@ class Evaluator {
    */
   evaluateUnaryExpression(operator, right) {
     switch (operator) {
-      case 'MINUS':
+      case "MINUS":
         this.checkNumberOperand(operator, right);
         return -right;
 
-      case 'BANG':
+      case "BANG":
         return !this.isTruthy(right);
 
       default:
@@ -391,12 +453,12 @@ class Evaluator {
    */
   evaluateBinaryExpression(left, operator, right) {
     switch (operator) {
-      case 'MINUS':
+      case "MINUS":
         this.checkNumberOperands(operator, left, right);
         return left - right;
 
-      case 'PLUS':
-        if (typeof left === 'number' && typeof right === 'number') {
+      case "PLUS":
+        if (typeof left === "number" && typeof right === "number") {
           return left + right;
         }
         // Convert numbers to strings for concatenation
@@ -404,56 +466,56 @@ class Evaluator {
         const rightStr = this.stringify(right);
         return leftStr + rightStr;
 
-      case 'SLASH':
+      case "SLASH":
         this.checkNumberOperands(operator, left, right);
         if (right === 0) {
-          throw new Error('División por cero');
+          throw new Error("División por cero");
         }
         return left / right;
 
-      case 'STAR':
+      case "STAR":
         this.checkNumberOperands(operator, left, right);
         return left * right;
 
-      case 'PERCENT':
+      case "PERCENT":
         this.checkNumberOperands(operator, left, right);
         if (right === 0) {
-          throw new Error('Módulo por cero');
+          throw new Error("Módulo por cero");
         }
         return left % right;
 
-      case 'GREATER':
-        if (typeof left === 'string' && typeof right === 'string') {
+      case "GREATER":
+        if (typeof left === "string" && typeof right === "string") {
           return left > right;
         }
         this.checkNumberOperands(operator, left, right);
         return left > right;
 
-      case 'GREATER_EQUAL':
-        if (typeof left === 'string' && typeof right === 'string') {
+      case "GREATER_EQUAL":
+        if (typeof left === "string" && typeof right === "string") {
           return left >= right;
         }
         this.checkNumberOperands(operator, left, right);
         return left >= right;
 
-      case 'LESS':
-        if (typeof left === 'string' && typeof right === 'string') {
+      case "LESS":
+        if (typeof left === "string" && typeof right === "string") {
           return left < right;
         }
         this.checkNumberOperands(operator, left, right);
         return left < right;
 
-      case 'LESS_EQUAL':
-        if (typeof left === 'string' && typeof right === 'string') {
+      case "LESS_EQUAL":
+        if (typeof left === "string" && typeof right === "string") {
           return left <= right;
         }
         this.checkNumberOperands(operator, left, right);
         return left <= right;
 
-      case 'EQUAL_EQUAL':
+      case "EQUAL_EQUAL":
         return this.isEqual(left, right);
 
-      case 'BANG_EQUAL':
+      case "BANG_EQUAL":
         return !this.isEqual(left, right);
 
       default:
@@ -468,8 +530,8 @@ class Evaluator {
    */
   isTruthy(value) {
     if (value === null) return false;
-    if (typeof value === 'boolean') return value;
-    if (typeof value === 'number') return value !== 0;
+    if (typeof value === "boolean") return value;
+    if (typeof value === "number") return value !== 0;
     return true;
   }
 
@@ -489,7 +551,7 @@ class Evaluator {
    * @param {any} operand - Operand
    */
   checkNumberOperand(operator, operand) {
-    if (typeof operand === 'number') return;
+    if (typeof operand === "number") return;
     throw new Error(`El operador ${operator} requiere un número`);
   }
 
@@ -500,7 +562,7 @@ class Evaluator {
    * @param {any} right - Right operand
    */
   checkNumberOperands(operator, left, right) {
-    if (typeof left === 'number' && typeof right === 'number') return;
+    if (typeof left === "number" && typeof right === "number") return;
     throw new Error(`El operador ${operator} requiere dos números`);
   }
 
@@ -512,7 +574,7 @@ class Evaluator {
   evaluateCallExpression(expression) {
     // Check if it's a built-in mathematical function BEFORE evaluating the callee
     if (
-      expression.callee.type === 'Variable' &&
+      expression.callee.type === "Variable" &&
       this.isMathFunction(expression.callee.name)
     ) {
       const args = [];
@@ -522,6 +584,18 @@ class Evaluator {
       return this.evaluateMathFunction(expression.callee.name, args);
     }
 
+    // Check if it's a built-in type conversion function
+    if (
+      expression.callee.type === "Variable" &&
+      this.isConversionFunction(expression.callee.name)
+    ) {
+      const args = [];
+      for (const argument of expression.arguments) {
+        args.push(this.evaluateExpression(argument));
+      }
+      return this.evaluateConversionFunction(expression.callee.name, args);
+    }
+
     const callee = this.evaluateExpression(expression.callee);
     const args = [];
 
@@ -529,13 +603,13 @@ class Evaluator {
       args.push(this.evaluateExpression(argument));
     }
 
-    if (callee.type !== 'Function') {
-      throw new Error('Solo se pueden llamar funciones');
+    if (callee.type !== "Function") {
+      throw new Error("Solo se pueden llamar funciones");
     }
 
     if (args.length !== callee.parameters.length) {
       throw new Error(
-        `Se esperaban ${callee.parameters.length} argumentos pero se recibieron ${args.length}`
+        `Se esperaban ${callee.parameters.length} argumentos pero se recibieron ${args.length}`,
       );
     }
 
@@ -561,38 +635,128 @@ class Evaluator {
   }
 
   /**
-   * Evaluates a method call (array or string)
+   * Evaluates a method call (array, string, number, or instance)
    * @param {Object} expression - Method call expression
    * @returns {any} Method result
    */
   evaluateMethodCall(expression) {
     const object = this.evaluateExpression(expression.object);
 
-    // Determine if it's an array or string method based on the object type
+    // Determine if it's an array, string, number, or instance method
     if (Array.isArray(object)) {
       return this.evaluateArrayMethod(
         object,
         expression.method,
-        expression.arguments
+        expression.arguments,
       );
-    } else if (typeof object === 'string') {
+    } else if (typeof object === "string") {
       // Check if the method is valid for strings
       if (
-        expression.method === 'agregar' ||
-        expression.method === 'remover' ||
-        expression.method === 'contiene' ||
-        expression.method === 'recorrer'
+        expression.method === "agregar" ||
+        expression.method === "remover" ||
+        expression.method === "recorrer" ||
+        expression.method === "primero" ||
+        expression.method === "ultimo"
       ) {
         throw new Error(
-          `El método ${expression.method}() solo se puede llamar en arreglos`
+          `El método ${expression.method}() solo se puede llamar en arreglos`,
         );
       }
-      return this.evaluateStringMethod(object, expression.method);
+      return this.evaluateStringMethod(
+        object,
+        expression.method,
+        expression.arguments,
+      );
+    } else if (typeof object === "number") {
+      return this.evaluateNumberMethod(
+        object,
+        expression.method,
+        expression.arguments,
+      );
+    } else if (object && object.type === "Instance") {
+      return this.evaluateInstanceMethodCall(
+        object,
+        expression.method,
+        expression.arguments,
+      );
     } else {
       throw new Error(
-        `Solo se pueden llamar métodos en arreglos o cadenas, se recibió ${typeof object}`
+        `Solo se pueden llamar métodos en arreglos, cadenas, números o instancias`,
+      );
+    }
+  }
+
+  /**
+   * Evaluates an instance method call
+   * @param {Object} instance - The instance object
+   * @param {string} methodName - The method name
+   * @param {Array} args - Method arguments
+   * @returns {any} Method result
+   */
+  evaluateInstanceMethodCall(instance, methodName, args) {
+    // Find the method in the class
+    let method = null;
+    const classObj = instance.classObj;
+
+    for (const m of classObj.methods) {
+      if (m.name === methodName) {
+        method = m;
+        break;
+      }
+    }
+
+    // If not found, check parent class
+    if (!method && instance.parentClass) {
+      for (const m of instance.parentClass.methods) {
+        if (m.name === methodName) {
+          method = m;
+          break;
+        }
+      }
+    }
+
+    if (!method) {
+      throw new Error(
+        `Método '${methodName}' no encontrado en la clase '${instance.className}'`,
       );
     }
+
+    // Evaluate arguments
+    const evaluatedArgs = [];
+    for (const arg of args) {
+      evaluatedArgs.push(this.evaluateExpression(arg));
+    }
+
+    // Check argument count
+    if (method.parameters.length !== evaluatedArgs.length) {
+      throw new Error(
+        `El método '${methodName}' espera ${method.parameters.length} argumentos pero recibió ${evaluatedArgs.length}`,
+      );
+    }
+
+    // Set up method environment
+    const methodEnv = new Environment(this.environment);
+    for (let i = 0; i < evaluatedArgs.length; i++) {
+      methodEnv.define(method.parameters[i], evaluatedArgs[i]);
+    }
+
+    const previousInstance = this.currentInstance;
+    const previousEnv = this.environment;
+    this.currentInstance = instance;
+    this.environment = methodEnv;
+
+    try {
+      this.executeBlock(method.body);
+      return null;
+    } catch (returnValue) {
+      if (returnValue instanceof ReturnException) {
+        return returnValue.value;
+      }
+      throw returnValue;
+    } finally {
+      this.environment = previousEnv;
+      this.currentInstance = previousInstance;
+    }
   }
 
   /**
@@ -604,22 +768,26 @@ class Evaluator {
    */
   evaluateArrayMethod(array, method, args = []) {
     switch (method) {
-      case 'longitud':
+      case "longitud":
         return array.length;
 
-      case 'primero':
+      case "primero":
         if (array.length === 0) {
-          throw new Error('No se puede obtener el primer elemento de un arreglo vacío');
+          throw new Error(
+            "No se puede obtener el primer elemento de un arreglo vacío",
+          );
         }
         return array[0];
 
-      case 'ultimo':
+      case "ultimo":
         if (array.length === 0) {
-          throw new Error('No se puede obtener el último elemento de un arreglo vacío');
+          throw new Error(
+            "No se puede obtener el último elemento de un arreglo vacío",
+          );
         }
         return array[array.length - 1];
 
-      case 'agregar':
+      case "agregar":
         // Evaluate all arguments and add them to the array
         for (const arg of args) {
           const value = this.evaluateExpression(arg);
@@ -627,29 +795,37 @@ class Evaluator {
         }
         return array.length; // Return the new length
 
-      case 'remover':
+      case "remover":
         // Remove and return the last element
         if (array.length === 0) {
-          throw new Error('No se puede eliminar un elemento de un arreglo vacío');
+          throw new Error(
+            "No se puede eliminar un elemento de un arreglo vacío",
+          );
         }
         return array.pop(); // Return the removed element
 
-      case 'contiene':
+      case "contiene":
         // Check if array contains the specified element
         if (args.length !== 1) {
-          throw new Error('El método contiene() requiere exactamente un argumento');
+          throw new Error(
+            "El método contiene() requiere exactamente un argumento",
+          );
         }
         const searchElement = this.evaluateExpression(args[0]);
         return array.includes(searchElement);
 
-      case 'recorrer':
+      case "recorrer":
         // Iterate through array and call function for each element
         if (args.length !== 1) {
-          throw new Error('El método recorrer() requiere exactamente un argumento');
+          throw new Error(
+            "El método recorrer() requiere exactamente un argumento",
+          );
         }
         const callback = this.evaluateExpression(args[0]);
-        if (callback.type !== 'Function') {
-          throw new Error('El método recorrer() requiere una función como argumento');
+        if (callback.type !== "Function") {
+          throw new Error(
+            "El método recorrer() requiere una función como argumento",
+          );
         }
 
         // Call the function for each element
@@ -660,19 +836,19 @@ class Evaluator {
           // Handle function parameters
           if (callback.parameters.length === 0) {
             // No parameters - use automatic variables
-            callbackEnv.define('elemento', array[i]);
-            callbackEnv.define('indice', i);
+            callbackEnv.define("elemento", array[i]);
+            callbackEnv.define("indice", i);
           } else if (callback.parameters.length === 1) {
             // One parameter - element only
             callbackEnv.define(callback.parameters[0], array[i]);
-            callbackEnv.define('indice', i);
+            callbackEnv.define("indice", i);
           } else if (callback.parameters.length === 2) {
             // Two parameters - element and index
             callbackEnv.define(callback.parameters[0], array[i]);
             callbackEnv.define(callback.parameters[1], i);
           } else {
             throw new Error(
-              'La función en recorrer() puede tener máximo 2 parámetros'
+              "La función en recorrer() puede tener máximo 2 parámetros",
             );
           }
 
@@ -687,6 +863,313 @@ class Evaluator {
         }
         return null; // forEach doesn't return anything
 
+      case "filtrar":
+        // Filter array elements based on a predicate function
+        if (args.length !== 1) {
+          throw new Error("filtrar() requiere exactamente 1 argumento");
+        }
+        const filterCallback = this.evaluateExpression(args[0]);
+        if (filterCallback.type !== "Function") {
+          throw new Error("filtrar() requiere una función como argumento");
+        }
+        const filteredArray = [];
+        for (let i = 0; i < array.length; i++) {
+          const filterEnv = new Environment(this.environment);
+          if (filterCallback.parameters.length >= 1) {
+            filterEnv.define(filterCallback.parameters[0], array[i]);
+          }
+          if (filterCallback.parameters.length >= 2) {
+            filterEnv.define(filterCallback.parameters[1], i);
+          }
+          const prevEnv = this.environment;
+          this.environment = filterEnv;
+          try {
+            this.executeBlock(filterCallback.body);
+          } catch (returnValue) {
+            if (returnValue instanceof ReturnException) {
+              if (this.isTruthy(returnValue.value)) {
+                filteredArray.push(array[i]);
+              }
+            } else {
+              throw returnValue;
+            }
+          } finally {
+            this.environment = prevEnv;
+          }
+        }
+        return filteredArray;
+
+      case "mapear":
+        // Transform each element using a function
+        if (args.length !== 1) {
+          throw new Error("mapear() requiere exactamente 1 argumento");
+        }
+        const mapCallback = this.evaluateExpression(args[0]);
+        if (mapCallback.type !== "Function") {
+          throw new Error("mapear() requiere una función como argumento");
+        }
+        const mappedArray = [];
+        for (let i = 0; i < array.length; i++) {
+          const mapEnv = new Environment(this.environment);
+          if (mapCallback.parameters.length >= 1) {
+            mapEnv.define(mapCallback.parameters[0], array[i]);
+          }
+          if (mapCallback.parameters.length >= 2) {
+            mapEnv.define(mapCallback.parameters[1], i);
+          }
+          const prevEnv = this.environment;
+          this.environment = mapEnv;
+          try {
+            this.executeBlock(mapCallback.body);
+            mappedArray.push(null); // If no return, push null
+          } catch (returnValue) {
+            if (returnValue instanceof ReturnException) {
+              mappedArray.push(returnValue.value);
+            } else {
+              throw returnValue;
+            }
+          } finally {
+            this.environment = prevEnv;
+          }
+        }
+        return mappedArray;
+
+      case "reducir":
+        // Reduce array to a single value
+        if (args.length < 1 || args.length > 2) {
+          throw new Error("reducir() requiere 1 o 2 argumentos");
+        }
+        const reduceCallback = this.evaluateExpression(args[0]);
+        if (reduceCallback.type !== "Function") {
+          throw new Error(
+            "reducir() requiere una función como primer argumento",
+          );
+        }
+        let accumulator =
+          args.length === 2 ? this.evaluateExpression(args[1]) : array[0];
+        const startIndex = args.length === 2 ? 0 : 1;
+        for (let i = startIndex; i < array.length; i++) {
+          const reduceEnv = new Environment(this.environment);
+          if (reduceCallback.parameters.length >= 1) {
+            reduceEnv.define(reduceCallback.parameters[0], accumulator);
+          }
+          if (reduceCallback.parameters.length >= 2) {
+            reduceEnv.define(reduceCallback.parameters[1], array[i]);
+          }
+          if (reduceCallback.parameters.length >= 3) {
+            reduceEnv.define(reduceCallback.parameters[2], i);
+          }
+          const prevEnv = this.environment;
+          this.environment = reduceEnv;
+          try {
+            this.executeBlock(reduceCallback.body);
+          } catch (returnValue) {
+            if (returnValue instanceof ReturnException) {
+              accumulator = returnValue.value;
+            } else {
+              throw returnValue;
+            }
+          } finally {
+            this.environment = prevEnv;
+          }
+        }
+        return accumulator;
+
+      case "ordenar":
+        // Sort array (optionally with comparison function)
+        if (args.length === 0) {
+          // Default sort (numeric or string)
+          return [...array].sort((a, b) => {
+            if (typeof a === "number" && typeof b === "number") {
+              return a - b;
+            }
+            return String(a).localeCompare(String(b));
+          });
+        } else if (args.length === 1) {
+          const sortCallback = this.evaluateExpression(args[0]);
+          if (sortCallback.type !== "Function") {
+            throw new Error("ordenar() requiere una función como argumento");
+          }
+          return [...array].sort((a, b) => {
+            const sortEnv = new Environment(this.environment);
+            if (sortCallback.parameters.length >= 1) {
+              sortEnv.define(sortCallback.parameters[0], a);
+            }
+            if (sortCallback.parameters.length >= 2) {
+              sortEnv.define(sortCallback.parameters[1], b);
+            }
+            const prevEnv = this.environment;
+            this.environment = sortEnv;
+            try {
+              this.executeBlock(sortCallback.body);
+              return 0;
+            } catch (returnValue) {
+              if (returnValue instanceof ReturnException) {
+                return returnValue.value;
+              }
+              throw returnValue;
+            } finally {
+              this.environment = prevEnv;
+            }
+          });
+        } else {
+          throw new Error("ordenar() acepta 0 o 1 argumentos");
+        }
+
+      case "invertir":
+        // Reverse array (returns new array)
+        return [...array].reverse();
+
+      case "buscar":
+        // Find first element matching predicate
+        if (args.length !== 1) {
+          throw new Error("buscar() requiere exactamente 1 argumento");
+        }
+        const findCallback = this.evaluateExpression(args[0]);
+        if (findCallback.type !== "Function") {
+          throw new Error("buscar() requiere una función como argumento");
+        }
+        for (let i = 0; i < array.length; i++) {
+          const findEnv = new Environment(this.environment);
+          if (findCallback.parameters.length >= 1) {
+            findEnv.define(findCallback.parameters[0], array[i]);
+          }
+          if (findCallback.parameters.length >= 2) {
+            findEnv.define(findCallback.parameters[1], i);
+          }
+          const prevEnv = this.environment;
+          this.environment = findEnv;
+          try {
+            this.executeBlock(findCallback.body);
+          } catch (returnValue) {
+            if (returnValue instanceof ReturnException) {
+              if (this.isTruthy(returnValue.value)) {
+                this.environment = prevEnv;
+                return array[i];
+              }
+            } else {
+              throw returnValue;
+            }
+          } finally {
+            this.environment = prevEnv;
+          }
+        }
+        return undefined;
+
+      case "algunos":
+        // Check if some elements match predicate
+        if (args.length !== 1) {
+          throw new Error("algunos() requiere exactamente 1 argumento");
+        }
+        const someCallback = this.evaluateExpression(args[0]);
+        if (someCallback.type !== "Function") {
+          throw new Error("algunos() requiere una función como argumento");
+        }
+        for (let i = 0; i < array.length; i++) {
+          const someEnv = new Environment(this.environment);
+          if (someCallback.parameters.length >= 1) {
+            someEnv.define(someCallback.parameters[0], array[i]);
+          }
+          if (someCallback.parameters.length >= 2) {
+            someEnv.define(someCallback.parameters[1], i);
+          }
+          const prevEnv = this.environment;
+          this.environment = someEnv;
+          try {
+            this.executeBlock(someCallback.body);
+          } catch (returnValue) {
+            if (returnValue instanceof ReturnException) {
+              if (this.isTruthy(returnValue.value)) {
+                this.environment = prevEnv;
+                return true;
+              }
+            } else {
+              throw returnValue;
+            }
+          } finally {
+            this.environment = prevEnv;
+          }
+        }
+        return false;
+
+      case "todos":
+        // Check if all elements match predicate
+        if (args.length !== 1) {
+          throw new Error("todos() requiere exactamente 1 argumento");
+        }
+        const everyCallback = this.evaluateExpression(args[0]);
+        if (everyCallback.type !== "Function") {
+          throw new Error("todos() requiere una función como argumento");
+        }
+        for (let i = 0; i < array.length; i++) {
+          const everyEnv = new Environment(this.environment);
+          if (everyCallback.parameters.length >= 1) {
+            everyEnv.define(everyCallback.parameters[0], array[i]);
+          }
+          if (everyCallback.parameters.length >= 2) {
+            everyEnv.define(everyCallback.parameters[1], i);
+          }
+          const prevEnv = this.environment;
+          this.environment = everyEnv;
+          try {
+            this.executeBlock(everyCallback.body);
+          } catch (returnValue) {
+            if (returnValue instanceof ReturnException) {
+              if (!this.isTruthy(returnValue.value)) {
+                this.environment = prevEnv;
+                return false;
+              }
+            } else {
+              throw returnValue;
+            }
+          } finally {
+            this.environment = prevEnv;
+          }
+        }
+        return true;
+
+      case "unir":
+        // Join array elements into string
+        if (args.length !== 1) {
+          throw new Error("unir() requiere exactamente 1 argumento");
+        }
+        const separator = this.evaluateExpression(args[0]);
+        if (typeof separator !== "string") {
+          throw new Error("unir() requiere un argumento de tipo cadena");
+        }
+        return array.join(separator);
+
+      case "cortar":
+        // Slice array (returns subarray)
+        if (args.length < 1 || args.length > 2) {
+          throw new Error("cortar() requiere 1 o 2 argumentos");
+        }
+        const sliceStart = this.evaluateExpression(args[0]);
+        if (typeof sliceStart !== "number") {
+          throw new Error("cortar() requiere argumentos numéricos");
+        }
+        if (args.length === 2) {
+          const sliceEnd = this.evaluateExpression(args[1]);
+          if (typeof sliceEnd !== "number") {
+            throw new Error("cortar() requiere argumentos numéricos");
+          }
+          return array.slice(sliceStart, sliceEnd);
+        }
+        return array.slice(sliceStart);
+
+      case "insertar":
+        // Insert element at position (modifies array)
+        if (args.length !== 2) {
+          throw new Error("insertar() requiere exactamente 2 argumentos");
+        }
+        const insertIndex = this.evaluateExpression(args[0]);
+        const insertValue = this.evaluateExpression(args[1]);
+        if (typeof insertIndex !== "number") {
+          throw new Error("insertar() requiere un índice numérico");
+        }
+        array.splice(insertIndex, 0, insertValue);
+        return array.length;
+
       default:
         throw new Error(`Método de arreglo desconocido: ${method}`);
     }
@@ -696,24 +1179,356 @@ class Evaluator {
    * Evaluates a string method
    * @param {string} string - The string object
    * @param {string} method - The method name
+   * @param {Array} args - Method arguments (optional)
    * @returns {any} Method result
    */
-  evaluateStringMethod(string, method) {
+  evaluateStringMethod(string, method, args = []) {
     switch (method) {
-      case 'longitud':
+      case "longitud":
         return string.length;
 
-      case 'mayusculas':
+      case "mayusculas":
         return string.toUpperCase();
 
-      case 'minusculas':
+      case "minusculas":
         return string.toLowerCase();
 
+      case "dividir":
+        if (args.length !== 1) {
+          throw new Error("dividir() requiere exactamente 1 argumento");
+        }
+        const separator = this.evaluateExpression(args[0]);
+        if (typeof separator !== "string") {
+          throw new Error("dividir() requiere un argumento de tipo cadena");
+        }
+        return string.split(separator);
+
+      case "reemplazar":
+        if (args.length !== 2) {
+          throw new Error("reemplazar() requiere exactamente 2 argumentos");
+        }
+        const search = this.evaluateExpression(args[0]);
+        const replacement = this.evaluateExpression(args[1]);
+        if (typeof search !== "string" || typeof replacement !== "string") {
+          throw new Error("reemplazar() requiere argumentos de tipo cadena");
+        }
+        return string.split(search).join(replacement);
+
+      case "recortar":
+        return string.trim();
+
+      case "incluye":
+        if (args.length !== 1) {
+          throw new Error("incluye() requiere exactamente 1 argumento");
+        }
+        const substring = this.evaluateExpression(args[0]);
+        if (typeof substring !== "string") {
+          throw new Error("incluye() requiere un argumento de tipo cadena");
+        }
+        return string.includes(substring);
+
+      case "empiezaCon":
+        if (args.length !== 1) {
+          throw new Error("empiezaCon() requiere exactamente 1 argumento");
+        }
+        const prefix = this.evaluateExpression(args[0]);
+        if (typeof prefix !== "string") {
+          throw new Error("empiezaCon() requiere un argumento de tipo cadena");
+        }
+        return string.startsWith(prefix);
+
+      case "terminaCon":
+        if (args.length !== 1) {
+          throw new Error("terminaCon() requiere exactamente 1 argumento");
+        }
+        const suffix = this.evaluateExpression(args[0]);
+        if (typeof suffix !== "string") {
+          throw new Error("terminaCon() requiere un argumento de tipo cadena");
+        }
+        return string.endsWith(suffix);
+
+      case "caracter":
+        if (args.length !== 1) {
+          throw new Error("caracter() requiere exactamente 1 argumento");
+        }
+        const charIndex = this.evaluateExpression(args[0]);
+        if (typeof charIndex !== "number") {
+          throw new Error("caracter() requiere un argumento numérico");
+        }
+        if (charIndex < 0 || charIndex >= string.length) {
+          throw new Error("Índice fuera de rango");
+        }
+        return string.charAt(charIndex);
+
+      case "subcadena":
+        if (args.length < 1 || args.length > 2) {
+          throw new Error("subcadena() requiere 1 o 2 argumentos");
+        }
+        const start = this.evaluateExpression(args[0]);
+        if (typeof start !== "number") {
+          throw new Error("subcadena() requiere argumentos numéricos");
+        }
+        if (args.length === 2) {
+          const end = this.evaluateExpression(args[1]);
+          if (typeof end !== "number") {
+            throw new Error("subcadena() requiere argumentos numéricos");
+          }
+          return string.substring(start, end);
+        }
+        return string.substring(start);
+
+      case "invertir":
+        return string.split("").reverse().join("");
+
+      case "contiene":
+        if (args.length !== 1) {
+          throw new Error("contiene() requiere exactamente 1 argumento");
+        }
+        const searchStr = this.evaluateExpression(args[0]);
+        if (typeof searchStr !== "string") {
+          throw new Error("contiene() requiere un argumento de tipo cadena");
+        }
+        return string.includes(searchStr);
+
       default:
         throw new Error(`Método de cadena desconocido: ${method}`);
     }
   }
 
+  /**
+   * Evaluates a number method
+   * @param {number} number - The number object
+   * @param {string} method - The method name
+   * @param {Array} args - Method arguments (optional)
+   * @returns {any} Method result
+   */
+  evaluateNumberMethod(number, method, args = []) {
+    switch (method) {
+      case "esPar":
+        return number % 2 === 0;
+
+      case "esImpar":
+        return number % 2 !== 0;
+
+      case "esPositivo":
+        return number > 0;
+
+      case "esNegativo":
+        return number < 0;
+
+      case "aTexto":
+        return String(number);
+
+      default:
+        throw new Error(`Método de número desconocido: ${method}`);
+    }
+  }
+
+  /**
+   * Evaluates a new expression (class instantiation)
+   * @param {Object} expression - New expression
+   * @returns {Object} Instance object
+   */
+  evaluateNewExpression(expression) {
+    const className = expression.className;
+    const classObj = this.environment.get(className);
+
+    if (!classObj || classObj.type !== "Class") {
+      throw new Error(`'${className}' no es una clase`);
+    }
+
+    // Create a new instance
+    const instance = {
+      type: "Instance",
+      className: className,
+      classObj: classObj,
+      properties: {},
+    };
+
+    // Evaluate constructor arguments
+    const args = [];
+    for (const arg of expression.arguments) {
+      args.push(this.evaluateExpression(arg));
+    }
+
+    // If class extends another, get parent class
+    let parentClass = null;
+    if (classObj.superclass) {
+      parentClass = this.environment.get(classObj.superclass);
+      if (!parentClass || parentClass.type !== "Class") {
+        throw new Error(`Clase padre '${classObj.superclass}' no encontrada`);
+      }
+      instance.parentClass = parentClass;
+    }
+
+    // Execute constructor if present
+    if (classObj.constructor) {
+      const previousInstance = this.currentInstance;
+      this.currentInstance = instance;
+
+      const constructorEnv = new Environment(this.environment);
+
+      // Bind constructor parameters
+      if (classObj.constructor.parameters.length !== args.length) {
+        throw new Error(
+          `El constructor de '${className}' espera ${classObj.constructor.parameters.length} argumentos pero recibió ${args.length}`,
+        );
+      }
+      for (let i = 0; i < args.length; i++) {
+        constructorEnv.define(classObj.constructor.parameters[i], args[i]);
+      }
+
+      const previousEnv = this.environment;
+      this.environment = constructorEnv;
+
+      try {
+        this.executeBlock(classObj.constructor.body);
+      } catch (returnValue) {
+        if (!(returnValue instanceof ReturnException)) {
+          throw returnValue;
+        }
+      } finally {
+        this.environment = previousEnv;
+        this.currentInstance = previousInstance;
+      }
+    }
+
+    return instance;
+  }
+
+  /**
+   * Evaluates this property access (este.propiedad)
+   * @param {Object} expression - ThisPropertyAccess expression
+   * @returns {any} Property value
+   */
+  evaluateThisPropertyAccess(expression) {
+    if (this.currentInstance === null) {
+      throw new Error("'este' solo se puede usar dentro de un método de clase");
+    }
+
+    const property = expression.property;
+
+    // Check if it's a property
+    if (property in this.currentInstance.properties) {
+      return this.currentInstance.properties[property];
+    }
+
+    // Check if it's a method
+    const classObj = this.currentInstance.classObj;
+    for (const method of classObj.methods) {
+      if (method.name === property) {
+        // Return a bound method
+        return {
+          type: "BoundMethod",
+          method: method,
+          instance: this.currentInstance,
+        };
+      }
+    }
+
+    // Check parent class methods
+    if (this.currentInstance.parentClass) {
+      for (const method of this.currentInstance.parentClass.methods) {
+        if (method.name === property) {
+          return {
+            type: "BoundMethod",
+            method: method,
+            instance: this.currentInstance,
+          };
+        }
+      }
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Evaluates this property assignment (este.propiedad = valor)
+   * @param {Object} expression - ThisPropertyAssign expression
+   * @returns {any} Assigned value
+   */
+  evaluateThisPropertyAssign(expression) {
+    if (this.currentInstance === null) {
+      throw new Error("'este' solo se puede usar dentro de un método de clase");
+    }
+
+    const value = this.evaluateExpression(expression.value);
+    this.currentInstance.properties[expression.property] = value;
+    return value;
+  }
+
+  /**
+   * Evaluates this method call (este.metodo())
+   * @param {Object} expression - ThisMethodCall expression
+   * @returns {any} Method result
+   */
+  evaluateThisMethodCall(expression) {
+    if (this.currentInstance === null) {
+      throw new Error("'este' solo se puede usar dentro de un método de clase");
+    }
+
+    return this.evaluateInstanceMethodCall(
+      this.currentInstance,
+      expression.method,
+      expression.arguments,
+    );
+  }
+
+  /**
+   * Evaluates super() call
+   * @param {Object} expression - SuperCall expression
+   * @returns {any} Result of parent constructor
+   */
+  evaluateSuperCall(expression) {
+    if (this.currentInstance === null) {
+      throw new Error(
+        "'super' solo se puede usar dentro de un método de clase",
+      );
+    }
+
+    const parentClass = this.currentInstance.parentClass;
+    if (!parentClass) {
+      throw new Error(
+        "'super' solo se puede usar en clases que extienden otra clase",
+      );
+    }
+
+    // Evaluate arguments
+    const args = [];
+    for (const arg of expression.arguments) {
+      args.push(this.evaluateExpression(arg));
+    }
+
+    // Execute parent constructor
+    if (parentClass.constructor) {
+      const constructorEnv = new Environment(this.environment);
+
+      if (parentClass.constructor.parameters.length !== args.length) {
+        throw new Error(
+          `El constructor padre espera ${parentClass.constructor.parameters.length} argumentos pero recibió ${args.length}`,
+        );
+      }
+      for (let i = 0; i < args.length; i++) {
+        constructorEnv.define(parentClass.constructor.parameters[i], args[i]);
+      }
+
+      const previousEnv = this.environment;
+      this.environment = constructorEnv;
+
+      try {
+        this.executeBlock(parentClass.constructor.body);
+      } catch (returnValue) {
+        if (!(returnValue instanceof ReturnException)) {
+          throw returnValue;
+        }
+      } finally {
+        this.environment = previousEnv;
+      }
+    }
+
+    return null;
+  }
+
   /**
    * Checks if a function name is a built-in mathematical function
    * @param {string} name - Function name
@@ -721,21 +1536,21 @@ class Evaluator {
    */
   isMathFunction(name) {
     const mathFunctions = [
-      'raiz',
-      'potencia',
-      'seno',
-      'coseno',
-      'tangente',
-      'logaritmo',
-      'valorAbsoluto',
-      'redondear',
-      'techo',
-      'piso',
-      'aleatorio',
-      'maximo',
-      'minimo',
-      'suma',
-      'promedio',
+      "raiz",
+      "potencia",
+      "seno",
+      "coseno",
+      "tangente",
+      "logaritmo",
+      "valorAbsoluto",
+      "redondear",
+      "techo",
+      "piso",
+      "aleatorio",
+      "maximo",
+      "minimo",
+      "suma",
+      "promedio",
     ];
     return mathFunctions.includes(name);
   }
@@ -748,159 +1563,163 @@ class Evaluator {
    */
   evaluateMathFunction(name, args) {
     switch (name) {
-      case 'raiz':
+      case "raiz":
         if (args.length !== 1) {
-          throw new Error('raiz() requiere exactamente 1 argumento');
+          throw new Error("raiz() requiere exactamente 1 argumento");
         }
-        if (typeof args[0] !== 'number') {
-          throw new Error('raiz() requiere un argumento numérico');
+        if (typeof args[0] !== "number") {
+          throw new Error("raiz() requiere un argumento numérico");
         }
         if (args[0] < 0) {
-          throw new Error('No se puede calcular la raíz cuadrada de un número negativo');
+          throw new Error(
+            "No se puede calcular la raíz cuadrada de un número negativo",
+          );
         }
         return Math.sqrt(args[0]);
 
-      case 'potencia':
+      case "potencia":
         if (args.length !== 2) {
-          throw new Error('potencia() requiere exactamente 2 argumentos');
+          throw new Error("potencia() requiere exactamente 2 argumentos");
         }
-        if (typeof args[0] !== 'number' || typeof args[1] !== 'number') {
-          throw new Error('potencia() requiere argumentos numéricos');
+        if (typeof args[0] !== "number" || typeof args[1] !== "number") {
+          throw new Error("potencia() requiere argumentos numéricos");
         }
         return Math.pow(args[0], args[1]);
 
-      case 'seno':
+      case "seno":
         if (args.length !== 1) {
-          throw new Error('seno() requiere exactamente 1 argumento');
+          throw new Error("seno() requiere exactamente 1 argumento");
         }
-        if (typeof args[0] !== 'number') {
-          throw new Error('seno() requiere un argumento numérico');
+        if (typeof args[0] !== "number") {
+          throw new Error("seno() requiere un argumento numérico");
         }
         return Math.sin(args[0]);
 
-      case 'coseno':
+      case "coseno":
         if (args.length !== 1) {
-          throw new Error('coseno() requiere exactamente 1 argumento');
+          throw new Error("coseno() requiere exactamente 1 argumento");
         }
-        if (typeof args[0] !== 'number') {
-          throw new Error('coseno() requiere un argumento numérico');
+        if (typeof args[0] !== "number") {
+          throw new Error("coseno() requiere un argumento numérico");
         }
         return Math.cos(args[0]);
 
-      case 'tangente':
+      case "tangente":
         if (args.length !== 1) {
-          throw new Error('tangente() requiere exactamente 1 argumento');
+          throw new Error("tangente() requiere exactamente 1 argumento");
         }
-        if (typeof args[0] !== 'number') {
-          throw new Error('tangente() requiere un argumento numérico');
+        if (typeof args[0] !== "number") {
+          throw new Error("tangente() requiere un argumento numérico");
         }
         return Math.tan(args[0]);
 
-      case 'logaritmo':
+      case "logaritmo":
         if (args.length !== 1) {
-          throw new Error('logaritmo() requiere exactamente 1 argumento');
+          throw new Error("logaritmo() requiere exactamente 1 argumento");
         }
-        if (typeof args[0] !== 'number') {
-          throw new Error('logaritmo() requiere un argumento numérico');
+        if (typeof args[0] !== "number") {
+          throw new Error("logaritmo() requiere un argumento numérico");
         }
         if (args[0] <= 0) {
-          throw new Error('No se puede calcular el logaritmo de un número no positivo');
+          throw new Error(
+            "No se puede calcular el logaritmo de un número no positivo",
+          );
         }
         return Math.log(args[0]);
 
-      case 'valorAbsoluto':
+      case "valorAbsoluto":
         if (args.length !== 1) {
-          throw new Error('valorAbsoluto() requiere exactamente 1 argumento');
+          throw new Error("valorAbsoluto() requiere exactamente 1 argumento");
         }
-        if (typeof args[0] !== 'number') {
-          throw new Error('valorAbsoluto() requiere un argumento numérico');
+        if (typeof args[0] !== "number") {
+          throw new Error("valorAbsoluto() requiere un argumento numérico");
         }
         return Math.abs(args[0]);
 
-      case 'redondear':
+      case "redondear":
         if (args.length !== 1) {
-          throw new Error('redondear() requiere exactamente 1 argumento');
+          throw new Error("redondear() requiere exactamente 1 argumento");
         }
-        if (typeof args[0] !== 'number') {
-          throw new Error('redondear() requiere un argumento numérico');
+        if (typeof args[0] !== "number") {
+          throw new Error("redondear() requiere un argumento numérico");
         }
         return Math.round(args[0]);
 
-      case 'techo':
+      case "techo":
         if (args.length !== 1) {
-          throw new Error('techo() requiere exactamente 1 argumento');
+          throw new Error("techo() requiere exactamente 1 argumento");
         }
-        if (typeof args[0] !== 'number') {
-          throw new Error('techo() requiere un argumento numérico');
+        if (typeof args[0] !== "number") {
+          throw new Error("techo() requiere un argumento numérico");
         }
         return Math.ceil(args[0]);
 
-      case 'piso':
+      case "piso":
         if (args.length !== 1) {
-          throw new Error('piso() requiere exactamente 1 argumento');
+          throw new Error("piso() requiere exactamente 1 argumento");
         }
-        if (typeof args[0] !== 'number') {
-          throw new Error('piso() requiere un argumento numérico');
+        if (typeof args[0] !== "number") {
+          throw new Error("piso() requiere un argumento numérico");
         }
         return Math.floor(args[0]);
 
-      case 'aleatorio':
+      case "aleatorio":
         if (args.length === 0) {
           return Math.random();
         } else if (args.length === 1) {
-          if (typeof args[0] !== 'number') {
-            throw new Error('aleatorio() requiere un argumento numérico');
+          if (typeof args[0] !== "number") {
+            throw new Error("aleatorio() requiere un argumento numérico");
           }
           return Math.random() * args[0];
         } else if (args.length === 2) {
-          if (typeof args[0] !== 'number' || typeof args[1] !== 'number') {
-            throw new Error('aleatorio() requiere argumentos numéricos');
+          if (typeof args[0] !== "number" || typeof args[1] !== "number") {
+            throw new Error("aleatorio() requiere argumentos numéricos");
           }
           return Math.random() * (args[1] - args[0]) + args[0];
         } else {
-          throw new Error('aleatorio() acepta 0, 1, o 2 argumentos');
+          throw new Error("aleatorio() acepta 0, 1, o 2 argumentos");
         }
 
-      case 'maximo':
+      case "maximo":
         if (args.length < 1) {
-          throw new Error('maximo() requiere al menos 1 argumento');
+          throw new Error("maximo() requiere al menos 1 argumento");
         }
         for (const arg of args) {
-          if (typeof arg !== 'number') {
-            throw new Error('maximo() requiere argumentos numéricos');
+          if (typeof arg !== "number") {
+            throw new Error("maximo() requiere argumentos numéricos");
           }
         }
         return Math.max(...args);
 
-      case 'minimo':
+      case "minimo":
         if (args.length < 1) {
-          throw new Error('minimo() requiere al menos 1 argumento');
+          throw new Error("minimo() requiere al menos 1 argumento");
         }
         for (const arg of args) {
-          if (typeof arg !== 'number') {
-            throw new Error('minimo() requiere argumentos numéricos');
+          if (typeof arg !== "number") {
+            throw new Error("minimo() requiere argumentos numéricos");
           }
         }
         return Math.min(...args);
 
-      case 'suma':
+      case "suma":
         if (args.length < 1) {
-          throw new Error('suma() requiere al menos 1 argumento');
+          throw new Error("suma() requiere al menos 1 argumento");
         }
         for (const arg of args) {
-          if (typeof arg !== 'number') {
-            throw new Error('suma() requiere argumentos numéricos');
+          if (typeof arg !== "number") {
+            throw new Error("suma() requiere argumentos numéricos");
           }
         }
         return args.reduce((sum, arg) => sum + arg, 0);
 
-      case 'promedio':
+      case "promedio":
         if (args.length < 1) {
-          throw new Error('promedio() requiere al menos 1 argumento');
+          throw new Error("promedio() requiere al menos 1 argumento");
         }
         for (const arg of args) {
-          if (typeof arg !== 'number') {
-            throw new Error('promedio() requiere argumentos numéricos');
+          if (typeof arg !== "number") {
+            throw new Error("promedio() requiere argumentos numéricos");
           }
         }
         return args.reduce((sum, arg) => sum + arg, 0) / args.length;
@@ -910,6 +1729,150 @@ class Evaluator {
     }
   }
 
+  /**
+   * Checks if a function name is a built-in type conversion function
+   * @param {string} name - Function name
+   * @returns {boolean} True if it's a conversion function
+   */
+  isConversionFunction(name) {
+    const conversionFunctions = [
+      "entero",
+      "decimal",
+      "texto",
+      "booleano",
+      "tipo",
+    ];
+    return conversionFunctions.includes(name);
+  }
+
+  /**
+   * Evaluates a type conversion function
+   * @param {string} name - Function name
+   * @param {Array} args - Function arguments
+   * @returns {any} Converted value
+   */
+  evaluateConversionFunction(name, args) {
+    if (args.length !== 1) {
+      throw new Error(`${name}() requiere exactamente 1 argumento`);
+    }
+
+    const value = args[0];
+
+    switch (name) {
+      case "entero":
+        // Convert to integer
+        if (typeof value === "number") {
+          return Math.trunc(value);
+        }
+        if (typeof value === "string") {
+          const parsed = parseInt(value, 10);
+          return isNaN(parsed) ? NaN : parsed;
+        }
+        if (typeof value === "boolean") {
+          return value ? 1 : 0;
+        }
+        if (value === null || value === undefined) {
+          return 0;
+        }
+        throw new Error("No se puede convertir a entero");
+
+      case "decimal":
+        // Convert to float
+        if (typeof value === "number") {
+          return value;
+        }
+        if (typeof value === "string") {
+          const parsed = parseFloat(value);
+          return isNaN(parsed) ? NaN : parsed;
+        }
+        if (typeof value === "boolean") {
+          return value ? 1 : 0;
+        }
+        if (value === null || value === undefined) {
+          return 0;
+        }
+        throw new Error("No se puede convertir a decimal");
+
+      case "texto":
+        // Convert to string (Spanish representation)
+        if (value === null) return "nulo";
+        if (value === undefined) return "indefinido";
+        if (typeof value === "boolean") return value ? "verdadero" : "falso";
+        if (typeof value === "string") return value;
+        if (Array.isArray(value)) {
+          return `[${value.map((v) => this.stringifyForTexto(v)).join(", ")}]`;
+        }
+        if (typeof value === "object") {
+          return "[objeto]";
+        }
+        return String(value);
+
+      case "booleano":
+        // Convert to boolean
+        if (value === null || value === undefined) return false;
+        if (typeof value === "boolean") return value;
+        if (typeof value === "number") return value !== 0;
+        if (typeof value === "string") return value.length > 0;
+        if (Array.isArray(value)) return value.length > 0;
+        return true;
+
+      case "tipo":
+        // Return type as Spanish string
+        if (value === null) return "nulo";
+        if (value === undefined) return "indefinido";
+        if (typeof value === "number") return "numero";
+        if (typeof value === "string") return "texto";
+        if (typeof value === "boolean") return "booleano";
+        if (Array.isArray(value)) return "arreglo";
+        if (typeof value === "object" && value.type === "Function")
+          return "funcion";
+        if (typeof value === "object" && value.type === "Instance")
+          return value.className;
+        if (typeof value === "object" && value.type === "Class") return "clase";
+        if (typeof value === "object") return "objeto";
+        return "desconocido";
+
+      default:
+        throw new Error(`Función de conversión desconocida: ${name}`);
+    }
+  }
+
+  /**
+   * Helper to stringify values for texto() function
+   * @param {any} value - Value to stringify
+   * @returns {string} String representation
+   */
+  stringifyForTexto(value) {
+    if (value === null) return "nulo";
+    if (value === undefined) return "indefinido";
+    if (typeof value === "boolean") return value ? "verdadero" : "falso";
+    if (typeof value === "string") return value;
+    if (Array.isArray(value)) {
+      return `[${value.map((v) => this.stringifyForTexto(v)).join(", ")}]`;
+    }
+    return String(value);
+  }
+
+  /**
+   * Evaluates a template string with interpolation
+   * @param {Object} expression - Template string expression
+   * @returns {string} Interpolated string result
+   */
+  evaluateTemplateString(expression) {
+    const { parts, expressions } = expression;
+    let result = "";
+
+    for (let i = 0; i < parts.length; i++) {
+      result += parts[i];
+      if (i < expressions.length) {
+        const value = this.evaluateExpression(expressions[i]);
+        result += this.stringifySpanish(value);
+      }
+    }
+
+    return result;
+  }
+
   /**
    * Evaluates an array literal
    * @param {Object} expression - Array literal expression
@@ -933,15 +1896,15 @@ class Evaluator {
     const index = this.evaluateExpression(expression.index);
 
     if (!Array.isArray(array)) {
-      throw new Error('Solo se pueden acceder elementos de arreglos');
+      throw new Error("Solo se pueden acceder elementos de arreglos");
     }
 
-    if (typeof index !== 'number') {
-      throw new Error('El índice del arreglo debe ser un número');
+    if (typeof index !== "number") {
+      throw new Error("El índice del arreglo debe ser un número");
     }
 
     if (index < 0 || index >= array.length) {
-      throw new Error('Índice del arreglo fuera de rango');
+      throw new Error("Índice del arreglo fuera de rango");
     }
 
     return array[index];
@@ -958,15 +1921,15 @@ class Evaluator {
     const value = this.evaluateExpression(expression.value);
 
     if (!Array.isArray(array)) {
-      throw new Error('Solo se pueden asignar elementos de arreglos');
+      throw new Error("Solo se pueden asignar elementos de arreglos");
     }
 
-    if (typeof index !== 'number') {
-      throw new Error('El índice del arreglo debe ser un número');
+    if (typeof index !== "number") {
+      throw new Error("El índice del arreglo debe ser un número");
     }
 
     if (index < 0 || index >= array.length) {
-      throw new Error('Índice del arreglo fuera de rango');
+      throw new Error("Índice del arreglo fuera de rango");
     }
 
     array[index] = value;
@@ -997,8 +1960,43 @@ class Evaluator {
   evaluatePropertyAccess(expression) {
     const object = this.evaluateExpression(expression.object);
 
-    if (typeof object !== 'object' || object === null) {
-      throw new Error('Solo se pueden acceder propiedades de objetos');
+    if (typeof object !== "object" || object === null) {
+      throw new Error("Solo se pueden acceder propiedades de objetos");
+    }
+
+    // Handle Instance objects
+    if (object.type === "Instance") {
+      // Check if it's a property
+      if (expression.name in object.properties) {
+        return object.properties[expression.name];
+      }
+
+      // Check if it's a method (will be called later via MethodCall)
+      const classObj = object.classObj;
+      for (const method of classObj.methods) {
+        if (method.name === expression.name) {
+          return {
+            type: "BoundMethod",
+            method: method,
+            instance: object,
+          };
+        }
+      }
+
+      // Check parent class methods
+      if (object.parentClass) {
+        for (const method of object.parentClass.methods) {
+          if (method.name === expression.name) {
+            return {
+              type: "BoundMethod",
+              method: method,
+              instance: object,
+            };
+          }
+        }
+      }
+
+      return undefined;
     }
 
     return object[expression.name];
@@ -1013,8 +2011,14 @@ class Evaluator {
     const object = this.evaluateExpression(expression.object);
     const value = this.evaluateExpression(expression.value);
 
-    if (typeof object !== 'object' || object === null) {
-      throw new Error('Solo se pueden asignar propiedades de objetos');
+    if (typeof object !== "object" || object === null) {
+      throw new Error("Solo se pueden asignar propiedades de objetos");
+    }
+
+    // Handle Instance objects
+    if (object.type === "Instance") {
+      object.properties[expression.name] = value;
+      return value;
     }
 
     object[expression.name] = value;
@@ -1029,7 +2033,7 @@ class Evaluator {
   evaluateLogicalExpression(expression) {
     const left = this.evaluateExpression(expression.left);
 
-    if (expression.operator === 'OR') {
+    if (expression.operator === "OR") {
       // Short-circuit evaluation for OR
       if (this.isTruthy(left)) {
         return left;
@@ -1037,7 +2041,7 @@ class Evaluator {
       return this.evaluateExpression(expression.right);
     }
 
-    if (expression.operator === 'AND') {
+    if (expression.operator === "AND") {
       // Short-circuit evaluation for AND
       if (!this.isTruthy(left)) {
         return left;
@@ -1059,7 +2063,7 @@ class Evaluator {
     const newValue = this.performCompoundOperation(
       currentValue,
       expression.operator,
-      rightValue
+      rightValue,
     );
 
     this.environment.assign(expression.name, newValue);
@@ -1077,20 +2081,20 @@ class Evaluator {
     const rightValue = this.evaluateExpression(expression.value);
 
     if (!Array.isArray(array)) {
-      throw new Error('Solo se pueden asignar elementos de arreglos');
+      throw new Error("Solo se pueden asignar elementos de arreglos");
     }
-    if (typeof index !== 'number') {
-      throw new Error('El índice del arreglo debe ser un número');
+    if (typeof index !== "number") {
+      throw new Error("El índice del arreglo debe ser un número");
     }
     if (index < 0 || index >= array.length) {
-      throw new Error('Índice del arreglo fuera de rango');
+      throw new Error("Índice del arreglo fuera de rango");
     }
 
     const currentValue = array[index];
     const newValue = this.performCompoundOperation(
       currentValue,
       expression.operator,
-      rightValue
+      rightValue,
     );
 
     array[index] = newValue;
@@ -1106,15 +2110,15 @@ class Evaluator {
     const object = this.evaluateExpression(expression.object);
     const rightValue = this.evaluateExpression(expression.value);
 
-    if (typeof object !== 'object' || object === null) {
-      throw new Error('Solo se pueden asignar propiedades de objetos');
+    if (typeof object !== "object" || object === null) {
+      throw new Error("Solo se pueden asignar propiedades de objetos");
     }
 
     const currentValue = object[expression.name];
     const newValue = this.performCompoundOperation(
       currentValue,
       expression.operator,
-      rightValue
+      rightValue,
     );
 
     object[expression.name] = newValue;
@@ -1130,42 +2134,42 @@ class Evaluator {
    */
   performCompoundOperation(left, operator, right) {
     switch (operator) {
-      case 'PLUS_EQUAL':
-        if (typeof left === 'number' && typeof right === 'number') {
+      case "PLUS_EQUAL":
+        if (typeof left === "number" && typeof right === "number") {
           return left + right;
         }
-        if (typeof left === 'string' || typeof right === 'string') {
+        if (typeof left === "string" || typeof right === "string") {
           return String(left) + String(right);
         }
-        throw new Error('No se pueden sumar valores no numéricos');
+        throw new Error("No se pueden sumar valores no numéricos");
 
-      case 'MINUS_EQUAL':
-        if (typeof left !== 'number' || typeof right !== 'number') {
-          throw new Error('Solo se pueden restar números');
+      case "MINUS_EQUAL":
+        if (typeof left !== "number" || typeof right !== "number") {
+          throw new Error("Solo se pueden restar números");
         }
         return left - right;
 
-      case 'STAR_EQUAL':
-        if (typeof left !== 'number' || typeof right !== 'number') {
-          throw new Error('Solo se pueden multiplicar números');
+      case "STAR_EQUAL":
+        if (typeof left !== "number" || typeof right !== "number") {
+          throw new Error("Solo se pueden multiplicar números");
         }
         return left * right;
 
-      case 'SLASH_EQUAL':
-        if (typeof left !== 'number' || typeof right !== 'number') {
-          throw new Error('Solo se pueden dividir números');
+      case "SLASH_EQUAL":
+        if (typeof left !== "number" || typeof right !== "number") {
+          throw new Error("Solo se pueden dividir números");
         }
         if (right === 0) {
-          throw new Error('División por cero');
+          throw new Error("División por cero");
         }
         return left / right;
 
-      case 'PERCENT_EQUAL':
-        if (typeof left !== 'number' || typeof right !== 'number') {
-          throw new Error('Solo se puede hacer módulo con números');
+      case "PERCENT_EQUAL":
+        if (typeof left !== "number" || typeof right !== "number") {
+          throw new Error("Solo se puede hacer módulo con números");
         }
         if (right === 0) {
-          throw new Error('Módulo por cero');
+          throw new Error("Módulo por cero");
         }
         return left % right;
 
@@ -1182,71 +2186,71 @@ class Evaluator {
   evaluatePostfixExpression(expression) {
     const operand = this.evaluateExpression(expression.operand);
 
-    if (expression.operator === 'PLUS_PLUS') {
-      if (typeof operand !== 'number') {
-        throw new Error('Solo se pueden incrementar números');
+    if (expression.operator === "PLUS_PLUS") {
+      if (typeof operand !== "number") {
+        throw new Error("Solo se pueden incrementar números");
       }
       const newValue = operand + 1;
 
       // Update the variable if it's a variable reference
-      if (expression.operand.type === 'Variable') {
+      if (expression.operand.type === "Variable") {
         this.environment.assign(expression.operand.name, newValue);
-      } else if (expression.operand.type === 'PropertyAccess') {
+      } else if (expression.operand.type === "PropertyAccess") {
         const object = this.evaluateExpression(expression.operand.object);
-        if (typeof object !== 'object' || object === null) {
-          throw new Error('Solo se pueden incrementar propiedades de objetos');
+        if (typeof object !== "object" || object === null) {
+          throw new Error("Solo se pueden incrementar propiedades de objetos");
         }
         object[expression.operand.name] = newValue;
-      } else if (expression.operand.type === 'ArrayAccess') {
+      } else if (expression.operand.type === "ArrayAccess") {
         const array = this.evaluateExpression(expression.operand.array);
         const index = this.evaluateExpression(expression.operand.index);
         if (!Array.isArray(array)) {
-          throw new Error('Solo se pueden incrementar elementos de arreglos');
+          throw new Error("Solo se pueden incrementar elementos de arreglos");
         }
-        if (typeof index !== 'number') {
-          throw new Error('El índice del arreglo debe ser un número');
+        if (typeof index !== "number") {
+          throw new Error("El índice del arreglo debe ser un número");
         }
         if (index < 0 || index >= array.length) {
-          throw new Error('Índice del arreglo fuera de rango');
+          throw new Error("Índice del arreglo fuera de rango");
         }
         array[index] = newValue;
       } else {
-        throw new Error('Objetivo de incremento inválido');
+        throw new Error("Objetivo de incremento inválido");
       }
 
       return operand; // Return the original value (postfix behavior)
     }
 
-    if (expression.operator === 'MINUS_MINUS') {
-      if (typeof operand !== 'number') {
-        throw new Error('Solo se pueden decrementar números');
+    if (expression.operator === "MINUS_MINUS") {
+      if (typeof operand !== "number") {
+        throw new Error("Solo se pueden decrementar números");
       }
       const newValue = operand - 1;
 
       // Update the variable if it's a variable reference
-      if (expression.operand.type === 'Variable') {
+      if (expression.operand.type === "Variable") {
         this.environment.assign(expression.operand.name, newValue);
-      } else if (expression.operand.type === 'PropertyAccess') {
+      } else if (expression.operand.type === "PropertyAccess") {
         const object = this.evaluateExpression(expression.operand.object);
-        if (typeof object !== 'object' || object === null) {
-          throw new Error('Solo se pueden decrementar propiedades de objetos');
+        if (typeof object !== "object" || object === null) {
+          throw new Error("Solo se pueden decrementar propiedades de objetos");
         }
         object[expression.operand.name] = newValue;
-      } else if (expression.operand.type === 'ArrayAccess') {
+      } else if (expression.operand.type === "ArrayAccess") {
         const array = this.evaluateExpression(expression.operand.array);
         const index = this.evaluateExpression(expression.operand.index);
         if (!Array.isArray(array)) {
-          throw new Error('Solo se pueden decrementar elementos de arreglos');
+          throw new Error("Solo se pueden decrementar elementos de arreglos");
         }
-        if (typeof index !== 'number') {
-          throw new Error('El índice del arreglo debe ser un número');
+        if (typeof index !== "number") {
+          throw new Error("El índice del arreglo debe ser un número");
         }
         if (index < 0 || index >= array.length) {
-          throw new Error('Índice del arreglo fuera de rango');
+          throw new Error("Índice del arreglo fuera de rango");
         }
         array[index] = newValue;
       } else {
-        throw new Error('Objetivo de decremento inválido');
+        throw new Error("Objetivo de decremento inválido");
       }
 
       return operand; // Return the original value (postfix behavior)
@@ -1261,11 +2265,28 @@ class Evaluator {
    * @returns {string} String representation
    */
   stringify(value) {
-    if (value === null) return 'null';
-    if (value === undefined) return 'undefined';
-    if (typeof value === 'string') return value;
+    if (value === null) return "null";
+    if (value === undefined) return "undefined";
+    if (typeof value === "string") return value;
     if (Array.isArray(value)) {
-      return '[' + value.map(v => this.stringify(v)).join(', ') + ']';
+      return `[${value.map((v) => this.stringify(v)).join(", ")}]`;
+    }
+    return value.toString();
+  }
+
+  /**
+   * Converts a value to its Spanish string representation for template strings
+   * @param {any} value - Value to convert
+   * @returns {string} Spanish string representation
+   */
+  stringifySpanish(value) {
+    if (value === null) return "nulo";
+    if (value === undefined) return "indefinido";
+    if (value === true) return "verdadero";
+    if (value === false) return "falso";
+    if (typeof value === "string") return value;
+    if (Array.isArray(value)) {
+      return `[${value.map((v) => this.stringifySpanish(v)).join(", ")}]`;
     }
     return value.toString();
   }
@@ -1294,6 +2315,91 @@ class Evaluator {
       this.executeBlock(statement.catchBlock);
     }
   }
+
+  /**
+   * Executes an elegir (switch) statement
+   * @param {Object} statement - Elegir statement to execute
+   */
+  executeElegirStatement(statement) {
+    const discriminantValue = this.evaluateExpression(statement.discriminant);
+
+    // Try to find a matching case
+    for (const caseClause of statement.cases) {
+      const testValue = this.evaluateExpression(caseClause.test);
+      if (discriminantValue === testValue) {
+        // Execute the matching case
+        for (const stmt of caseClause.consequent) {
+          this.execute(stmt);
+        }
+        return; // Exit after executing the matching case (no fall-through)
+      }
+    }
+
+    // If no case matched, execute default if present
+    if (statement.defaultCase) {
+      for (const stmt of statement.defaultCase.consequent) {
+        this.execute(stmt);
+      }
+    }
+  }
+
+  /**
+   * Executes a hacer/mientras (do-while) statement
+   * @param {Object} statement - HacerMientras statement to execute
+   */
+  executeHacerMientrasStatement(statement) {
+    do {
+      try {
+        this.executeBlock(statement.body);
+      } catch (error) {
+        if (error instanceof BreakException) {
+          break;
+        }
+        if (error instanceof ContinueException) {
+          continue;
+        }
+        throw error;
+      }
+    } while (this.isTruthy(this.evaluateExpression(statement.condition)));
+  }
+
+  /**
+   * Executes a para cada (for-each) statement
+   * @param {Object} statement - ForEach statement to execute
+   */
+  executeForEachStatement(statement) {
+    const iterable = this.evaluateExpression(statement.iterable);
+
+    if (!Array.isArray(iterable)) {
+      throw new Error("para cada solo puede iterar sobre arreglos");
+    }
+
+    for (const element of iterable) {
+      // Create a new environment for each iteration
+      const loopEnv = new Environment(this.environment);
+      loopEnv.define(statement.iterator, element);
+
+      const previousEnv = this.environment;
+      this.environment = loopEnv;
+
+      try {
+        this.executeBlock(statement.body);
+      } catch (error) {
+        if (error instanceof BreakException) {
+          this.environment = previousEnv;
+          break;
+        }
+        if (error instanceof ContinueException) {
+          this.environment = previousEnv;
+          continue;
+        }
+        this.environment = previousEnv;
+        throw error;
+      }
+
+      this.environment = previousEnv;
+    }
+  }
 }
 
 /**
@@ -1302,6 +2408,7 @@ class Evaluator {
 class Environment {
   constructor(enclosing = null) {
     this.values = {};
+    this.constants = new Set();
     this.enclosing = enclosing;
   }
 
@@ -1314,12 +2421,41 @@ class Environment {
     this.values[name] = value;
   }
 
+  /**
+   * Defines a constant in the environment
+   * @param {string} name - Constant name
+   * @param {any} value - Constant value
+   */
+  defineConstant(name, value) {
+    this.values[name] = value;
+    this.constants.add(name);
+  }
+
+  /**
+   * Checks if a name is a constant
+   * @param {string} name - Name to check
+   * @returns {boolean} True if it's a constant
+   */
+  isConstant(name) {
+    if (this.constants.has(name)) {
+      return true;
+    }
+    if (this.enclosing !== null) {
+      return this.enclosing.isConstant(name);
+    }
+    return false;
+  }
+
   /**
    * Assigns a value to an existing variable
    * @param {string} name - Variable name
    * @param {any} value - Value to assign
    */
   assign(name, value) {
+    if (this.isConstant(name)) {
+      throw new Error(`No se puede reasignar la constante: ${name}`);
+    }
+
     if (name in this.values) {
       this.values[name] = value;
       return;
@@ -1365,7 +2501,7 @@ class ReturnException {
  */
 class BreakException {
   constructor() {
-    this.type = 'break';
+    this.type = "break";
   }
 }
 
@@ -1374,7 +2510,7 @@ class BreakException {
  */
 class ContinueException {
   constructor() {
-    this.type = 'continue';
+    this.type = "continue";
   }
 }
 
@@ -1383,7 +2519,7 @@ class ContinueException {
  */
 class TryCatchException {
   constructor(message) {
-    this.type = 'try-catch';
+    this.type = "try-catch";
     this.message = message;
   }
 }