jslike 1.8.4 → 1.8.6

package/dist/esm/interpreter/interpreter.js

@@ -229,6 +229,78 @@ function collectRuntimeIdentifierReferences(node) {
   return references;
 }
 
+function getExportName(nameNode) {
+  return nameNode?.name ?? nameNode?.value;
+}
+
+function collectDeclarationExportNames(declaration) {
+  const names = [];
+
+  if (!declaration || isTypeOnlyDeclaration(declaration)) {
+    return names;
+  }
+
+  if (declaration.type === 'FunctionDeclaration' ||
+      declaration.type === 'ClassDeclaration' ||
+      declaration.type === 'TSEnumDeclaration') {
+    const name = getPatternName(declaration.id);
+    if (name) names.push(name);
+    return names;
+  }
+
+  if (declaration.type === 'VariableDeclaration') {
+    for (const declarator of declaration.declarations || []) {
+      const name = getPatternName(declarator.id);
+      if (name) names.push(name);
+    }
+  }
+
+  return names;
+}
+
+function collectStaticExportNames(moduleAst) {
+  const names = new Set();
+
+  for (const statement of moduleAst?.body || []) {
+    if (statement.type === 'ExportDefaultDeclaration') {
+      names.add('default');
+      continue;
+    }
+
+    if (statement.type !== 'ExportNamedDeclaration' || statement.exportKind === 'type') {
+      continue;
+    }
+
+    if (statement.declaration) {
+      for (const name of collectDeclarationExportNames(statement.declaration)) {
+        names.add(name);
+      }
+      continue;
+    }
+
+    for (const specifier of statement.specifiers || []) {
+      if (specifier.exportKind === 'type') {
+        continue;
+      }
+
+      const exportedName = getExportName(specifier.exported);
+      if (exportedName) {
+        names.add(exportedName);
+      }
+    }
+  }
+
+  return names;
+}
+
+function predeclareModuleExports(moduleAst, moduleExports) {
+  for (const name of collectStaticExportNames(moduleAst)) {
+    if (!Object.prototype.hasOwnProperty.call(moduleExports, name)) {
+      moduleExports[name] = undefined;
+    }
+  }
+}
+
 export class Interpreter {
   constructor(globalEnv, options = {}) {
     this.globalEnv = globalEnv;
@@ -2255,12 +2327,17 @@ export class Interpreter {
         });
         moduleInterpreter.moduleCache = this.moduleCache;  // Share cache
 
-        // Execute module and collect exports
-        await moduleInterpreter.evaluateAsync(moduleAst, moduleEnv);
-
-        // Cache the module exports
         moduleExports = moduleInterpreter.moduleExports;
+        predeclareModuleExports(moduleAst, moduleExports);
         this.moduleCache.set(resolvedPath, moduleExports);
+
+        try {
+          // Execute module and populate the cached exports object.
+          await moduleInterpreter.evaluateAsync(moduleAst, moduleEnv);
+        } catch (error) {
+          this.moduleCache.delete(resolvedPath);
+          throw error;
+        }
       }
     }
 
