jslike 1.8.1 → 1.8.3

package/dist/esm/errors/enhanced-error.js

@@ -54,22 +54,48 @@ function getAvailableMethods(obj) {
 
   const methods = new Set();
 
-  // Get own properties
-  Object.getOwnPropertyNames(obj).forEach(name => {
-    if (typeof obj[name] === 'function') {
-      methods.add(name);
+  const addSafeMethods = (target, includeConstructor = true) => {
+    let names;
+    try {
+      names = Object.getOwnPropertyNames(target);
+    } catch {
+      return;
     }
-  });
 
-  // 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') {
+    names.forEach(name => {
+      if (!includeConstructor && name === 'constructor') return;
+
+      let descriptor;
+      try {
+        descriptor = Object.getOwnPropertyDescriptor(target, name);
+      } catch {
+        return;
+      }
+
+      if (descriptor && 'value' in descriptor && typeof descriptor.value === 'function') {
         methods.add(name);
       }
     });
-    proto = Object.getPrototypeOf(proto);
+  };
+
+  // Get own properties
+  addSafeMethods(obj);
+
+  // Get prototype methods
+  let proto;
+  try {
+    proto = Object.getPrototypeOf(obj);
+  } catch {
+    proto = null;
+  }
+
+  while (proto && proto !== Object.prototype) {
+    addSafeMethods(proto, false);
+    try {
+      proto = Object.getPrototypeOf(proto);
+    } catch {
+      proto = null;
+    }
   }
 
   return Array.from(methods).sort();

package/dist/esm/interpreter/interpreter.js

@@ -2666,6 +2666,7 @@ export class Interpreter {
     let constructor = null;
     const methods = {};
     const staticMethods = {};
+    const instanceFields = [];
 
     for (const member of node.body.body) {
       if (member.type === 'MethodDefinition') {
@@ -2679,6 +2680,8 @@ export class Interpreter {
         } else {
           methods[methodName] = methodFunc;
         }
+      } else if (member.type === 'PropertyDefinition' && !member.static && !member.declare && !member.abstract) {
+        instanceFields.push(member);
       }
     }
 
@@ -2686,18 +2689,11 @@ export 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;
@@ -2708,6 +2704,12 @@ export 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);
@@ -2742,6 +2744,69 @@ export 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,
@@ -2753,7 +2818,7 @@ export 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'
@@ -2763,21 +2828,11 @@ export 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;

package/dist/index.cjs

@@ -11425,19 +11425,40 @@ function findSimilar(target, candidates, maxDistance = 3) {
 function getAvailableMethods(obj) {
   if (obj === null || obj === void 0) return [];
   const methods = /* @__PURE__ */ new Set();
-  Object.getOwnPropertyNames(obj).forEach((name) => {
-    if (typeof obj[name] === "function") {
-      methods.add(name);
+  const addSafeMethods = (target, includeConstructor = true) => {
+    let names;
+    try {
+      names = Object.getOwnPropertyNames(target);
+    } catch {
+      return;
     }
-  });
-  let proto = Object.getPrototypeOf(obj);
-  while (proto && proto !== Object.prototype) {
-    Object.getOwnPropertyNames(proto).forEach((name) => {
-      if (typeof proto[name] === "function" && name !== "constructor") {
+    names.forEach((name) => {
+      if (!includeConstructor && name === "constructor") return;
+      let descriptor;
+      try {
+        descriptor = Object.getOwnPropertyDescriptor(target, name);
+      } catch {
+        return;
+      }
+      if (descriptor && "value" in descriptor && typeof descriptor.value === "function") {
         methods.add(name);
       }
     });
-    proto = Object.getPrototypeOf(proto);
+  };
+  addSafeMethods(obj);
+  let proto;
+  try {
+    proto = Object.getPrototypeOf(obj);
+  } catch {
+    proto = null;
+  }
+  while (proto && proto !== Object.prototype) {
+    addSafeMethods(proto, false);
+    try {
+      proto = Object.getPrototypeOf(proto);
+    } catch {
+      proto = null;
+    }
   }
   return Array.from(methods).sort();
 }
@@ -13552,6 +13573,7 @@ var Interpreter = class _Interpreter {
     let constructor = null;
     const methods = {};
     const staticMethods = {};
+    const instanceFields = [];
     for (const member of node.body.body) {
       if (member.type === "MethodDefinition") {
         const methodName = member.key.name || member.key.value;
@@ -13563,23 +13585,26 @@ var Interpreter = class _Interpreter {
         } else {
           methods[methodName] = methodFunc;
         }
+      } else if (member.type === "PropertyDefinition" && !member.static && !member.declare && !member.abstract) {
+        instanceFields.push(member);
       }
     }
     const classConstructor = function(...args) {
       const instance = Object.create(classConstructor.prototype);
-      if (constructor) {
-        const result = interpreter.callMethodFunction(constructor, instance, args, env, superClass);
-        if (result && result.__explicitReturn && result.value && typeof result.value === "object" && result.value !== instance) {
-          return result.value;
-        }
-      } else if (superClass) {
-        superClass.call(instance, ...args);
+      const result = interpreter.constructClassInto(classConstructor, instance, args, env);
+      if (result && result.__explicitReturn && result.value && typeof result.value === "object" && result.value !== instance) {
+        return result.value;
       }
       return instance;
     };
     if (constructor) {
       classConstructor.__constructor = constructor;
     }
+    classConstructor.__instanceFields = instanceFields;
+    classConstructor.__superClass = superClass;
+    classConstructor.__constructInto = (instance, args) => {
+      return interpreter.constructClassInto(classConstructor, instance, args, env);
+    };
     if (superClass) {
       classConstructor.prototype = Object.create(superClass.prototype);
       classConstructor.prototype.constructor = classConstructor;
@@ -13605,6 +13630,59 @@ var Interpreter = class _Interpreter {
     classConstructor.__className = className;
     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 void 0;
+    }
+    if (constructor) {
+      const result = this.callMethodFunction(constructor, instance, args, env, superClass, initializeOwnFields);
+      initializeOwnFields();
+      return result;
+    }
+    this.initializeSuperClass(superClass, instance, args);
+    initializeOwnFields();
+    return void 0;
+  }
+  initializeSuperClass(superClass, instance, args) {
+    if (superClass.__constructInto) {
+      return superClass.__constructInto(instance, args);
+    }
+    const tempInstance = Reflect.construct(superClass, args, instance.constructor);
+    Object.getOwnPropertyNames(tempInstance).forEach((name) => {
+      instance[name] = tempInstance[name];
+    });
+    return void 0;
+  }
+  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) : void 0;
+    }
+  }
+  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,
@@ -13615,20 +13693,16 @@ var Interpreter = 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);
     funcEnv.define("this", thisContext);
     if (superClass) {
       const superFunc = (...superArgs) => {
-        if (superClass.__constructor) {
-          this.callMethodFunction(superClass.__constructor, thisContext, superArgs, env, null);
-        } else {
-          const tempInstance = Reflect.construct(superClass, superArgs, thisContext.constructor);
-          Object.getOwnPropertyNames(tempInstance).forEach((name) => {
-            thisContext[name] = tempInstance[name];
-          });
+        const result2 = this.initializeSuperClass(superClass, thisContext, superArgs);
+        if (afterSuper) {
+          afterSuper();
         }
-        return void 0;
+        return result2 && result2.__explicitReturn ? result2.value : void 0;
       };
       superFunc.__isSuperConstructor = true;
       superFunc.__superClass = superClass;

package/dist/index.d.cts

@@ -12100,22 +12100,48 @@ function getAvailableMethods(obj) {
 
   const methods = new Set();
 
-  // Get own properties
-  Object.getOwnPropertyNames(obj).forEach(name => {
-    if (typeof obj[name] === 'function') {
-      methods.add(name);
+  const addSafeMethods = (target, includeConstructor = true) => {
+    let names;
+    try {
+      names = Object.getOwnPropertyNames(target);
+    } catch {
+      return;
     }
-  });
 
-  // 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') {
+    names.forEach(name => {
+      if (!includeConstructor && name === 'constructor') return;
+
+      let descriptor;
+      try {
+        descriptor = Object.getOwnPropertyDescriptor(target, name);
+      } catch {
+        return;
+      }
+
+      if (descriptor && 'value' in descriptor && typeof descriptor.value === 'function') {
         methods.add(name);
       }
     });
-    proto = Object.getPrototypeOf(proto);
+  };
+
+  // Get own properties
+  addSafeMethods(obj);
+
+  // Get prototype methods
+  let proto;
+  try {
+    proto = Object.getPrototypeOf(obj);
+  } catch {
+    proto = null;
+  }
+
+  while (proto && proto !== Object.prototype) {
+    addSafeMethods(proto, false);
+    try {
+      proto = Object.getPrototypeOf(proto);
+    } catch {
+      proto = null;
+    }
   }
 
   return Array.from(methods).sort();
@@ -14833,6 +14859,7 @@ class Interpreter {
     let constructor = null;
     const methods = {};
     const staticMethods = {};
+    const instanceFields = [];
 
     for (const member of node.body.body) {
       if (member.type === 'MethodDefinition') {
@@ -14846,6 +14873,8 @@ class Interpreter {
         } else {
           methods[methodName] = methodFunc;
         }
+      } else if (member.type === 'PropertyDefinition' && !member.static && !member.declare && !member.abstract) {
+        instanceFields.push(member);
       }
     }
 
@@ -14853,18 +14882,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;
@@ -14875,6 +14897,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);
@@ -14909,6 +14937,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,
@@ -14920,7 +15011,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'
@@ -14930,21 +15021,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;

package/dist/index.d.ts

@@ -12100,22 +12100,48 @@ function getAvailableMethods(obj) {
 
   const methods = new Set();
 
-  // Get own properties
-  Object.getOwnPropertyNames(obj).forEach(name => {
-    if (typeof obj[name] === 'function') {
-      methods.add(name);
+  const addSafeMethods = (target, includeConstructor = true) => {
+    let names;
+    try {
+      names = Object.getOwnPropertyNames(target);
+    } catch {
+      return;
     }
-  });
 
-  // 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') {
+    names.forEach(name => {
+      if (!includeConstructor && name === 'constructor') return;
+
+      let descriptor;
+      try {
+        descriptor = Object.getOwnPropertyDescriptor(target, name);
+      } catch {
+        return;
+      }
+
+      if (descriptor && 'value' in descriptor && typeof descriptor.value === 'function') {
         methods.add(name);
       }
     });
-    proto = Object.getPrototypeOf(proto);
+  };
+
+  // Get own properties
+  addSafeMethods(obj);
+
+  // Get prototype methods
+  let proto;
+  try {
+    proto = Object.getPrototypeOf(obj);
+  } catch {
+    proto = null;
+  }
+
+  while (proto && proto !== Object.prototype) {
+    addSafeMethods(proto, false);
+    try {
+      proto = Object.getPrototypeOf(proto);
+    } catch {
+      proto = null;
+    }
   }
 
   return Array.from(methods).sort();
@@ -14833,6 +14859,7 @@ class Interpreter {
     let constructor = null;
     const methods = {};
     const staticMethods = {};
+    const instanceFields = [];
 
     for (const member of node.body.body) {
       if (member.type === 'MethodDefinition') {
@@ -14846,6 +14873,8 @@ class Interpreter {
         } else {
           methods[methodName] = methodFunc;
         }
+      } else if (member.type === 'PropertyDefinition' && !member.static && !member.declare && !member.abstract) {
+        instanceFields.push(member);
       }
     }
 
@@ -14853,18 +14882,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;
@@ -14875,6 +14897,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);
@@ -14909,6 +14937,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,
@@ -14920,7 +15011,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'
@@ -14930,21 +15021,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;

package/dist/index.js

@@ -11391,19 +11391,40 @@ function findSimilar(target, candidates, maxDistance = 3) {
 function getAvailableMethods(obj) {
   if (obj === null || obj === void 0) return [];
   const methods = /* @__PURE__ */ new Set();
-  Object.getOwnPropertyNames(obj).forEach((name) => {
-    if (typeof obj[name] === "function") {
-      methods.add(name);
+  const addSafeMethods = (target, includeConstructor = true) => {
+    let names;
+    try {
+      names = Object.getOwnPropertyNames(target);
+    } catch {
+      return;
     }
-  });
-  let proto = Object.getPrototypeOf(obj);
-  while (proto && proto !== Object.prototype) {
-    Object.getOwnPropertyNames(proto).forEach((name) => {
-      if (typeof proto[name] === "function" && name !== "constructor") {
+    names.forEach((name) => {
+      if (!includeConstructor && name === "constructor") return;
+      let descriptor;
+      try {
+        descriptor = Object.getOwnPropertyDescriptor(target, name);
+      } catch {
+        return;
+      }
+      if (descriptor && "value" in descriptor && typeof descriptor.value === "function") {
         methods.add(name);
       }
     });
-    proto = Object.getPrototypeOf(proto);
+  };
+  addSafeMethods(obj);
+  let proto;
+  try {
+    proto = Object.getPrototypeOf(obj);
+  } catch {
+    proto = null;
+  }
+  while (proto && proto !== Object.prototype) {
+    addSafeMethods(proto, false);
+    try {
+      proto = Object.getPrototypeOf(proto);
+    } catch {
+      proto = null;
+    }
   }
   return Array.from(methods).sort();
 }
@@ -13518,6 +13539,7 @@ var Interpreter = class _Interpreter {
     let constructor = null;
     const methods = {};
     const staticMethods = {};
+    const instanceFields = [];
     for (const member of node.body.body) {
       if (member.type === "MethodDefinition") {
         const methodName = member.key.name || member.key.value;
@@ -13529,23 +13551,26 @@ var Interpreter = class _Interpreter {
         } else {
           methods[methodName] = methodFunc;
         }
+      } else if (member.type === "PropertyDefinition" && !member.static && !member.declare && !member.abstract) {
+        instanceFields.push(member);
       }
     }
     const classConstructor = function(...args) {
       const instance = Object.create(classConstructor.prototype);
-      if (constructor) {
-        const result = interpreter.callMethodFunction(constructor, instance, args, env, superClass);
-        if (result && result.__explicitReturn && result.value && typeof result.value === "object" && result.value !== instance) {
-          return result.value;
-        }
-      } else if (superClass) {
-        superClass.call(instance, ...args);
+      const result = interpreter.constructClassInto(classConstructor, instance, args, env);
+      if (result && result.__explicitReturn && result.value && typeof result.value === "object" && result.value !== instance) {
+        return result.value;
       }
       return instance;
     };
     if (constructor) {
       classConstructor.__constructor = constructor;
     }
+    classConstructor.__instanceFields = instanceFields;
+    classConstructor.__superClass = superClass;
+    classConstructor.__constructInto = (instance, args) => {
+      return interpreter.constructClassInto(classConstructor, instance, args, env);
+    };
     if (superClass) {
       classConstructor.prototype = Object.create(superClass.prototype);
       classConstructor.prototype.constructor = classConstructor;
@@ -13571,6 +13596,59 @@ var Interpreter = class _Interpreter {
     classConstructor.__className = className;
     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 void 0;
+    }
+    if (constructor) {
+      const result = this.callMethodFunction(constructor, instance, args, env, superClass, initializeOwnFields);
+      initializeOwnFields();
+      return result;
+    }
+    this.initializeSuperClass(superClass, instance, args);
+    initializeOwnFields();
+    return void 0;
+  }
+  initializeSuperClass(superClass, instance, args) {
+    if (superClass.__constructInto) {
+      return superClass.__constructInto(instance, args);
+    }
+    const tempInstance = Reflect.construct(superClass, args, instance.constructor);
+    Object.getOwnPropertyNames(tempInstance).forEach((name) => {
+      instance[name] = tempInstance[name];
+    });
+    return void 0;
+  }
+  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) : void 0;
+    }
+  }
+  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,
@@ -13581,20 +13659,16 @@ var Interpreter = 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);
     funcEnv.define("this", thisContext);
     if (superClass) {
       const superFunc = (...superArgs) => {
-        if (superClass.__constructor) {
-          this.callMethodFunction(superClass.__constructor, thisContext, superArgs, env, null);
-        } else {
-          const tempInstance = Reflect.construct(superClass, superArgs, thisContext.constructor);
-          Object.getOwnPropertyNames(tempInstance).forEach((name) => {
-            thisContext[name] = tempInstance[name];
-          });
+        const result2 = this.initializeSuperClass(superClass, thisContext, superArgs);
+        if (afterSuper) {
+          afterSuper();
         }
-        return void 0;
+        return result2 && result2.__explicitReturn ? result2.value : void 0;
       };
       superFunc.__isSuperConstructor = true;
       superFunc.__superClass = superClass;

package/package.json

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