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

package/dist/index.js

@@ -8420,6 +8420,214 @@ var enforceIanitorCheckType = createRule({
 });
 var enforce_ianitor_check_type_default = enforceIanitorCheckType;
 
+// src/rules/no-async-constructor.ts
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
+var PROMISE_CHAIN_METHODS = new Set(["then", "catch", "finally"]);
+function isNode(value) {
+  return typeof value === "object" && value !== null && "type" in value;
+}
+function hasDynamicProperties(_node) {
+  return true;
+}
+function getAsyncMethodNames(classBody) {
+  const asyncMethods = new Set;
+  for (const element of classBody.body) {
+    if (element.type !== AST_NODE_TYPES.MethodDefinition)
+      continue;
+    if (element.kind !== "method")
+      continue;
+    if (!element.value.async)
+      continue;
+    if (element.key.type === AST_NODE_TYPES.Identifier)
+      asyncMethods.add(element.key.name);
+  }
+  return asyncMethods;
+}
+function isPromiseChainCall(node) {
+  if (node.callee.type !== AST_NODE_TYPES.MemberExpression)
+    return false;
+  const { property } = node.callee;
+  if (property.type !== AST_NODE_TYPES.Identifier)
+    return false;
+  return PROMISE_CHAIN_METHODS.has(property.name);
+}
+function isAsyncIIFE(node) {
+  const { callee } = node;
+  if (callee.type === AST_NODE_TYPES.ArrowFunctionExpression && callee.async)
+    return true;
+  if (callee.type === AST_NODE_TYPES.FunctionExpression && callee.async)
+    return true;
+  return false;
+}
+function isThisAsyncMethodCall(node, asyncMethods) {
+  const { callee } = node;
+  if (callee.type !== AST_NODE_TYPES.MemberExpression)
+    return;
+  if (callee.object.type !== AST_NODE_TYPES.ThisExpression)
+    return;
+  if (callee.property.type !== AST_NODE_TYPES.Identifier)
+    return;
+  const methodName = callee.property.name;
+  return asyncMethods.has(methodName) ? methodName : undefined;
+}
+function isAssignedToThisProperty(node, parent) {
+  if (!parent)
+    return false;
+  if (parent.type !== AST_NODE_TYPES.AssignmentExpression)
+    return false;
+  if (parent.right !== node)
+    return false;
+  const { left } = parent;
+  return left.type === AST_NODE_TYPES.MemberExpression && left.object.type === AST_NODE_TYPES.ThisExpression;
+}
+function getLocalVariableAssignment(node, parent) {
+  if (!parent)
+    return;
+  if (parent.type !== AST_NODE_TYPES.VariableDeclarator)
+    return;
+  if (parent.init !== node)
+    return;
+  if (parent.id.type !== AST_NODE_TYPES.Identifier)
+    return;
+  return parent.id.name;
+}
+function isExpressionStatement(parent) {
+  return parent?.type === AST_NODE_TYPES.ExpressionStatement;
+}
+function checkAsyncMethodCall(current, parent, asyncMethods) {
+  const asyncMethodName = isThisAsyncMethodCall(current, asyncMethods);
+  if (asyncMethodName === undefined)
+    return;
+  if (isAssignedToThisProperty(current, parent))
+    return;
+  if (isExpressionStatement(parent)) {
+    return {
+      data: { methodName: asyncMethodName },
+      messageId: "unhandledAsyncCall",
+      node: current
+    };
+  }
+  const variableName = getLocalVariableAssignment(current, parent);
+  if (variableName !== undefined) {
+    return {
+      data: { variableName },
+      messageId: "orphanedPromise",
+      node: current
+    };
+  }
+  return;
+}
+function isNonIIFEFunction(node, parent) {
+  if (node.type !== AST_NODE_TYPES.ArrowFunctionExpression && node.type !== AST_NODE_TYPES.FunctionExpression) {
+    return false;
+  }
+  if (parent?.type === AST_NODE_TYPES.CallExpression && parent.callee === node) {
+    return false;
+  }
+  return true;
+}
+function findConstructorViolations(constructorBody, asyncMethods) {
+  const violations = new Array;
+  let size = 0;
+  const visited2 = new WeakSet;
+  const parentMap = new WeakMap;
+  function traverse(current) {
+    if (visited2.has(current))
+      return;
+    visited2.add(current);
+    const parent = parentMap.get(current);
+    if (isNonIIFEFunction(current, parent))
+      return;
+    if (current.type === AST_NODE_TYPES.AwaitExpression) {
+      violations[size++] = { messageId: "awaitInConstructor", node: current };
+    }
+    if (current.type === AST_NODE_TYPES.CallExpression) {
+      if (isPromiseChainCall(current)) {
+        violations[size++] = { messageId: "promiseChainInConstructor", node: current };
+      }
+      if (isAsyncIIFE(current))
+        violations[size++] = { messageId: "asyncIifeInConstructor", node: current };
+      const asyncViolation = checkAsyncMethodCall(current, parent, asyncMethods);
+      if (asyncViolation)
+        violations[size++] = asyncViolation;
+    }
+    if (!hasDynamicProperties(current))
+      return;
+    for (const key in current) {
+      const childValue = current[key];
+      if (childValue === undefined)
+        continue;
+      if (Array.isArray(childValue)) {
+        for (const item of childValue) {
+          if (!isNode(item))
+            continue;
+          parentMap.set(item, current);
+          traverse(item);
+        }
+        continue;
+      }
+      if (!isNode(childValue))
+        continue;
+      parentMap.set(childValue, current);
+      traverse(childValue);
+    }
+  }
+  traverse(constructorBody);
+  return violations;
+}
+function reportViolation(context, violation) {
+  if (violation.data) {
+    context.report({
+      data: violation.data,
+      messageId: violation.messageId,
+      node: violation.node
+    });
+    return;
+  }
+  context.report({
+    messageId: violation.messageId,
+    node: violation.node
+  });
+}
+var noAsyncConstructor = {
+  create(context) {
+    return {
+      "MethodDefinition[kind='constructor']"(node) {
+        const constructorValue = node.value;
+        if (constructorValue.type !== AST_NODE_TYPES.FunctionExpression)
+          return;
+        const { body } = constructorValue;
+        if (body.type !== AST_NODE_TYPES.BlockStatement)
+          return;
+        const classNode = node.parent;
+        if (classNode.type !== AST_NODE_TYPES.ClassBody)
+          return;
+        const asyncMethods = getAsyncMethodNames(classNode);
+        const violations = findConstructorViolations(body, asyncMethods);
+        for (const violation of violations)
+          reportViolation(context, violation);
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Disallow asynchronous operations inside class constructors. Constructors return immediately, " + "so async work causes race conditions, unhandled rejections, and incomplete object states.",
+      recommended: true
+    },
+    messages: {
+      asyncIifeInConstructor: "Refactor this asynchronous operation outside of the constructor. " + "Async IIFEs create unhandled promises and incomplete object state.",
+      awaitInConstructor: "Refactor this asynchronous operation outside of the constructor. " + "Using 'await' in a constructor causes the class to be instantiated before the async operation completes.",
+      orphanedPromise: "Refactor this asynchronous operation outside of the constructor. " + "Promise assigned to '{{variableName}}' is never consumed - errors will be silently swallowed.",
+      promiseChainInConstructor: "Refactor this asynchronous operation outside of the constructor. " + "Promise chains (.then/.catch/.finally) in constructors lead to race conditions.",
+      unhandledAsyncCall: "Refactor this asynchronous operation outside of the constructor. " + "Calling async method '{{methodName}}' without handling its result creates uncontrolled async behavior."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var no_async_constructor_default = noAsyncConstructor;
+
 // src/rules/no-color3-constructor.ts
 import { TSESTree as TSESTree4 } from "@typescript-eslint/types";
 var isNumericLiteralNode = Compile(build_default.Object({
@@ -8496,7 +8704,7 @@ var noColor3Constructor = {
 var no_color3_constructor_default = noColor3Constructor;
 
 // src/rules/no-instance-methods-without-this.ts
-import { AST_NODE_TYPES } from "@typescript-eslint/types";
+import { AST_NODE_TYPES as AST_NODE_TYPES2 } from "@typescript-eslint/types";
 var DEFAULT_OPTIONS = {
   checkPrivate: true,
   checkProtected: true,
@@ -8526,19 +8734,19 @@ function shouldCheckMethod(node, options3) {
     return false;
   return true;
 }
-function isNode(value) {
+function isNode2(value) {
   return typeof value === "object" && value !== null && "type" in value;
 }
-function hasDynamicProperties(_node) {
+function hasDynamicProperties2(_node) {
   return true;
 }
 function traverseForThis(currentNode, visited2) {
   if (visited2.has(currentNode))
     return false;
   visited2.add(currentNode);
-  if (currentNode.type === AST_NODE_TYPES.ThisExpression || currentNode.type === AST_NODE_TYPES.Super)
+  if (currentNode.type === AST_NODE_TYPES2.ThisExpression || currentNode.type === AST_NODE_TYPES2.Super)
     return true;
-  if (!hasDynamicProperties(currentNode))
+  if (!hasDynamicProperties2(currentNode))
     return false;
   for (const key in currentNode) {
     const childValue = currentNode[key];
@@ -8546,18 +8754,18 @@ function traverseForThis(currentNode, visited2) {
       continue;
     if (Array.isArray(childValue)) {
       for (const item of childValue)
-        if (isNode(item) && traverseForThis(item, visited2))
+        if (isNode2(item) && traverseForThis(item, visited2))
           return true;
       continue;
     }
-    if (isNode(childValue) && traverseForThis(childValue, visited2))
+    if (isNode2(childValue) && traverseForThis(childValue, visited2))
       return true;
   }
   return false;
 }
 function methodUsesThis(node) {
   const value = node.value;
-  if (value === undefined || value.type !== AST_NODE_TYPES.FunctionExpression)
+  if (value === undefined || value.type !== AST_NODE_TYPES2.FunctionExpression)
     return false;
   return traverseForThis(value, new WeakSet);
 }
@@ -8571,7 +8779,7 @@ var noInstanceMethodsWithoutThis = {
           return;
         if (methodUsesThis(node))
           return;
-        const methodName = node.key.type === AST_NODE_TYPES.Identifier ? node.key.name : "unknown";
+        const methodName = node.key.type === AST_NODE_TYPES2.Identifier ? node.key.name : "unknown";
         context.report({
           data: { methodName },
           messageId: "noInstanceMethodWithoutThis",
@@ -8769,13 +8977,13 @@ var noWarn = {
 var no_warn_default = noWarn;
 
 // src/rules/prefer-sequence-overloads.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES2 } from "@typescript-eslint/types";
+import { AST_NODE_TYPES as AST_NODE_TYPES3 } from "@typescript-eslint/types";
 var sequenceDescriptors = [
   { keypointName: "ColorSequenceKeypoint", sequenceName: "ColorSequence" },
   { keypointName: "NumberSequenceKeypoint", sequenceName: "NumberSequence" }
 ];
 function isSequenceIdentifier(node) {
-  if (node.type !== AST_NODE_TYPES2.Identifier)
+  if (node.type !== AST_NODE_TYPES3.Identifier)
     return false;
   for (const { sequenceName } of sequenceDescriptors)
     if (sequenceName === node.name)
@@ -8789,16 +8997,16 @@ function findDescriptor(sequenceName) {
   return;
 }
 var isNumericLiteral = Compile(build_default.Object({
-  type: build_default.Literal(AST_NODE_TYPES2.Literal),
+  type: build_default.Literal(AST_NODE_TYPES3.Literal),
   value: build_default.Number()
 }));
 function isExpressionArgument(argument) {
-  return argument !== undefined && argument.type !== AST_NODE_TYPES2.SpreadElement;
+  return argument !== undefined && argument.type !== AST_NODE_TYPES3.SpreadElement;
 }
 function extractKeypoint(element, descriptor) {
-  if (element === undefined || element.type !== AST_NODE_TYPES2.NewExpression)
+  if (element === undefined || element.type !== AST_NODE_TYPES3.NewExpression)
     return;
-  if (element.callee.type !== AST_NODE_TYPES2.Identifier || element.callee.name !== descriptor.keypointName)
+  if (element.callee.type !== AST_NODE_TYPES3.Identifier || element.callee.name !== descriptor.keypointName)
     return;
   if (element.arguments.length !== 2)
     return;
@@ -8828,7 +9036,7 @@ var preferSequenceOverloads = {
         if (descriptor === undefined || node.arguments.length !== 1)
           return;
         const [argument] = node.arguments;
-        if (argument === undefined || argument.type !== AST_NODE_TYPES2.ArrayExpression || argument.elements.length !== 2)
+        if (argument === undefined || argument.type !== AST_NODE_TYPES3.ArrayExpression || argument.elements.length !== 2)
           return;
         const firstElement = argument.elements[0] ?? undefined;
         const secondElement = argument.elements[1] ?? undefined;
@@ -9368,7 +9576,7 @@ var requireNamedEffectFunctions = {
 var require_named_effect_functions_default = requireNamedEffectFunctions;
 
 // src/rules/require-paired-calls.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES3 } from "@typescript-eslint/types";
+import { AST_NODE_TYPES as AST_NODE_TYPES4 } from "@typescript-eslint/types";
 var isStringArray = Compile(build_default.Readonly(build_default.Array(build_default.String())));
 var isPairConfiguration = Compile(build_default.Readonly(build_default.Object({
   alternatives: build_default.Optional(isStringArray),
@@ -9386,20 +9594,20 @@ var isRuleOptions3 = Compile(build_default.Partial(build_default.Readonly(build_
   pairs: build_default.Readonly(build_default.Array(isPairConfiguration))
 }))));
 var LOOP_NODE_TYPES = new Set([
-  AST_NODE_TYPES3.DoWhileStatement,
-  AST_NODE_TYPES3.ForInStatement,
-  AST_NODE_TYPES3.ForOfStatement,
-  AST_NODE_TYPES3.ForStatement,
-  AST_NODE_TYPES3.WhileStatement
+  AST_NODE_TYPES4.DoWhileStatement,
+  AST_NODE_TYPES4.ForInStatement,
+  AST_NODE_TYPES4.ForOfStatement,
+  AST_NODE_TYPES4.ForStatement,
+  AST_NODE_TYPES4.WhileStatement
 ]);
 var DEFAULT_ROBLOX_YIELDING_FUNCTIONS = ["task.wait", "wait", "*.WaitForChild", "*.*Async"];
 function getCallName(node) {
   const { callee } = node;
-  if (callee.type === AST_NODE_TYPES3.Identifier)
+  if (callee.type === AST_NODE_TYPES4.Identifier)
     return callee.name;
-  if (callee.type === AST_NODE_TYPES3.MemberExpression) {
-    const object3 = callee.object.type === AST_NODE_TYPES3.Identifier ? callee.object.name : undefined;
-    const property = callee.property.type === AST_NODE_TYPES3.Identifier ? callee.property.name : undefined;
+  if (callee.type === AST_NODE_TYPES4.MemberExpression) {
+    const object3 = callee.object.type === AST_NODE_TYPES4.Identifier ? callee.object.name : undefined;
+    const property = callee.property.type === AST_NODE_TYPES4.Identifier ? callee.property.name : undefined;
     if (object3 !== undefined && property !== undefined)
       return `${object3}.${property}`;
   }
@@ -9435,12 +9643,12 @@ function isLoopLikeStatement(node) {
   return LOOP_NODE_TYPES.has(node.type);
 }
 function isSwitchStatement(node) {
-  return node?.type === AST_NODE_TYPES3.SwitchStatement;
+  return node?.type === AST_NODE_TYPES4.SwitchStatement;
 }
 function findLabeledStatementBody(label, startingNode) {
   let current = startingNode;
   while (current) {
-    if (current.type === AST_NODE_TYPES3.LabeledStatement && current.label.name === label.name)
+    if (current.type === AST_NODE_TYPES4.LabeledStatement && current.label.name === label.name)
       return current.body;
     current = current.parent ?? undefined;
   }
@@ -9693,7 +9901,7 @@ var rule = {
     function onIfConsequentExit(node) {
       const consequentNode = node;
       const parent = consequentNode.parent;
-      if (parent?.type === AST_NODE_TYPES3.IfStatement) {
+      if (parent?.type === AST_NODE_TYPES4.IfStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -9708,7 +9916,7 @@ var rule = {
     function onIfAlternateExit(node) {
       const alternateNode = node;
       const parent = alternateNode.parent;
-      if (parent?.type === AST_NODE_TYPES3.IfStatement) {
+      if (parent?.type === AST_NODE_TYPES4.IfStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -9757,7 +9965,7 @@ var rule = {
     function onTryBlockExit(node) {
       const blockNode = node;
       const { parent } = blockNode;
-      if (parent?.type === AST_NODE_TYPES3.TryStatement) {
+      if (parent?.type === AST_NODE_TYPES4.TryStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -9776,7 +9984,7 @@ var rule = {
     function onCatchClauseExit(node) {
       const catchNode = node;
       const { parent } = catchNode;
-      if (parent?.type === AST_NODE_TYPES3.TryStatement) {
+      if (parent?.type === AST_NODE_TYPES4.TryStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -9839,7 +10047,7 @@ var rule = {
     function onSwitchCaseExit(node) {
       const caseNode = node;
       const { parent } = caseNode;
-      if (parent?.type === AST_NODE_TYPES3.SwitchStatement) {
+      if (parent?.type === AST_NODE_TYPES4.SwitchStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -9870,7 +10078,7 @@ var rule = {
       for (const { opener, config, node: node2 } of openerStack) {
         const validClosers = getValidClosers(config);
         const closer = validClosers.length === 1 ? validClosers[0] ?? "closer" : validClosers.join("' or '");
-        const statementType = statementNode.type === AST_NODE_TYPES3.ReturnStatement ? "return" : "throw";
+        const statementType = statementNode.type === AST_NODE_TYPES4.ReturnStatement ? "return" : "throw";
         const lineNumber = statementNode.loc?.start.line ?? 0;
         context.report({
           data: {
@@ -9887,7 +10095,7 @@ var rule = {
       const statementNode = node;
       if (openerStack.length === 0)
         return;
-      const targetLoop = statementNode.type === AST_NODE_TYPES3.ContinueStatement ? resolveContinueTargetLoop(statementNode) : resolveBreakTargetLoop(statementNode);
+      const targetLoop = statementNode.type === AST_NODE_TYPES4.ContinueStatement ? resolveContinueTargetLoop(statementNode) : resolveBreakTargetLoop(statementNode);
       if (!targetLoop)
         return;
       for (const { node: openerNode, config, opener, loopAncestors } of openerStack) {
@@ -9895,7 +10103,7 @@ var rule = {
           continue;
         const validClosers = getValidClosers(config);
         const closer = validClosers.length === 1 ? validClosers[0] ?? "closer" : validClosers.join("' or '");
-        const statementType = statementNode.type === AST_NODE_TYPES3.BreakStatement ? "break" : "continue";
+        const statementType = statementNode.type === AST_NODE_TYPES4.BreakStatement ? "break" : "continue";
         const lineNumber = statementNode.loc?.start.line ?? 0;
         context.report({
           data: {
@@ -10033,7 +10241,7 @@ var rule = {
           continue;
         const validClosers = getValidClosers(config);
         const closer = validClosers.length === 1 ? validClosers[0] ?? "closer" : validClosers.join("' or '");
-        const asyncType = asyncNode.type === AST_NODE_TYPES3.AwaitExpression ? "await" : "yield";
+        const asyncType = asyncNode.type === AST_NODE_TYPES4.AwaitExpression ? "await" : "yield";
         context.report({
           data: { asyncType, closer, opener },
           messageId: "asyncViolation",
@@ -11160,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]/;
@@ -11580,7 +13071,9 @@ var rules = {
   "ban-instances": ban_instances_default,
   "ban-react-fc": ban_react_fc_default,
   "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,
@@ -11602,6 +13095,7 @@ var recommended = {
   rules: {
     "cease-nonsense/ban-react-fc": "error",
     "cease-nonsense/enforce-ianitor-check-type": "error",
+    "cease-nonsense/no-async-constructor": "error",
     "cease-nonsense/no-color3-constructor": "error",
     "cease-nonsense/no-instance-methods-without-this": "error",
     "cease-nonsense/no-print": "error",
@@ -11636,4 +13130,4 @@ export {
   createBanInstancesOptions
 };
 
-//# debugId=42A0B9F9085ECD6764756E2164756E21
+//# debugId=F981FE172662E0F564756E2164756E21