eslint-plugin-etc-misc 1.1.2 → 1.1.4

package/dist/plugin.cjs

@@ -3745,8 +3745,111 @@ var deprecatedRule14 = withDeprecatedRuleLifecycle(rule53, {
 var no_value_tostring_default = deprecatedRule14;
 
 // dist/rules/no-vulnerable.js
+var import_node_fs = require("node:fs");
+var import_node_module = require("node:module");
+var import_node_path5 = require("node:path");
 var import_recheck = require("recheck");
 var import_ts_extras38 = require("ts-extras");
+var requireFromWorkingDirectory = (0, import_node_module.createRequire)((0, import_node_path5.join)(process.cwd(), "package.json"));
+var isUnknownRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isModuleNotFoundError = (error) => {
+  if (!isUnknownRecord2(error)) {
+    return false;
+  }
+  return (0, import_ts_extras38.keyIn)(error, "code") && error["code"] === "MODULE_NOT_FOUND";
+};
+var createRequireFromPluginPackage = () => {
+  try {
+    return (0, import_node_module.createRequire)(requireFromWorkingDirectory.resolve("eslint-plugin-etc-misc/package.json"));
+  } catch (error) {
+    if (isModuleNotFoundError(error)) {
+      return requireFromWorkingDirectory;
+    }
+    throw error;
+  }
+};
+var requireFromPluginPackage = createRequireFromPluginPackage();
+var isExistingFile = (filePath) => {
+  try {
+    return (0, import_node_fs.statSync)(filePath).isFile();
+  } catch {
+    return false;
+  }
+};
+var shouldOverrideRuntimePath = (currentPath) => !(0, import_ts_extras38.isDefined)(currentPath) || !isExistingFile(currentPath) || (0, import_node_path5.basename)(currentPath).toLowerCase() === "package.json";
+var resolvePackageSiblingFile = (packageJsonSpecifier, siblingFileName) => {
+  try {
+    const packageJsonPath = requireFromPluginPackage.resolve(packageJsonSpecifier);
+    return (0, import_node_path5.join)((0, import_node_path5.dirname)(packageJsonPath), siblingFileName);
+  } catch (error) {
+    if (isModuleNotFoundError(error)) {
+      return null;
+    }
+    throw error;
+  }
+};
+var resolveRecheckJarPath = () => resolvePackageSiblingFile("recheck-jar/package.json", "recheck.jar");
+var resolveRecheckWindowsBinaryPath = () => {
+  if (process.platform !== "win32" || process.arch !== "x64") {
+    return null;
+  }
+  return resolvePackageSiblingFile("recheck-windows-x64/package.json", "recheck.exe");
+};
+var recheckJarPath = process.platform === "win32" ? resolveRecheckJarPath() : null;
+var recheckWindowsBinaryPath = process.platform === "win32" ? resolveRecheckWindowsBinaryPath() : null;
+var deleteRecheckEnvironmentValue = (key) => {
+  if (key === "RECHECK_BIN") {
+    delete process.env["RECHECK_BIN"];
+    return;
+  }
+  delete process.env["RECHECK_JAR"];
+};
+var getRecheckEnvironmentValue = (key) => key === "RECHECK_BIN" ? process.env["RECHECK_BIN"] : process.env["RECHECK_JAR"];
+var setRecheckEnvironmentValue = (key, value) => {
+  if (key === "RECHECK_BIN") {
+    process.env["RECHECK_BIN"] = value;
+    return;
+  }
+  process.env["RECHECK_JAR"] = value;
+};
+var getRecheckEnvironmentOverrides = () => {
+  if (process.platform !== "win32") {
+    return {};
+  }
+  const overrides = {};
+  if (recheckJarPath !== null && isExistingFile(recheckJarPath) && shouldOverrideRuntimePath(getRecheckEnvironmentValue("RECHECK_JAR"))) {
+    overrides.RECHECK_JAR = recheckJarPath;
+  }
+  if (recheckWindowsBinaryPath !== null && isExistingFile(recheckWindowsBinaryPath) && shouldOverrideRuntimePath(getRecheckEnvironmentValue("RECHECK_BIN"))) {
+    overrides.RECHECK_BIN = recheckWindowsBinaryPath;
+  }
+  return overrides;
+};
+var restoreEnvironmentValue = (key, value) => {
+  if (!(0, import_ts_extras38.isDefined)(value)) {
+    deleteRecheckEnvironmentValue(key);
+    return;
+  }
+  setRecheckEnvironmentValue(key, value);
+};
+var withRecheckEnvironmentOverrides = (callback) => {
+  const overrides = getRecheckEnvironmentOverrides();
+  const previousBin = getRecheckEnvironmentValue("RECHECK_BIN");
+  const previousJar = getRecheckEnvironmentValue("RECHECK_JAR");
+  if ((0, import_ts_extras38.isDefined)(overrides.RECHECK_BIN)) {
+    setRecheckEnvironmentValue("RECHECK_BIN", overrides.RECHECK_BIN);
+  }
+  if ((0, import_ts_extras38.isDefined)(overrides.RECHECK_JAR)) {
+    setRecheckEnvironmentValue("RECHECK_JAR", overrides.RECHECK_JAR);
+  }
+  try {
+    return callback();
+  } finally {
+    restoreEnvironmentValue("RECHECK_BIN", previousBin);
+    restoreEnvironmentValue("RECHECK_JAR", previousJar);
+  }
+};
+var runRecheck = (source, flags, parameters) => withRecheckEnvironmentOverrides(() => (0, import_recheck.checkSync)(source, flags, parameters));
 var getStaticStringValue = (node) => {
   if (node.type === "Literal" && typeof node.value === "string") {
     return node.value;
@@ -3796,13 +3899,42 @@ var getDiagnosticsErrorMessage = (error) => {
   }
   return "No additional details provided.";
 };
+var getThrownErrorMessage = (error) => {
+  if (error instanceof Error && error.message.length > 0) {
+    return error.message;
+  }
+  if (typeof error === "string" && error.length > 0) {
+    return error;
+  }
+  return "No additional details provided.";
+};
 var rule54 = ruleCreator({
   create: (context, [rawOptions]) => {
     const options = rawOptions ?? {};
     const { ignoreErrors = true, permittableComplexities = [], ...recheckParameters } = options;
     const allowedComplexities = new Set(permittableComplexities);
     const reportDiagnostics = (node, source, flags) => {
-      const diagnostics = (0, import_recheck.checkSync)(source, flags, recheckParameters);
+      const diagnostics = (() => {
+        try {
+          return runRecheck(source, flags, recheckParameters);
+        } catch (error) {
+          if (ignoreErrors) {
+            return null;
+          }
+          context.report({
+            data: {
+              kind: "unexpected",
+              message: getThrownErrorMessage(error)
+            },
+            messageId: "checkerError",
+            node
+          });
+          return null;
+        }
+      })();
+      if (diagnostics === null) {
+        return;
+      }
       if (diagnostics.status === "safe") {
         return;
       }