jslike 1.7.2 → 1.7.3

package/dist/esm/interpreter/interpreter.js

@@ -39,6 +39,121 @@ export class Interpreter {
     }
   }
 
+  async evaluateAsyncRawValue(node, env) {
+    if (!node) return { value: undefined };
+
+    if (node.type === 'CallExpression') {
+      return await this.evaluateCallExpressionAsyncRawValue(node, env);
+    }
+
+    if (node.type === 'MemberExpression') {
+      const obj = (await this.evaluateAsyncRawValue(node.object, env)).value;
+
+      if (node.optional && (obj === null || obj === undefined)) {
+        return { value: 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 { value: obj[prop] };
+    }
+
+    if (node.type === 'ChainExpression') {
+      return await this.evaluateAsyncRawValue(node.expression, env);
+    }
+
+    if (node.type === 'ConditionalExpression') {
+      const test = await this.evaluateAsync(node.test, env);
+      return await this.evaluateAsyncRawValue(test ? node.consequent : node.alternate, env);
+    }
+
+    if (node.type === 'LogicalExpression') {
+      const left = await this.evaluateAsync(node.left, env);
+      if (node.operator === '&&') {
+        return left ? await this.evaluateAsyncRawValue(node.right, env) : { value: left };
+      }
+      if (node.operator === '||') {
+        return left ? { value: left } : await this.evaluateAsyncRawValue(node.right, env);
+      }
+      if (node.operator === '??') {
+        return left !== null && left !== undefined
+          ? { value: left }
+          : await this.evaluateAsyncRawValue(node.right, env);
+      }
+    }
+
+    if (node.type === 'SequenceExpression') {
+      for (let i = 0; i < node.expressions.length - 1; i++) {
+        await this.evaluateAsync(node.expressions[i], env);
+      }
+      return await this.evaluateAsyncRawValue(node.expressions[node.expressions.length - 1], env);
+    }
+
+    if (node.type === 'NewExpression') {
+      return { value: this.evaluateNewExpression(node, env) };
+    }
+
+    if (['Literal', 'Identifier', 'ThisExpression', 'Super'].includes(node.type)) {
+      return { value: this.evaluate(node, env) };
+    }
+
+    return { value: await this.evaluateAsync(node, env) };
+  }
+
+  async evaluateCallExpressionAsyncRawValue(node, env) {
+    let thisContext = undefined;
+    let callee;
+    let objectName = null;
+    let methodName = null;
+
+    if (node.callee.type === 'MemberExpression') {
+      thisContext = (await this.evaluateAsyncRawValue(node.callee.object, env)).value;
+      if (node.callee.optional && (thisContext === null || thisContext === undefined)) {
+        return { value: undefined };
+      }
+      const prop = node.callee.computed
+        ? await this.evaluateAsync(node.callee.property, env)
+        : node.callee.property.name;
+      callee = thisContext[prop];
+
+      methodName = prop;
+      objectName = this.getExpressionName(node.callee.object);
+    } else {
+      callee = await this.evaluateAsync(node.callee, env);
+    }
+
+    if (node.optional && (callee === null || callee === undefined)) {
+      return { value: undefined };
+    }
+
+    const rawArgs = [];
+    for (const arg of node.arguments) {
+      rawArgs.push(await this.evaluateAsync(arg, env));
+    }
+    const args = this.flattenSpreadArgs(rawArgs);
+
+    if (typeof callee === 'function') {
+      const value = thisContext !== undefined
+        ? callee.call(thisContext, ...args)
+        : callee(...args);
+      return { value };
+    } else if (callee && callee.__isFunction) {
+      return { value: this.callUserFunction(callee, args, env, thisContext) };
+    }
+
+    if (objectName && methodName) {
+      throw createMethodNotFoundError(objectName, methodName, thisContext);
+    }
+
+    throw new TypeError(`${node.callee.name || 'Expression'} is not a function`);
+  }
+
   // Async evaluation for async functions - handles await expressions
   async evaluateAsync(node, env) {
     if (!node) return undefined;
@@ -77,7 +192,7 @@ export class Interpreter {
     if (node.type === 'VariableDeclaration') {
       for (const declarator of node.declarations) {
         const value = declarator.init
-          ? await this.evaluateAsync(declarator.init, env)
+          ? (await this.evaluateAsyncRawValue(declarator.init, env)).value
           : undefined;
 
         const isConst = node.kind === 'const';
@@ -134,54 +249,8 @@ export class Interpreter {
 
     // 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);
-        if (node.callee.optional && (thisContext === null || thisContext === undefined)) {
-          return undefined;
-        }
-        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 rawArgs = [];
-      for (const arg of node.arguments) {
-        rawArgs.push(await this.evaluateAsync(arg, env));
-      }
-      const args = this.flattenSpreadArgs(rawArgs);
-
-      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`);
+      const result = (await this.evaluateCallExpressionAsyncRawValue(node, env)).value;
+      return await result;
     }
 
     // For chain expressions (optional chaining)
@@ -191,7 +260,7 @@ export class Interpreter {
 
     // For member expressions in async context
     if (node.type === 'MemberExpression') {
-      const obj = await this.evaluateAsync(node.object, env);
+      const obj = (await this.evaluateAsyncRawValue(node.object, env)).value;
 
       // Handle optional chaining
       if (node.optional && (obj === null || obj === undefined)) {
@@ -513,7 +582,7 @@ export class Interpreter {
 
     // For AssignmentExpression with async value
     if (node.type === 'AssignmentExpression') {
-      const value = await this.evaluateAsync(node.right, env);
+      const value = (await this.evaluateAsyncRawValue(node.right, env)).value;
 
       if (node.left.type === 'Identifier') {
         const name = node.left.name;

package/dist/index.cjs

@@ -6507,6 +6507,91 @@ var Interpreter = class _Interpreter {
       return null;
     }
   }
+  async evaluateAsyncRawValue(node, env) {
+    if (!node) return { value: void 0 };
+    if (node.type === "CallExpression") {
+      return await this.evaluateCallExpressionAsyncRawValue(node, env);
+    }
+    if (node.type === "MemberExpression") {
+      const obj = (await this.evaluateAsyncRawValue(node.object, env)).value;
+      if (node.optional && (obj === null || obj === void 0)) {
+        return { value: void 0 };
+      }
+      if (obj === null || obj === void 0) {
+        throw new TypeError(`Cannot read property of ${obj}`);
+      }
+      const prop = node.computed ? await this.evaluateAsync(node.property, env) : node.property.name;
+      return { value: obj[prop] };
+    }
+    if (node.type === "ChainExpression") {
+      return await this.evaluateAsyncRawValue(node.expression, env);
+    }
+    if (node.type === "ConditionalExpression") {
+      const test = await this.evaluateAsync(node.test, env);
+      return await this.evaluateAsyncRawValue(test ? node.consequent : node.alternate, env);
+    }
+    if (node.type === "LogicalExpression") {
+      const left = await this.evaluateAsync(node.left, env);
+      if (node.operator === "&&") {
+        return left ? await this.evaluateAsyncRawValue(node.right, env) : { value: left };
+      }
+      if (node.operator === "||") {
+        return left ? { value: left } : await this.evaluateAsyncRawValue(node.right, env);
+      }
+      if (node.operator === "??") {
+        return left !== null && left !== void 0 ? { value: left } : await this.evaluateAsyncRawValue(node.right, env);
+      }
+    }
+    if (node.type === "SequenceExpression") {
+      for (let i = 0; i < node.expressions.length - 1; i++) {
+        await this.evaluateAsync(node.expressions[i], env);
+      }
+      return await this.evaluateAsyncRawValue(node.expressions[node.expressions.length - 1], env);
+    }
+    if (node.type === "NewExpression") {
+      return { value: this.evaluateNewExpression(node, env) };
+    }
+    if (["Literal", "Identifier", "ThisExpression", "Super"].includes(node.type)) {
+      return { value: this.evaluate(node, env) };
+    }
+    return { value: await this.evaluateAsync(node, env) };
+  }
+  async evaluateCallExpressionAsyncRawValue(node, env) {
+    let thisContext = void 0;
+    let callee;
+    let objectName = null;
+    let methodName = null;
+    if (node.callee.type === "MemberExpression") {
+      thisContext = (await this.evaluateAsyncRawValue(node.callee.object, env)).value;
+      if (node.callee.optional && (thisContext === null || thisContext === void 0)) {
+        return { value: void 0 };
+      }
+      const prop = node.callee.computed ? await this.evaluateAsync(node.callee.property, env) : node.callee.property.name;
+      callee = thisContext[prop];
+      methodName = prop;
+      objectName = this.getExpressionName(node.callee.object);
+    } else {
+      callee = await this.evaluateAsync(node.callee, env);
+    }
+    if (node.optional && (callee === null || callee === void 0)) {
+      return { value: void 0 };
+    }
+    const rawArgs = [];
+    for (const arg of node.arguments) {
+      rawArgs.push(await this.evaluateAsync(arg, env));
+    }
+    const args = this.flattenSpreadArgs(rawArgs);
+    if (typeof callee === "function") {
+      const value = thisContext !== void 0 ? callee.call(thisContext, ...args) : callee(...args);
+      return { value };
+    } else if (callee && callee.__isFunction) {
+      return { value: this.callUserFunction(callee, args, env, thisContext) };
+    }
+    if (objectName && methodName) {
+      throw createMethodNotFoundError(objectName, methodName, thisContext);
+    }
+    throw new TypeError(`${node.callee.name || "Expression"} is not a function`);
+  }
   // Async evaluation for async functions - handles await expressions
   async evaluateAsync(node, env) {
     if (!node) return void 0;
@@ -6532,7 +6617,7 @@ var Interpreter = class _Interpreter {
     }
     if (node.type === "VariableDeclaration") {
       for (const declarator of node.declarations) {
-        const value = declarator.init ? await this.evaluateAsync(declarator.init, env) : void 0;
+        const value = declarator.init ? (await this.evaluateAsyncRawValue(declarator.init, env)).value : void 0;
         const isConst = node.kind === "const";
         if (declarator.id.type === "Identifier") {
           env.define(declarator.id.name, value, isConst);
@@ -6573,48 +6658,14 @@ var Interpreter = class _Interpreter {
       return this.evaluateBinaryExpressionValues(node.operator, left, right);
     }
     if (node.type === "CallExpression") {
-      let thisContext = void 0;
-      let callee;
-      let objectName = null;
-      let methodName = null;
-      if (node.callee.type === "MemberExpression") {
-        thisContext = await this.evaluateAsync(node.callee.object, env);
-        if (node.callee.optional && (thisContext === null || thisContext === void 0)) {
-          return void 0;
-        }
-        const prop = node.callee.computed ? await this.evaluateAsync(node.callee.property, env) : node.callee.property.name;
-        callee = thisContext[prop];
-        methodName = prop;
-        objectName = this.getExpressionName(node.callee.object);
-      } else {
-        callee = await this.evaluateAsync(node.callee, env);
-      }
-      if (node.optional && (callee === null || callee === void 0)) {
-        return void 0;
-      }
-      const rawArgs = [];
-      for (const arg of node.arguments) {
-        rawArgs.push(await this.evaluateAsync(arg, env));
-      }
-      const args = this.flattenSpreadArgs(rawArgs);
-      if (typeof callee === "function") {
-        if (thisContext !== void 0) {
-          return await callee.call(thisContext, ...args);
-        }
-        return await callee(...args);
-      } else if (callee && callee.__isFunction) {
-        return await this.callUserFunction(callee, args, env, thisContext);
-      }
-      if (objectName && methodName) {
-        throw createMethodNotFoundError(objectName, methodName, thisContext);
-      }
-      throw new TypeError(`${node.callee.name || "Expression"} is not a function`);
+      const result = (await this.evaluateCallExpressionAsyncRawValue(node, env)).value;
+      return await result;
     }
     if (node.type === "ChainExpression") {
       return await this.evaluateAsync(node.expression, env);
     }
     if (node.type === "MemberExpression") {
-      const obj = await this.evaluateAsync(node.object, env);
+      const obj = (await this.evaluateAsyncRawValue(node.object, env)).value;
       if (node.optional && (obj === null || obj === void 0)) {
         return void 0;
       }
@@ -6872,7 +6923,7 @@ var Interpreter = class _Interpreter {
       return test ? await this.evaluateAsync(node.consequent, env) : await this.evaluateAsync(node.alternate, env);
     }
     if (node.type === "AssignmentExpression") {
-      const value = await this.evaluateAsync(node.right, env);
+      const value = (await this.evaluateAsyncRawValue(node.right, env)).value;
       if (node.left.type === "Identifier") {
         const name = node.left.name;
         if (node.operator === "=") {

package/dist/index.d.cts

@@ -7204,6 +7204,121 @@ class Interpreter {
     }
   }
 
+  async evaluateAsyncRawValue(node, env) {
+    if (!node) return { value: undefined };
+
+    if (node.type === 'CallExpression') {
+      return await this.evaluateCallExpressionAsyncRawValue(node, env);
+    }
+
+    if (node.type === 'MemberExpression') {
+      const obj = (await this.evaluateAsyncRawValue(node.object, env)).value;
+
+      if (node.optional && (obj === null || obj === undefined)) {
+        return { value: 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 { value: obj[prop] };
+    }
+
+    if (node.type === 'ChainExpression') {
+      return await this.evaluateAsyncRawValue(node.expression, env);
+    }
+
+    if (node.type === 'ConditionalExpression') {
+      const test = await this.evaluateAsync(node.test, env);
+      return await this.evaluateAsyncRawValue(test ? node.consequent : node.alternate, env);
+    }
+
+    if (node.type === 'LogicalExpression') {
+      const left = await this.evaluateAsync(node.left, env);
+      if (node.operator === '&&') {
+        return left ? await this.evaluateAsyncRawValue(node.right, env) : { value: left };
+      }
+      if (node.operator === '||') {
+        return left ? { value: left } : await this.evaluateAsyncRawValue(node.right, env);
+      }
+      if (node.operator === '??') {
+        return left !== null && left !== undefined
+          ? { value: left }
+          : await this.evaluateAsyncRawValue(node.right, env);
+      }
+    }
+
+    if (node.type === 'SequenceExpression') {
+      for (let i = 0; i < node.expressions.length - 1; i++) {
+        await this.evaluateAsync(node.expressions[i], env);
+      }
+      return await this.evaluateAsyncRawValue(node.expressions[node.expressions.length - 1], env);
+    }
+
+    if (node.type === 'NewExpression') {
+      return { value: this.evaluateNewExpression(node, env) };
+    }
+
+    if (['Literal', 'Identifier', 'ThisExpression', 'Super'].includes(node.type)) {
+      return { value: this.evaluate(node, env) };
+    }
+
+    return { value: await this.evaluateAsync(node, env) };
+  }
+
+  async evaluateCallExpressionAsyncRawValue(node, env) {
+    let thisContext = undefined;
+    let callee;
+    let objectName = null;
+    let methodName = null;
+
+    if (node.callee.type === 'MemberExpression') {
+      thisContext = (await this.evaluateAsyncRawValue(node.callee.object, env)).value;
+      if (node.callee.optional && (thisContext === null || thisContext === undefined)) {
+        return { value: undefined };
+      }
+      const prop = node.callee.computed
+        ? await this.evaluateAsync(node.callee.property, env)
+        : node.callee.property.name;
+      callee = thisContext[prop];
+
+      methodName = prop;
+      objectName = this.getExpressionName(node.callee.object);
+    } else {
+      callee = await this.evaluateAsync(node.callee, env);
+    }
+
+    if (node.optional && (callee === null || callee === undefined)) {
+      return { value: undefined };
+    }
+
+    const rawArgs = [];
+    for (const arg of node.arguments) {
+      rawArgs.push(await this.evaluateAsync(arg, env));
+    }
+    const args = this.flattenSpreadArgs(rawArgs);
+
+    if (typeof callee === 'function') {
+      const value = thisContext !== undefined
+        ? callee.call(thisContext, ...args)
+        : callee(...args);
+      return { value };
+    } else if (callee && callee.__isFunction) {
+      return { value: this.callUserFunction(callee, args, env, thisContext) };
+    }
+
+    if (objectName && methodName) {
+      throw createMethodNotFoundError(objectName, methodName, thisContext);
+    }
+
+    throw new TypeError(`${node.callee.name || 'Expression'} is not a function`);
+  }
+
   // Async evaluation for async functions - handles await expressions
   async evaluateAsync(node, env) {
     if (!node) return undefined;
@@ -7242,7 +7357,7 @@ class Interpreter {
     if (node.type === 'VariableDeclaration') {
       for (const declarator of node.declarations) {
         const value = declarator.init
-          ? await this.evaluateAsync(declarator.init, env)
+          ? (await this.evaluateAsyncRawValue(declarator.init, env)).value
           : undefined;
 
         const isConst = node.kind === 'const';
@@ -7299,54 +7414,8 @@ class Interpreter {
 
     // 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);
-        if (node.callee.optional && (thisContext === null || thisContext === undefined)) {
-          return undefined;
-        }
-        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 rawArgs = [];
-      for (const arg of node.arguments) {
-        rawArgs.push(await this.evaluateAsync(arg, env));
-      }
-      const args = this.flattenSpreadArgs(rawArgs);
-
-      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`);
+      const result = (await this.evaluateCallExpressionAsyncRawValue(node, env)).value;
+      return await result;
     }
 
     // For chain expressions (optional chaining)
@@ -7356,7 +7425,7 @@ class Interpreter {
 
     // For member expressions in async context
     if (node.type === 'MemberExpression') {
-      const obj = await this.evaluateAsync(node.object, env);
+      const obj = (await this.evaluateAsyncRawValue(node.object, env)).value;
 
       // Handle optional chaining
       if (node.optional && (obj === null || obj === undefined)) {
@@ -7678,7 +7747,7 @@ class Interpreter {
 
     // For AssignmentExpression with async value
     if (node.type === 'AssignmentExpression') {
-      const value = await this.evaluateAsync(node.right, env);
+      const value = (await this.evaluateAsyncRawValue(node.right, env)).value;
 
       if (node.left.type === 'Identifier') {
         const name = node.left.name;

package/dist/index.d.ts

@@ -7204,6 +7204,121 @@ class Interpreter {
     }
   }
 
+  async evaluateAsyncRawValue(node, env) {
+    if (!node) return { value: undefined };
+
+    if (node.type === 'CallExpression') {
+      return await this.evaluateCallExpressionAsyncRawValue(node, env);
+    }
+
+    if (node.type === 'MemberExpression') {
+      const obj = (await this.evaluateAsyncRawValue(node.object, env)).value;
+
+      if (node.optional && (obj === null || obj === undefined)) {
+        return { value: 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 { value: obj[prop] };
+    }
+
+    if (node.type === 'ChainExpression') {
+      return await this.evaluateAsyncRawValue(node.expression, env);
+    }
+
+    if (node.type === 'ConditionalExpression') {
+      const test = await this.evaluateAsync(node.test, env);
+      return await this.evaluateAsyncRawValue(test ? node.consequent : node.alternate, env);
+    }
+
+    if (node.type === 'LogicalExpression') {
+      const left = await this.evaluateAsync(node.left, env);
+      if (node.operator === '&&') {
+        return left ? await this.evaluateAsyncRawValue(node.right, env) : { value: left };
+      }
+      if (node.operator === '||') {
+        return left ? { value: left } : await this.evaluateAsyncRawValue(node.right, env);
+      }
+      if (node.operator === '??') {
+        return left !== null && left !== undefined
+          ? { value: left }
+          : await this.evaluateAsyncRawValue(node.right, env);
+      }
+    }
+
+    if (node.type === 'SequenceExpression') {
+      for (let i = 0; i < node.expressions.length - 1; i++) {
+        await this.evaluateAsync(node.expressions[i], env);
+      }
+      return await this.evaluateAsyncRawValue(node.expressions[node.expressions.length - 1], env);
+    }
+
+    if (node.type === 'NewExpression') {
+      return { value: this.evaluateNewExpression(node, env) };
+    }
+
+    if (['Literal', 'Identifier', 'ThisExpression', 'Super'].includes(node.type)) {
+      return { value: this.evaluate(node, env) };
+    }
+
+    return { value: await this.evaluateAsync(node, env) };
+  }
+
+  async evaluateCallExpressionAsyncRawValue(node, env) {
+    let thisContext = undefined;
+    let callee;
+    let objectName = null;
+    let methodName = null;
+
+    if (node.callee.type === 'MemberExpression') {
+      thisContext = (await this.evaluateAsyncRawValue(node.callee.object, env)).value;
+      if (node.callee.optional && (thisContext === null || thisContext === undefined)) {
+        return { value: undefined };
+      }
+      const prop = node.callee.computed
+        ? await this.evaluateAsync(node.callee.property, env)
+        : node.callee.property.name;
+      callee = thisContext[prop];
+
+      methodName = prop;
+      objectName = this.getExpressionName(node.callee.object);
+    } else {
+      callee = await this.evaluateAsync(node.callee, env);
+    }
+
+    if (node.optional && (callee === null || callee === undefined)) {
+      return { value: undefined };
+    }
+
+    const rawArgs = [];
+    for (const arg of node.arguments) {
+      rawArgs.push(await this.evaluateAsync(arg, env));
+    }
+    const args = this.flattenSpreadArgs(rawArgs);
+
+    if (typeof callee === 'function') {
+      const value = thisContext !== undefined
+        ? callee.call(thisContext, ...args)
+        : callee(...args);
+      return { value };
+    } else if (callee && callee.__isFunction) {
+      return { value: this.callUserFunction(callee, args, env, thisContext) };
+    }
+
+    if (objectName && methodName) {
+      throw createMethodNotFoundError(objectName, methodName, thisContext);
+    }
+
+    throw new TypeError(`${node.callee.name || 'Expression'} is not a function`);
+  }
+
   // Async evaluation for async functions - handles await expressions
   async evaluateAsync(node, env) {
     if (!node) return undefined;
@@ -7242,7 +7357,7 @@ class Interpreter {
     if (node.type === 'VariableDeclaration') {
       for (const declarator of node.declarations) {
         const value = declarator.init
-          ? await this.evaluateAsync(declarator.init, env)
+          ? (await this.evaluateAsyncRawValue(declarator.init, env)).value
           : undefined;
 
         const isConst = node.kind === 'const';
@@ -7299,54 +7414,8 @@ class Interpreter {
 
     // 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);
-        if (node.callee.optional && (thisContext === null || thisContext === undefined)) {
-          return undefined;
-        }
-        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 rawArgs = [];
-      for (const arg of node.arguments) {
-        rawArgs.push(await this.evaluateAsync(arg, env));
-      }
-      const args = this.flattenSpreadArgs(rawArgs);
-
-      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`);
+      const result = (await this.evaluateCallExpressionAsyncRawValue(node, env)).value;
+      return await result;
     }
 
     // For chain expressions (optional chaining)
@@ -7356,7 +7425,7 @@ class Interpreter {
 
     // For member expressions in async context
     if (node.type === 'MemberExpression') {
-      const obj = await this.evaluateAsync(node.object, env);
+      const obj = (await this.evaluateAsyncRawValue(node.object, env)).value;
 
       // Handle optional chaining
       if (node.optional && (obj === null || obj === undefined)) {
@@ -7678,7 +7747,7 @@ class Interpreter {
 
     // For AssignmentExpression with async value
     if (node.type === 'AssignmentExpression') {
-      const value = await this.evaluateAsync(node.right, env);
+      const value = (await this.evaluateAsyncRawValue(node.right, env)).value;
 
       if (node.left.type === 'Identifier') {
         const name = node.left.name;

package/dist/index.js

@@ -6473,6 +6473,91 @@ var Interpreter = class _Interpreter {
       return null;
     }
   }
+  async evaluateAsyncRawValue(node, env) {
+    if (!node) return { value: void 0 };
+    if (node.type === "CallExpression") {
+      return await this.evaluateCallExpressionAsyncRawValue(node, env);
+    }
+    if (node.type === "MemberExpression") {
+      const obj = (await this.evaluateAsyncRawValue(node.object, env)).value;
+      if (node.optional && (obj === null || obj === void 0)) {
+        return { value: void 0 };
+      }
+      if (obj === null || obj === void 0) {
+        throw new TypeError(`Cannot read property of ${obj}`);
+      }
+      const prop = node.computed ? await this.evaluateAsync(node.property, env) : node.property.name;
+      return { value: obj[prop] };
+    }
+    if (node.type === "ChainExpression") {
+      return await this.evaluateAsyncRawValue(node.expression, env);
+    }
+    if (node.type === "ConditionalExpression") {
+      const test = await this.evaluateAsync(node.test, env);
+      return await this.evaluateAsyncRawValue(test ? node.consequent : node.alternate, env);
+    }
+    if (node.type === "LogicalExpression") {
+      const left = await this.evaluateAsync(node.left, env);
+      if (node.operator === "&&") {
+        return left ? await this.evaluateAsyncRawValue(node.right, env) : { value: left };
+      }
+      if (node.operator === "||") {
+        return left ? { value: left } : await this.evaluateAsyncRawValue(node.right, env);
+      }
+      if (node.operator === "??") {
+        return left !== null && left !== void 0 ? { value: left } : await this.evaluateAsyncRawValue(node.right, env);
+      }
+    }
+    if (node.type === "SequenceExpression") {
+      for (let i = 0; i < node.expressions.length - 1; i++) {
+        await this.evaluateAsync(node.expressions[i], env);
+      }
+      return await this.evaluateAsyncRawValue(node.expressions[node.expressions.length - 1], env);
+    }
+    if (node.type === "NewExpression") {
+      return { value: this.evaluateNewExpression(node, env) };
+    }
+    if (["Literal", "Identifier", "ThisExpression", "Super"].includes(node.type)) {
+      return { value: this.evaluate(node, env) };
+    }
+    return { value: await this.evaluateAsync(node, env) };
+  }
+  async evaluateCallExpressionAsyncRawValue(node, env) {
+    let thisContext = void 0;
+    let callee;
+    let objectName = null;
+    let methodName = null;
+    if (node.callee.type === "MemberExpression") {
+      thisContext = (await this.evaluateAsyncRawValue(node.callee.object, env)).value;
+      if (node.callee.optional && (thisContext === null || thisContext === void 0)) {
+        return { value: void 0 };
+      }
+      const prop = node.callee.computed ? await this.evaluateAsync(node.callee.property, env) : node.callee.property.name;
+      callee = thisContext[prop];
+      methodName = prop;
+      objectName = this.getExpressionName(node.callee.object);
+    } else {
+      callee = await this.evaluateAsync(node.callee, env);
+    }
+    if (node.optional && (callee === null || callee === void 0)) {
+      return { value: void 0 };
+    }
+    const rawArgs = [];
+    for (const arg of node.arguments) {
+      rawArgs.push(await this.evaluateAsync(arg, env));
+    }
+    const args = this.flattenSpreadArgs(rawArgs);
+    if (typeof callee === "function") {
+      const value = thisContext !== void 0 ? callee.call(thisContext, ...args) : callee(...args);
+      return { value };
+    } else if (callee && callee.__isFunction) {
+      return { value: this.callUserFunction(callee, args, env, thisContext) };
+    }
+    if (objectName && methodName) {
+      throw createMethodNotFoundError(objectName, methodName, thisContext);
+    }
+    throw new TypeError(`${node.callee.name || "Expression"} is not a function`);
+  }
   // Async evaluation for async functions - handles await expressions
   async evaluateAsync(node, env) {
     if (!node) return void 0;
@@ -6498,7 +6583,7 @@ var Interpreter = class _Interpreter {
     }
     if (node.type === "VariableDeclaration") {
       for (const declarator of node.declarations) {
-        const value = declarator.init ? await this.evaluateAsync(declarator.init, env) : void 0;
+        const value = declarator.init ? (await this.evaluateAsyncRawValue(declarator.init, env)).value : void 0;
         const isConst = node.kind === "const";
         if (declarator.id.type === "Identifier") {
           env.define(declarator.id.name, value, isConst);
@@ -6539,48 +6624,14 @@ var Interpreter = class _Interpreter {
       return this.evaluateBinaryExpressionValues(node.operator, left, right);
     }
     if (node.type === "CallExpression") {
-      let thisContext = void 0;
-      let callee;
-      let objectName = null;
-      let methodName = null;
-      if (node.callee.type === "MemberExpression") {
-        thisContext = await this.evaluateAsync(node.callee.object, env);
-        if (node.callee.optional && (thisContext === null || thisContext === void 0)) {
-          return void 0;
-        }
-        const prop = node.callee.computed ? await this.evaluateAsync(node.callee.property, env) : node.callee.property.name;
-        callee = thisContext[prop];
-        methodName = prop;
-        objectName = this.getExpressionName(node.callee.object);
-      } else {
-        callee = await this.evaluateAsync(node.callee, env);
-      }
-      if (node.optional && (callee === null || callee === void 0)) {
-        return void 0;
-      }
-      const rawArgs = [];
-      for (const arg of node.arguments) {
-        rawArgs.push(await this.evaluateAsync(arg, env));
-      }
-      const args = this.flattenSpreadArgs(rawArgs);
-      if (typeof callee === "function") {
-        if (thisContext !== void 0) {
-          return await callee.call(thisContext, ...args);
-        }
-        return await callee(...args);
-      } else if (callee && callee.__isFunction) {
-        return await this.callUserFunction(callee, args, env, thisContext);
-      }
-      if (objectName && methodName) {
-        throw createMethodNotFoundError(objectName, methodName, thisContext);
-      }
-      throw new TypeError(`${node.callee.name || "Expression"} is not a function`);
+      const result = (await this.evaluateCallExpressionAsyncRawValue(node, env)).value;
+      return await result;
     }
     if (node.type === "ChainExpression") {
       return await this.evaluateAsync(node.expression, env);
     }
     if (node.type === "MemberExpression") {
-      const obj = await this.evaluateAsync(node.object, env);
+      const obj = (await this.evaluateAsyncRawValue(node.object, env)).value;
       if (node.optional && (obj === null || obj === void 0)) {
         return void 0;
       }
@@ -6838,7 +6889,7 @@ var Interpreter = class _Interpreter {
       return test ? await this.evaluateAsync(node.consequent, env) : await this.evaluateAsync(node.alternate, env);
     }
     if (node.type === "AssignmentExpression") {
-      const value = await this.evaluateAsync(node.right, env);
+      const value = (await this.evaluateAsyncRawValue(node.right, env)).value;
       if (node.left.type === "Identifier") {
         const name = node.left.name;
         if (node.operator === "=") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jslike",
-  "version": "1.7.2",
+  "version": "1.7.3",
   "description": "Production-ready JavaScript interpreter with full ES6+ support using Acorn parser",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",