@@ -2768,7 +2845,7 @@ export class Interpreter {
     // Add methods to prototype
     for (const [name, method] of Object.entries(methods)) {
       classConstructor.prototype[name] = function(...args) {
-        const result = interpreter.callMethodFunction(method, this, args, env);
+        const result = interpreter.callMethodFunction(method, this, args, env, superClass);
         // Unwrap explicit return marker
         if (result && result.__explicitReturn) {
           return result.value;
@@ -2841,6 +2918,9 @@ export class Interpreter {
     for (const field of classConstructor.__instanceFields || []) {
       const fieldEnv = new Environment(env);
       fieldEnv.define('this', instance);
+      if (classConstructor.__superClass) {
+        fieldEnv.define('super', this.createSuperBinding(classConstructor.__superClass, instance, false));
+      }
       const name = this.getClassFieldName(field, fieldEnv);
       instance[name] = field.value ? this.evaluate(field.value, fieldEnv) : undefined;
     }
@@ -2856,6 +2936,38 @@ export class Interpreter {
     return field.key.value;
   }
 
+  createSuperBinding(superClass, thisContext, allowConstructor = false, afterSuper = null) {
+    const superConstructor = (...superArgs) => {
+      if (!allowConstructor) {
+        throw new ReferenceError("'super' keyword is unexpected here");
+      }
+      const result = this.initializeSuperClass(superClass, thisContext, superArgs);
+      if (afterSuper) {
+        afterSuper();
+      }
+      return result && result.__explicitReturn ? result.value : undefined;
+    };
+
+    superConstructor.__isSuperConstructor = true;
+    superConstructor.__superClass = superClass;
+
+    return new Proxy(superConstructor, {
+      get(target, prop, receiver) {
+        if (prop in target) {
+          return Reflect.get(target, prop, receiver);
+        }
+
+        const prototype = superClass?.prototype;
+        if (!prototype) {
+          return undefined;
+        }
+
+        const value = Reflect.get(prototype, prop, thisContext);
+        return typeof value === 'function' ? value.bind(thisContext) : value;
+      }
+    });
+  }
+
   createMethodFunction(funcNode, env, className) {
     const func = {
       __isFunction: true,
@@ -2875,18 +2987,7 @@ export class Interpreter {
 
     // Bind 'super' if superClass exists
     if (superClass) {
-      // Create a super function that calls the parent constructor
-      const superFunc = (...superArgs) => {
-        const result = this.initializeSuperClass(superClass, thisContext, superArgs);
-        if (afterSuper) {
-          afterSuper();
-        }
-        return result && result.__explicitReturn ? result.value : undefined;
-      };
-      // Store both the function and mark it as super
-      superFunc.__isSuperConstructor = true;
-      superFunc.__superClass = superClass;
-      funcEnv.define('super', superFunc);
+      funcEnv.define('super', this.createSuperBinding(superClass, thisContext, true, afterSuper));
     }
 
     this.bindFunctionParameters(methodFunc.__params, args, funcEnv, thisContext);

package/dist/index.cjs

@@ -11710,6 +11710,62 @@ function collectRuntimeIdentifierReferences(node) {
   visit(node);
   return references;
 }
+function getExportName(nameNode) {
+  return (nameNode == null ? void 0 : nameNode.name) ?? (nameNode == null ? void 0 : nameNode.value);
+}
+function collectDeclarationExportNames(declaration) {
+  const names = [];
+  if (!declaration || isTypeOnlyDeclaration(declaration)) {
+    return names;
+  }
+  if (declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration" || declaration.type === "TSEnumDeclaration") {
+    const name = getPatternName(declaration.id);
+    if (name) names.push(name);
+    return names;
+  }
+  if (declaration.type === "VariableDeclaration") {
+    for (const declarator of declaration.declarations || []) {
+      const name = getPatternName(declarator.id);
+      if (name) names.push(name);
+    }
+  }
+  return names;
+}
+function collectStaticExportNames(moduleAst) {
+  const names = /* @__PURE__ */ new Set();
+  for (const statement of (moduleAst == null ? void 0 : moduleAst.body) || []) {
+    if (statement.type === "ExportDefaultDeclaration") {
+      names.add("default");
+      continue;
+    }
+    if (statement.type !== "ExportNamedDeclaration" || statement.exportKind === "type") {
+      continue;
+    }
+    if (statement.declaration) {
+      for (const name of collectDeclarationExportNames(statement.declaration)) {
+        names.add(name);
+      }
+      continue;
+    }
+    for (const specifier of statement.specifiers || []) {
+      if (specifier.exportKind === "type") {
+        continue;
+      }
+      const exportedName = getExportName(specifier.exported);
+      if (exportedName) {
+        names.add(exportedName);
+      }
+    }
+  }
+  return names;
+}
+function predeclareModuleExports(moduleAst, moduleExports) {
+  for (const name of collectStaticExportNames(moduleAst)) {
+    if (!Object.prototype.hasOwnProperty.call(moduleExports, name)) {
+      moduleExports[name] = void 0;
+    }
+  }
+}
 var Interpreter = class _Interpreter {
   constructor(globalEnv, options = {}) {
     this.globalEnv = globalEnv;
@@ -13279,9 +13335,15 @@ var Interpreter = class _Interpreter {
           executionController: this.executionController
         });
         moduleInterpreter.moduleCache = this.moduleCache;
-        await moduleInterpreter.evaluateAsync(moduleAst, moduleEnv);
         moduleExports = moduleInterpreter.moduleExports;
+        predeclareModuleExports(moduleAst, moduleExports);
         this.moduleCache.set(resolvedPath, moduleExports);
+        try {
+          await moduleInterpreter.evaluateAsync(moduleAst, moduleEnv);
+        } catch (error) {
+          this.moduleCache.delete(resolvedPath);
+          throw error;
+        }
       }
     }
     this.bindImportSpecifiers(node, env, modulePath, moduleExports);
@@ -13658,7 +13720,7 @@ var Interpreter = class _Interpreter {
     }
     for (const [name, method] of Object.entries(methods)) {
       classConstructor.prototype[name] = function(...args) {
-        const result = interpreter.callMethodFunction(method, this, args, env);
+        const result = interpreter.callMethodFunction(method, this, args, env, superClass);
         if (result && result.__explicitReturn) {
           return result.value;
         }
@@ -13717,6 +13779,9 @@ var Interpreter = class _Interpreter {
     for (const field of classConstructor.__instanceFields || []) {
       const fieldEnv = new Environment(env);
       fieldEnv.define("this", instance);
+      if (classConstructor.__superClass) {
+        fieldEnv.define("super", this.createSuperBinding(classConstructor.__superClass, instance, false));
+      }
       const name = this.getClassFieldName(field, fieldEnv);
       instance[name] = field.value ? this.evaluate(field.value, fieldEnv) : void 0;
     }
@@ -13730,6 +13795,33 @@ var Interpreter = class _Interpreter {
     }
     return field.key.value;
   }
+  createSuperBinding(superClass, thisContext, allowConstructor = false, afterSuper = null) {
+    const superConstructor = (...superArgs) => {
+      if (!allowConstructor) {
+        throw new ReferenceError("'super' keyword is unexpected here");
+      }
+      const result = this.initializeSuperClass(superClass, thisContext, superArgs);
+      if (afterSuper) {
+        afterSuper();
+      }
+      return result && result.__explicitReturn ? result.value : void 0;
+    };
+    superConstructor.__isSuperConstructor = true;
+    superConstructor.__superClass = superClass;
+    return new Proxy(superConstructor, {
+      get(target, prop, receiver) {
+        if (prop in target) {
+          return Reflect.get(target, prop, receiver);
+        }
+        const prototype = superClass == null ? void 0 : superClass.prototype;
+        if (!prototype) {
+          return void 0;
+        }
+        const value = Reflect.get(prototype, prop, thisContext);
+        return typeof value === "function" ? value.bind(thisContext) : value;
+      }
+    });
+  }
   createMethodFunction(funcNode, env, className) {
     const func = {
       __isFunction: true,
@@ -13744,16 +13836,7 @@ var Interpreter = class _Interpreter {
     const funcEnv = new Environment(methodFunc.__env || env);
     funcEnv.define("this", thisContext);
     if (superClass) {
-      const superFunc = (...superArgs) => {
-        const result2 = this.initializeSuperClass(superClass, thisContext, superArgs);
-        if (afterSuper) {
-          afterSuper();
-        }
-        return result2 && result2.__explicitReturn ? result2.value : void 0;
-      };
-      superFunc.__isSuperConstructor = true;
-      superFunc.__superClass = superClass;
-      funcEnv.define("super", superFunc);
+      funcEnv.define("super", this.createSuperBinding(superClass, thisContext, true, afterSuper));
     }
     this.bindFunctionParameters(methodFunc.__params, args, funcEnv, thisContext);
     const result = this.evaluate(methodFunc.__body, funcEnv);

package/dist/index.d.cts

@@ -12422,6 +12422,78 @@ function collectRuntimeIdentifierReferences(node) {
   return references;
 }
 
+function getExportName(nameNode) {
+  return nameNode?.name ?? nameNode?.value;
+}
+
+function collectDeclarationExportNames(declaration) {
+  const names = [];
+
+  if (!declaration || isTypeOnlyDeclaration(declaration)) {
+    return names;
+  }
+
+  if (declaration.type === 'FunctionDeclaration' ||
+      declaration.type === 'ClassDeclaration' ||
+      declaration.type === 'TSEnumDeclaration') {
+    const name = getPatternName(declaration.id);
+    if (name) names.push(name);
+    return names;
+  }
+
+  if (declaration.type === 'VariableDeclaration') {
+    for (const declarator of declaration.declarations || []) {
+      const name = getPatternName(declarator.id);
+      if (name) names.push(name);
+    }
+  }
+
+  return names;
+}
+
+function collectStaticExportNames(moduleAst) {
+  const names = new Set();
+
+  for (const statement of moduleAst?.body || []) {
+    if (statement.type === 'ExportDefaultDeclaration') {
+      names.add('default');
+      continue;
+    }
+
+    if (statement.type !== 'ExportNamedDeclaration' || statement.exportKind === 'type') {
+      continue;
+    }
+
+    if (statement.declaration) {
+      for (const name of collectDeclarationExportNames(statement.declaration)) {
+        names.add(name);
+      }
+      continue;
+    }
+
+    for (const specifier of statement.specifiers || []) {
+      if (specifier.exportKind === 'type') {
+        continue;
+      }
+
+      const exportedName = getExportName(specifier.exported);
+      if (exportedName) {
+        names.add(exportedName);
+      }
+    }
+  }
+
+  return names;
+}
+
+function predeclareModuleExports(moduleAst, moduleExports) {
+  for (const name of collectStaticExportNames(moduleAst)) {
+    if (!Object.prototype.hasOwnProperty.call(moduleExports, name)) {
+      moduleExports[name] = undefined;
+    }
+  }
+}
+
 class Interpreter {
   constructor(globalEnv, options = {}) {
     this.globalEnv = globalEnv;
@@ -14448,12 +14520,17 @@ class Interpreter {
         });
         moduleInterpreter.moduleCache = this.moduleCache;  // Share cache
 
-        // Execute module and collect exports
-        await moduleInterpreter.evaluateAsync(moduleAst, moduleEnv);
-
-        // Cache the module exports
         moduleExports = moduleInterpreter.moduleExports;
+        predeclareModuleExports(moduleAst, moduleExports);
         this.moduleCache.set(resolvedPath, moduleExports);
+
+        try {
+          // Execute module and populate the cached exports object.
+          await moduleInterpreter.evaluateAsync(moduleAst, moduleEnv);
+        } catch (error) {
+          this.moduleCache.delete(resolvedPath);
+          throw error;
+        }
       }
     }
 
@@ -14961,7 +15038,7 @@ class Interpreter {
     // Add methods to prototype
     for (const [name, method] of Object.entries(methods)) {
       classConstructor.prototype[name] = function(...args) {
-        const result = interpreter.callMethodFunction(method, this, args, env);
+        const result = interpreter.callMethodFunction(method, this, args, env, superClass);
         // Unwrap explicit return marker
         if (result && result.__explicitReturn) {
           return result.value;
@@ -15034,6 +15111,9 @@ class Interpreter {
     for (const field of classConstructor.__instanceFields || []) {
       const fieldEnv = new Environment(env);
       fieldEnv.define('this', instance);
+      if (classConstructor.__superClass) {
+        fieldEnv.define('super', this.createSuperBinding(classConstructor.__superClass, instance, false));
+      }
       const name = this.getClassFieldName(field, fieldEnv);
       instance[name] = field.value ? this.evaluate(field.value, fieldEnv) : undefined;
     }
@@ -15049,6 +15129,38 @@ class Interpreter {
     return field.key.value;
   }
 
+  createSuperBinding(superClass, thisContext, allowConstructor = false, afterSuper = null) {
+    const superConstructor = (...superArgs) => {
+      if (!allowConstructor) {
+        throw new ReferenceError("'super' keyword is unexpected here");
+      }
+      const result = this.initializeSuperClass(superClass, thisContext, superArgs);
+      if (afterSuper) {
+        afterSuper();
+      }
+      return result && result.__explicitReturn ? result.value : undefined;
+    };
+
+    superConstructor.__isSuperConstructor = true;
+    superConstructor.__superClass = superClass;
+
+    return new Proxy(superConstructor, {
+      get(target, prop, receiver) {
+        if (prop in target) {
+          return Reflect.get(target, prop, receiver);
+        }
+
+        const prototype = superClass?.prototype;
+        if (!prototype) {
+          return undefined;
+        }
+
+        const value = Reflect.get(prototype, prop, thisContext);
+        return typeof value === 'function' ? value.bind(thisContext) : value;
+      }
+    });
+  }
+
   createMethodFunction(funcNode, env, className) {
     const func = {
       __isFunction: true,
@@ -15068,18 +15180,7 @@ class Interpreter {
 
     // Bind 'super' if superClass exists
     if (superClass) {
-      // Create a super function that calls the parent constructor
-      const superFunc = (...superArgs) => {
-        const result = this.initializeSuperClass(superClass, thisContext, superArgs);
-        if (afterSuper) {
-          afterSuper();
-        }
-        return result && result.__explicitReturn ? result.value : undefined;
-      };
-      // Store both the function and mark it as super
-      superFunc.__isSuperConstructor = true;
-      superFunc.__superClass = superClass;
-      funcEnv.define('super', superFunc);
+      funcEnv.define('super', this.createSuperBinding(superClass, thisContext, true, afterSuper));
     }
 
     this.bindFunctionParameters(methodFunc.__params, args, funcEnv, thisContext);

package/dist/index.d.ts

@@ -12422,6 +12422,78 @@ function collectRuntimeIdentifierReferences(node) {
   return references;
 }
 
+function getExportName(nameNode) {
+  return nameNode?.name ?? nameNode?.value;
+}
+
+function collectDeclarationExportNames(declaration) {
+  const names = [];
+
+  if (!declaration || isTypeOnlyDeclaration(declaration)) {
+    return names;
+  }
+
+  if (declaration.type === 'FunctionDeclaration' ||
+      declaration.type === 'ClassDeclaration' ||
+      declaration.type === 'TSEnumDeclaration') {
+    const name = getPatternName(declaration.id);
+    if (name) names.push(name);
+    return names;
+  }
+
+  if (declaration.type === 'VariableDeclaration') {
+    for (const declarator of declaration.declarations || []) {
+      const name = getPatternName(declarator.id);
+      if (name) names.push(name);
+    }
+  }
+
+  return names;
+}
+
+function collectStaticExportNames(moduleAst) {
+  const names = new Set();
+
+  for (const statement of moduleAst?.body || []) {
+    if (statement.type === 'ExportDefaultDeclaration') {
+      names.add('default');
+      continue;
+    }
+
+    if (statement.type !== 'ExportNamedDeclaration' || statement.exportKind === 'type') {
+      continue;
+    }
+
+    if (statement.declaration) {
+      for (const name of collectDeclarationExportNames(statement.declaration)) {
+        names.add(name);
+      }
+      continue;
+    }
+
+    for (const specifier of statement.specifiers || []) {
+      if (specifier.exportKind === 'type') {
+        continue;
+      }
+
+      const exportedName = getExportName(specifier.exported);
+      if (exportedName) {
+        names.add(exportedName);
+      }
+    }
+  }
+
+  return names;
+}
+
+function predeclareModuleExports(moduleAst, moduleExports) {
+  for (const name of collectStaticExportNames(moduleAst)) {
+    if (!Object.prototype.hasOwnProperty.call(moduleExports, name)) {
+      moduleExports[name] = undefined;
+    }
+  }
+}
+
 class Interpreter {
   constructor(globalEnv, options = {}) {
     this.globalEnv = globalEnv;
@@ -14448,12 +14520,17 @@ class Interpreter {
         });
         moduleInterpreter.moduleCache = this.moduleCache;  // Share cache
 
-        // Execute module and collect exports
-        await moduleInterpreter.evaluateAsync(moduleAst, moduleEnv);
-
-        // Cache the module exports
         moduleExports = moduleInterpreter.moduleExports;
+        predeclareModuleExports(moduleAst, moduleExports);
         this.moduleCache.set(resolvedPath, moduleExports);
+
+        try {
+          // Execute module and populate the cached exports object.
+          await moduleInterpreter.evaluateAsync(moduleAst, moduleEnv);
+        } catch (error) {
+          this.moduleCache.delete(resolvedPath);
+          throw error;
+        }
       }
     }
 
@@ -14961,7 +15038,7 @@ class Interpreter {
     // Add methods to prototype
     for (const [name, method] of Object.entries(methods)) {
       classConstructor.prototype[name] = function(...args) {
-        const result = interpreter.callMethodFunction(method, this, args, env);
+        const result = interpreter.callMethodFunction(method, this, args, env, superClass);
         // Unwrap explicit return marker
         if (result && result.__explicitReturn) {
           return result.value;
@@ -15034,6 +15111,9 @@ class Interpreter {
     for (const field of classConstructor.__instanceFields || []) {
       const fieldEnv = new Environment(env);
       fieldEnv.define('this', instance);
+      if (classConstructor.__superClass) {
+        fieldEnv.define('super', this.createSuperBinding(classConstructor.__superClass, instance, false));
+      }
       const name = this.getClassFieldName(field, fieldEnv);
       instance[name] = field.value ? this.evaluate(field.value, fieldEnv) : undefined;
     }
@@ -15049,6 +15129,38 @@ class Interpreter {
     return field.key.value;
   }
 
+  createSuperBinding(superClass, thisContext, allowConstructor = false, afterSuper = null) {
+    const superConstructor = (...superArgs) => {
+      if (!allowConstructor) {
+        throw new ReferenceError("'super' keyword is unexpected here");
+      }
+      const result = this.initializeSuperClass(superClass, thisContext, superArgs);
+      if (afterSuper) {
+        afterSuper();
+      }
+      return result && result.__explicitReturn ? result.value : undefined;
+    };
+
+    superConstructor.__isSuperConstructor = true;
+    superConstructor.__superClass = superClass;
+
+    return new Proxy(superConstructor, {
+      get(target, prop, receiver) {
+        if (prop in target) {
+          return Reflect.get(target, prop, receiver);
+        }
+
+        const prototype = superClass?.prototype;
+        if (!prototype) {
+          return undefined;
+        }
+
+        const value = Reflect.get(prototype, prop, thisContext);
+        return typeof value === 'function' ? value.bind(thisContext) : value;
+      }
+    });
+  }
+
   createMethodFunction(funcNode, env, className) {
     const func = {
       __isFunction: true,
@@ -15068,18 +15180,7 @@ class Interpreter {
 
     // Bind 'super' if superClass exists
     if (superClass) {
-      // Create a super function that calls the parent constructor
-      const superFunc = (...superArgs) => {
-        const result = this.initializeSuperClass(superClass, thisContext, superArgs);
-        if (afterSuper) {
-          afterSuper();
-        }
-        return result && result.__explicitReturn ? result.value : undefined;
-      };
-      // Store both the function and mark it as super
-      superFunc.__isSuperConstructor = true;
-      superFunc.__superClass = superClass;
-      funcEnv.define('super', superFunc);
+      funcEnv.define('super', this.createSuperBinding(superClass, thisContext, true, afterSuper));
     }
 
     this.bindFunctionParameters(methodFunc.__params, args, funcEnv, thisContext);

package/dist/index.js

@@ -11676,6 +11676,62 @@ function collectRuntimeIdentifierReferences(node) {
   visit(node);
   return references;
 }
+function getExportName(nameNode) {
+  return (nameNode == null ? void 0 : nameNode.name) ?? (nameNode == null ? void 0 : nameNode.value);
+}
+function collectDeclarationExportNames(declaration) {
+  const names = [];
+  if (!declaration || isTypeOnlyDeclaration(declaration)) {
+    return names;
+  }
+  if (declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration" || declaration.type === "TSEnumDeclaration") {
+    const name = getPatternName(declaration.id);
+    if (name) names.push(name);
+    return names;
+  }
+  if (declaration.type === "VariableDeclaration") {
+    for (const declarator of declaration.declarations || []) {
+      const name = getPatternName(declarator.id);
+      if (name) names.push(name);
+    }
+  }
+  return names;
+}
+function collectStaticExportNames(moduleAst) {
+  const names = /* @__PURE__ */ new Set();
+  for (const statement of (moduleAst == null ? void 0 : moduleAst.body) || []) {
+    if (statement.type === "ExportDefaultDeclaration") {
+      names.add("default");
+      continue;
+    }
+    if (statement.type !== "ExportNamedDeclaration" || statement.exportKind === "type") {
+      continue;
+    }
+    if (statement.declaration) {
+      for (const name of collectDeclarationExportNames(statement.declaration)) {
+        names.add(name);
+      }
+      continue;
+    }
+    for (const specifier of statement.specifiers || []) {
+      if (specifier.exportKind === "type") {
+        continue;
+      }
+      const exportedName = getExportName(specifier.exported);
+      if (exportedName) {
+        names.add(exportedName);
+      }
+    }
+  }
+  return names;
+}
+function predeclareModuleExports(moduleAst, moduleExports) {
+  for (const name of collectStaticExportNames(moduleAst)) {
+    if (!Object.prototype.hasOwnProperty.call(moduleExports, name)) {
+      moduleExports[name] = void 0;
+    }
+  }
+}
 var Interpreter = class _Interpreter {
   constructor(globalEnv, options = {}) {
     this.globalEnv = globalEnv;
@@ -13245,9 +13301,15 @@ var Interpreter = class _Interpreter {
           executionController: this.executionController
         });
         moduleInterpreter.moduleCache = this.moduleCache;
-        await moduleInterpreter.evaluateAsync(moduleAst, moduleEnv);
         moduleExports = moduleInterpreter.moduleExports;
+        predeclareModuleExports(moduleAst, moduleExports);
         this.moduleCache.set(resolvedPath, moduleExports);
+        try {
+          await moduleInterpreter.evaluateAsync(moduleAst, moduleEnv);
+        } catch (error) {
+          this.moduleCache.delete(resolvedPath);
+          throw error;
+        }
       }
     }
     this.bindImportSpecifiers(node, env, modulePath, moduleExports);
@@ -13624,7 +13686,7 @@ var Interpreter = class _Interpreter {
     }
     for (const [name, method] of Object.entries(methods)) {
       classConstructor.prototype[name] = function(...args) {
-        const result = interpreter.callMethodFunction(method, this, args, env);
+        const result = interpreter.callMethodFunction(method, this, args, env, superClass);
         if (result && result.__explicitReturn) {
           return result.value;
         }
@@ -13683,6 +13745,9 @@ var Interpreter = class _Interpreter {
     for (const field of classConstructor.__instanceFields || []) {
       const fieldEnv = new Environment(env);
       fieldEnv.define("this", instance);
+      if (classConstructor.__superClass) {
+        fieldEnv.define("super", this.createSuperBinding(classConstructor.__superClass, instance, false));
+      }
       const name = this.getClassFieldName(field, fieldEnv);
       instance[name] = field.value ? this.evaluate(field.value, fieldEnv) : void 0;
     }
@@ -13696,6 +13761,33 @@ var Interpreter = class _Interpreter {
     }
     return field.key.value;
   }
+  createSuperBinding(superClass, thisContext, allowConstructor = false, afterSuper = null) {
+    const superConstructor = (...superArgs) => {
+      if (!allowConstructor) {
+        throw new ReferenceError("'super' keyword is unexpected here");
+      }
+      const result = this.initializeSuperClass(superClass, thisContext, superArgs);
+      if (afterSuper) {
+        afterSuper();
+      }
+      return result && result.__explicitReturn ? result.value : void 0;
+    };
+    superConstructor.__isSuperConstructor = true;
+    superConstructor.__superClass = superClass;
+    return new Proxy(superConstructor, {
+      get(target, prop, receiver) {
+        if (prop in target) {
+          return Reflect.get(target, prop, receiver);
+        }
+        const prototype = superClass == null ? void 0 : superClass.prototype;
+        if (!prototype) {
+          return void 0;
+        }
+        const value = Reflect.get(prototype, prop, thisContext);
+        return typeof value === "function" ? value.bind(thisContext) : value;
+      }
+    });
+  }
   createMethodFunction(funcNode, env, className) {
     const func = {
       __isFunction: true,
@@ -13710,16 +13802,7 @@ var Interpreter = class _Interpreter {
     const funcEnv = new Environment(methodFunc.__env || env);
     funcEnv.define("this", thisContext);
     if (superClass) {
-      const superFunc = (...superArgs) => {
-        const result2 = this.initializeSuperClass(superClass, thisContext, superArgs);
-        if (afterSuper) {
-          afterSuper();
-        }
-        return result2 && result2.__explicitReturn ? result2.value : void 0;
-      };
-      superFunc.__isSuperConstructor = true;
-      superFunc.__superClass = superClass;
-      funcEnv.define("super", superFunc);
+      funcEnv.define("super", this.createSuperBinding(superClass, thisContext, true, afterSuper));
     }
     this.bindFunctionParameters(methodFunc.__params, args, funcEnv, thisContext);
     const result = this.evaluate(methodFunc.__body, funcEnv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jslike",
-  "version": "1.8.4",
+  "version": "1.8.6",
   "description": "Production-ready JavaScript interpreter with full ES6+ support using Acorn parser",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
@@ -62,7 +62,7 @@
     }
   },
   "bin": {
-    "jslike": "./bin/jslike.js"
+    "jslike": "bin/jslike.js"
   },
   "scripts": {
     "build": "node scripts/bundle-acorn.js && tsup && node scripts/post-build.js",