jslike 1.0.0

package/src/interpreter/interpreter.js

@@ -0,0 +1,1795 @@
+import { Environment, ReturnValue, BreakSignal, ContinueSignal, ThrowSignal } from '../runtime/environment.js';
+import { parse as acornParse } from '../parser.js';
+import { createMethodNotFoundError } from '../errors/enhanced-error.js';
+
+export class Interpreter {
+  constructor(globalEnv, options = {}) {
+    this.globalEnv = globalEnv;
+    this.moduleResolver = options.moduleResolver;
+    this.moduleCache = new Map();  // Cache loaded modules
+    this.moduleExports = {};  // Track exports in current module
+    this.abortSignal = options.abortSignal;
+  }
+
+  // Check if execution should be aborted
+  checkAbortSignal() {
+    if (this.abortSignal && this.abortSignal.aborted) {
+      const error = new Error('The operation was aborted');
+      error.name = 'AbortError';
+      throw error;
+    }
+  }
+
+  // Async evaluation for async functions - handles await expressions
+  async evaluateAsync(node, env) {
+    if (!node) return undefined;
+
+    // Check for abort signal before evaluating
+    this.checkAbortSignal();
+
+    // Handle await expressions by actually awaiting the promise
+    if (node.type === 'AwaitExpression') {
+      const promise = await this.evaluateAsync(node.argument, env);
+      return await promise;
+    }
+
+    // For block statements, evaluate each statement async
+    if (node.type === 'BlockStatement') {
+      let result = undefined;
+      for (const statement of node.body) {
+        result = await this.evaluateAsync(statement, env);
+        if (result instanceof ReturnValue || result instanceof ThrowSignal ||
+            result instanceof BreakSignal || result instanceof ContinueSignal) {
+          return result;
+        }
+      }
+      return result;
+    }
+
+    // For expression statements, evaluate the expression async
+    if (node.type === 'ExpressionStatement') {
+      return await this.evaluateAsync(node.expression, env);
+    }
+
+    // For variable declarations with await in init
+    if (node.type === 'VariableDeclaration') {
+      for (const declarator of node.declarations) {
+        const value = declarator.init
+          ? await this.evaluateAsync(declarator.init, env)
+          : undefined;
+
+        const isConst = node.kind === 'const';
+        if (declarator.id.type === 'Identifier') {
+          env.define(declarator.id.name, value, isConst);
+        } else if (declarator.id.type === 'ObjectPattern') {
+          this.bindObjectPattern(declarator.id, value, env, isConst);
+        } else if (declarator.id.type === 'ArrayPattern') {
+          this.bindArrayPattern(declarator.id, value, env, isConst);
+        }
+      }
+      return undefined;
+    }
+
+    // For Program nodes (evaluate all statements async)
+    if (node.type === 'Program') {
+      let result = undefined;
+      for (const statement of node.body) {
+        result = await this.evaluateAsync(statement, env);
+      }
+      return result;
+    }
+
+    // For import declarations (always async)
+    if (node.type === 'ImportDeclaration') {
+      return await this.evaluateImportDeclaration(node, env);
+    }
+
+    // For export declarations
+    if (node.type === 'ExportNamedDeclaration') {
+      return this.evaluateExportNamedDeclaration(node, env);
+    }
+
+    if (node.type === 'ExportDefaultDeclaration') {
+      return this.evaluateExportDefaultDeclaration(node, env);
+    }
+
+    // For return statements with await
+    if (node.type === 'ReturnStatement') {
+      const value = node.argument ? await this.evaluateAsync(node.argument, env) : undefined;
+      return new ReturnValue(value);
+    }
+
+    // For binary/unary expressions that might contain awaits
+    if (node.type === 'BinaryExpression') {
+      const left = await this.evaluateAsync(node.left, env);
+      const right = await this.evaluateAsync(node.right, env);
+      return this.evaluateBinaryExpressionValues(node.operator, left, right);
+    }
+
+    // For call expressions (might be calling async functions)
+    if (node.type === 'CallExpression') {
+      let thisContext = undefined;
+      let callee;
+      let objectName = null;
+      let methodName = null;
+
+      if (node.callee.type === 'MemberExpression') {
+        thisContext = await this.evaluateAsync(node.callee.object, env);
+        const prop = node.callee.computed
+          ? await this.evaluateAsync(node.callee.property, env)
+          : node.callee.property.name;
+        callee = thisContext[prop];
+
+        // Capture names for enhanced error messages
+        methodName = prop;
+        objectName = this.getExpressionName(node.callee.object);
+      } else {
+        callee = await this.evaluateAsync(node.callee, env);
+      }
+
+      // Handle optional call - if optional and callee is null/undefined, return undefined
+      if (node.optional && (callee === null || callee === undefined)) {
+        return undefined;
+      }
+
+      const args = [];
+      for (const arg of node.arguments) {
+        args.push(await this.evaluateAsync(arg, env));
+      }
+
+      if (typeof callee === 'function') {
+        if (thisContext !== undefined) {
+          return await callee.call(thisContext, ...args);
+        }
+        return await callee(...args);
+      } else if (callee && callee.__isFunction) {
+        return await this.callUserFunction(callee, args, env, thisContext);
+      }
+
+      // Throw enhanced error for member expression calls
+      if (objectName && methodName) {
+        throw createMethodNotFoundError(objectName, methodName, thisContext);
+      }
+
+      throw new TypeError(`${node.callee.name || 'Expression'} is not a function`);
+    }
+
+    // For chain expressions (optional chaining)
+    if (node.type === 'ChainExpression') {
+      return await this.evaluateAsync(node.expression, env);
+    }
+
+    // For member expressions in async context
+    if (node.type === 'MemberExpression') {
+      const obj = await this.evaluateAsync(node.object, env);
+
+      // Handle optional chaining
+      if (node.optional && (obj === null || obj === undefined)) {
+        return undefined;
+      }
+
+      if (obj === null || obj === undefined) {
+        throw new TypeError(`Cannot read property of ${obj}`);
+      }
+
+      const prop = node.computed
+        ? await this.evaluateAsync(node.property, env)
+        : node.property.name;
+
+      return obj[prop];
+    }
+
+    // For template literals with await expressions
+    if (node.type === 'TemplateLiteral') {
+      let result = '';
+      for (let i = 0; i < node.quasis.length; i++) {
+        result += node.quasis[i].value.cooked || node.quasis[i].value.raw;
+        if (i < node.expressions.length) {
+          const exprValue = await this.evaluateAsync(node.expressions[i], env);
+          result += String(exprValue);
+        }
+      }
+      return result;
+    }
+
+    // For logical expressions with async operands (await support)
+    if (node.type === 'LogicalExpression') {
+      const left = await this.evaluateAsync(node.left, env);
+
+      if (node.operator === '&&') {
+        return left ? await this.evaluateAsync(node.right, env) : left;
+      } else if (node.operator === '||') {
+        return left ? left : await this.evaluateAsync(node.right, env);
+      } else if (node.operator === '??') {
+        return left !== null && left !== undefined ? left : await this.evaluateAsync(node.right, env);
+      }
+
+      throw new Error(`Unknown logical operator: ${node.operator}`);
+    }
+
+    // For try-catch-finally with async operations
+    if (node.type === 'TryStatement') {
+      let result;
+
+      try {
+        result = await this.evaluateAsync(node.block, env);
+
+        if (result instanceof ThrowSignal) {
+          throw result.value;
+        }
+      } catch (error) {
+        if (node.handler) {
+          const catchEnv = new Environment(env);
+          if (node.handler.param) {
+            catchEnv.define(node.handler.param.name, error);
+          }
+          result = await this.evaluateAsync(node.handler.body, catchEnv);
+        } else {
+          throw error;
+        }
+      } finally {
+        if (node.finalizer) {
+          const finalResult = await this.evaluateAsync(node.finalizer, env);
+          // If finally block throws or returns, it overrides the try/catch result
+          if (finalResult instanceof ThrowSignal || finalResult instanceof ReturnValue) {
+            return finalResult;
+          }
+        }
+      }
+
+      return result;
+    }
+
+    // For new expressions (async constructors)
+    if (node.type === 'NewExpression') {
+      const result = this.evaluateNewExpression(node, env);
+      // If it's a promise, await it
+      if (result && typeof result.then === 'function') {
+        return await result;
+      }
+      return result;
+    }
+
+    // For everything else, delegate to sync evaluate
+    return this.evaluate(node, env);
+  }
+
+  evaluate(node, env) {
+    if (!node) return undefined;
+
+    // Check for abort signal before evaluating
+    this.checkAbortSignal();
+
+    switch (node.type) {
+      case 'Program':
+        return this.evaluateProgram(node, env);
+
+      case 'Literal':
+        // Handle regex literals
+        if (node.regex) {
+          return new RegExp(node.regex.pattern, node.regex.flags);
+        }
+        return node.value;
+
+      case 'Identifier':
+        return env.get(node.name);
+
+      case 'BinaryExpression':
+        return this.evaluateBinaryExpression(node, env);
+
+      case 'UnaryExpression':
+        return this.evaluateUnaryExpression(node, env);
+
+      case 'UpdateExpression':
+        return this.evaluateUpdateExpression(node, env);
+
+      case 'AwaitExpression':
+        return this.evaluateAwaitExpression(node, env);
+
+      case 'AssignmentExpression':
+        return this.evaluateAssignmentExpression(node, env);
+
+      case 'LogicalExpression':
+        return this.evaluateLogicalExpression(node, env);
+
+      case 'ConditionalExpression':
+        return this.evaluateConditionalExpression(node, env);
+
+      case 'CallExpression':
+        return this.evaluateCallExpression(node, env);
+
+      case 'MemberExpression':
+        return this.evaluateMemberExpression(node, env);
+
+      case 'ChainExpression':
+        return this.evaluateChainExpression(node, env);
+
+      case 'ArrayExpression':
+        return this.evaluateArrayExpression(node, env);
+
+      case 'ObjectExpression':
+        return this.evaluateObjectExpression(node, env);
+
+      case 'FunctionExpression':
+      case 'ArrowFunctionExpression':
+        return this.evaluateFunctionExpression(node, env);
+
+      case 'NewExpression':
+        return this.evaluateNewExpression(node, env);
+
+      case 'ThisExpression':
+        return this.evaluateThisExpression(node, env);
+
+      case 'Super':
+        return this.evaluateSuperExpression(node, env);
+
+      case 'SequenceExpression':
+        return this.evaluateSequenceExpression(node, env);
+
+      case 'VariableDeclaration':
+        return this.evaluateVariableDeclaration(node, env);
+
+      case 'FunctionDeclaration':
+        return this.evaluateFunctionDeclaration(node, env);
+
+      case 'ImportDeclaration':
+        return this.evaluateImportDeclaration(node, env);
+
+      case 'ExportNamedDeclaration':
+        return this.evaluateExportNamedDeclaration(node, env);
+
+      case 'ExportDefaultDeclaration':
+        return this.evaluateExportDefaultDeclaration(node, env);
+
+      case 'BlockStatement':
+        return this.evaluateBlockStatement(node, env);
+
+      case 'ExpressionStatement':
+        return this.evaluate(node.expression, env);
+
+      case 'ReturnStatement':
+        return new ReturnValue(node.argument ? this.evaluate(node.argument, env) : undefined);
+
+      case 'IfStatement':
+        return this.evaluateIfStatement(node, env);
+
+      case 'WhileStatement':
+        return this.evaluateWhileStatement(node, env);
+
+      case 'DoWhileStatement':
+        return this.evaluateDoWhileStatement(node, env);
+
+      case 'ForStatement':
+        return this.evaluateForStatement(node, env);
+
+      case 'ForInStatement':
+        return this.evaluateForInStatement(node, env);
+
+      case 'ForOfStatement':
+        return this.evaluateForOfStatement(node, env);
+
+      case 'BreakStatement':
+        return new BreakSignal();
+
+      case 'ContinueStatement':
+        return new ContinueSignal();
+
+      case 'ThrowStatement':
+        return new ThrowSignal(this.evaluate(node.argument, env));
+
+      case 'TryStatement':
+        return this.evaluateTryStatement(node, env);
+
+      case 'SwitchStatement':
+        return this.evaluateSwitchStatement(node, env);
+
+      case 'EmptyStatement':
+        return undefined;
+
+      // ES6+ Features
+      case 'TemplateLiteral':
+        return this.evaluateTemplateLiteral(node, env);
+
+      case 'ClassDeclaration':
+        return this.evaluateClassDeclaration(node, env);
+
+      case 'ClassExpression':
+        return this.evaluateClassExpression(node, env);
+
+      case 'MethodDefinition':
+        return this.evaluateMethodDefinition(node, env);
+
+      case 'SpreadElement':
+        return this.evaluateSpreadElement(node, env);
+
+      case 'RestElement':
+        return this.evaluateRestElement(node, env);
+
+      case 'ObjectPattern':
+        return this.evaluateObjectPattern(node, env);
+
+      case 'ArrayPattern':
+        return this.evaluateArrayPattern(node, env);
+
+      case 'AssignmentPattern':
+        return this.evaluateAssignmentPattern(node, env);
+
+      case 'Property':
+        return this.evaluateProperty(node, env);
+
+      default:
+        throw new Error(`Unknown node type: ${node.type}`);
+    }
+  }
+
+  evaluateProgram(node, env) {
+    let result = undefined;
+    for (let i = 0; i < node.body.length; i++) {
+      const statement = node.body[i];
+      const isLast = i === node.body.length - 1;
+
+      // Special case: Last statement is a BlockStatement that looks like object literal
+      // Handle both shorthand { x, y } and full syntax { key: value, key2: value2 }
+      if (isLast && statement.type === 'BlockStatement') {
+        const objLiteral = this.tryConvertBlockToObjectLiteral(statement, env);
+        if (objLiteral !== null) {
+          return objLiteral;
+        }
+      }
+
+      const statementResult = this.evaluate(statement, env);
+      if (statementResult instanceof ReturnValue || statementResult instanceof ThrowSignal) {
+        return statementResult;
+      }
+      result = statementResult;
+    }
+    return result;
+  }
+
+  // Try to convert a BlockStatement to an object literal
+  // Returns null if the block doesn't look like an object literal
+  tryConvertBlockToObjectLiteral(block, env) {
+    if (block.body.length === 0) return null;
+
+    // Check if it's shorthand syntax: { x, y }
+    if (block.body.length === 1 && block.body[0].type === 'ExpressionStatement') {
+      const expr = block.body[0].expression;
+
+      // SequenceExpression of Identifiers: { x, y, z }
+      if (expr.type === 'SequenceExpression' &&
+          expr.expressions.every(e => e.type === 'Identifier')) {
+        const obj = {};
+        for (const identifier of expr.expressions) {
+          obj[identifier.name] = env.get(identifier.name);
+        }
+        return obj;
+      }
+
+      // Single Identifier: { x }
+      if (expr.type === 'Identifier') {
+        const obj = {};
+        obj[expr.name] = env.get(expr.name);
+        return obj;
+      }
+    }
+
+    // Check if it's labeled statements that look like object properties
+    // Example: { first: first(arr), last: last(arr) }
+    // This gets parsed as LabeledStatements in script mode
+    const allLabeled = block.body.every(stmt => stmt.type === 'LabeledStatement');
+    if (!allLabeled) return null;
+
+    // Convert labeled statements to object properties
+    const obj = {};
+    for (const stmt of block.body) {
+      const label = stmt.label.name;
+
+      // The body of LabeledStatement should be ExpressionStatement
+      if (stmt.body.type !== 'ExpressionStatement') {
+        return null; // Not an object literal pattern
+      }
+
+      const value = this.evaluate(stmt.body.expression, env);
+      obj[label] = value;
+    }
+
+    return obj;
+  }
+
+  evaluateBinaryExpression(node, env) {
+    const left = this.evaluate(node.left, env);
+    const right = this.evaluate(node.right, env);
+    return this.evaluateBinaryExpressionValues(node.operator, left, right);
+  }
+
+  evaluateBinaryExpressionValues(operator, left, right) {
+    switch (operator) {
+      case '+': return left + right;
+      case '-': return left - right;
+      case '*': return left * right;
+      case '/': return left / right;
+      case '%': return left % right;
+      case '**': return left ** right;
+      case '<': return left < right;
+      case '>': return left > right;
+      case '<=': return left <= right;
+      case '>=': return left >= right;
+      case '==': return left == right;
+      case '!=': return left != right;
+      case '===': return left === right;
+      case '!==': return left !== right;
+      case '&': return left & right;
+      case '|': return left | right;
+      case '^': return left ^ right;
+      case '<<': return left << right;
+      case '>>': return left >> right;
+      case '>>>': return left >>> right;
+      case 'in': {
+        // Check right operand is not null/undefined
+        if (right === null || right === undefined) {
+          throw new TypeError(
+            'Cannot use "in" operator to search for property in null or undefined'
+          );
+        }
+        // Coerce left operand to string/symbol for property key
+        const key = String(left);
+        return key in Object(right);
+      }
+      case 'instanceof': {
+        // Check right operand is a constructor function or JSLike function
+        if (typeof right !== 'function' && !(right && right.__isFunction)) {
+          throw new TypeError(
+            'Right-hand side of instanceof is not a constructor'
+          );
+        }
+        // Primitives (null/undefined) always return false
+        if (left === null || left === undefined) {
+          return false;
+        }
+        // Special case: check if left is a JSLike function and right is Function constructor
+        if (right === Function && left && left.__isFunction) {
+          return true;
+        }
+        // Use JavaScript's instanceof for native objects
+        if (typeof right === 'function') {
+          return left instanceof right;
+        }
+        // For JSLike functions, check prototype chain
+        return false;
+      }
+      default:
+        throw new Error(`Unknown binary operator: ${operator}`);
+    }
+  }
+
+  evaluateUnaryExpression(node, env) {
+    const argument = this.evaluate(node.argument, env);
+
+    switch (node.operator) {
+      case '+': return +argument;
+      case '-': return -argument;
+      case '!': return !argument;
+      case '~': return ~argument;
+      case 'typeof':
+        // JSLike functions should report as 'function'
+        if (argument && argument.__isFunction) {
+          return 'function';
+        }
+        return typeof argument;
+      case 'void': return undefined;
+      case 'delete':
+        if (node.argument.type === 'MemberExpression') {
+          const obj = this.evaluate(node.argument.object, env);
+          const prop = node.argument.computed
+            ? this.evaluate(node.argument.property, env)
+            : node.argument.property.name;
+          return delete obj[prop];
+        }
+        return true;
+      default:
+        throw new Error(`Unknown unary operator: ${node.operator}`);
+    }
+  }
+
+  evaluateUpdateExpression(node, env) {
+    if (node.argument.type === 'Identifier') {
+      const name = node.argument.name;
+      const current = env.get(name);
+      // Wang feature: treat null/undefined as 0 for increment/decrement
+      const numericCurrent = (current === null || current === undefined) ? 0 : Number(current);
+      const newValue = node.operator === '++' ? numericCurrent + 1 : numericCurrent - 1;
+      env.set(name, newValue);
+      return node.prefix ? newValue : numericCurrent;
+    } else if (node.argument.type === 'MemberExpression') {
+      const obj = this.evaluate(node.argument.object, env);
+
+      // Check for null/undefined object
+      if (obj === null || obj === undefined) {
+        throw new TypeError(
+          `Cannot read properties of ${obj} (reading '${
+            node.argument.computed
+              ? this.evaluate(node.argument.property, env)
+              : node.argument.property.name
+          }')`
+        );
+      }
+
+      const prop = node.argument.computed
+        ? this.evaluate(node.argument.property, env)
+        : node.argument.property.name;
+
+      // Get current value and convert to number
+      let current = obj[prop];
+      // Wang feature: treat null/undefined as 0 for increment/decrement
+      const numericCurrent = (current === null || current === undefined) ? 0 : Number(current);
+      const newValue = node.operator === '++' ? numericCurrent + 1 : numericCurrent - 1;
+      obj[prop] = newValue;
+
+      return node.prefix ? newValue : numericCurrent;
+    }
+    throw new Error('Invalid update expression target');
+  }
+
+  evaluateAwaitExpression(node, env) {
+    // Evaluate the argument (should be a Promise)
+    const promise = this.evaluate(node.argument, env);
+
+    // Return the promise - the caller must handle it
+    // This is a simplified implementation that relies on the runtime being async
+    return promise;
+  }
+
+  evaluateAssignmentExpression(node, env) {
+    const value = this.evaluate(node.right, env);
+
+    if (node.left.type === 'Identifier') {
+      const name = node.left.name;
+
+      if (node.operator === '=') {
+        if (env.has(name)) {
+          env.set(name, value);
+        } else {
+          env.define(name, value);
+        }
+        return value;
+      } else {
+        const current = env.get(name);
+        const newValue = this.applyCompoundAssignment(node.operator, current, value);
+        env.set(name, newValue);
+        return newValue;
+      }
+    } else if (node.left.type === 'MemberExpression') {
+      const obj = this.evaluate(node.left.object, env);
+      const prop = node.left.computed
+        ? this.evaluate(node.left.property, env)
+        : node.left.property.name;
+
+      if (node.operator === '=') {
+        obj[prop] = value;
+        return value;
+      } else {
+        const newValue = this.applyCompoundAssignment(node.operator, obj[prop], value);
+        obj[prop] = newValue;
+        return newValue;
+      }
+    }
+
+    throw new Error('Invalid assignment target');
+  }
+
+  applyCompoundAssignment(operator, left, right) {
+    // For numeric operators, coerce undefined to 0 (like JavaScript does for += with numbers)
+    // But keep undefined for string concatenation
+    const isNumericOp = operator !== '+=';
+    const leftVal = (isNumericOp && left === undefined) ? 0 : left;
+
+    switch (operator) {
+      case '+=':
+        // Special case: undefined + number should coerce undefined to 0
+        if (left === undefined && typeof right === 'number') {
+          return 0 + right;
+        }
+        return left + right;
+      case '-=': return leftVal - right;
+      case '*=': return leftVal * right;
+      case '/=': return leftVal / right;
+      case '%=': return leftVal % right;
+      default: throw new Error(`Unknown assignment operator: ${operator}`);
+    }
+  }
+
+  evaluateLogicalExpression(node, env) {
+    const left = this.evaluate(node.left, env);
+
+    if (node.operator === '&&') {
+      return left ? this.evaluate(node.right, env) : left;
+    } else if (node.operator === '||') {
+      return left ? left : this.evaluate(node.right, env);
+    } else if (node.operator === '??') {
+      return left !== null && left !== undefined ? left : this.evaluate(node.right, env);
+    }
+
+    throw new Error(`Unknown logical operator: ${node.operator}`);
+  }
+
+  evaluateConditionalExpression(node, env) {
+    const test = this.evaluate(node.test, env);
+    return test
+      ? this.evaluate(node.consequent, env)
+      : this.evaluate(node.alternate, env);
+  }
+
+  evaluateCallExpression(node, env) {
+    //  Determine thisContext for method calls
+    let thisContext = undefined;
+    let callee;
+    let objectName = null;
+    let methodName = null;
+
+    if (node.callee.type === 'MemberExpression') {
+      // For method calls like obj.method(), set this to obj
+      thisContext = this.evaluate(node.callee.object, env);
+      const prop = node.callee.computed
+        ? this.evaluate(node.callee.property, env)
+        : node.callee.property.name;
+      callee = thisContext[prop];
+
+      // Capture names for enhanced error messages
+      methodName = prop;
+      objectName = this.getExpressionName(node.callee.object);
+    } else {
+      callee = this.evaluate(node.callee, env);
+    }
+
+    // Handle optional call - if optional and callee is null/undefined, return undefined
+    if (node.optional && (callee === null || callee === undefined)) {
+      return undefined;
+    }
+
+    const args = node.arguments.map(arg => this.evaluate(arg, env));
+
+    if (typeof callee === 'function') {
+      // Native JavaScript function or class method
+      if (thisContext !== undefined) {
+        return callee.call(thisContext, ...args);
+      }
+      return callee(...args);
+    } else if (callee && callee.__isFunction) {
+      // User-defined function - pass thisContext
+      return this.callUserFunction(callee, args, env, thisContext);
+    }
+
+    // Throw enhanced error for member expression calls
+    if (objectName && methodName) {
+      throw createMethodNotFoundError(objectName, methodName, thisContext);
+    }
+
+    throw new TypeError(`${node.callee.name || 'Expression'} is not a function`);
+  }
+
+  // Helper to get a readable name for an expression (for error messages)
+  getExpressionName(node) {
+    if (!node) return 'object';
+
+    switch (node.type) {
+      case 'Identifier':
+        return node.name;
+      case 'ThisExpression':
+        return 'this';
+      case 'MemberExpression':
+        const objName = this.getExpressionName(node.object);
+        const propName = node.computed ? '[...]' : node.property.name;
+        return `${objName}.${propName}`;
+      default:
+        return 'object';
+    }
+  }
+
+  callUserFunction(func, args, callingEnv, thisContext = undefined) {
+    // Extract metadata if function is wrapped
+    const metadata = func.__metadata || func;
+    const funcEnv = new Environment(metadata.closure);
+
+    // Bind 'this' if provided (for method calls)
+    if (thisContext !== undefined) {
+      funcEnv.define('this', thisContext);
+    }
+
+    // Bind parameters
+    for (let i = 0; i < metadata.params.length; i++) {
+      const param = metadata.params[i];
+
+      if (param.type === 'Identifier') {
+        // Simple parameter: function(x)
+        funcEnv.define(param.name, args[i]);
+      } else if (param.type === 'AssignmentPattern') {
+        // Default parameter: function(x = defaultValue)
+        const value = args[i] !== undefined ? args[i] : this.evaluate(param.right, funcEnv);
+        funcEnv.define(param.left.name, value);
+      } else if (param.type === 'RestElement') {
+        // Rest parameter: function(...rest)
+        funcEnv.define(param.argument.name, args.slice(i));
+        break; // Rest element must be last
+      } else if (param.type === 'ObjectPattern') {
+        // Destructuring parameter: function({a, b})
+        this.bindObjectPattern(param, args[i], funcEnv);
+      } else if (param.type === 'ArrayPattern') {
+        // Array destructuring parameter: function([a, b])
+        this.bindArrayPattern(param, args[i], funcEnv);
+      } else {
+        // Fallback for simple parameter names
+        funcEnv.define(param.name, args[i]);
+      }
+    }
+
+    // Execute function body
+    // If async, use async evaluation and return a promise
+    if (metadata.async) {
+      return (async () => {
+        if (metadata.expression) {
+          // Arrow function with expression body
+          const result = await this.evaluateAsync(metadata.body, funcEnv);
+          // If the result is a ThrowSignal, throw the error
+          if (result instanceof ThrowSignal) {
+            throw result.value;
+          }
+          return result;
+        } else {
+          // Block statement body
+          const result = await this.evaluateAsync(metadata.body, funcEnv);
+          if (result instanceof ReturnValue) {
+            return result.value;
+          }
+          // If the result is a ThrowSignal, throw the error
+          if (result instanceof ThrowSignal) {
+            throw result.value;
+          }
+          return undefined;
+        }
+      })();
+    } else {
+      // Synchronous evaluation for non-async functions
+      if (metadata.expression) {
+        const result = this.evaluate(metadata.body, funcEnv);
+        // If the result is a ThrowSignal, throw the error
+        if (result instanceof ThrowSignal) {
+          throw result.value;
+        }
+        return result;
+      } else {
+        const result = this.evaluate(metadata.body, funcEnv);
+        if (result instanceof ReturnValue) {
+          return result.value;
+        }
+        // If the result is a ThrowSignal, throw the error
+        if (result instanceof ThrowSignal) {
+          throw result.value;
+        }
+        return undefined;
+      }
+    }
+  }
+
+  evaluateMemberExpression(node, env) {
+    const obj = this.evaluate(node.object, env);
+
+    // Handle optional chaining - if optional and obj is null/undefined, return undefined
+    if (node.optional && (obj === null || obj === undefined)) {
+      return undefined;
+    }
+
+    if (obj === null || obj === undefined) {
+      throw new TypeError(`Cannot read property of ${obj}`);
+    }
+
+    const prop = node.computed
+      ? this.evaluate(node.property, env)
+      : node.property.name;
+
+    return obj[prop];
+  }
+
+  evaluateChainExpression(node, env) {
+    // ChainExpression is a wrapper for optional chaining expressions
+    // It contains the actual expression (MemberExpression or CallExpression with optional: true)
+    // We just evaluate the inner expression, which will handle the optional logic
+    return this.evaluate(node.expression, env);
+  }
+
+  evaluateArrayExpression(node, env) {
+    const result = [];
+    for (const elem of node.elements) {
+      if (!elem) {
+        // Hole in array [1, , 3]
+        result.push(undefined);
+      } else if (elem.type === 'SpreadElement') {
+        // Spread syntax [...arr]
+        const spreadValue = this.evaluate(elem.argument, env);
+        if (Array.isArray(spreadValue)) {
+          result.push(...spreadValue);
+        } else if (typeof spreadValue[Symbol.iterator] === 'function') {
+          result.push(...spreadValue);
+        } else {
+          throw new TypeError('Spread syntax requires an iterable');
+        }
+      } else {
+        result.push(this.evaluate(elem, env));
+      }
+    }
+    return result;
+  }
+
+  evaluateObjectExpression(node, env) {
+    const obj = {};
+    for (const prop of node.properties) {
+      if (prop.type === 'SpreadElement') {
+        // Object spread {...other}
+        const spreadValue = this.evaluate(prop.argument, env);
+        if (typeof spreadValue === 'object' && spreadValue !== null) {
+          Object.assign(obj, spreadValue);
+        }
+      } else {
+        // Regular property or shorthand
+        const key = prop.key.type === 'Identifier' && !prop.computed
+          ? prop.key.name
+          : this.evaluate(prop.key, env);
+
+        // Handle shorthand properties {x} => {x: x}
+        const value = prop.value ? this.evaluate(prop.value, env) : env.get(key);
+
+        // Handle method shorthand: method() {}
+        if (prop.method && prop.value.type === 'FunctionExpression') {
+          obj[key] = (...args) => {
+            const funcValue = this.evaluate(prop.value, env);
+            return this.callUserFunction(funcValue, args, env);
+          };
+        } else {
+          obj[key] = value;
+        }
+      }
+    }
+    return obj;
+  }
+
+  evaluateFunctionExpression(node, env) {
+    const funcMetadata = {
+      __isFunction: true,
+      params: node.params,
+      body: node.body,
+      closure: env,
+      expression: node.type === 'ArrowFunctionExpression' && node.expression,
+      async: node.async || false
+    };
+
+    // Wrap in actual JavaScript function so it can be called by native code
+    const interpreter = this;
+
+    // Create async or sync wrapper based on function type
+    // Note: using regular function (not arrow) to capture 'this' for method calls
+    const wrappedFunc = funcMetadata.async
+      ? async function(...args) {
+          return await interpreter.callUserFunction(funcMetadata, args, funcMetadata.closure, this);
+        }
+      : function(...args) {
+          return interpreter.callUserFunction(funcMetadata, args, funcMetadata.closure, this);
+        };
+
+    // Preserve metadata for JSLike's internal use
+    wrappedFunc.__isFunction = true;
+    wrappedFunc.__metadata = funcMetadata;
+
+    return wrappedFunc;
+  }
+
+  evaluateNewExpression(node, env) {
+    const constructor = this.evaluate(node.callee, env);
+    const args = node.arguments.map(arg => this.evaluate(arg, env));
+
+    // Handle user-defined functions (including async and arrow functions)
+    if (constructor && constructor.__isFunction) {
+      const result = this.callUserFunction(constructor, args, env);
+      // If result is a promise (async function), return it directly
+      // The async context will handle it
+      if (result && typeof result.then === 'function') {
+        return result.then(res => {
+          if (res && typeof res === 'object') {
+            return res;
+          }
+          return {};
+        });
+      }
+      // If the function returns an object, use it; otherwise create a new object
+      if (result && typeof result === 'object') {
+        return result;
+      }
+      // For arrow/async functions that don't return an object, create one
+      return {};
+    }
+
+    if (typeof constructor === 'function') {
+      // For native functions and classes, try to construct
+      // Arrow functions and async functions can't be constructed with 'new' in JavaScript,
+      // but if they return an object, we can use that
+      try {
+        return new constructor(...args);
+      } catch (err) {
+        // If construction fails (e.g., arrow function, async function),
+        // try calling it normally and see if it returns an object
+        if (err.message && err.message.includes('not a constructor')) {
+          const result = constructor(...args);
+          // If result is a promise, handle it
+          if (result && typeof result.then === 'function') {
+            return result.then(res => {
+              if (res && typeof res === 'object') {
+                return res;
+              }
+              throw new TypeError(`Type mismatch in new expression: ${node.callee.name || 'Expression'} is not a constructor`);
+            });
+          }
+          if (result && typeof result === 'object') {
+            return result;
+          }
+          throw new TypeError(`Type mismatch in new expression: ${node.callee.name || 'Expression'} is not a constructor`);
+        }
+        throw err;
+      }
+    }
+
+    throw new TypeError(`Type mismatch in new expression: ${node.callee.name || 'Expression'} is not a constructor`);
+  }
+
+  evaluateThisExpression(node, env) {
+    try {
+      return env.get('this');
+    } catch (e) {
+      // 'this' not defined in current scope
+      return undefined;
+    }
+  }
+
+  evaluateSuperExpression(node, env) {
+    // Super is used in class methods to access parent class
+    try {
+      return env.get('super');
+    } catch (e) {
+      throw new ReferenceError("'super' keyword is unexpected here");
+    }
+  }
+
+  evaluateSequenceExpression(node, env) {
+    let result;
+    for (const expr of node.expressions) {
+      result = this.evaluate(expr, env);
+    }
+    return result;
+  }
+
+  evaluateVariableDeclaration(node, env) {
+    const isConst = node.kind === 'const';
+
+    for (const declarator of node.declarations) {
+      const value = declarator.init
+        ? this.evaluate(declarator.init, env)
+        : undefined;
+
+      // Handle destructuring patterns
+      if (declarator.id.type === 'ObjectPattern') {
+        this.bindObjectPattern(declarator.id, value, env, isConst);
+      } else if (declarator.id.type === 'ArrayPattern') {
+        this.bindArrayPattern(declarator.id, value, env, isConst);
+      } else {
+        env.define(declarator.id.name, value, isConst);
+      }
+    }
+    return undefined;
+  }
+
+  bindObjectPattern(pattern, value, env, isConst = false) {
+    if (value === null || value === undefined) {
+      throw new TypeError('Cannot destructure undefined or null');
+    }
+
+    for (const prop of pattern.properties) {
+      if (prop.type === 'RestElement') {
+        // Handle rest properties {...rest}
+        const assignedKeys = pattern.properties
+          .filter(p => p.type !== 'RestElement')
+          .map(p => p.key.name || p.key.value);
+        const restObj = {};
+        for (const key in value) {
+          if (!assignedKeys.includes(key)) {
+            restObj[key] = value[key];
+          }
+        }
+        env.define(prop.argument.name, restObj, isConst);
+      } else {
+        const key = prop.key.name || prop.key.value;
+        const propValue = value[key];
+
+        if (prop.value.type === 'Identifier') {
+          env.define(prop.value.name, propValue, isConst);
+        } else if (prop.value.type === 'AssignmentPattern') {
+          // Handle default values
+          const finalValue = propValue !== undefined
+            ? propValue
+            : this.evaluate(prop.value.right, env);
+          env.define(prop.value.left.name, finalValue, isConst);
+        } else if (prop.value.type === 'ObjectPattern') {
+          this.bindObjectPattern(prop.value, propValue, env, isConst);
+        } else if (prop.value.type === 'ArrayPattern') {
+          this.bindArrayPattern(prop.value, propValue, env, isConst);
+        }
+      }
+    }
+  }
+
+  bindArrayPattern(pattern, value, env, isConst = false) {
+    if (!Array.isArray(value)) {
+      throw new TypeError('Cannot destructure non-iterable');
+    }
+
+    for (let i = 0; i < pattern.elements.length; i++) {
+      const element = pattern.elements[i];
+      if (!element) continue; // Hole in pattern [a, , c]
+
+      if (element.type === 'RestElement') {
+        // Handle rest elements [...rest]
+        const restValues = value.slice(i);
+        env.define(element.argument.name, restValues, isConst);
+        break;
+      } else if (element.type === 'Identifier') {
+        env.define(element.name, value[i], isConst);
+      } else if (element.type === 'AssignmentPattern') {
+        // Handle default values
+        const finalValue = value[i] !== undefined
+          ? value[i]
+          : this.evaluate(element.right, env);
+        env.define(element.left.name, finalValue, isConst);
+      } else if (element.type === 'ObjectPattern') {
+        this.bindObjectPattern(element, value[i], env, isConst);
+      } else if (element.type === 'ArrayPattern') {
+        this.bindArrayPattern(element, value[i], env, isConst);
+      }
+    }
+  }
+
+  evaluateFunctionDeclaration(node, env) {
+    const funcMetadata = {
+      __isFunction: true,
+      params: node.params,
+      body: node.body,
+      closure: env,
+      expression: false,
+      async: node.async || false
+    };
+
+    // Wrap in actual JavaScript function so it can be called by native code
+    const interpreter = this;
+
+    // Create async or sync wrapper based on function type
+    // Note: using regular function (not arrow) to capture 'this' for method calls
+    const wrappedFunc = funcMetadata.async
+      ? async function(...args) {
+          return await interpreter.callUserFunction(funcMetadata, args, funcMetadata.closure, this);
+        }
+      : function(...args) {
+          return interpreter.callUserFunction(funcMetadata, args, funcMetadata.closure, this);
+        };
+
+    // Preserve metadata for JSLike's internal use
+    wrappedFunc.__isFunction = true;
+    wrappedFunc.__metadata = funcMetadata;
+
+    env.define(node.id.name, wrappedFunc);
+    return undefined;
+  }
+
+  async evaluateImportDeclaration(node, env) {
+    // Get module path from import source
+    const modulePath = node.source.value;
+
+    // Check if module resolver is configured
+    if (!this.moduleResolver) {
+      throw new Error('Module resolver not configured - cannot import modules');
+    }
+
+    // Check if module is already cached
+    let moduleExports;
+    if (this.moduleCache.has(modulePath)) {
+      moduleExports = this.moduleCache.get(modulePath);
+    } else {
+      // Resolve and load module code
+      const moduleCode = await this.moduleResolver.resolve(modulePath);
+      if (!moduleCode) {
+        throw new Error(`Cannot find module '${modulePath}'`);
+      }
+
+      // Parse and execute module in its own environment
+      const moduleAst = acornParse(moduleCode, {
+        ecmaVersion: 2020,
+        sourceType: 'module',
+        locations: false
+      });
+      const moduleEnv = new Environment(this.globalEnv);
+
+      // Create a new interpreter for the module with shared module cache
+      const moduleInterpreter = new Interpreter(this.globalEnv, {
+        moduleResolver: this.moduleResolver
+      });
+      moduleInterpreter.moduleCache = this.moduleCache;  // Share cache
+
+      // Execute module and collect exports
+      await moduleInterpreter.evaluateAsync(moduleAst, moduleEnv);
+
+      // Cache the module exports
+      moduleExports = moduleInterpreter.moduleExports;
+      this.moduleCache.set(modulePath, moduleExports);
+    }
+
+    // Import specified bindings into current environment
+    for (const specifier of node.specifiers) {
+      if (specifier.type === 'ImportSpecifier') {
+        // Named import: import { foo, bar } from "module"
+        const importedName = specifier.imported.name;
+        const localName = specifier.local.name;
+
+        if (!(importedName in moduleExports)) {
+          throw new Error(`Module '${modulePath}' has no export '${importedName}'`);
+        }
+
+        env.define(localName, moduleExports[importedName]);
+      } else if (specifier.type === 'ImportDefaultSpecifier') {
+        // Default import: import foo from "module"
+        const localName = specifier.local.name;
+
+        if (!('default' in moduleExports)) {
+          throw new Error(`Module '${modulePath}' has no default export`);
+        }
+
+        env.define(localName, moduleExports.default);
+      } else if (specifier.type === 'ImportNamespaceSpecifier') {
+        // Namespace import: import * as foo from "module"
+        const localName = specifier.local.name;
+        env.define(localName, moduleExports);
+      }
+    }
+
+    return undefined;
+  }
+
+  evaluateExportNamedDeclaration(node, env) {
+    // Handle export with declaration: export function foo() {} or export const x = 42
+    if (node.declaration) {
+      const result = this.evaluate(node.declaration, env);
+
+      // Register exported names
+      if (node.declaration.type === 'FunctionDeclaration') {
+        // export function foo() {}
+        const name = node.declaration.id.name;
+        this.moduleExports[name] = env.get(name);
+      } else if (node.declaration.type === 'VariableDeclaration') {
+        // export const x = 42, y = 10
+        for (const declarator of node.declaration.declarations) {
+          const name = declarator.id.name;
+          this.moduleExports[name] = env.get(name);
+        }
+      } else if (node.declaration.type === 'ClassDeclaration') {
+        // export class Foo {}
+        const name = node.declaration.id.name;
+        this.moduleExports[name] = env.get(name);
+      }
+
+      return result;
+    }
+
+    // Handle export list: export { foo, bar }
+    if (node.specifiers && node.specifiers.length > 0) {
+      for (const specifier of node.specifiers) {
+        const exportedName = specifier.exported.name;
+        const localName = specifier.local.name;
+        this.moduleExports[exportedName] = env.get(localName);
+      }
+    }
+
+    return undefined;
+  }
+
+  evaluateExportDefaultDeclaration(node, env) {
+    // Evaluate the default export expression/declaration
+    let value;
+
+    if (node.declaration.type === 'FunctionDeclaration' || node.declaration.type === 'ClassDeclaration') {
+      // export default function foo() {} or export default class Foo {}
+      value = this.evaluate(node.declaration, env);
+      // If it has a name, it's also defined in the environment
+      if (node.declaration.id) {
+        value = env.get(node.declaration.id.name);
+      }
+    } else {
+      // export default expression
+      value = this.evaluate(node.declaration, env);
+    }
+
+    // Register as default export
+    this.moduleExports.default = value;
+
+    return undefined;
+  }
+
+  evaluateBlockStatement(node, env) {
+    const blockEnv = new Environment(env);
+    let result;
+
+    for (const statement of node.body) {
+      result = this.evaluate(statement, blockEnv);
+      if (result instanceof ReturnValue ||
+          result instanceof BreakSignal ||
+          result instanceof ContinueSignal ||
+          result instanceof ThrowSignal) {
+        return result;
+      }
+    }
+
+    return result;
+  }
+
+  evaluateIfStatement(node, env) {
+    const test = this.evaluate(node.test, env);
+
+    if (test) {
+      return this.evaluate(node.consequent, env);
+    } else if (node.alternate) {
+      return this.evaluate(node.alternate, env);
+    }
+
+    return undefined;
+  }
+
+  evaluateWhileStatement(node, env) {
+    let result;
+
+    while (this.evaluate(node.test, env)) {
+      result = this.evaluate(node.body, env);
+
+      if (result instanceof BreakSignal) {
+        break;
+      }
+      if (result instanceof ContinueSignal) {
+        continue;
+      }
+      if (result instanceof ReturnValue || result instanceof ThrowSignal) {
+        return result;
+      }
+    }
+
+    return undefined;
+  }
+
+  evaluateDoWhileStatement(node, env) {
+    let result;
+
+    do {
+      result = this.evaluate(node.body, env);
+
+      if (result instanceof BreakSignal) {
+        break;
+      }
+      if (result instanceof ContinueSignal) {
+        continue;
+      }
+      if (result instanceof ReturnValue || result instanceof ThrowSignal) {
+        return result;
+      }
+    } while (this.evaluate(node.test, env));
+
+    return undefined;
+  }
+
+  evaluateForStatement(node, env) {
+    const forEnv = new Environment(env);
+    let result;
+
+    if (node.init) {
+      this.evaluate(node.init, forEnv);
+    }
+
+    while (!node.test || this.evaluate(node.test, forEnv)) {
+      result = this.evaluate(node.body, forEnv);
+
+      if (result instanceof BreakSignal) {
+        break;
+      }
+      if (result instanceof ContinueSignal) {
+        if (node.update) {
+          this.evaluate(node.update, forEnv);
+        }
+        continue;
+      }
+      if (result instanceof ReturnValue || result instanceof ThrowSignal) {
+        return result;
+      }
+
+      if (node.update) {
+        this.evaluate(node.update, forEnv);
+      }
+    }
+
+    return undefined;
+  }
+
+  evaluateForInStatement(node, env) {
+    const forEnv = new Environment(env);
+    const obj = this.evaluate(node.right, forEnv);
+    let result;
+
+    // Check for null or undefined - JavaScript throws TypeError
+    if (obj === null || obj === undefined) {
+      throw new TypeError(`Cannot use 'in' operator to iterate over ${obj}`);
+    }
+
+    // Get the variable name from the declaration
+    const varName = node.left.declarations[0].id.name;
+
+    // Define the variable once before the loop
+    forEnv.define(varName, undefined);
+
+    for (const key in obj) {
+      // Update the variable value for each iteration
+      forEnv.set(varName, key);
+      result = this.evaluate(node.body, forEnv);
+
+      if (result instanceof BreakSignal) {
+        break;
+      }
+      if (result instanceof ContinueSignal) {
+        continue;
+      }
+      if (result instanceof ReturnValue || result instanceof ThrowSignal) {
+        return result;
+      }
+    }
+
+    return undefined;
+  }
+
+  evaluateForOfStatement(node, env) {
+    const forEnv = new Environment(env);
+    const iterable = this.evaluate(node.right, forEnv);
+    let result;
+
+    const declarator = node.left.declarations[0];
+    const isConst = node.left.kind === 'const';
+
+    for (const value of iterable) {
+      // Create a new child environment for each iteration to handle const properly
+      const iterEnv = forEnv.extend();
+
+      // Bind the value using the appropriate pattern
+      if (declarator.id.type === 'Identifier') {
+        iterEnv.define(declarator.id.name, value, isConst);
+      } else if (declarator.id.type === 'ArrayPattern') {
+        this.bindArrayPattern(declarator.id, value, iterEnv, isConst);
+      } else if (declarator.id.type === 'ObjectPattern') {
+        this.bindObjectPattern(declarator.id, value, iterEnv, isConst);
+      }
+
+      result = this.evaluate(node.body, iterEnv);
+
+      if (result instanceof BreakSignal) {
+        break;
+      }
+      if (result instanceof ContinueSignal) {
+        continue;
+      }
+      if (result instanceof ReturnValue || result instanceof ThrowSignal) {
+        return result;
+      }
+    }
+
+    return undefined;
+  }
+
+  evaluateTryStatement(node, env) {
+    let result;
+
+    try {
+      result = this.evaluate(node.block, env);
+
+      if (result instanceof ThrowSignal) {
+        throw result.value;
+      }
+    } catch (error) {
+      if (node.handler) {
+        const catchEnv = new Environment(env);
+        if (node.handler.param) {
+          catchEnv.define(node.handler.param.name, error);
+        }
+        result = this.evaluate(node.handler.body, catchEnv);
+      } else {
+        throw error;
+      }
+    } finally {
+      if (node.finalizer) {
+        const finalResult = this.evaluate(node.finalizer, env);
+        // If finally block throws or returns, it overrides the try/catch result
+        if (finalResult instanceof ThrowSignal || finalResult instanceof ReturnValue) {
+          return finalResult;
+        }
+      }
+    }
+
+    return result;
+  }
+
+  evaluateSwitchStatement(node, env) {
+    const discriminant = this.evaluate(node.discriminant, env);
+    let matched = false;
+    let result;
+
+    for (const switchCase of node.cases) {
+      // Check if this case matches (or if we're in fall-through mode)
+      if (!matched && switchCase.test) {
+        const testValue = this.evaluate(switchCase.test, env);
+        if (testValue === discriminant) {
+          matched = true;
+        }
+      } else if (!switchCase.test) {
+        // Default case
+        matched = true;
+      }
+
+      // Execute consequent if matched
+      if (matched) {
+        for (const statement of switchCase.consequent) {
+          result = this.evaluate(statement, env);
+
+          if (result instanceof BreakSignal) {
+            return undefined;
+          }
+          if (result instanceof ReturnValue || result instanceof ThrowSignal) {
+            return result;
+          }
+        }
+      }
+    }
+
+    return undefined;
+  }
+
+  // ===== ES6+ Feature Implementations =====
+
+  evaluateTemplateLiteral(node, env) {
+    let result = '';
+    for (let i = 0; i < node.quasis.length; i++) {
+      result += node.quasis[i].value.cooked || node.quasis[i].value.raw;
+      if (i < node.expressions.length) {
+        const exprValue = this.evaluate(node.expressions[i], env);
+        result += String(exprValue);
+      }
+    }
+    return result;
+  }
+
+  evaluateClassDeclaration(node, env) {
+    const className = node.id.name;
+    const classFunc = this.createClass(node, env);
+    env.define(className, classFunc);
+    return undefined;
+  }
+
+  evaluateClassExpression(node, env) {
+    return this.createClass(node, env);
+  }
+
+  createClass(node, env) {
+    const className = node.id ? node.id.name : 'AnonymousClass';
+    const superClass = node.superClass ? this.evaluate(node.superClass, env) : null;
+    const interpreter = this; // Capture interpreter reference
+
+    // Find constructor
+    let constructor = null;
+    const methods = {};
+    const staticMethods = {};
+
+    for (const member of node.body.body) {
+      if (member.type === 'MethodDefinition') {
+        const methodName = member.key.name || member.key.value;
+        const methodFunc = this.createMethodFunction(member.value, env, className);
+
+        if (member.kind === 'constructor') {
+          constructor = methodFunc;
+        } else if (member.static) {
+          staticMethods[methodName] = methodFunc;
+        } else {
+          methods[methodName] = methodFunc;
+        }
+      }
+    }
+
+    // Create class constructor function
+    const classConstructor = function(...args) {
+      // Create instance
+      const instance = Object.create(classConstructor.prototype);
+
+      // Call constructor - super() must be called explicitly inside constructor
+      if (constructor) {
+        const result = interpreter.callMethodFunction(constructor, instance, args, env, superClass);
+        // Only use the returned object if it's an explicit return of an object (not the instance)
+        if (result && result.__explicitReturn && result.value && typeof result.value === 'object' && result.value !== instance) {
+          return result.value;
+        }
+      } else if (superClass) {
+        // If no constructor defined but has superClass, implicitly call super()
+        // Call the superClass constructor properly - it's a classConstructor function
+        superClass.call(instance, ...args);
+      }
+
+      return instance;
+    };
+
+    // Store the constructor method on the classConstructor for super() to access
+    if (constructor) {
+      classConstructor.__constructor = constructor;
+    }
+
+    // Set up prototype chain
+    if (superClass) {
+      classConstructor.prototype = Object.create(superClass.prototype);
+      classConstructor.prototype.constructor = classConstructor;
+    }
+
+    // Add methods to prototype
+    for (const [name, method] of Object.entries(methods)) {
+      classConstructor.prototype[name] = function(...args) {
+        const result = interpreter.callMethodFunction(method, this, args, env);
+        // Unwrap explicit return marker
+        if (result && result.__explicitReturn) {
+          return result.value;
+        }
+        return result;
+      };
+    }
+
+    // Add static methods
+    for (const [name, method] of Object.entries(staticMethods)) {
+      classConstructor[name] = function(...args) {
+        const result = interpreter.callMethodFunction(method, classConstructor, args, env);
+        // Unwrap explicit return marker
+        if (result && result.__explicitReturn) {
+          return result.value;
+        }
+        return result;
+      };
+    }
+
+    classConstructor.__className = className;
+    return classConstructor;
+  }
+
+  createMethodFunction(funcNode, env, className) {
+    const func = {
+      __isFunction: true,
+      __params: funcNode.params,
+      __body: funcNode.body,
+      __env: env,
+      __className: className
+    };
+    return func;
+  }
+
+  callMethodFunction(methodFunc, thisContext, args, env, superClass = null) {
+    const funcEnv = new Environment(methodFunc.__env || env);
+
+    // Bind 'this'
+    funcEnv.define('this', thisContext);
+
+    // Bind 'super' if superClass exists
+    if (superClass) {
+      // Create a super function that calls the parent constructor
+      const superFunc = (...superArgs) => {
+        // Call the parent constructor method if it exists
+        if (superClass.__constructor) {
+          this.callMethodFunction(superClass.__constructor, thisContext, superArgs, env, null);
+        }
+        // Otherwise, call superClass as a regular constructor (for native/external classes)
+        else {
+          // For native constructors like Error, we need to use Reflect.construct
+          // to properly initialize the instance properties
+          const tempInstance = Reflect.construct(superClass, superArgs, thisContext.constructor);
+          // Copy properties from the temp instance to our thisContext
+          Object.getOwnPropertyNames(tempInstance).forEach(name => {
+            thisContext[name] = tempInstance[name];
+          });
+        }
+        return undefined;
+      };
+      // Store both the function and mark it as super
+      superFunc.__isSuperConstructor = true;
+      superFunc.__superClass = superClass;
+      funcEnv.define('super', superFunc);
+    }
+
+    // Bind parameters
+    for (let i = 0; i < methodFunc.__params.length; i++) {
+      const param = methodFunc.__params[i];
+
+      if (param.type === 'Identifier') {
+        // Simple parameter: function(x)
+        funcEnv.define(param.name, args[i]);
+      } else if (param.type === 'AssignmentPattern') {
+        // Default parameter: function(x = defaultValue)
+        const value = args[i] !== undefined ? args[i] : this.evaluate(param.right, funcEnv);
+        funcEnv.define(param.left.name, value);
+      } else if (param.type === 'RestElement') {
+        // Rest parameter: function(...rest)
+        funcEnv.define(param.argument.name, args.slice(i));
+        break; // Rest element must be last
+      } else if (param.type === 'ObjectPattern') {
+        // Destructuring parameter: function({a, b})
+        this.bindObjectPattern(param, args[i], funcEnv);
+      } else if (param.type === 'ArrayPattern') {
+        // Array destructuring parameter: function([a, b])
+        this.bindArrayPattern(param, args[i], funcEnv);
+      } else {
+        // Fallback for simple parameter names
+        funcEnv.define(param.name, args[i]);
+      }
+    }
+
+    const result = this.evaluate(methodFunc.__body, funcEnv);
+
+    if (result instanceof ReturnValue) {
+      // Mark that this was an explicit return for constructor handling
+      return { __explicitReturn: true, value: result.value };
+    }
+
+    // If the result is a ThrowSignal, throw the error
+    if (result instanceof ThrowSignal) {
+      throw result.value;
+    }
+
+    // Return implicit result (for arrow function expressions)
+    return result;
+  }
+
+  evaluateMethodDefinition(node, env) {
+    // This is handled by class creation
+    return undefined;
+  }
+
+  evaluateSpreadElement(node, env) {
+    const arg = this.evaluate(node.argument, env);
+    if (Array.isArray(arg)) {
+      return { __spread: true, __values: arg };
+    }
+    if (typeof arg === 'object' && arg !== null) {
+      return { __spread: true, __values: Object.entries(arg) };
+    }
+    throw new TypeError('Spread syntax requires an iterable');
+  }
+
+  evaluateRestElement(node, env) {
+    // Handled during parameter binding
+    return undefined;
+  }
+
+  evaluateObjectPattern(node, env) {
+    // Handled during destructuring
+    return undefined;
+  }
+
+  evaluateArrayPattern(node, env) {
+    // Handled during destructuring
+    return undefined;
+  }
+
+  evaluateAssignmentPattern(node, env) {
+    // Handled during parameter binding with defaults
+    return undefined;
+  }
+
+  evaluateProperty(node, env) {
+    // Already handled in evaluateObjectExpression
+    return undefined;
+  }
+}