jslike 1.3.1 → 1.4.0

package/{src/parser.js → dist/index.d.cts}

@@ -828,10 +828,10 @@ var pp$8 = Parser.prototype;
 // to its body instead of creating a new node.
 
 pp$8.parseTopLevel = function(node) {
-  var exports = Object.create(null);
+  var exports$1 = Object.create(null);
   if (!node.body) { node.body = []; }
   while (this.type !== types$1.eof) {
-    var stmt = this.parseStatement(null, true, exports);
+    var stmt = this.parseStatement(null, true, exports$1);
     node.body.push(stmt);
   }
   if (this.inModule)
@@ -938,7 +938,7 @@ pp$8.isUsing = function(isFor) {
 // `if (foo) /blah/.exec(foo)`, where looking at the previous token
 // does not help.
 
-pp$8.parseStatement = function(context, topLevel, exports) {
+pp$8.parseStatement = function(context, topLevel, exports$1) {
   var starttype = this.type, node = this.startNode(), kind;
 
   if (this.isLet(context)) {
@@ -993,7 +993,7 @@ pp$8.parseStatement = function(context, topLevel, exports) {
       if (!this.inModule)
         { this.raise(this.start, "'import' and 'export' may appear only with 'sourceType: module'"); }
     }
-    return starttype === types$1._import ? this.parseImport(node) : this.parseExport(node, exports)
+    return starttype === types$1._import ? this.parseImport(node) : this.parseExport(node, exports$1)
 
     // If the statement does not start with a statement keyword or a
     // brace, it's an ExpressionStatement or LabeledStatement. We
@@ -1749,11 +1749,11 @@ function checkKeyName(node, name) {
 
 // Parses module export declaration.
 
-pp$8.parseExportAllDeclaration = function(node, exports) {
+pp$8.parseExportAllDeclaration = function(node, exports$1) {
   if (this.options.ecmaVersion >= 11) {
     if (this.eatContextual("as")) {
       node.exported = this.parseModuleExportName();
-      this.checkExport(exports, node.exported, this.lastTokStart);
+      this.checkExport(exports$1, node.exported, this.lastTokStart);
     } else {
       node.exported = null;
     }
@@ -1767,14 +1767,14 @@ pp$8.parseExportAllDeclaration = function(node, exports) {
   return this.finishNode(node, "ExportAllDeclaration")
 };
 
-pp$8.parseExport = function(node, exports) {
+pp$8.parseExport = function(node, exports$1) {
   this.next();
   // export * from '...'
   if (this.eat(types$1.star)) {
-    return this.parseExportAllDeclaration(node, exports)
+    return this.parseExportAllDeclaration(node, exports$1)
   }
   if (this.eat(types$1._default)) { // export default ...
-    this.checkExport(exports, "default", this.lastTokStart);
+    this.checkExport(exports$1, "default", this.lastTokStart);
     node.declaration = this.parseExportDefaultDeclaration();
     return this.finishNode(node, "ExportDefaultDeclaration")
   }
@@ -1782,16 +1782,16 @@ pp$8.parseExport = function(node, exports) {
   if (this.shouldParseExportStatement()) {
     node.declaration = this.parseExportDeclaration(node);
     if (node.declaration.type === "VariableDeclaration")
-      { this.checkVariableExport(exports, node.declaration.declarations); }
+      { this.checkVariableExport(exports$1, node.declaration.declarations); }
     else
-      { this.checkExport(exports, node.declaration.id, node.declaration.id.start); }
+      { this.checkExport(exports$1, node.declaration.id, node.declaration.id.start); }
     node.specifiers = [];
     node.source = null;
     if (this.options.ecmaVersion >= 16)
       { node.attributes = []; }
   } else { // export { x, y as z } [from '...']
     node.declaration = null;
-    node.specifiers = this.parseExportSpecifiers(exports);
+    node.specifiers = this.parseExportSpecifiers(exports$1);
     if (this.eatContextual("from")) {
       if (this.type !== types$1.string) { this.unexpected(); }
       node.source = this.parseExprAtom();
@@ -1841,47 +1841,47 @@ pp$8.parseExportDefaultDeclaration = function() {
   }
 };
 
-pp$8.checkExport = function(exports, name, pos) {
-  if (!exports) { return }
+pp$8.checkExport = function(exports$1, name, pos) {
+  if (!exports$1) { return }
   if (typeof name !== "string")
     { name = name.type === "Identifier" ? name.name : name.value; }
-  if (hasOwn(exports, name))
+  if (hasOwn(exports$1, name))
     { this.raiseRecoverable(pos, "Duplicate export '" + name + "'"); }
-  exports[name] = true;
+  exports$1[name] = true;
 };
 
-pp$8.checkPatternExport = function(exports, pat) {
+pp$8.checkPatternExport = function(exports$1, pat) {
   var type = pat.type;
   if (type === "Identifier")
-    { this.checkExport(exports, pat, pat.start); }
+    { this.checkExport(exports$1, pat, pat.start); }
   else if (type === "ObjectPattern")
     { for (var i = 0, list = pat.properties; i < list.length; i += 1)
       {
         var prop = list[i];
 
-        this.checkPatternExport(exports, prop);
+        this.checkPatternExport(exports$1, prop);
       } }
   else if (type === "ArrayPattern")
     { for (var i$1 = 0, list$1 = pat.elements; i$1 < list$1.length; i$1 += 1) {
       var elt = list$1[i$1];
 
-        if (elt) { this.checkPatternExport(exports, elt); }
+        if (elt) { this.checkPatternExport(exports$1, elt); }
     } }
   else if (type === "Property")
-    { this.checkPatternExport(exports, pat.value); }
+    { this.checkPatternExport(exports$1, pat.value); }
   else if (type === "AssignmentPattern")
-    { this.checkPatternExport(exports, pat.left); }
+    { this.checkPatternExport(exports$1, pat.left); }
   else if (type === "RestElement")
-    { this.checkPatternExport(exports, pat.argument); }
+    { this.checkPatternExport(exports$1, pat.argument); }
 };
 
-pp$8.checkVariableExport = function(exports, decls) {
-  if (!exports) { return }
+pp$8.checkVariableExport = function(exports$1, decls) {
+  if (!exports$1) { return }
   for (var i = 0, list = decls; i < list.length; i += 1)
     {
     var decl = list[i];
 
-    this.checkPatternExport(exports, decl.id);
+    this.checkPatternExport(exports$1, decl.id);
   }
 };
 
@@ -1896,13 +1896,13 @@ pp$8.shouldParseExportStatement = function() {
 
 // Parses a comma-separated list of module exports.
 
-pp$8.parseExportSpecifier = function(exports) {
+pp$8.parseExportSpecifier = function(exports$1) {
   var node = this.startNode();
   node.local = this.parseModuleExportName();
 
   node.exported = this.eatContextual("as") ? this.parseModuleExportName() : node.local;
   this.checkExport(
-    exports,
+    exports$1,
     node.exported,
     node.exported.start
   );
@@ -1910,7 +1910,7 @@ pp$8.parseExportSpecifier = function(exports) {
   return this.finishNode(node, "ExportSpecifier")
 };
 
-pp$8.parseExportSpecifiers = function(exports) {
+pp$8.parseExportSpecifiers = function(exports$1) {
   var nodes = [], first = true;
   // export { x, y as z } [from '...']
   this.expect(types$1.braceL);
@@ -1920,7 +1920,7 @@ pp$8.parseExportSpecifiers = function(exports) {
       if (this.afterTrailingComma(types$1.braceR)) { break }
     } else { first = false; }
 
-    nodes.push(this.parseExportSpecifier(exports));
+    nodes.push(this.parseExportSpecifier(exports$1));
   }
   return nodes
 };
@@ -6218,24 +6218,3259 @@ Parser.acorn = {
 //
 // [estree]: https://github.com/estree/estree
 
-function parse(input, options) {
+function parse$1(input, options) {
   return Parser.parse(input, options)
 }
 
-// This function tries to parse a single expression at a given
-// offset in a string. Useful for parsing mixed-language formats
-// that embed JavaScript expressions.
+// Runtime Environment for variable scoping and storage
 
-function parseExpressionAt(input, pos, options) {
-  return Parser.parseExpressionAt(input, pos, options)
+class Environment {
+  constructor(parent = null) {
+    this.parent = parent;
+    this.vars = new Map();
+    this.consts = new Set(); // Track const variables
+  }
+
+  define(name, value, isConst = false) {
+    if (this.vars.has(name)) {
+      throw new Error(`Variable '${name}' already declared`);
+    }
+    this.vars.set(name, value);
+    if (isConst) {
+      this.consts.add(name);
+    }
+    return value;
+  }
+
+  get(name) {
+    if (this.vars.has(name)) {
+      return this.vars.get(name);
+    }
+    if (this.parent) {
+      return this.parent.get(name);
+    }
+    throw new ReferenceError(`Variable "${name}" is not defined`);
+  }
+
+  set(name, value) {
+    if (this.vars.has(name)) {
+      // Check if trying to reassign a const variable
+      if (this.consts.has(name)) {
+        throw new TypeError(`Cannot reassign const variable '${name}'`);
+      }
+      this.vars.set(name, value);
+      return value;
+    }
+    if (this.parent) {
+      return this.parent.set(name, value);
+    }
+    throw new ReferenceError(`Variable "${name}" is not defined`);
+  }
+
+  has(name) {
+    return this.vars.has(name) || (this.parent ? this.parent.has(name) : false);
+  }
+
+  // For let/const block scoping
+  extend() {
+    return new Environment(this);
+  }
+}
+
+// Special control flow signals
+class ReturnValue {
+  constructor(value) {
+    this.value = value;
+  }
+}
+
+class BreakSignal {
+  constructor() {}
+}
+
+class ContinueSignal {
+  constructor() {}
+}
+
+class ThrowSignal {
+  constructor(value) {
+    this.value = value;
+  }
+}
+
+/**
+ * Enhanced error classes for better developer experience
+ */
+
+// Simple Levenshtein distance for "did you mean" suggestions
+function levenshteinDistance(a, b) {
+  const matrix = [];
+
+  for (let i = 0; i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+
+  for (let j = 0; j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1,
+          matrix[i][j - 1] + 1,
+          matrix[i - 1][j] + 1
+        );
+      }
+    }
+  }
+
+  return matrix[b.length][a.length];
+}
+
+// Find similar strings for suggestions
+function findSimilar(target, candidates, maxDistance = 3) {
+  const suggestions = [];
+
+  for (const candidate of candidates) {
+    const distance = levenshteinDistance(target.toLowerCase(), candidate.toLowerCase());
+    if (distance <= maxDistance && distance > 0) {
+      suggestions.push({ name: candidate, distance });
+    }
+  }
+
+  return suggestions
+    .sort((a, b) => a.distance - b.distance)
+    .slice(0, 3)
+    .map(s => s.name);
+}
+
+// Get available methods/properties on an object
+function getAvailableMethods(obj) {
+  if (obj === null || obj === undefined) return [];
+
+  const methods = new Set();
+
+  // Get own properties
+  Object.getOwnPropertyNames(obj).forEach(name => {
+    if (typeof obj[name] === 'function') {
+      methods.add(name);
+    }
+  });
+
+  // Get prototype methods
+  let proto = Object.getPrototypeOf(obj);
+  while (proto && proto !== Object.prototype) {
+    Object.getOwnPropertyNames(proto).forEach(name => {
+      if (typeof proto[name] === 'function' && name !== 'constructor') {
+        methods.add(name);
+      }
+    });
+    proto = Object.getPrototypeOf(proto);
+  }
+
+  return Array.from(methods).sort();
+}
+
+class EnhancedTypeError extends TypeError {
+  constructor(message, context = {}) {
+    super(message);
+    this.name = 'TypeError';
+    this.objectName = context.objectName || 'object';
+    this.methodName = context.methodName || 'method';
+    this.objectValue = context.objectValue;
+    this.availableMethods = context.availableMethods || [];
+    this.suggestions = context.suggestions || [];
+  }
+
+  getFormattedMessage() {
+    let formatted = this.message;
+
+    // Add available methods
+    if (this.availableMethods.length > 0) {
+      const methodList = this.availableMethods.slice(0, 10).join(', ');
+      const more = this.availableMethods.length > 10
+        ? ` (and ${this.availableMethods.length - 10} more)`
+        : '';
+      formatted += `\n\nAvailable methods on '${this.objectName}': ${methodList}${more}`;
+    }
+
+    // Add suggestions
+    if (this.suggestions.length > 0) {
+      formatted += `\n\nDid you mean: ${this.suggestions.join(', ')}?`;
+    }
+
+    return formatted;
+  }
+}
+
+function createMethodNotFoundError(objectName, methodName, objectValue) {
+  const availableMethods = getAvailableMethods(objectValue);
+  const suggestions = findSimilar(methodName, availableMethods);
+
+  const message = `TypeError when calling method '${methodName}' on object '${objectName}': ` +
+    `Expected: function, Received: undefined`;
+
+  return new EnhancedTypeError(message, {
+    objectName,
+    methodName,
+    objectValue,
+    availableMethods,
+    suggestions
+  });
+}
+
+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') {
+      const blockEnv = new Environment(env);
+      let result = undefined;
+      for (const statement of node.body) {
+        result = await this.evaluateAsync(statement, blockEnv);
+        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);
+        // Handle top-level return and throw
+        if (result instanceof ReturnValue || result instanceof ThrowSignal) {
+          return result;
+        }
+      }
+      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 ForStatement with async body
+    if (node.type === 'ForStatement') {
+      const forEnv = new Environment(env);
+      if (node.init) {
+        await this.evaluateAsync(node.init, forEnv);
+      }
+      while (!node.test || await this.evaluateAsync(node.test, forEnv)) {
+        const result = await this.evaluateAsync(node.body, forEnv);
+        if (result instanceof BreakSignal) {
+          break;
+        }
+        if (result instanceof ContinueSignal) {
+          if (node.update) {
+            await this.evaluateAsync(node.update, forEnv);
+          }
+          continue;
+        }
+        if (result instanceof ReturnValue || result instanceof ThrowSignal) {
+          return result;
+        }
+        if (node.update) {
+          await this.evaluateAsync(node.update, forEnv);
+        }
+      }
+      return undefined;
+    }
+
+    // For ForOfStatement with async body
+    if (node.type === 'ForOfStatement') {
+      const forEnv = new Environment(env);
+      const iterable = await this.evaluateAsync(node.right, forEnv);
+      const declarator = node.left.declarations[0];
+      const isConst = node.left.kind === 'const';
+
+      for (const value of iterable) {
+        const iterEnv = forEnv.extend();
+        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);
+        }
+        const result = await this.evaluateAsync(node.body, iterEnv);
+        if (result instanceof BreakSignal) {
+          break;
+        }
+        if (result instanceof ContinueSignal) {
+          continue;
+        }
+        if (result instanceof ReturnValue || result instanceof ThrowSignal) {
+          return result;
+        }
+      }
+      return undefined;
+    }
+
+    // For ForInStatement with async body
+    if (node.type === 'ForInStatement') {
+      const forEnv = new Environment(env);
+      const obj = await this.evaluateAsync(node.right, forEnv);
+      if (obj === null || obj === undefined) {
+        throw new TypeError(`Cannot use 'in' operator to iterate over ${obj}`);
+      }
+      const varName = node.left.declarations[0].id.name;
+      forEnv.define(varName, undefined);
+
+      for (const key in obj) {
+        forEnv.set(varName, key);
+        const result = await this.evaluateAsync(node.body, forEnv);
+        if (result instanceof BreakSignal) {
+          break;
+        }
+        if (result instanceof ContinueSignal) {
+          continue;
+        }
+        if (result instanceof ReturnValue || result instanceof ThrowSignal) {
+          return result;
+        }
+      }
+      return undefined;
+    }
+
+    // For WhileStatement with async body
+    if (node.type === 'WhileStatement') {
+      while (await this.evaluateAsync(node.test, env)) {
+        const result = await this.evaluateAsync(node.body, env);
+        if (result instanceof BreakSignal) {
+          break;
+        }
+        if (result instanceof ContinueSignal) {
+          continue;
+        }
+        if (result instanceof ReturnValue || result instanceof ThrowSignal) {
+          return result;
+        }
+      }
+      return undefined;
+    }
+
+    // For DoWhileStatement with async body
+    if (node.type === 'DoWhileStatement') {
+      do {
+        const result = await this.evaluateAsync(node.body, env);
+        if (result instanceof BreakSignal) {
+          break;
+        }
+        if (result instanceof ContinueSignal) {
+          continue;
+        }
+        if (result instanceof ReturnValue || result instanceof ThrowSignal) {
+          return result;
+        }
+      } while (await this.evaluateAsync(node.test, env));
+      return undefined;
+    }
+
+    // For IfStatement with async branches
+    if (node.type === 'IfStatement') {
+      const test = await this.evaluateAsync(node.test, env);
+      if (test) {
+        return await this.evaluateAsync(node.consequent, env);
+      } else if (node.alternate) {
+        return await this.evaluateAsync(node.alternate, env);
+      }
+      return undefined;
+    }
+
+    // For SwitchStatement with async cases
+    if (node.type === 'SwitchStatement') {
+      const discriminant = await this.evaluateAsync(node.discriminant, env);
+      let matched = false;
+
+      for (const switchCase of node.cases) {
+        if (!matched && switchCase.test) {
+          const testValue = await this.evaluateAsync(switchCase.test, env);
+          if (testValue === discriminant) {
+            matched = true;
+          }
+        } else if (!switchCase.test) {
+          matched = true;
+        }
+
+        if (matched) {
+          for (const statement of switchCase.consequent) {
+            const result = await this.evaluateAsync(statement, env);
+            if (result instanceof BreakSignal) {
+              return undefined;
+            }
+            if (result instanceof ReturnValue || result instanceof ThrowSignal) {
+              return result;
+            }
+          }
+        }
+      }
+      return undefined;
+    }
+
+    // For ConditionalExpression (ternary) with async operands
+    if (node.type === 'ConditionalExpression') {
+      const test = await this.evaluateAsync(node.test, env);
+      return test
+        ? await this.evaluateAsync(node.consequent, env)
+        : await this.evaluateAsync(node.alternate, env);
+    }
+
+    // For AssignmentExpression with async value
+    if (node.type === 'AssignmentExpression') {
+      const value = await this.evaluateAsync(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 = await this.evaluateAsync(node.left.object, env);
+        const prop = node.left.computed
+          ? await this.evaluateAsync(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');
+    }
+
+    // For UnaryExpression with async argument
+    if (node.type === 'UnaryExpression') {
+      if (node.operator === 'delete' && node.argument.type === 'MemberExpression') {
+        const obj = await this.evaluateAsync(node.argument.object, env);
+        const prop = node.argument.computed
+          ? await this.evaluateAsync(node.argument.property, env)
+          : node.argument.property.name;
+        return delete obj[prop];
+      }
+      const argument = await this.evaluateAsync(node.argument, env);
+      switch (node.operator) {
+        case '+': return +argument;
+        case '-': return -argument;
+        case '!': return !argument;
+        case '~': return ~argument;
+        case 'typeof':
+          if (argument && argument.__isFunction) {
+            return 'function';
+          }
+          return typeof argument;
+        case 'void': return undefined;
+        case 'delete': return true;
+        default:
+          throw new Error(`Unknown unary operator: ${node.operator}`);
+      }
+    }
+
+    // For UpdateExpression with async member access
+    if (node.type === 'UpdateExpression') {
+      if (node.argument.type === 'Identifier') {
+        const name = node.argument.name;
+        const current = env.get(name);
+        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 = await this.evaluateAsync(node.argument.object, env);
+        if (obj === null || obj === undefined) {
+          throw new TypeError(
+            `Cannot read properties of ${obj} (reading '${
+              node.argument.computed
+                ? await this.evaluateAsync(node.argument.property, env)
+                : node.argument.property.name
+            }')`
+          );
+        }
+        const prop = node.argument.computed
+          ? await this.evaluateAsync(node.argument.property, env)
+          : node.argument.property.name;
+        let current = obj[prop];
+        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');
+    }
+
+    // For ArrayExpression with async elements
+    if (node.type === 'ArrayExpression') {
+      const result = [];
+      for (const elem of node.elements) {
+        if (!elem) {
+          result.push(undefined);
+        } else if (elem.type === 'SpreadElement') {
+          const spreadValue = await this.evaluateAsync(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(await this.evaluateAsync(elem, env));
+        }
+      }
+      return result;
+    }
+
+    // For ObjectExpression with async values
+    if (node.type === 'ObjectExpression') {
+      const obj = {};
+      for (const prop of node.properties) {
+        if (prop.type === 'SpreadElement') {
+          const spreadValue = await this.evaluateAsync(prop.argument, env);
+          if (typeof spreadValue === 'object' && spreadValue !== null) {
+            Object.assign(obj, spreadValue);
+          }
+        } else {
+          const key = prop.key.type === 'Identifier' && !prop.computed
+            ? prop.key.name
+            : await this.evaluateAsync(prop.key, env);
+          const value = prop.value ? await this.evaluateAsync(prop.value, env) : env.get(key);
+          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;
+    }
+
+    // For SequenceExpression with async expressions
+    if (node.type === 'SequenceExpression') {
+      let result;
+      for (const expr of node.expressions) {
+        result = await this.evaluateAsync(expr, env);
+      }
+      return result;
+    }
+
+    // For ThrowStatement with async argument
+    if (node.type === 'ThrowStatement') {
+      return new ThrowSignal(await this.evaluateAsync(node.argument, env));
+    }
+
+    // For FunctionDeclaration - define in environment
+    if (node.type === 'FunctionDeclaration') {
+      return this.evaluateFunctionDeclaration(node, env);
+    }
+
+    // For FunctionExpression/ArrowFunctionExpression - create function
+    if (node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') {
+      return this.evaluateFunctionExpression(node, env);
+    }
+
+    // For ClassDeclaration
+    if (node.type === 'ClassDeclaration') {
+      return this.evaluateClassDeclaration(node, env);
+    }
+
+    // For ClassExpression
+    if (node.type === 'ClassExpression') {
+      return this.evaluateClassExpression(node, env);
+    }
+
+    // Only leaf nodes should fall through to sync evaluate
+    // These have no sub-expressions that could contain await
+    if (['Literal', 'Identifier', 'BreakStatement', 'ContinueStatement',
+         'EmptyStatement', 'ThisExpression', 'Super'].includes(node.type)) {
+      return this.evaluate(node, env);
+    }
+
+    // Safety check - if we get here, we missed a node type
+    throw new Error(`Unhandled node type in evaluateAsync: ${node.type}`);
+  }
+
+  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 resolution = await this.moduleResolver.resolve(modulePath);
+      if (!resolution) {
+        throw new Error(`Cannot find module '${modulePath}'`);
+      }
+
+      // Handle both old (string) and new (ModuleResolution) formats
+      const moduleCode = typeof resolution === 'string' ? resolution : resolution.code;
+
+      // Parse and execute module in its own environment
+      const moduleAst = parse$1(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;
+  }
+}
+
+// Built-in global objects and functions
+
+function createGlobalEnvironment(env) {
+  // Global objects (only those not already defined below)
+  env.define('Date', Date);
+
+  // console object
+  env.define('console', {
+    log: (...args) => {
+      console.log(...args);
+      return undefined;
+    },
+    error: (...args) => {
+      console.error(...args);
+      return undefined;
+    },
+    warn: (...args) => {
+      console.warn(...args);
+      return undefined;
+    },
+    info: (...args) => {
+      console.info(...args);
+      return undefined;
+    },
+    dir: (...args) => {
+      console.dir(...args);
+      return undefined;
+    }
+  });
+
+  // Math object
+  env.define('Math', {
+    PI: Math.PI,
+    E: Math.E,
+    abs: Math.abs,
+    acos: Math.acos,
+    asin: Math.asin,
+    atan: Math.atan,
+    atan2: Math.atan2,
+    ceil: Math.ceil,
+    cos: Math.cos,
+    exp: Math.exp,
+    floor: Math.floor,
+    log: Math.log,
+    max: Math.max,
+    min: Math.min,
+    pow: Math.pow,
+    random: Math.random,
+    round: Math.round,
+    sin: Math.sin,
+    sqrt: Math.sqrt,
+    tan: Math.tan,
+    trunc: Math.trunc
+  });
+
+  // Global values
+  env.define('undefined', undefined);
+
+  // Global functions
+  env.define('parseInt', parseInt);
+  env.define('parseFloat', parseFloat);
+  env.define('isNaN', isNaN);
+  env.define('isFinite', isFinite);
+
+  // Array constructor
+  env.define('Array', Array);
+
+  // Object constructor
+  env.define('Object', Object);
+
+  // String constructor
+  env.define('String', String);
+
+  // Number constructor
+  env.define('Number', Number);
+
+  // Boolean constructor
+  env.define('Boolean', Boolean);
+
+  // Function constructor
+  env.define('Function', Function);
+
+  // RegExp constructor
+  env.define('RegExp', RegExp);
+
+  // Symbol constructor
+  env.define('Symbol', Symbol);
+
+  // Map and Set constructors
+  env.define('Map', Map);
+  env.define('Set', Set);
+  env.define('WeakMap', WeakMap);
+  env.define('WeakSet', WeakSet);
+
+  // JSON object
+  env.define('JSON', {
+    parse: JSON.parse,
+    stringify: JSON.stringify
+  });
+
+  // setTimeout, setInterval (basic implementations)
+  env.define('setTimeout', setTimeout);
+  env.define('setInterval', setInterval);
+  env.define('clearTimeout', clearTimeout);
+  env.define('clearInterval', clearInterval);
+
+  // Promise
+  env.define('Promise', Promise);
+
+  // Error constructors
+  env.define('Error', Error);
+  env.define('TypeError', TypeError);
+  env.define('ReferenceError', ReferenceError);
+  env.define('SyntaxError', SyntaxError);
+  env.define('RangeError', RangeError);
+
+  // Global console functions (shortcuts for console.log/warn/error)
+  env.define('log', (...args) => {
+    console.log(...args);
+    return undefined;
+  });
+  env.define('warn', (...args) => {
+    console.warn(...args);
+    return undefined;
+  });
+  env.define('error', (...args) => {
+    console.error(...args);
+    return undefined;
+  });
+
+  // Wang Standard Library - Array Operations
+  env.define('sort_by', (array, keyOrFn) => {
+    const arr = [...array];
+    if (typeof keyOrFn === 'function') {
+      return arr.sort((a, b) => {
+        const aVal = keyOrFn(a);
+        const bVal = keyOrFn(b);
+        return aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
+      });
+    } else {
+      return arr.sort((a, b) => {
+        const aVal = a[keyOrFn];
+        const bVal = b[keyOrFn];
+        return aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
+      });
+    }
+  });
+
+  env.define('reverse', (array) => {
+    return [...array].reverse();
+  });
+
+  env.define('unique', (array) => {
+    return [...new Set(array)];
+  });
+
+  env.define('unique_by', (array, key) => {
+    const seen = new Set();
+    return array.filter(item => {
+      const val = item[key];
+      if (seen.has(val)) return false;
+      seen.add(val);
+      return true;
+    });
+  });
+
+  env.define('group_by', (array, key) => {
+    return array.reduce((groups, item) => {
+      const groupKey = item[key];
+      if (!groups[groupKey]) groups[groupKey] = [];
+      groups[groupKey].push(item);
+      return groups;
+    }, {});
+  });
+
+  env.define('chunk', (array, size) => {
+    const chunks = [];
+    for (let i = 0; i < array.length; i += size) {
+      chunks.push(array.slice(i, i + size));
+    }
+    return chunks;
+  });
+
+  env.define('flatten', (array, depth = 1) => {
+    return array.flat(depth);
+  });
+
+  env.define('first', (array, n) => {
+    if (n === undefined) return array[0];
+    return array.slice(0, n);
+  });
+
+  env.define('last', (array, n) => {
+    if (n === undefined) return array[array.length - 1];
+    return array.slice(-n);
+  });
+
+  env.define('take', (array, n) => {
+    return array.slice(0, n);
+  });
+
+  env.define('drop', (array, n) => {
+    return array.slice(n);
+  });
+
+  env.define('zip', (...arrays) => {
+    const length = Math.min(...arrays.map(a => a.length));
+    return Array.from({ length }, (_, i) => arrays.map(a => a[i]));
+  });
+
+  env.define('partition', (array, predicate) => {
+    const truthy = [];
+    const falsy = [];
+    array.forEach(item => {
+      if (predicate(item)) truthy.push(item);
+      else falsy.push(item);
+    });
+    return [truthy, falsy];
+  });
+
+  env.define('filter', (array, predicate) => {
+    return array.filter(predicate);
+  });
+
+  env.define('map', (array, fn) => {
+    return array.map(fn);
+  });
+
+  env.define('find', (array, predicate) => {
+    return array.find(predicate);
+  });
+
+  env.define('find_index', (array, predicate) => {
+    return array.findIndex(predicate);
+  });
+
+  env.define('every', (array, predicate) => {
+    return array.every(predicate);
+  });
+
+  env.define('some', (array, predicate) => {
+    return array.some(predicate);
+  });
+
+  env.define('count', (array, predicate) => {
+    if (!predicate) {
+      return array.length;
+    }
+    return array.filter(predicate).length;
+  });
+
+  // Wang Standard Library - Object Operations
+  env.define('keys', (obj) => {
+    return Object.keys(obj);
+  });
+
+  env.define('values', (obj) => {
+    return Object.values(obj);
+  });
+
+  env.define('entries', (obj) => {
+    return Object.entries(obj);
+  });
+
+  env.define('pick', (obj, keys) => {
+    const result = {};
+    keys.forEach(key => {
+      if (key in obj) result[key] = obj[key];
+    });
+    return result;
+  });
+
+  env.define('omit', (obj, keys) => {
+    const result = { ...obj };
+    keys.forEach(key => delete result[key]);
+    return result;
+  });
+
+  env.define('merge', (...objects) => {
+    return Object.assign({}, ...objects);
+  });
+
+  env.define('get', (obj, path, defaultValue) => {
+    const keys = path.split('.');
+    let current = obj;
+    for (const key of keys) {
+      if (current == null) return defaultValue;
+      current = current[key];
+    }
+    return current !== undefined ? current : defaultValue;
+  });
+
+  env.define('set', (obj, path, value) => {
+    const keys = path.split('.');
+    const result = JSON.parse(JSON.stringify(obj)); // Deep clone
+    let current = result;
+    for (let i = 0; i < keys.length - 1; i++) {
+      const key = keys[i];
+      if (!(key in current)) current[key] = {};
+      current = current[key];
+    }
+    current[keys[keys.length - 1]] = value;
+    return result;
+  });
+
+  env.define('clone', (obj) => {
+    return JSON.parse(JSON.stringify(obj));
+  });
+
+  // Wang Standard Library - String Operations
+  env.define('split', (str, separator) => {
+    return str.split(separator);
+  });
+
+  env.define('join', (array, separator) => {
+    return array.join(separator);
+  });
+
+  env.define('trim', (str) => {
+    return str.trim();
+  });
+
+  env.define('trim_start', (str) => {
+    return str.trimStart();
+  });
+
+  env.define('trim_end', (str) => {
+    return str.trimEnd();
+  });
+
+  env.define('upper', (str) => {
+    return str.toUpperCase();
+  });
+
+  env.define('toUpperCase', (str) => {
+    return str.toUpperCase();
+  });
+
+  env.define('lower', (str) => {
+    return str.toLowerCase();
+  });
+
+  env.define('toLowerCase', (str) => {
+    return str.toLowerCase();
+  });
+
+  env.define('capitalize', (str) => {
+    if (!str) return str;
+    return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+  });
+
+  env.define('starts_with', (str, prefix) => {
+    return str.startsWith(prefix);
+  });
+
+  env.define('ends_with', (str, suffix) => {
+    return str.endsWith(suffix);
+  });
+
+  env.define('includes', (str, substring) => {
+    return str.includes(substring);
+  });
+
+  env.define('pad_start', (str, length, char = ' ') => {
+    return str.padStart(length, char);
+  });
+
+  env.define('pad_end', (str, length, char = ' ') => {
+    return str.padEnd(length, char);
+  });
+
+  env.define('truncate', (str, length) => {
+    if (str.length <= length) return str;
+    return str.slice(0, length - 3) + '...';
+  });
+
+  env.define('replace_all', (str, search, replace) => {
+    return str.replaceAll(search, replace);
+  });
+
+  // Wang Standard Library - Type Checking
+  env.define('is_string', (value) => {
+    return typeof value === 'string';
+  });
+
+  env.define('is_number', (value) => {
+    return typeof value === 'number';
+  });
+
+  env.define('is_boolean', (value) => {
+    return typeof value === 'boolean';
+  });
+
+  env.define('is_array', (value) => {
+    return Array.isArray(value);
+  });
+
+  env.define('is_object', (value) => {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+  });
+
+  env.define('is_function', (value) => {
+    return typeof value === 'function';
+  });
+
+  env.define('is_null', (value) => {
+    return value === null;
+  });
+
+  env.define('is_undefined', (value) => {
+    return value === undefined;
+  });
+
+  env.define('is_empty', (value) => {
+    if (value == null) return true;
+    if (typeof value === 'string' || Array.isArray(value)) return value.length === 0;
+    if (typeof value === 'object') return Object.keys(value).length === 0;
+    return false;
+  });
+
+  // Wang Standard Library - Math Operations
+  env.define('min', (array) => {
+    return Math.min(...array);
+  });
+
+  env.define('max', (array) => {
+    return Math.max(...array);
+  });
+
+  env.define('sum', (array) => {
+    return array.reduce((a, b) => a + b, 0);
+  });
+
+  env.define('avg', (array) => {
+    return array.reduce((a, b) => a + b, 0) / array.length;
+  });
+
+  env.define('median', (array) => {
+    const sorted = [...array].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 === 0
+      ? (sorted[mid - 1] + sorted[mid]) / 2
+      : sorted[mid];
+  });
+
+  env.define('round', (num, decimals = 0) => {
+    const factor = Math.pow(10, decimals);
+    return Math.round(num * factor) / factor;
+  });
+
+  env.define('floor', (num) => {
+    return Math.floor(num);
+  });
+
+  env.define('ceil', (num) => {
+    return Math.ceil(num);
+  });
+
+  env.define('abs', (num) => {
+    return Math.abs(num);
+  });
+
+  env.define('clamp', (num, min, max) => {
+    return Math.min(Math.max(num, min), max);
+  });
+
+  env.define('range', (start, end, step) => {
+    // Support range(n) -> [0, 1, ..., n-1]
+    if (end === undefined) {
+      end = start;
+      start = 0;
+      step = 1;
+    }
+    if (step === undefined) {
+      step = start < end ? 1 : -1;
+    }
+
+    const result = [];
+    if (step > 0) {
+      for (let i = start; i < end; i += step) {
+        result.push(i);
+      }
+    } else {
+      for (let i = start; i > end; i += step) {
+        result.push(i);
+      }
+    }
+    return result;
+  });
+
+  // Wang Standard Library - Utility Functions
+  env.define('uuid', () => {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+      const r = Math.random() * 16 | 0;
+      const v = c === 'x' ? r : (r & 0x3 | 0x8);
+      return v.toString(16);
+    });
+  });
+
+  env.define('to_json', (value) => {
+    return JSON.stringify(value);
+  });
+
+  env.define('from_json', (str) => {
+    return JSON.parse(str);
+  });
+
+  env.define('sleep', async (ms) => {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  });
+
+  env.define('wait', async (ms) => {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  });
+
+  return env;
+}
+
+/**
+ * WangInterpreter compatibility adapter for JSLike
+ * Maps Wang's interpreter API to JSLike's API
+ */
+
+
+class WangInterpreter {
+  constructor(options = {}) {
+    this.options = options;
+    this.moduleResolver = options.moduleResolver;
+    this.functions = options.functions || {};
+    // Create a persistent environment for setVariable support
+    this.persistentEnv = null;
+  }
+
+  setVariable(name, value) {
+    // If persistent environment doesn't exist, create it
+    if (!this.persistentEnv) {
+      this.persistentEnv = createEnvironment();
+
+      // Add custom functions
+      for (const [funcName, func] of Object.entries(this.functions)) {
+        if (this.persistentEnv.has(funcName)) {
+          this.persistentEnv.set(funcName, func);
+        } else {
+          this.persistentEnv.define(funcName, func);
+        }
+      }
+    }
+
+    // Set the variable in persistent environment
+    if (this.persistentEnv.has(name)) {
+      this.persistentEnv.set(name, value);
+    } else {
+      this.persistentEnv.define(name, value);
+    }
+  }
+
+  // Alias for setVariable - specifically for binding functions
+  bindFunction(name, func) {
+    return this.setVariable(name, func);
+  }
+
+  // Expose global context for accessing variables after execution
+  get globalContext() {
+    return {
+      variables: this.persistentEnv?.vars || new Map()
+    };
+  }
+
+  createExecutionEnvironment() {
+    // Create fresh environment for each execution
+    const env = createEnvironment();
+
+    // Add custom functions to environment, overriding built-ins if needed
+    for (const [name, func] of Object.entries(this.functions)) {
+      // Use set() to override existing variables instead of define()
+      if (env.has(name)) {
+        env.set(name, func);
+      } else {
+        env.define(name, func);
+      }
+    }
+
+    return env;
+  }
+
+  async execute(code, initialEnv = undefined, userOptions = {}) {
+    // Use provided environment, persistent environment, or create fresh one
+    const env = initialEnv || this.persistentEnv || this.createExecutionEnvironment();
+
+    // Setup console capture if withMetadata option is enabled
+    const withMetadata = userOptions.withMetadata || false;
+    const capturedLogs = [];
+
+    if (withMetadata) {
+      // Override log/warn/error functions to capture calls
+      const createCapture = (type) => {
+        return (...args) => {
+          capturedLogs.push({
+            type,
+            args,
+            timestamp: Date.now()
+          });
+          // Still output to console
+          console[type](...args);
+          return undefined;
+        };
+      };
+
+      env.set('log', createCapture('log'));
+      env.set('warn', createCapture('warn'));
+      env.set('error', createCapture('error'));
+    }
+
+    // Check if code contains top-level return statements
+    // Need to detect `return` at start of line, but NOT inside function bodies
+    // Simple heuristic: check if braces are balanced before the return statement
+    const hasTopLevelReturn = this.hasTopLevelReturn(code);
+
+    // Prepare execution options
+    const options = {
+      moduleResolver: this.moduleResolver
+      // sourceType will be auto-detected from code
+    };
+
+    let result;
+    if (hasTopLevelReturn) {
+      // Wrap code in async IIFE to support top-level return statements
+      const wrappedCode = `(async function() { ${code} })()`;
+      try {
+        result = await execute(wrappedCode, env, options);
+      } catch (error) {
+        throw error;
+      }
+    } else {
+      // Execute directly - JSLike returns last evaluated expression
+      try {
+        result = await execute(code, env, options);
+      } catch (error) {
+        throw error;
+      }
+    }
+
+    // Return result with metadata if requested
+    if (withMetadata) {
+      return {
+        result,
+        metadata: {
+          logs: capturedLogs
+        }
+      };
+    }
+
+    return result;
+  }
+
+  hasTopLevelReturn(code) {
+    const lines = code.split('\n');
+    let braceDepth = 0;
+
+    for (const line of lines) {
+      // Check if this line has a return statement at the start (ignoring whitespace)
+      const trimmed = line.trim();
+      if (trimmed.startsWith('return ') || trimmed === 'return') {
+        // If we're at brace depth 0, it's a top-level return
+        if (braceDepth === 0) {
+          return true;
+        }
+      }
+
+      // Count braces on this line (after checking for return)
+      for (const char of line) {
+        if (char === '{') braceDepth++;
+        if (char === '}') braceDepth--;
+      }
+    }
+
+    return false;
+  }
+
+  async executeModule(code) {
+    // Same as execute for now - modules are handled by execute()
+    return await this.execute(code);
+  }
+}
+
+class InMemoryModuleResolver {
+  constructor() {
+    this.modules = new Map();
+  }
+
+  addModule(name, code, metadata) {
+    this.modules.set(name, { code, metadata });
+  }
+
+  async resolve(modulePath, fromPath) {
+    const module = this.modules.get(modulePath);
+    if (!module) {
+      return null;
+    }
+    return {
+      code: typeof module === 'string' ? module : module.code,
+      path: modulePath,
+      metadata: module.metadata
+    };
+  }
+
+  async exists(modulePath, fromPath) {
+    return this.modules.has(modulePath);
+  }
+
+  async list(prefix) {
+    const paths = Array.from(this.modules.keys());
+    if (prefix) {
+      return paths.filter(p => p.startsWith(prefix));
+    }
+    return paths;
+  }
+}
+
+// Use bundled Acorn parser for zero runtime dependencies
+
+// Helper to detect if code contains module syntax or top-level await
+function containsModuleSyntax(code) {
+  // Trigger module mode for:
+  // 1. import/export statements
+  // 2. Top-level await (await not inside a function)
+  if (/^\s*(import|export)\s+/m.test(code)) {
+    return true;
+  }
+
+  // Check for top-level await (simple heuristic: await at start of line or after statement)
+  // This isn't perfect but handles common cases, including await in template literals
+  // Also matches await after operators like || or && or = or inside parentheses
+  if (/^await\s+/m.test(code) || /[;\n{(|&=]\s*await\s+/.test(code)) {
+    return true;
+  }
+
+  return false;
+}
+
+
+function parse(code, options = {}) {
+  // Determine sourceType: use 'module' ONLY if explicitly requested or if code has imports/exports
+  // Default to 'script' for better compatibility with labeled statements
+  let sourceType = options.sourceType || 'script';
+  if (!options.sourceType && containsModuleSyntax(code)) {
+    sourceType = 'module';
+  }
+
+  // Parse with Acorn
+  try {
+    return parse$1(code, {
+      ecmaVersion: 2022,  // Support ES2022 features (including top-level await)
+      sourceType: sourceType,
+      locations: true,     // Track source locations for better error messages
+      allowReturnOutsideFunction: true  // Allow top-level return statements
+    });
+  } catch (error) {
+    // Reformat error message for consistency
+    throw new SyntaxError(
+      `Parse error at line ${error.loc?.line || '?'}: ${error.message}`
+    );
+  }
+}
+
+// Helper to detect if AST contains import/export declarations
+function containsModuleDeclarations(node) {
+  if (!node || typeof node !== 'object') return false;
+
+  if (node.type === 'ImportDeclaration' ||
+      node.type === 'ExportNamedDeclaration' ||
+      node.type === 'ExportDefaultDeclaration' ||
+      node.type === 'ExportAllDeclaration') {
+    return true;
+  }
+
+  // Check Program body for module declarations
+  if (node.type === 'Program' && node.body) {
+    for (const statement of node.body) {
+      if (containsModuleDeclarations(statement)) return true;
+    }
+  }
+
+  return false;
+}
+
+// Helper to detect if AST contains top-level await expressions
+function containsTopLevelAwait(node) {
+  if (!node || typeof node !== 'object') return false;
+
+  if (node.type === 'AwaitExpression') return true;
+
+  // Don't recurse into function bodies (they handle their own await)
+  if (node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') {
+    return false;
+  }
+
+  // Check all properties
+  for (const key in node) {
+    if (key === 'loc' || key === 'range') continue;
+    const value = node[key];
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (containsTopLevelAwait(item)) return true;
+      }
+    } else if (typeof value === 'object') {
+      if (containsTopLevelAwait(value)) return true;
+    }
+  }
+
+  return false;
+}
+
+async function execute(code, env = null, options = {}) {
+  // Parse the code
+  const ast = parse(code, options);
+
+  // Create global environment if not provided
+  if (!env) {
+    env = createGlobalEnvironment(new Environment());
+  }
+
+  // Create a child environment for user code to allow shadowing of built-ins
+  // This prevents conflicts when user code declares variables with same names as stdlib functions
+  const userEnv = env.extend();
+
+  // Create interpreter with module resolver and abort signal if provided
+  const interpreter = new Interpreter(env, {
+    moduleResolver: options.moduleResolver,
+    abortSignal: options.abortSignal
+  });
+
+  // Use async evaluation if:
+  // 1. Explicitly requested module mode
+  // 2. AST contains import/export declarations
+  // 3. Code contains top-level await
+  const needsAsync = options.sourceType === 'module' ||
+                     containsModuleDeclarations(ast) ||
+                     containsTopLevelAwait(ast);
+
+  if (needsAsync) {
+    const result = await interpreter.evaluateAsync(ast, userEnv);
+    return result instanceof ReturnValue ? result.value : result;
+  } else {
+    const result = interpreter.evaluate(ast, userEnv);
+    return result instanceof ReturnValue ? result.value : result;
+  }
+}
+
+function createEnvironment() {
+  return createGlobalEnvironment(new Environment());
 }
 
-// Acorn is organized as a tokenizer and a recursive-descent parser.
-// The `tokenizer` export provides an interface to the tokenizer.
+// Export utility functions for CLI tools
+const isTopLevelAwait = containsModuleSyntax;
 
-function tokenizer(input, options) {
-  return Parser.tokenizer(input, options)
+/**
+ * Abstract base class for module resolution
+ * Extend this class to implement custom module loading strategies
+ */
+class ModuleResolver {
+  /**
+   * Resolve a module and return its code
+   * @param {string} modulePath - The module path to resolve
+   * @param {string} [fromPath] - The path of the importing module
+   * @returns {Promise<ModuleResolution>} The resolved module
+   */
+  async resolve(modulePath, fromPath) {
+    throw new Error('ModuleResolver.resolve() must be implemented by subclass');
+  }
+
+  /**
+   * Check if a module exists
+   * @param {string} modulePath - The module path to check
+   * @param {string} [fromPath] - The path of the importing module
+   * @returns {Promise<boolean>} Whether the module exists
+   */
+  async exists(modulePath, fromPath) {
+    throw new Error('ModuleResolver.exists() must be implemented by subclass');
+  }
+
+  /**
+   * List available modules
+   * @param {string} [prefix] - Optional prefix to filter modules
+   * @returns {Promise<string[]>} List of module paths
+   */
+  async list(prefix) {
+    throw new Error('ModuleResolver.list() must be implemented by subclass');
+  }
 }
 
-export { Node, Parser, Position, SourceLocation, TokContext, Token, TokenType, defaultOptions, getLineInfo, isIdentifierChar, isIdentifierStart, isNewLine, keywords as keywordTypes, lineBreak, lineBreakG, nonASCIIwhitespace, parse, parseExpressionAt, types as tokContexts, types$1 as tokTypes, tokenizer, version };
+/**
+ * @typedef {Object} ModuleResolution
+ * @property {string} code - The module source code
+ * @property {string} path - The resolved module path
+ * @property {any} [metadata] - Optional metadata about the module
+ */
 
+export { Environment, InMemoryModuleResolver, Interpreter, ModuleResolver, WangInterpreter, createEnvironment, execute, isTopLevelAwait, parse };