@pobammer-ts/eslint-cease-nonsense-rules 1.3.0 → 1.4.0

package/dist/index.js

@@ -11368,6 +11368,1289 @@ var useExhaustiveDependencies = {
 };
 var use_exhaustive_dependencies_default = useExhaustiveDependencies;
 
+// src/rules/no-commented-code.ts
+import path from "node:path";
+
+// node_modules/oxc-parser/src-js/index.js
+import { createRequire as createRequire3 } from "node:module";
+
+// node_modules/oxc-parser/src-js/bindings.js
+import { createRequire } from "node:module";
+var require2 = createRequire(import.meta.url);
+var __dirname2 = new URL(".", import.meta.url).pathname;
+var { readFileSync } = require2("node:fs");
+var nativeBinding = null;
+var loadErrors = [];
+var isMusl = () => {
+  let musl = false;
+  if (process.platform === "linux") {
+    musl = isMuslFromFilesystem();
+    if (musl === null) {
+      musl = isMuslFromReport();
+    }
+    if (musl === null) {
+      musl = isMuslFromChildProcess();
+    }
+  }
+  return musl;
+};
+var isFileMusl = (f) => f.includes("libc.musl-") || f.includes("ld-musl-");
+var isMuslFromFilesystem = () => {
+  try {
+    return readFileSync("/usr/bin/ldd", "utf-8").includes("musl");
+  } catch {
+    return null;
+  }
+};
+var isMuslFromReport = () => {
+  let report = null;
+  if (typeof process.report?.getReport === "function") {
+    process.report.excludeNetwork = true;
+    report = process.report.getReport();
+  }
+  if (!report) {
+    return null;
+  }
+  if (report.header && report.header.glibcVersionRuntime) {
+    return false;
+  }
+  if (Array.isArray(report.sharedObjects)) {
+    if (report.sharedObjects.some(isFileMusl)) {
+      return true;
+    }
+  }
+  return false;
+};
+var isMuslFromChildProcess = () => {
+  try {
+    return require2("child_process").execSync("ldd --version", { encoding: "utf8" }).includes("musl");
+  } catch (e) {
+    return false;
+  }
+};
+function requireNative() {
+  if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) {
+    try {
+      return require2(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
+    } catch (err) {
+      loadErrors.push(err);
+    }
+  } else if (process.platform === "android") {
+    if (process.arch === "arm64") {
+      try {
+        return require2("./parser.android-arm64.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@oxc-parser/binding-android-arm64");
+        const bindingPackageVersion = require2("@oxc-parser/binding-android-arm64/package.json").version;
+        if (bindingPackageVersion !== "0.101.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.101.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else if (process.arch === "arm") {
+      try {
+        return require2("./parser.android-arm-eabi.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@oxc-parser/binding-android-arm-eabi");
+        const bindingPackageVersion = require2("@oxc-parser/binding-android-arm-eabi/package.json").version;
+        if (bindingPackageVersion !== "0.101.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.101.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`));
+    }
+  } else if (process.platform === "win32") {
+    if (process.arch === "x64") {
+      if (process.config?.variables?.shlib_suffix === "dll.a" || process.config?.variables?.node_target_type === "shared_library") {
+        try {
+          return require2("./parser.win32-x64-gnu.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@oxc-parser/binding-win32-x64-gnu");
+          const bindingPackageVersion = require2("@oxc-parser/binding-win32-x64-gnu/package.json").version;
+          if (bindingPackageVersion !== "0.101.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.101.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else {
+        try {
+          return require2("./parser.win32-x64-msvc.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@oxc-parser/binding-win32-x64-msvc");
+          const bindingPackageVersion = require2("@oxc-parser/binding-win32-x64-msvc/package.json").version;
+          if (bindingPackageVersion !== "0.101.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.101.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      }
+    } else if (process.arch === "ia32") {
+      try {
+        return require2("./parser.win32-ia32-msvc.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@oxc-parser/binding-win32-ia32-msvc");
+        const bindingPackageVersion = require2("@oxc-parser/binding-win32-ia32-msvc/package.json").version;
+        if (bindingPackageVersion !== "0.101.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.101.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else if (process.arch === "arm64") {
+      try {
+        return require2("./parser.win32-arm64-msvc.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@oxc-parser/binding-win32-arm64-msvc");
+        const bindingPackageVersion = require2("@oxc-parser/binding-win32-arm64-msvc/package.json").version;
+        if (bindingPackageVersion !== "0.101.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.101.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`));
+    }
+  } else if (process.platform === "darwin") {
+    try {
+      return require2("./parser.darwin-universal.node");
+    } catch (e) {
+      loadErrors.push(e);
+    }
+    try {
+      const binding = require2("@oxc-parser/binding-darwin-universal");
+      const bindingPackageVersion = require2("@oxc-parser/binding-darwin-universal/package.json").version;
+      if (bindingPackageVersion !== "0.101.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+        throw new Error(`Native binding package version mismatch, expected 0.101.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+      }
+      return binding;
+    } catch (e) {
+      loadErrors.push(e);
+    }
+    if (process.arch === "x64") {
+      try {
+        return require2("./parser.darwin-x64.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@oxc-parser/binding-darwin-x64");
+        const bindingPackageVersion = require2("@oxc-parser/binding-darwin-x64/package.json").version;
+        if (bindingPackageVersion !== "0.101.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.101.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else if (process.arch === "arm64") {
+      try {
+        return require2("./parser.darwin-arm64.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@oxc-parser/binding-darwin-arm64");
+        const bindingPackageVersion = require2("@oxc-parser/binding-darwin-arm64/package.json").version;
+        if (bindingPackageVersion !== "0.101.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.101.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`));
+    }
+  } else if (process.platform === "freebsd") {
+    if (process.arch === "x64") {
+      try {
+        return require2("./parser.freebsd-x64.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@oxc-parser/binding-freebsd-x64");
+        const bindingPackageVersion = require2("@oxc-parser/binding-freebsd-x64/package.json").version;
+        if (bindingPackageVersion !== "0.101.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.101.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else if (process.arch === "arm64") {
+      try {
+        return require2("./parser.freebsd-arm64.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@oxc-parser/binding-freebsd-arm64");
+        const bindingPackageVersion = require2("@oxc-parser/binding-freebsd-arm64/package.json").version;
+        if (bindingPackageVersion !== "0.101.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.101.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`));
+    }
+  } else if (process.platform === "linux") {
+    if (process.arch === "x64") {
+      if (isMusl()) {
+        try {
+          return require2("./parser.linux-x64-musl.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@oxc-parser/binding-linux-x64-musl");
+          const bindingPackageVersion = require2("@oxc-parser/binding-linux-x64-musl/package.json").version;
+          if (bindingPackageVersion !== "0.101.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.101.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else {
+        try {
+          return require2("./parser.linux-x64-gnu.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@oxc-parser/binding-linux-x64-gnu");
+          const bindingPackageVersion = require2("@oxc-parser/binding-linux-x64-gnu/package.json").version;
+          if (bindingPackageVersion !== "0.101.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.101.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      }
+    } else if (process.arch === "arm64") {
+      if (isMusl()) {
+        try {
+          return require2("./parser.linux-arm64-musl.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@oxc-parser/binding-linux-arm64-musl");
+          const bindingPackageVersion = require2("@oxc-parser/binding-linux-arm64-musl/package.json").version;
+          if (bindingPackageVersion !== "0.101.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.101.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else {
+        try {
+          return require2("./parser.linux-arm64-gnu.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@oxc-parser/binding-linux-arm64-gnu");
+          const bindingPackageVersion = require2("@oxc-parser/binding-linux-arm64-gnu/package.json").version;
+          if (bindingPackageVersion !== "0.101.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.101.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      }
+    } else if (process.arch === "arm") {
+      if (isMusl()) {
+        try {
+          return require2("./parser.linux-arm-musleabihf.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@oxc-parser/binding-linux-arm-musleabihf");
+          const bindingPackageVersion = require2("@oxc-parser/binding-linux-arm-musleabihf/package.json").version;
+          if (bindingPackageVersion !== "0.101.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.101.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else {
+        try {
+          return require2("./parser.linux-arm-gnueabihf.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@oxc-parser/binding-linux-arm-gnueabihf");
+          const bindingPackageVersion = require2("@oxc-parser/binding-linux-arm-gnueabihf/package.json").version;
+          if (bindingPackageVersion !== "0.101.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.101.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      }
+    } else if (process.arch === "loong64") {
+      if (isMusl()) {
+        try {
+          return require2("./parser.linux-loong64-musl.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@oxc-parser/binding-linux-loong64-musl");
+          const bindingPackageVersion = require2("@oxc-parser/binding-linux-loong64-musl/package.json").version;
+          if (bindingPackageVersion !== "0.101.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.101.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else {
+        try {
+          return require2("./parser.linux-loong64-gnu.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@oxc-parser/binding-linux-loong64-gnu");
+          const bindingPackageVersion = require2("@oxc-parser/binding-linux-loong64-gnu/package.json").version;
+          if (bindingPackageVersion !== "0.101.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.101.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      }
+    } else if (process.arch === "riscv64") {
+      if (isMusl()) {
+        try {
+          return require2("./parser.linux-riscv64-musl.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@oxc-parser/binding-linux-riscv64-musl");
+          const bindingPackageVersion = require2("@oxc-parser/binding-linux-riscv64-musl/package.json").version;
+          if (bindingPackageVersion !== "0.101.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.101.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else {
+        try {
+          return require2("./parser.linux-riscv64-gnu.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@oxc-parser/binding-linux-riscv64-gnu");
+          const bindingPackageVersion = require2("@oxc-parser/binding-linux-riscv64-gnu/package.json").version;
+          if (bindingPackageVersion !== "0.101.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.101.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      }
+    } else if (process.arch === "ppc64") {
+      try {
+        return require2("./parser.linux-ppc64-gnu.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@oxc-parser/binding-linux-ppc64-gnu");
+        const bindingPackageVersion = require2("@oxc-parser/binding-linux-ppc64-gnu/package.json").version;
+        if (bindingPackageVersion !== "0.101.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.101.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else if (process.arch === "s390x") {
+      try {
+        return require2("./parser.linux-s390x-gnu.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@oxc-parser/binding-linux-s390x-gnu");
+        const bindingPackageVersion = require2("@oxc-parser/binding-linux-s390x-gnu/package.json").version;
+        if (bindingPackageVersion !== "0.101.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.101.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`));
+    }
+  } else if (process.platform === "openharmony") {
+    if (process.arch === "arm64") {
+      try {
+        return require2("./parser.openharmony-arm64.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@oxc-parser/binding-openharmony-arm64");
+        const bindingPackageVersion = require2("@oxc-parser/binding-openharmony-arm64/package.json").version;
+        if (bindingPackageVersion !== "0.101.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.101.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else if (process.arch === "x64") {
+      try {
+        return require2("./parser.openharmony-x64.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@oxc-parser/binding-openharmony-x64");
+        const bindingPackageVersion = require2("@oxc-parser/binding-openharmony-x64/package.json").version;
+        if (bindingPackageVersion !== "0.101.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.101.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else if (process.arch === "arm") {
+      try {
+        return require2("./parser.openharmony-arm.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@oxc-parser/binding-openharmony-arm");
+        const bindingPackageVersion = require2("@oxc-parser/binding-openharmony-arm/package.json").version;
+        if (bindingPackageVersion !== "0.101.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.101.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`));
+    }
+  } else {
+    loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`));
+  }
+}
+nativeBinding = requireNative();
+if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+  let wasiBinding = null;
+  let wasiBindingError = null;
+  try {
+    wasiBinding = require2("./parser.wasi.cjs");
+    nativeBinding = wasiBinding;
+  } catch (err) {
+    if (process.env.NAPI_RS_FORCE_WASI) {
+      wasiBindingError = err;
+    }
+  }
+  if (!nativeBinding) {
+    try {
+      wasiBinding = require2("@oxc-parser/binding-wasm32-wasi");
+      nativeBinding = wasiBinding;
+    } catch (err) {
+      if (process.env.NAPI_RS_FORCE_WASI) {
+        wasiBindingError.cause = err;
+        loadErrors.push(err);
+      }
+    }
+  }
+  if (process.env.NAPI_RS_FORCE_WASI === "error" && !wasiBinding) {
+    const error2 = new Error("WASI binding not found and NAPI_RS_FORCE_WASI is set to error");
+    error2.cause = wasiBindingError;
+    throw error2;
+  }
+}
+if (!nativeBinding && globalThis.process?.versions?.["webcontainer"]) {
+  try {
+    nativeBinding = require2("./webcontainer-fallback.cjs");
+  } catch (err) {
+    loadErrors.push(err);
+  }
+}
+if (!nativeBinding) {
+  if (loadErrors.length > 0) {
+    throw new Error(`Cannot find native binding. ` + `npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). ` + "Please try `npm i` again after removing both package-lock.json and node_modules directory.", {
+      cause: loadErrors.reduce((err, cur) => {
+        cur.cause = err;
+        return cur;
+      })
+    });
+  }
+  throw new Error(`Failed to load native binding`);
+}
+var { Severity, ParseResult, ExportExportNameKind, ExportImportNameKind, ExportLocalNameKind, ImportNameKind, parse: parse3, parseSync, rawTransferSupported } = nativeBinding;
+
+// node_modules/oxc-parser/src-js/wrap.js
+function wrap(result) {
+  let program, module3, comments, errors4;
+  return {
+    get program() {
+      if (!program)
+        program = jsonParseAst(result.program);
+      return program;
+    },
+    get module() {
+      if (!module3)
+        module3 = result.module;
+      return module3;
+    },
+    get comments() {
+      if (!comments)
+        comments = result.comments;
+      return comments;
+    },
+    get errors() {
+      if (!errors4)
+        errors4 = result.errors;
+      return errors4;
+    }
+  };
+}
+function jsonParseAst(programJson) {
+  const { node: program, fixes } = JSON.parse(programJson);
+  for (const fixPath of fixes) {
+    applyFix(program, fixPath);
+  }
+  return program;
+}
+function applyFix(program, fixPath) {
+  let node = program;
+  for (const key of fixPath) {
+    node = node[key];
+  }
+  if (node.bigint) {
+    node.value = BigInt(node.bigint);
+  } else {
+    try {
+      node.value = RegExp(node.regex.pattern, node.regex.flags);
+    } catch {}
+  }
+}
+
+// node_modules/oxc-parser/generated/visit/keys.js
+var { freeze } = Object;
+var $EMPTY = freeze([]);
+var DECORATORS__KEY__TYPE_ANNOTATION__VALUE = freeze([
+  "decorators",
+  "key",
+  "typeAnnotation",
+  "value"
+]);
+var LEFT__RIGHT = freeze(["left", "right"]);
+var ARGUMENT = freeze(["argument"]);
+var BODY = freeze(["body"]);
+var LABEL = freeze(["label"]);
+var CALLEE__TYPE_ARGUMENTS__ARGUMENTS = freeze(["callee", "typeArguments", "arguments"]);
+var EXPRESSION = freeze(["expression"]);
+var DECORATORS__ID__TYPE_PARAMETERS__SUPER_CLASS__SUPER_TYPE_ARGUMENTS__IMPLEMENTS__BODY = freeze([
+  "decorators",
+  "id",
+  "typeParameters",
+  "superClass",
+  "superTypeArguments",
+  "implements",
+  "body"
+]);
+var TEST__CONSEQUENT__ALTERNATE = freeze(["test", "consequent", "alternate"]);
+var LEFT__RIGHT__BODY = freeze(["left", "right", "body"]);
+var ID__TYPE_PARAMETERS__PARAMS__RETURN_TYPE__BODY = freeze([
+  "id",
+  "typeParameters",
+  "params",
+  "returnType",
+  "body"
+]);
+var KEY__VALUE = freeze(["key", "value"]);
+var LOCAL = freeze(["local"]);
+var OBJECT__PROPERTY = freeze(["object", "property"]);
+var DECORATORS__KEY__TYPE_ANNOTATION = freeze(["decorators", "key", "typeAnnotation"]);
+var EXPRESSION__TYPE_ANNOTATION = freeze(["expression", "typeAnnotation"]);
+var TYPE_PARAMETERS__PARAMS__RETURN_TYPE = freeze(["typeParameters", "params", "returnType"]);
+var EXPRESSION__TYPE_ARGUMENTS = freeze(["expression", "typeArguments"]);
+var MEMBERS = freeze(["members"]);
+var ID__BODY = freeze(["id", "body"]);
+var TYPES = freeze(["types"]);
+var TYPE_ANNOTATION = freeze(["typeAnnotation"]);
+var PARAMS = freeze(["params"]);
+var keys_default = freeze({
+  DebuggerStatement: $EMPTY,
+  EmptyStatement: $EMPTY,
+  Literal: $EMPTY,
+  PrivateIdentifier: $EMPTY,
+  Super: $EMPTY,
+  TemplateElement: $EMPTY,
+  ThisExpression: $EMPTY,
+  JSXClosingFragment: $EMPTY,
+  JSXEmptyExpression: $EMPTY,
+  JSXIdentifier: $EMPTY,
+  JSXOpeningFragment: $EMPTY,
+  JSXText: $EMPTY,
+  TSAnyKeyword: $EMPTY,
+  TSBigIntKeyword: $EMPTY,
+  TSBooleanKeyword: $EMPTY,
+  TSIntrinsicKeyword: $EMPTY,
+  TSJSDocUnknownType: $EMPTY,
+  TSNeverKeyword: $EMPTY,
+  TSNullKeyword: $EMPTY,
+  TSNumberKeyword: $EMPTY,
+  TSObjectKeyword: $EMPTY,
+  TSStringKeyword: $EMPTY,
+  TSSymbolKeyword: $EMPTY,
+  TSThisType: $EMPTY,
+  TSUndefinedKeyword: $EMPTY,
+  TSUnknownKeyword: $EMPTY,
+  TSVoidKeyword: $EMPTY,
+  AccessorProperty: DECORATORS__KEY__TYPE_ANNOTATION__VALUE,
+  ArrayExpression: freeze(["elements"]),
+  ArrayPattern: freeze(["decorators", "elements", "typeAnnotation"]),
+  ArrowFunctionExpression: freeze(["typeParameters", "params", "returnType", "body"]),
+  AssignmentExpression: LEFT__RIGHT,
+  AssignmentPattern: freeze(["decorators", "left", "right", "typeAnnotation"]),
+  AwaitExpression: ARGUMENT,
+  BinaryExpression: LEFT__RIGHT,
+  BlockStatement: BODY,
+  BreakStatement: LABEL,
+  CallExpression: CALLEE__TYPE_ARGUMENTS__ARGUMENTS,
+  CatchClause: freeze(["param", "body"]),
+  ChainExpression: EXPRESSION,
+  ClassBody: BODY,
+  ClassDeclaration: DECORATORS__ID__TYPE_PARAMETERS__SUPER_CLASS__SUPER_TYPE_ARGUMENTS__IMPLEMENTS__BODY,
+  ClassExpression: DECORATORS__ID__TYPE_PARAMETERS__SUPER_CLASS__SUPER_TYPE_ARGUMENTS__IMPLEMENTS__BODY,
+  ConditionalExpression: TEST__CONSEQUENT__ALTERNATE,
+  ContinueStatement: LABEL,
+  Decorator: EXPRESSION,
+  DoWhileStatement: freeze(["body", "test"]),
+  ExportAllDeclaration: freeze(["exported", "source", "attributes"]),
+  ExportDefaultDeclaration: freeze(["declaration"]),
+  ExportNamedDeclaration: freeze(["declaration", "specifiers", "source", "attributes"]),
+  ExportSpecifier: freeze(["local", "exported"]),
+  ExpressionStatement: EXPRESSION,
+  ForInStatement: LEFT__RIGHT__BODY,
+  ForOfStatement: LEFT__RIGHT__BODY,
+  ForStatement: freeze(["init", "test", "update", "body"]),
+  FunctionDeclaration: ID__TYPE_PARAMETERS__PARAMS__RETURN_TYPE__BODY,
+  FunctionExpression: ID__TYPE_PARAMETERS__PARAMS__RETURN_TYPE__BODY,
+  Identifier: freeze(["decorators", "typeAnnotation"]),
+  IfStatement: TEST__CONSEQUENT__ALTERNATE,
+  ImportAttribute: KEY__VALUE,
+  ImportDeclaration: freeze(["specifiers", "source", "attributes"]),
+  ImportDefaultSpecifier: LOCAL,
+  ImportExpression: freeze(["source", "options"]),
+  ImportNamespaceSpecifier: LOCAL,
+  ImportSpecifier: freeze(["imported", "local"]),
+  LabeledStatement: freeze(["label", "body"]),
+  LogicalExpression: LEFT__RIGHT,
+  MemberExpression: OBJECT__PROPERTY,
+  MetaProperty: freeze(["meta", "property"]),
+  MethodDefinition: freeze(["decorators", "key", "value"]),
+  NewExpression: CALLEE__TYPE_ARGUMENTS__ARGUMENTS,
+  ObjectExpression: freeze(["properties"]),
+  ObjectPattern: freeze(["decorators", "properties", "typeAnnotation"]),
+  ParenthesizedExpression: EXPRESSION,
+  Program: BODY,
+  Property: KEY__VALUE,
+  PropertyDefinition: DECORATORS__KEY__TYPE_ANNOTATION__VALUE,
+  RestElement: freeze(["decorators", "argument", "typeAnnotation"]),
+  ReturnStatement: ARGUMENT,
+  SequenceExpression: freeze(["expressions"]),
+  SpreadElement: ARGUMENT,
+  StaticBlock: BODY,
+  SwitchCase: freeze(["test", "consequent"]),
+  SwitchStatement: freeze(["discriminant", "cases"]),
+  TaggedTemplateExpression: freeze(["tag", "typeArguments", "quasi"]),
+  TemplateLiteral: freeze(["quasis", "expressions"]),
+  ThrowStatement: ARGUMENT,
+  TryStatement: freeze(["block", "handler", "finalizer"]),
+  UnaryExpression: ARGUMENT,
+  UpdateExpression: ARGUMENT,
+  V8IntrinsicExpression: freeze(["name", "arguments"]),
+  VariableDeclaration: freeze(["declarations"]),
+  VariableDeclarator: freeze(["id", "init"]),
+  WhileStatement: freeze(["test", "body"]),
+  WithStatement: freeze(["object", "body"]),
+  YieldExpression: ARGUMENT,
+  JSXAttribute: freeze(["name", "value"]),
+  JSXClosingElement: freeze(["name"]),
+  JSXElement: freeze(["openingElement", "children", "closingElement"]),
+  JSXExpressionContainer: EXPRESSION,
+  JSXFragment: freeze(["openingFragment", "children", "closingFragment"]),
+  JSXMemberExpression: OBJECT__PROPERTY,
+  JSXNamespacedName: freeze(["namespace", "name"]),
+  JSXOpeningElement: freeze(["name", "typeArguments", "attributes"]),
+  JSXSpreadAttribute: ARGUMENT,
+  JSXSpreadChild: EXPRESSION,
+  TSAbstractAccessorProperty: DECORATORS__KEY__TYPE_ANNOTATION,
+  TSAbstractMethodDefinition: KEY__VALUE,
+  TSAbstractPropertyDefinition: DECORATORS__KEY__TYPE_ANNOTATION,
+  TSArrayType: freeze(["elementType"]),
+  TSAsExpression: EXPRESSION__TYPE_ANNOTATION,
+  TSCallSignatureDeclaration: TYPE_PARAMETERS__PARAMS__RETURN_TYPE,
+  TSClassImplements: EXPRESSION__TYPE_ARGUMENTS,
+  TSConditionalType: freeze(["checkType", "extendsType", "trueType", "falseType"]),
+  TSConstructSignatureDeclaration: TYPE_PARAMETERS__PARAMS__RETURN_TYPE,
+  TSConstructorType: TYPE_PARAMETERS__PARAMS__RETURN_TYPE,
+  TSDeclareFunction: ID__TYPE_PARAMETERS__PARAMS__RETURN_TYPE__BODY,
+  TSEmptyBodyFunctionExpression: freeze(["id", "typeParameters", "params", "returnType"]),
+  TSEnumBody: MEMBERS,
+  TSEnumDeclaration: ID__BODY,
+  TSEnumMember: freeze(["id", "initializer"]),
+  TSExportAssignment: EXPRESSION,
+  TSExternalModuleReference: EXPRESSION,
+  TSFunctionType: TYPE_PARAMETERS__PARAMS__RETURN_TYPE,
+  TSImportEqualsDeclaration: freeze(["id", "moduleReference"]),
+  TSImportType: freeze(["argument", "options", "qualifier", "typeArguments"]),
+  TSIndexSignature: freeze(["parameters", "typeAnnotation"]),
+  TSIndexedAccessType: freeze(["objectType", "indexType"]),
+  TSInferType: freeze(["typeParameter"]),
+  TSInstantiationExpression: EXPRESSION__TYPE_ARGUMENTS,
+  TSInterfaceBody: BODY,
+  TSInterfaceDeclaration: freeze(["id", "typeParameters", "extends", "body"]),
+  TSInterfaceHeritage: EXPRESSION__TYPE_ARGUMENTS,
+  TSIntersectionType: TYPES,
+  TSJSDocNonNullableType: TYPE_ANNOTATION,
+  TSJSDocNullableType: TYPE_ANNOTATION,
+  TSLiteralType: freeze(["literal"]),
+  TSMappedType: freeze(["key", "constraint", "nameType", "typeAnnotation"]),
+  TSMethodSignature: freeze(["key", "typeParameters", "params", "returnType"]),
+  TSModuleBlock: BODY,
+  TSModuleDeclaration: ID__BODY,
+  TSNamedTupleMember: freeze(["label", "elementType"]),
+  TSNamespaceExportDeclaration: freeze(["id"]),
+  TSNonNullExpression: EXPRESSION,
+  TSOptionalType: TYPE_ANNOTATION,
+  TSParameterProperty: freeze(["decorators", "parameter"]),
+  TSParenthesizedType: TYPE_ANNOTATION,
+  TSPropertySignature: freeze(["key", "typeAnnotation"]),
+  TSQualifiedName: LEFT__RIGHT,
+  TSRestType: TYPE_ANNOTATION,
+  TSSatisfiesExpression: EXPRESSION__TYPE_ANNOTATION,
+  TSTemplateLiteralType: freeze(["quasis", "types"]),
+  TSTupleType: freeze(["elementTypes"]),
+  TSTypeAliasDeclaration: freeze(["id", "typeParameters", "typeAnnotation"]),
+  TSTypeAnnotation: TYPE_ANNOTATION,
+  TSTypeAssertion: freeze(["typeAnnotation", "expression"]),
+  TSTypeLiteral: MEMBERS,
+  TSTypeOperator: TYPE_ANNOTATION,
+  TSTypeParameter: freeze(["name", "constraint", "default"]),
+  TSTypeParameterDeclaration: PARAMS,
+  TSTypeParameterInstantiation: PARAMS,
+  TSTypePredicate: freeze(["parameterName", "typeAnnotation"]),
+  TSTypeQuery: freeze(["exprName", "typeArguments"]),
+  TSTypeReference: freeze(["typeName", "typeArguments"]),
+  TSUnionType: TYPES
+});
+// node_modules/oxc-parser/src-js/visit/index.js
+import { createRequire as createRequire2 } from "node:module";
+var walkProgram = null;
+var addVisitorToCompiled;
+var createCompiledVisitor;
+var finalizeCompiledVisitor;
+
+class Visitor {
+  #compiledVisitor = null;
+  constructor(visitor) {
+    if (walkProgram === null) {
+      const require3 = createRequire2(import.meta.url);
+      ({ walkProgram } = require3("../../generated/visit/walk.js"));
+      ({
+        addVisitorToCompiled,
+        createCompiledVisitor,
+        finalizeCompiledVisitor
+      } = require3("./visitor.js"));
+    }
+    const compiledVisitor = createCompiledVisitor();
+    addVisitorToCompiled(visitor);
+    const needsVisit = finalizeCompiledVisitor();
+    if (needsVisit)
+      this.#compiledVisitor = compiledVisitor;
+  }
+  visit(program) {
+    const compiledVisitor = this.#compiledVisitor;
+    if (compiledVisitor !== null)
+      walkProgram(program, compiledVisitor);
+  }
+}
+
+// node_modules/oxc-parser/src-js/index.js
+var require3 = createRequire3(import.meta.url);
+var parseSyncRaw = null;
+var parseRaw;
+var parseSyncLazy = null;
+var parseLazy;
+var LazyVisitor;
+function loadRawTransfer() {
+  if (parseSyncRaw === null) {
+    ({ parseSyncRaw, parse: parseRaw } = require3("./raw-transfer/eager.js"));
+  }
+}
+function loadRawTransferLazy() {
+  if (parseSyncLazy === null) {
+    ({ parseSyncLazy, parse: parseLazy, Visitor: LazyVisitor } = require3("./raw-transfer/lazy.js"));
+  }
+}
+function parseSync2(filename, sourceText, options3) {
+  if (options3?.experimentalRawTransfer) {
+    loadRawTransfer();
+    return parseSyncRaw(filename, sourceText, options3);
+  }
+  if (options3?.experimentalLazy) {
+    loadRawTransferLazy();
+    return parseSyncLazy(filename, sourceText, options3);
+  }
+  return wrap(parseSync(filename, sourceText, options3));
+}
+
+// src/recognizers/detector.ts
+function recognize(detector, line) {
+  const matches = detector.scan(line);
+  if (matches === 0)
+    return 0;
+  return 1 - (1 - detector.probability) ** matches;
+}
+
+// src/recognizers/code-recognizer.ts
+var PROBABILITY_THRESHOLD = 0.9;
+function computeProbability(detectors, line) {
+  let probability = 0;
+  for (const detector of detectors) {
+    const detected = recognize(detector, line);
+    probability = 1 - (1 - probability) * (1 - detected);
+  }
+  return probability;
+}
+function isLikelyCode(detectors, line) {
+  return computeProbability(detectors, line) >= PROBABILITY_THRESHOLD;
+}
+function hasCodeLines(detectors, lines) {
+  return lines.some((line) => isLikelyCode(detectors, line));
+}
+
+// src/recognizers/camel-case-detector.ts
+function createCamelCaseDetector(probability) {
+  return {
+    probability,
+    scan(line) {
+      for (let index2 = 0;index2 < line.length - 1; index2 += 1) {
+        const current = line.charAt(index2);
+        const next = line.charAt(index2 + 1);
+        if (current === current.toLowerCase() && next === next.toUpperCase() && next !== next.toLowerCase()) {
+          return 1;
+        }
+      }
+      return 0;
+    }
+  };
+}
+
+// src/recognizers/contains-detector.ts
+var WHITESPACE_GLOBAL_REGEX = /\s+/g;
+var ESCAPE = /[-/\\^$*+?.()|[\]{}]/g;
+function escapeForRegex(value) {
+  return value.replaceAll(ESCAPE, String.raw`\$&`);
+}
+function createContainsDetector(probability, patterns2) {
+  const compiledPatterns = patterns2.map((pattern4) => typeof pattern4 === "string" ? new RegExp(escapeForRegex(pattern4), "g") : new RegExp(pattern4.source, "g"));
+  return {
+    probability,
+    scan(line) {
+      const compressed = line.replace(WHITESPACE_GLOBAL_REGEX, "");
+      let total = 0;
+      for (const pattern4 of compiledPatterns) {
+        pattern4.lastIndex = 0;
+        const matches = compressed.match(pattern4);
+        if (matches)
+          total += matches.length;
+      }
+      return total;
+    }
+  };
+}
+
+// src/recognizers/end-with-detector.ts
+var WHITESPACE_REGEX = /\s/;
+function createEndWithDetector(probability, endings) {
+  const endingsSet = new Set(endings);
+  return {
+    probability,
+    scan(line) {
+      for (let index2 = line.length - 1;index2 >= 0; index2 -= 1) {
+        const char = line.charAt(index2);
+        if (endingsSet.has(char))
+          return 1;
+        if (!WHITESPACE_REGEX.test(char) && char !== "*" && char !== "/")
+          return 0;
+      }
+      return 0;
+    }
+  };
+}
+
+// src/recognizers/keywords-detector.ts
+var WORD_SPLIT_REGEX = /[ \t(),{}]/;
+function createKeywordsDetector(probability, keywords) {
+  const keywordsSet = new Set(keywords);
+  return {
+    probability,
+    scan(line) {
+      const words = line.split(WORD_SPLIT_REGEX);
+      let count = 0;
+      for (const word of words)
+        if (keywordsSet.has(word))
+          count += 1;
+      return count;
+    }
+  };
+}
+
+// src/recognizers/javascript-footprint.ts
+var JS_KEYWORDS = [
+  "public",
+  "abstract",
+  "class",
+  "implements",
+  "extends",
+  "return",
+  "throw",
+  "private",
+  "protected",
+  "enum",
+  "continue",
+  "assert",
+  "boolean",
+  "this",
+  "instanceof",
+  "interface",
+  "static",
+  "void",
+  "super",
+  "true",
+  "case:",
+  "let",
+  "const",
+  "var",
+  "async",
+  "await",
+  "break",
+  "yield",
+  "typeof",
+  "import",
+  "export"
+];
+var OPERATORS2 = ["++", "||", "&&", "===", "?.", "??"];
+var CODE_PATTERNS = [
+  "for(",
+  "if(",
+  "while(",
+  "catch(",
+  "switch(",
+  "try{",
+  "else{",
+  "this.",
+  "window.",
+  /;\s+\/\//,
+  "import '",
+  'import "',
+  "require("
+];
+var LINE_ENDINGS = ["}", ";", "{"];
+function createJavaScriptDetectors() {
+  return [
+    createEndWithDetector(0.95, LINE_ENDINGS),
+    createKeywordsDetector(0.7, OPERATORS2),
+    createKeywordsDetector(0.3, JS_KEYWORDS),
+    createContainsDetector(0.95, CODE_PATTERNS),
+    createCamelCaseDetector(0.5)
+  ];
+}
+
+// src/rules/no-commented-code.ts
+var EXCLUDED_STATEMENTS = new Set(["BreakStatement", "LabeledStatement", "ContinueStatement"]);
+var detectors = createJavaScriptDetectors();
+function isCommentWithLocation(comment) {
+  return comment.loc !== undefined && comment.range !== undefined;
+}
+function areAdjacentLineComments(previous, next, sourceCode) {
+  const previousLine = previous.loc.start.line;
+  const nextLine = next.loc.start.line;
+  if (previousLine + 1 !== nextLine)
+    return false;
+  const commentForApi = {
+    loc: previous.loc,
+    range: previous.range,
+    type: previous.type,
+    value: previous.value
+  };
+  const tokenAfterPrevious = sourceCode.getTokenAfter(commentForApi);
+  return !tokenAfterPrevious || tokenAfterPrevious.loc.start.line > nextLine;
+}
+function groupComments(comments, sourceCode) {
+  const groups = new Array;
+  let groupsSize = 0;
+  let currentLineComments = new Array;
+  let size = 0;
+  for (const comment of comments) {
+    if (!isCommentWithLocation(comment))
+      continue;
+    if (comment.type === "Block") {
+      if (size > 0) {
+        groups[groupsSize++] = {
+          comments: currentLineComments,
+          value: currentLineComments.map((c) => c.value).join(`
+`)
+        };
+        currentLineComments = [];
+        size = 0;
+      }
+      groups[groupsSize++] = {
+        comments: [comment],
+        value: comment.value
+      };
+    } else if (size === 0)
+      currentLineComments[size++] = comment;
+    else {
+      const lastComment = currentLineComments.at(-1);
+      if (lastComment && areAdjacentLineComments(lastComment, comment, sourceCode)) {
+        currentLineComments[size++] = comment;
+      } else {
+        groups[groupsSize++] = {
+          comments: currentLineComments,
+          value: currentLineComments.map(({ value }) => value).join(`
+`)
+        };
+        currentLineComments = [comment];
+        size = 1;
+      }
+    }
+  }
+  if (size > 0) {
+    groups[groupsSize++] = {
+      comments: currentLineComments,
+      value: currentLineComments.map(({ value }) => value).join(`
+`)
+    };
+  }
+  return groups;
+}
+function injectMissingBraces(value) {
+  const openCount = (value.match(/{/g) ?? []).length;
+  const closeCount = (value.match(/}/g) ?? []).length;
+  const diff2 = openCount - closeCount;
+  if (diff2 > 0)
+    return value + "}".repeat(diff2);
+  if (diff2 < 0)
+    return "{".repeat(-diff2) + value;
+  return value;
+}
+function couldBeJsCode(input) {
+  const lines = input.split(`
+`);
+  return hasCodeLines(detectors, lines);
+}
+function isReturnOrThrowExclusion(statement) {
+  if (statement.type !== "ReturnStatement" && statement.type !== "ThrowStatement")
+    return false;
+  return statement.argument === undefined || statement.argument.type === "Identifier";
+}
+function isUnaryPlusMinus(expression) {
+  return expression.type === "UnaryExpression" && (expression.operator === "+" || expression.operator === "-");
+}
+function isExcludedLiteral(expression) {
+  if (expression.type !== "Literal")
+    return false;
+  return typeof expression.value === "string" || typeof expression.value === "number";
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== undefined;
+}
+function isParsedStatement(value) {
+  if (!isRecord2(value))
+    return false;
+  return typeof value.type === "string";
+}
+function toParsedStatements(body) {
+  const result = [];
+  for (const item of body) {
+    if (isParsedStatement(item))
+      result.push(item);
+  }
+  return result;
+}
+function isExpressionExclusion(statement, codeText) {
+  if (statement.type !== "ExpressionStatement")
+    return false;
+  const expression = statement.expression;
+  if (!expression)
+    return false;
+  if (expression.type === "Identifier")
+    return true;
+  if (expression.type === "SequenceExpression")
+    return true;
+  if (isUnaryPlusMinus(expression))
+    return true;
+  if (isExcludedLiteral(expression))
+    return true;
+  if (!codeText.trimEnd().endsWith(";"))
+    return true;
+  return false;
+}
+function isExclusion(statements, codeText) {
+  if (statements.length !== 1)
+    return false;
+  const statement = statements.at(0);
+  if (!statement)
+    return false;
+  if (EXCLUDED_STATEMENTS.has(statement.type))
+    return true;
+  if (isReturnOrThrowExclusion(statement))
+    return true;
+  if (isExpressionExclusion(statement, codeText))
+    return true;
+  return false;
+}
+var ALLOWED_PARSE_ERROR_PATTERNS = [/A 'return' statement can only be used within a function body/];
+function hasOnlyAllowedErrors(errors4) {
+  return errors4.every((error2) => ALLOWED_PARSE_ERROR_PATTERNS.some((pattern4) => pattern4.test(error2.message)));
+}
+function isValidParseResult(result) {
+  const hasValidErrors = result.errors.length === 0 || hasOnlyAllowedErrors(result.errors);
+  return hasValidErrors && result.program.body.length > 0;
+}
+function tryParse(value, filename) {
+  const ext = path.extname(filename);
+  const parseFilename = `file${ext || ".js"}`;
+  const result = parseSync2(parseFilename, value);
+  if (isValidParseResult(result))
+    return result;
+  if (ext !== ".tsx" && ext !== ".jsx") {
+    const jsxResult = parseSync2("file.tsx", value);
+    if (isValidParseResult(jsxResult))
+      return jsxResult;
+  }
+  return;
+}
+function containsCode(value, filename) {
+  if (!couldBeJsCode(value))
+    return false;
+  try {
+    const result = tryParse(value, filename);
+    if (!result)
+      return false;
+    const statements = toParsedStatements(result.program.body);
+    return !isExclusion(statements, value);
+  } catch {
+    return false;
+  }
+}
+var noCommentedCode = {
+  create(context) {
+    return {
+      "Program:exit"() {
+        const allComments = context.sourceCode.getAllComments();
+        const groups = groupComments(allComments, context.sourceCode);
+        for (const group of groups) {
+          const trimmedValue = group.value.trim();
+          if (trimmedValue === "}")
+            continue;
+          const balanced = injectMissingBraces(trimmedValue);
+          if (containsCode(balanced, context.filename)) {
+            const firstComment = group.comments.at(0);
+            const lastComment = group.comments.at(-1);
+            if (!firstComment || !lastComment)
+              continue;
+            context.report({
+              loc: {
+                end: lastComment.loc.end,
+                start: firstComment.loc.start
+              },
+              messageId: "commentedCode",
+              suggest: [
+                {
+                  desc: "Remove this commented out code",
+                  fix(fixer) {
+                    return fixer.removeRange([firstComment.range[0], lastComment.range[1]]);
+                  }
+                }
+              ]
+            });
+          }
+        }
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Disallow commented-out code",
+      recommended: false
+    },
+    hasSuggestions: true,
+    messages: {
+      commentedCode: "Remove this commented out code."
+    },
+    schema: [],
+    type: "suggestion"
+  }
+};
+var no_commented_code_default = noCommentedCode;
+
 // src/rules/use-hook-at-top-level.ts
 import { TSESTree as TSESTree10 } from "@typescript-eslint/types";
 var HOOK_NAME_PATTERN = /^use[A-Z]/;
@@ -11790,6 +13073,7 @@ var rules = {
   "enforce-ianitor-check-type": enforce_ianitor_check_type_default,
   "no-async-constructor": no_async_constructor_default,
   "no-color3-constructor": no_color3_constructor_default,
+  "no-commented-code": no_commented_code_default,
   "no-instance-methods-without-this": no_instance_methods_without_this_default,
   "no-print": no_print_default,
   "no-shorthand-names": no_shorthand_names_default,
@@ -11846,4 +13130,4 @@ export {
   createBanInstancesOptions
 };
 
-//# debugId=734DB8BE5C92D79464756E2164756E21
+//# debugId=F981FE172662E0F564756E2164756E21