jslike 1.8.2 → 1.8.4

package/dist/index.d.cts

@@ -12250,6 +12250,10 @@ function getPatternName(pattern) {
   return pattern.name;
 }
 
+function unwrapTSParameterProperty(param) {
+  return param?.type === 'TSParameterProperty' ? param.parameter : param;
+}
+
 function collectRuntimeIdentifierReferences(node) {
   const references = new Set();
   const skipKeys = new Set([
@@ -13871,34 +13875,7 @@ class Interpreter {
       funcEnv.define('this', thisContext);
     }
 
-    // Bind parameters
-    for (let i = 0; i < metadata.params.length; i++) {
-      const param = metadata.params[i].type === 'TSParameterProperty'
-        ? metadata.params[i].parameter
-        : 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]);
-      }
-    }
+    this.bindFunctionParameters(metadata.params, args, funcEnv);
 
     // Execute function body
     // If async, use async evaluation and return a promise
@@ -14255,7 +14232,7 @@ class Interpreter {
           const finalValue = propValue !== undefined
             ? propValue
             : this.evaluate(prop.value.right, env);
-          env.define(prop.value.left.name, finalValue, isConst);
+          this.bindPattern(prop.value.left, finalValue, env, isConst);
         } else if (prop.value.type === 'ObjectPattern') {
           this.bindObjectPattern(prop.value, propValue, env, isConst);
         } else if (prop.value.type === 'ArrayPattern') {
@@ -14286,7 +14263,7 @@ class Interpreter {
         const finalValue = value[i] !== undefined
           ? value[i]
           : this.evaluate(element.right, env);
-        env.define(element.left.name, finalValue, isConst);
+        this.bindPattern(element.left, finalValue, env, isConst);
       } else if (element.type === 'ObjectPattern') {
         this.bindObjectPattern(element, value[i], env, isConst);
       } else if (element.type === 'ArrayPattern') {
@@ -14295,6 +14272,78 @@ class Interpreter {
     }
   }
 
+  bindPattern(pattern, value, env, isConst = false) {
+    if (pattern.type === 'Identifier') {
+      env.define(pattern.name, value, isConst);
+    } else if (pattern.type === 'ObjectPattern') {
+      this.bindObjectPattern(pattern, value, env, isConst);
+    } else if (pattern.type === 'ArrayPattern') {
+      this.bindArrayPattern(pattern, value, env, isConst);
+    } else if (pattern.type === 'AssignmentPattern') {
+      const finalValue = value !== undefined ? value : this.evaluate(pattern.right, env);
+      this.bindPattern(pattern.left, finalValue, env, isConst);
+    } else if (pattern.type === 'RestElement') {
+      this.bindPattern(pattern.argument, value, env, isConst);
+    }
+  }
+
+  bindFunctionParameters(params, args, env, thisContext = null) {
+    for (let i = 0; i < params.length; i++) {
+      const originalParam = params[i];
+      const param = unwrapTSParameterProperty(originalParam);
+
+      this.bindFunctionParameter(param, args[i], args.slice(i), env);
+
+      if (originalParam.type === 'TSParameterProperty' && thisContext) {
+        const propertyName = getPatternName(originalParam.parameter);
+        if (propertyName) {
+          thisContext[propertyName] = env.get(propertyName);
+        }
+      }
+
+      if (param.type === 'RestElement') {
+        break;
+      }
+    }
+  }
+
+  bindFunctionParameter(param, arg, restArgs, env) {
+    if (param.type === 'Identifier') {
+      this.bindPattern(param, arg, env);
+      return;
+    }
+
+    if (param.type === 'AssignmentPattern') {
+      const value = arg !== undefined ? arg : this.evaluate(param.right, env);
+      this.bindPattern(param.left, value, env);
+      return;
+    }
+
+    if (param.type === 'RestElement') {
+      const target = param.argument;
+      if (target.type === 'Identifier') {
+        env.define(target.name, restArgs);
+      } else if (target.type === 'ArrayPattern') {
+        this.bindArrayPattern(target, restArgs, env);
+      } else if (target.type === 'ObjectPattern') {
+        this.bindObjectPattern(target, restArgs, env);
+      }
+      return;
+    }
+
+    if (param.type === 'ObjectPattern') {
+      this.bindPattern(param, arg, env);
+      return;
+    }
+
+    if (param.type === 'ArrayPattern') {
+      this.bindPattern(param, arg, env);
+      return;
+    }
+
+    env.define(param.name, arg);
+  }
+
   evaluateFunctionDeclaration(node, env) {
     const funcMetadata = {
       __isFunction: true,
@@ -14859,6 +14908,7 @@ class Interpreter {
     let constructor = null;
     const methods = {};
     const staticMethods = {};
+    const instanceFields = [];
 
     for (const member of node.body.body) {
       if (member.type === 'MethodDefinition') {
@@ -14872,6 +14922,8 @@ class Interpreter {
         } else {
           methods[methodName] = methodFunc;
         }
+      } else if (member.type === 'PropertyDefinition' && !member.static && !member.declare && !member.abstract) {
+        instanceFields.push(member);
       }
     }
 
@@ -14879,18 +14931,11 @@ class Interpreter {
     const classConstructor = function(...args) {
       // Create instance
       const instance = Object.create(classConstructor.prototype);
+      const result = interpreter.constructClassInto(classConstructor, instance, args, env);
 
-      // 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);
+      // 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;
       }
 
       return instance;
@@ -14901,6 +14946,12 @@ class Interpreter {
       classConstructor.__constructor = constructor;
     }
 
+    classConstructor.__instanceFields = instanceFields;
+    classConstructor.__superClass = superClass;
+    classConstructor.__constructInto = (instance, args) => {
+      return interpreter.constructClassInto(classConstructor, instance, args, env);
+    };
+
     // Set up prototype chain
     if (superClass) {
       classConstructor.prototype = Object.create(superClass.prototype);
@@ -14935,6 +14986,69 @@ class Interpreter {
     return classConstructor;
   }
 
+  constructClassInto(classConstructor, instance, args, env) {
+    const superClass = classConstructor.__superClass;
+    const constructor = classConstructor.__constructor;
+    let fieldsInitialized = false;
+
+    const initializeOwnFields = () => {
+      if (!fieldsInitialized) {
+        this.initializeClassFields(classConstructor, instance, env);
+        fieldsInitialized = true;
+      }
+    };
+
+    if (!superClass) {
+      initializeOwnFields();
+      if (constructor) {
+        return this.callMethodFunction(constructor, instance, args, env, null);
+      }
+      return undefined;
+    }
+
+    if (constructor) {
+      const result = this.callMethodFunction(constructor, instance, args, env, superClass, initializeOwnFields);
+      initializeOwnFields();
+      return result;
+    }
+
+    this.initializeSuperClass(superClass, instance, args);
+    initializeOwnFields();
+    return undefined;
+  }
+
+  initializeSuperClass(superClass, instance, args) {
+    if (superClass.__constructInto) {
+      return superClass.__constructInto(instance, args);
+    }
+
+    // For native constructors like Error, use Reflect.construct and copy instance properties.
+    const tempInstance = Reflect.construct(superClass, args, instance.constructor);
+    Object.getOwnPropertyNames(tempInstance).forEach(name => {
+      instance[name] = tempInstance[name];
+    });
+    return undefined;
+  }
+
+  initializeClassFields(classConstructor, instance, env) {
+    for (const field of classConstructor.__instanceFields || []) {
+      const fieldEnv = new Environment(env);
+      fieldEnv.define('this', instance);
+      const name = this.getClassFieldName(field, fieldEnv);
+      instance[name] = field.value ? this.evaluate(field.value, fieldEnv) : undefined;
+    }
+  }
+
+  getClassFieldName(field, env) {
+    if (field.computed) {
+      return this.evaluate(field.key, env);
+    }
+    if (field.key.type === 'Identifier' || field.key.type === 'PrivateIdentifier') {
+      return field.key.name;
+    }
+    return field.key.value;
+  }
+
   createMethodFunction(funcNode, env, className) {
     const func = {
       __isFunction: true,
@@ -14946,7 +15060,7 @@ class Interpreter {
     return func;
   }
 
-  callMethodFunction(methodFunc, thisContext, args, env, superClass = null) {
+  callMethodFunction(methodFunc, thisContext, args, env, superClass = null, afterSuper = null) {
     const funcEnv = new Environment(methodFunc.__env || env);
 
     // Bind 'this'
@@ -14956,21 +15070,11 @@ class Interpreter {
     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];
-          });
+        const result = this.initializeSuperClass(superClass, thisContext, superArgs);
+        if (afterSuper) {
+          afterSuper();
         }
-        return undefined;
+        return result && result.__explicitReturn ? result.value : undefined;
       };
       // Store both the function and mark it as super
       superFunc.__isSuperConstructor = true;
@@ -14978,42 +15082,7 @@ class Interpreter {
       funcEnv.define('super', superFunc);
     }
 
-    // Bind parameters
-    for (let i = 0; i < methodFunc.__params.length; i++) {
-      const originalParam = methodFunc.__params[i];
-      const param = originalParam.type === 'TSParameterProperty'
-        ? originalParam.parameter
-        : originalParam;
-
-      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]);
-      }
-
-      if (originalParam.type === 'TSParameterProperty') {
-        const propertyName = getPatternName(originalParam.parameter);
-        if (propertyName) {
-          thisContext[propertyName] = funcEnv.get(propertyName);
-        }
-      }
-    }
+    this.bindFunctionParameters(methodFunc.__params, args, funcEnv, thisContext);
 
     const result = this.evaluate(methodFunc.__body, funcEnv);
 

package/dist/index.d.ts

@@ -12250,6 +12250,10 @@ function getPatternName(pattern) {
   return pattern.name;
 }
 
+function unwrapTSParameterProperty(param) {
+  return param?.type === 'TSParameterProperty' ? param.parameter : param;
+}
+
 function collectRuntimeIdentifierReferences(node) {
   const references = new Set();
   const skipKeys = new Set([
@@ -13871,34 +13875,7 @@ class Interpreter {
       funcEnv.define('this', thisContext);
     }
 
-    // Bind parameters
-    for (let i = 0; i < metadata.params.length; i++) {
-      const param = metadata.params[i].type === 'TSParameterProperty'
-        ? metadata.params[i].parameter
-        : 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]);
-      }
-    }
+    this.bindFunctionParameters(metadata.params, args, funcEnv);
 
     // Execute function body
     // If async, use async evaluation and return a promise
@@ -14255,7 +14232,7 @@ class Interpreter {
           const finalValue = propValue !== undefined
             ? propValue
             : this.evaluate(prop.value.right, env);
-          env.define(prop.value.left.name, finalValue, isConst);
+          this.bindPattern(prop.value.left, finalValue, env, isConst);
         } else if (prop.value.type === 'ObjectPattern') {
           this.bindObjectPattern(prop.value, propValue, env, isConst);
         } else if (prop.value.type === 'ArrayPattern') {
@@ -14286,7 +14263,7 @@ class Interpreter {
         const finalValue = value[i] !== undefined
           ? value[i]
           : this.evaluate(element.right, env);
-        env.define(element.left.name, finalValue, isConst);
+        this.bindPattern(element.left, finalValue, env, isConst);
       } else if (element.type === 'ObjectPattern') {
         this.bindObjectPattern(element, value[i], env, isConst);
       } else if (element.type === 'ArrayPattern') {
@@ -14295,6 +14272,78 @@ class Interpreter {
     }
   }
 
+  bindPattern(pattern, value, env, isConst = false) {
+    if (pattern.type === 'Identifier') {
+      env.define(pattern.name, value, isConst);
+    } else if (pattern.type === 'ObjectPattern') {
+      this.bindObjectPattern(pattern, value, env, isConst);
+    } else if (pattern.type === 'ArrayPattern') {
+      this.bindArrayPattern(pattern, value, env, isConst);
+    } else if (pattern.type === 'AssignmentPattern') {
+      const finalValue = value !== undefined ? value : this.evaluate(pattern.right, env);
+      this.bindPattern(pattern.left, finalValue, env, isConst);
+    } else if (pattern.type === 'RestElement') {
+      this.bindPattern(pattern.argument, value, env, isConst);
+    }
+  }
+
+  bindFunctionParameters(params, args, env, thisContext = null) {
+    for (let i = 0; i < params.length; i++) {
+      const originalParam = params[i];
+      const param = unwrapTSParameterProperty(originalParam);
+
+      this.bindFunctionParameter(param, args[i], args.slice(i), env);
+
+      if (originalParam.type === 'TSParameterProperty' && thisContext) {
+        const propertyName = getPatternName(originalParam.parameter);
+        if (propertyName) {
+          thisContext[propertyName] = env.get(propertyName);
+        }
+      }
+
+      if (param.type === 'RestElement') {
+        break;
+      }
+    }
+  }
+
+  bindFunctionParameter(param, arg, restArgs, env) {
+    if (param.type === 'Identifier') {
+      this.bindPattern(param, arg, env);
+      return;
+    }
+
+    if (param.type === 'AssignmentPattern') {
+      const value = arg !== undefined ? arg : this.evaluate(param.right, env);
+      this.bindPattern(param.left, value, env);
+      return;
+    }
+
+    if (param.type === 'RestElement') {
+      const target = param.argument;
+      if (target.type === 'Identifier') {
+        env.define(target.name, restArgs);
+      } else if (target.type === 'ArrayPattern') {
+        this.bindArrayPattern(target, restArgs, env);
+      } else if (target.type === 'ObjectPattern') {
+        this.bindObjectPattern(target, restArgs, env);
+      }
+      return;
+    }
+
+    if (param.type === 'ObjectPattern') {
+      this.bindPattern(param, arg, env);
+      return;
+    }
+
+    if (param.type === 'ArrayPattern') {
+      this.bindPattern(param, arg, env);
+      return;
+    }
+
+    env.define(param.name, arg);
+  }
+
   evaluateFunctionDeclaration(node, env) {
     const funcMetadata = {
       __isFunction: true,
@@ -14859,6 +14908,7 @@ class Interpreter {
     let constructor = null;
     const methods = {};
     const staticMethods = {};
+    const instanceFields = [];
 
     for (const member of node.body.body) {
       if (member.type === 'MethodDefinition') {
@@ -14872,6 +14922,8 @@ class Interpreter {
         } else {
           methods[methodName] = methodFunc;
         }
+      } else if (member.type === 'PropertyDefinition' && !member.static && !member.declare && !member.abstract) {
+        instanceFields.push(member);
       }
     }
 
@@ -14879,18 +14931,11 @@ class Interpreter {
     const classConstructor = function(...args) {
       // Create instance
       const instance = Object.create(classConstructor.prototype);
+      const result = interpreter.constructClassInto(classConstructor, instance, args, env);
 
-      // 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);
+      // 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;
       }
 
       return instance;
@@ -14901,6 +14946,12 @@ class Interpreter {
       classConstructor.__constructor = constructor;
     }
 
+    classConstructor.__instanceFields = instanceFields;
+    classConstructor.__superClass = superClass;
+    classConstructor.__constructInto = (instance, args) => {
+      return interpreter.constructClassInto(classConstructor, instance, args, env);
+    };
+
     // Set up prototype chain
     if (superClass) {
       classConstructor.prototype = Object.create(superClass.prototype);
@@ -14935,6 +14986,69 @@ class Interpreter {
     return classConstructor;
   }
 
+  constructClassInto(classConstructor, instance, args, env) {
+    const superClass = classConstructor.__superClass;
+    const constructor = classConstructor.__constructor;
+    let fieldsInitialized = false;
+
+    const initializeOwnFields = () => {
+      if (!fieldsInitialized) {
+        this.initializeClassFields(classConstructor, instance, env);
+        fieldsInitialized = true;
+      }
+    };
+
+    if (!superClass) {
+      initializeOwnFields();
+      if (constructor) {
+        return this.callMethodFunction(constructor, instance, args, env, null);
+      }
+      return undefined;
+    }
+
+    if (constructor) {
+      const result = this.callMethodFunction(constructor, instance, args, env, superClass, initializeOwnFields);
+      initializeOwnFields();
+      return result;
+    }
+
+    this.initializeSuperClass(superClass, instance, args);
+    initializeOwnFields();
+    return undefined;
+  }
+
+  initializeSuperClass(superClass, instance, args) {
+    if (superClass.__constructInto) {
+      return superClass.__constructInto(instance, args);
+    }
+
+    // For native constructors like Error, use Reflect.construct and copy instance properties.
+    const tempInstance = Reflect.construct(superClass, args, instance.constructor);
+    Object.getOwnPropertyNames(tempInstance).forEach(name => {
+      instance[name] = tempInstance[name];
+    });
+    return undefined;
+  }
+
+  initializeClassFields(classConstructor, instance, env) {
+    for (const field of classConstructor.__instanceFields || []) {
+      const fieldEnv = new Environment(env);
+      fieldEnv.define('this', instance);
+      const name = this.getClassFieldName(field, fieldEnv);
+      instance[name] = field.value ? this.evaluate(field.value, fieldEnv) : undefined;
+    }
+  }
+
+  getClassFieldName(field, env) {
+    if (field.computed) {
+      return this.evaluate(field.key, env);
+    }
+    if (field.key.type === 'Identifier' || field.key.type === 'PrivateIdentifier') {
+      return field.key.name;
+    }
+    return field.key.value;
+  }
+
   createMethodFunction(funcNode, env, className) {
     const func = {
       __isFunction: true,
@@ -14946,7 +15060,7 @@ class Interpreter {
     return func;
   }
 
-  callMethodFunction(methodFunc, thisContext, args, env, superClass = null) {
+  callMethodFunction(methodFunc, thisContext, args, env, superClass = null, afterSuper = null) {
     const funcEnv = new Environment(methodFunc.__env || env);
 
     // Bind 'this'
@@ -14956,21 +15070,11 @@ class Interpreter {
     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];
-          });
+        const result = this.initializeSuperClass(superClass, thisContext, superArgs);
+        if (afterSuper) {
+          afterSuper();
         }
-        return undefined;
+        return result && result.__explicitReturn ? result.value : undefined;
       };
       // Store both the function and mark it as super
       superFunc.__isSuperConstructor = true;
@@ -14978,42 +15082,7 @@ class Interpreter {
       funcEnv.define('super', superFunc);
     }
 
-    // Bind parameters
-    for (let i = 0; i < methodFunc.__params.length; i++) {
-      const originalParam = methodFunc.__params[i];
-      const param = originalParam.type === 'TSParameterProperty'
-        ? originalParam.parameter
-        : originalParam;
-
-      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]);
-      }
-
-      if (originalParam.type === 'TSParameterProperty') {
-        const propertyName = getPatternName(originalParam.parameter);
-        if (propertyName) {
-          thisContext[propertyName] = funcEnv.get(propertyName);
-        }
-      }
-    }
+    this.bindFunctionParameters(methodFunc.__params, args, funcEnv, thisContext);
 
     const result = this.evaluate(methodFunc.__body, funcEnv);