jslike 1.8.0 → 1.8.2

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();
 }
@@ -11527,6 +11548,165 @@ function getPatternName(pattern) {
   if (pattern.type === "TSParameterProperty") return getPatternName(pattern.parameter);
   return pattern.name;
 }
+function collectRuntimeIdentifierReferences(node) {
+  const references = /* @__PURE__ */ new Set();
+  const skipKeys = /* @__PURE__ */ new Set([
+    "type",
+    "start",
+    "end",
+    "loc",
+    "range",
+    "raw",
+    "typeAnnotation",
+    "returnType",
+    "typeParameters",
+    "typeArguments",
+    "implements"
+  ]);
+  const visitPatternDefaults = (pattern) => {
+    if (!pattern || typeof pattern !== "object") return;
+    if (pattern.type === "AssignmentPattern") {
+      visit(pattern.right);
+      visitPatternDefaults(pattern.left);
+    } else if (pattern.type === "ObjectPattern") {
+      for (const property of pattern.properties || []) {
+        visitPatternDefaults(property.value || property.argument);
+      }
+    } else if (pattern.type === "ArrayPattern") {
+      for (const element of pattern.elements || []) {
+        visitPatternDefaults(element);
+      }
+    } else if (pattern.type === "RestElement") {
+      visitPatternDefaults(pattern.argument);
+    } else if (pattern.type === "TSParameterProperty") {
+      visitPatternDefaults(pattern.parameter);
+    }
+  };
+  const visitFunction = (fn) => {
+    for (const param of fn.params || []) {
+      visitPatternDefaults(param);
+    }
+    visit(fn.body);
+  };
+  const visitJSXName = (jsxName) => {
+    if (!jsxName || typeof jsxName !== "object") return;
+    if (jsxName.type === "JSXIdentifier") {
+      if (/^[A-Z]/.test(jsxName.name)) {
+        references.add(jsxName.name);
+      }
+    } else if (jsxName.type === "JSXMemberExpression") {
+      visitJSXName(jsxName.object);
+    } else if (jsxName.type === "JSXNamespacedName") {
+      visitJSXName(jsxName.namespace);
+    }
+  };
+  const visit = (current2, parent = null, parentKey = null) => {
+    var _a, _b, _c;
+    if (!current2 || typeof current2 !== "object") return;
+    if (Array.isArray(current2)) {
+      for (const item of current2) visit(item, parent, parentKey);
+      return;
+    }
+    if ((_a = current2.type) == null ? void 0 : _a.startsWith("TS")) {
+      if (isTypeWrapperExpression(current2)) {
+        visit(getTypeWrapperInnerExpression(current2), current2, "expression");
+      } else if (current2.type === "TSEnumDeclaration") {
+        for (const member of current2.members || []) {
+          visit(member.initializer);
+        }
+      }
+      return;
+    }
+    switch (current2.type) {
+      case "Identifier":
+        references.add(current2.name);
+        return;
+      case "ImportDeclaration":
+        return;
+      case "ExportNamedDeclaration":
+        if (current2.declaration) {
+          visit(current2.declaration, current2, "declaration");
+        } else if (current2.exportKind !== "type") {
+          for (const specifier of current2.specifiers || []) {
+            if (specifier.exportKind !== "type" && ((_b = specifier.local) == null ? void 0 : _b.name)) {
+              references.add(specifier.local.name);
+            }
+          }
+        }
+        return;
+      case "ExportDefaultDeclaration":
+        visit(current2.declaration, current2, "declaration");
+        return;
+      case "VariableDeclarator":
+        visitPatternDefaults(current2.id);
+        visit(current2.init, current2, "init");
+        return;
+      case "FunctionDeclaration":
+        visitFunction(current2);
+        return;
+      case "FunctionExpression":
+      case "ArrowFunctionExpression":
+        visitFunction(current2);
+        return;
+      case "ClassDeclaration":
+      case "ClassExpression":
+        visit(current2.superClass, current2, "superClass");
+        visit(current2.body, current2, "body");
+        return;
+      case "MemberExpression":
+      case "OptionalMemberExpression":
+        visit(current2.object, current2, "object");
+        if (current2.computed) {
+          visit(current2.property, current2, "property");
+        }
+        return;
+      case "Property":
+        if (current2.computed) {
+          visit(current2.key, current2, "key");
+        }
+        visit(current2.value, current2, "value");
+        return;
+      case "MethodDefinition":
+      case "PropertyDefinition":
+        if (current2.computed) {
+          visit(current2.key, current2, "key");
+        }
+        if (!current2.declare && !current2.abstract) {
+          visit(current2.value, current2, "value");
+        }
+        return;
+      case "AssignmentPattern":
+        visit(current2.right, current2, "right");
+        return;
+      case "RestElement":
+        return;
+      case "ObjectPattern":
+      case "ArrayPattern":
+        visitPatternDefaults(current2);
+        return;
+      case "JSXElement":
+        visitJSXName((_c = current2.openingElement) == null ? void 0 : _c.name);
+        for (const child of current2.children || []) {
+          visit(child);
+        }
+        return;
+      case "JSXFragment":
+        for (const child of current2.children || []) {
+          visit(child);
+        }
+        return;
+      case "JSXExpressionContainer":
+        visit(current2.expression, current2, "expression");
+        return;
+    }
+    for (const [key, value] of Object.entries(current2)) {
+      if (skipKeys.has(key)) continue;
+      visit(value, current2, key);
+    }
+  };
+  visit(node);
+  return references;
+}
 var Interpreter = class _Interpreter {
   constructor(globalEnv, options = {}) {
     this.globalEnv = globalEnv;
@@ -11535,6 +11715,8 @@ var Interpreter = class _Interpreter {
     this.moduleResolutionCache = options.moduleResolutionCache || /* @__PURE__ */ new Map();
     this.moduleExports = {};
     this.currentModulePath = options.currentModulePath;
+    this.isTypeScriptModule = options.isTypeScriptModule || false;
+    this.runtimeIdentifierReferences = null;
     this.abortSignal = options.abortSignal;
     this.executionController = options.executionController;
   }
@@ -11700,14 +11882,20 @@ var Interpreter = class _Interpreter {
       return void 0;
     }
     if (node.type === "Program") {
+      const previousReferences = this.runtimeIdentifierReferences;
+      this.runtimeIdentifierReferences = collectRuntimeIdentifierReferences(node);
       let result = void 0;
-      for (const statement of node.body) {
-        result = await this.evaluateAsync(statement, env);
-        if (result instanceof ReturnValue || result instanceof ThrowSignal) {
-          return result;
+      try {
+        for (const statement of node.body) {
+          result = await this.evaluateAsync(statement, env);
+          if (result instanceof ReturnValue || result instanceof ThrowSignal) {
+            return result;
+          }
         }
+        return result;
+      } finally {
+        this.runtimeIdentifierReferences = previousReferences;
       }
-      return result;
     }
     if (node.type === "ImportDeclaration") {
       return await this.evaluateImportDeclaration(node, env);
@@ -12331,23 +12519,29 @@ var Interpreter = class _Interpreter {
     }
   }
   evaluateProgram(node, env) {
+    const previousReferences = this.runtimeIdentifierReferences;
+    this.runtimeIdentifierReferences = collectRuntimeIdentifierReferences(node);
     let result = void 0;
-    for (let i = 0; i < node.body.length; i++) {
-      const statement = node.body[i];
-      const isLast = i === node.body.length - 1;
-      if (isLast && statement.type === "BlockStatement") {
-        const objLiteral = this.tryConvertBlockToObjectLiteral(statement, env);
-        if (objLiteral !== null) {
-          return objLiteral;
+    try {
+      for (let i = 0; i < node.body.length; i++) {
+        const statement = node.body[i];
+        const isLast = i === node.body.length - 1;
+        if (isLast && statement.type === "BlockStatement") {
+          const objLiteral = this.tryConvertBlockToObjectLiteral(statement, env);
+          if (objLiteral !== null) {
+            return objLiteral;
+          }
         }
+        const statementResult = this.evaluate(statement, env);
+        if (statementResult instanceof ReturnValue || statementResult instanceof ThrowSignal) {
+          return statementResult;
+        }
+        result = statementResult;
       }
-      const statementResult = this.evaluate(statement, env);
-      if (statementResult instanceof ReturnValue || statementResult instanceof ThrowSignal) {
-        return statementResult;
-      }
-      result = statementResult;
+      return result;
+    } finally {
+      this.runtimeIdentifierReferences = previousReferences;
     }
-    return result;
   }
   // Try to convert a BlockStatement to an object literal
   // Returns null if the block doesn't look like an object literal
@@ -12995,6 +13189,9 @@ var Interpreter = class _Interpreter {
     if (node.importKind === "type" || node.specifiers.length > 0 && node.specifiers.every((specifier) => specifier.importKind === "type")) {
       return void 0;
     }
+    if (this.isTypeScriptModule && node.specifiers.length > 0 && node.specifiers.every((specifier) => !this.isRuntimeImportSpecifier(specifier))) {
+      return void 0;
+    }
     if (!this.moduleResolver) {
       throw new Error("Module resolver not configured - cannot import modules");
     }
@@ -13030,6 +13227,7 @@ var Interpreter = class _Interpreter {
           moduleResolver: this.moduleResolver,
           moduleResolutionCache: this.moduleResolutionCache,
           currentModulePath: resolvedPath,
+          isTypeScriptModule: isTypeScriptPath(resolvedPath),
           abortSignal: this.abortSignal,
           executionController: this.executionController
         });
@@ -13044,7 +13242,7 @@ var Interpreter = class _Interpreter {
   }
   bindImportSpecifiers(node, env, modulePath, moduleExports) {
     for (const specifier of node.specifiers) {
-      if (specifier.importKind === "type") {
+      if (!this.isRuntimeImportSpecifier(specifier)) {
         continue;
       }
       if (specifier.type === "ImportSpecifier") {
@@ -13067,6 +13265,20 @@ var Interpreter = class _Interpreter {
     }
     return void 0;
   }
+  isRuntimeImportSpecifier(specifier) {
+    var _a;
+    if (specifier.importKind === "type") {
+      return false;
+    }
+    if (!this.isTypeScriptModule) {
+      return true;
+    }
+    const localName = (_a = specifier.local) == null ? void 0 : _a.name;
+    if (!localName || !this.runtimeIdentifierReferences) {
+      return true;
+    }
+    return this.runtimeIdentifierReferences.has(localName);
+  }
   evaluateExportNamedDeclaration(node, env) {
     if (node.exportKind === "type" || isTypeOnlyDeclaration(node.declaration)) {
       return void 0;
@@ -14551,7 +14763,8 @@ async function execute(code, env = null, options = {}) {
       moduleResolver: options.moduleResolver,
       abortSignal: options.abortSignal,
       executionController: controller,
-      currentModulePath: options.sourcePath
+      currentModulePath: options.sourcePath,
+      isTypeScriptModule: options.typescript || options.tsx || isTypeScriptPath2(options.sourcePath)
     });
     const needsAsync = options.sourceType === "module" || containsModuleDeclarations(ast) || containsTopLevelAwait(ast) || controller != null;
     if (needsAsync) {