oxclippy 0.1.0

package/dist/oxclippy.js

@@ -0,0 +1,2428 @@
+// src/types.ts
+function isLiteral(node, value) {
+  if (!node || node.type !== "Literal")
+    return false;
+  return value === undefined ? true : node.value === value;
+}
+function isBoolLiteral(node) {
+  return isLiteral(node) && typeof node.value === "boolean";
+}
+function isIdentifier(node, name) {
+  if (!node || node.type !== "Identifier")
+    return false;
+  return name === undefined ? true : node.name === name;
+}
+function isCallOf(node, object, method) {
+  if (node.type !== "CallExpression")
+    return false;
+  const callee = node.callee;
+  if (callee.type !== "MemberExpression")
+    return false;
+  return isIdentifier(callee.object, object) && isIdentifier(callee.property, method);
+}
+function isMethodCall(node, method) {
+  if (node.type !== "CallExpression")
+    return false;
+  const callee = node.callee;
+  return callee.type === "MemberExpression" && !callee.computed && isIdentifier(callee.property, method);
+}
+function unwrapBlock(node) {
+  if (!node)
+    return null;
+  if (node.type === "BlockStatement") {
+    return node.body.length === 1 ? node.body[0] : null;
+  }
+  return node;
+}
+function getFunctionBody(node) {
+  const body = node.body;
+  if (!body)
+    return null;
+  if (body.type === "BlockStatement")
+    return body.body;
+  return null;
+}
+function getForOfVar(node) {
+  const left = node.left;
+  if (left.type === "VariableDeclaration" && left.declarations.length === 1) {
+    const decl = left.declarations[0];
+    if (decl.id && decl.id.type === "Identifier")
+      return decl.id.name;
+  }
+  return null;
+}
+
+// src/rules/needless-bool.ts
+var needless_bool_default = {
+  create(context) {
+    return {
+      IfStatement(node) {
+        if (!node.alternate)
+          return;
+        const consequent = unwrapBlock(node.consequent);
+        const alternate = unwrapBlock(node.alternate);
+        if (!consequent || !alternate)
+          return;
+        if (consequent.type === "ReturnStatement" && alternate.type === "ReturnStatement") {
+          const cArg = consequent.argument;
+          const aArg = alternate.argument;
+          if (isBoolLiteral(cArg) && isBoolLiteral(aArg) && cArg.value !== aArg.value) {
+            const suggestion = cArg.value ? "return <condition>" : "return !<condition>";
+            context.report({
+              message: `Needless bool: this if/else returns opposing booleans. Simplify to \`${suggestion}\`. (clippy::needless_bool)`,
+              node
+            });
+          }
+          return;
+        }
+        if (consequent.type === "ExpressionStatement" && alternate.type === "ExpressionStatement" && consequent.expression.type === "AssignmentExpression" && alternate.expression.type === "AssignmentExpression" && consequent.expression.operator === "=" && alternate.expression.operator === "=") {
+          const cExpr = consequent.expression;
+          const aExpr = alternate.expression;
+          if (cExpr.left.type === "Identifier" && aExpr.left.type === "Identifier" && cExpr.left.name === aExpr.left.name && isBoolLiteral(cExpr.right) && isBoolLiteral(aExpr.right) && cExpr.right.value !== aExpr.right.value) {
+            const varName = cExpr.left.name;
+            const suggestion = cExpr.right.value ? `${varName} = <condition>` : `${varName} = !<condition>`;
+            context.report({
+              message: `Needless bool: this if/else assigns opposing booleans. Simplify to \`${suggestion}\`. (clippy::needless_bool)`,
+              node
+            });
+          }
+        }
+      }
+    };
+  }
+};
+
+// src/rules/collapsible-if.ts
+var collapsible_if_default = {
+  create(context) {
+    return {
+      IfStatement(node) {
+        if (node.alternate)
+          return;
+        const body = node.consequent;
+        if (!body)
+          return;
+        let inner = null;
+        if (body.type === "BlockStatement" && body.body.length === 1) {
+          inner = body.body[0];
+        } else if (body.type === "IfStatement") {
+          inner = body;
+        }
+        if (!inner || inner.type !== "IfStatement")
+          return;
+        if (inner.alternate)
+          return;
+        context.report({
+          message: "Collapsible if: these nested ifs can be combined with `&&`. (clippy::collapsible_if)",
+          node
+        });
+      }
+    };
+  }
+};
+
+// src/rules/neg-multiply.ts
+function isNegOne(node) {
+  if (node.type === "UnaryExpression" && node.operator === "-" && node.argument.type === "Literal" && node.argument.value === 1) {
+    return true;
+  }
+  if (node.type === "Literal" && node.value === -1)
+    return true;
+  return false;
+}
+var neg_multiply_default = {
+  create(context) {
+    return {
+      BinaryExpression(node) {
+        if (node.operator !== "*")
+          return;
+        if (isNegOne(node.left) || isNegOne(node.right)) {
+          context.report({
+            message: "Neg multiply: multiplying by -1 is less readable than negation. Use `-x` instead of `x * -1`. (clippy::neg_multiply)",
+            node
+          });
+        }
+      }
+    };
+  }
+};
+
+// src/rules/bool-comparison.ts
+var bool_comparison_default = {
+  create(context) {
+    return {
+      BinaryExpression(node) {
+        if (node.operator !== "===" && node.operator !== "!==")
+          return;
+        const leftBool = isBoolLiteral(node.left);
+        const rightBool = isBoolLiteral(node.right);
+        if (!leftBool && !rightBool)
+          return;
+        if (leftBool && rightBool)
+          return;
+        const boolVal = leftBool ? node.left.value : node.right.value;
+        const isEqual = node.operator === "===";
+        let suggestion;
+        if (boolVal && isEqual || !boolVal && !isEqual) {
+          suggestion = "use the expression directly";
+        } else {
+          suggestion = "negate the expression with `!`";
+        }
+        context.report({
+          message: `Bool comparison: comparison to \`${boolVal}\` is needless. Instead, ${suggestion}. (clippy::bool_comparison)`,
+          node
+        });
+      }
+    };
+  }
+};
+
+// src/rules/identity-op.ts
+var identity_op_default = {
+  create(context) {
+    return {
+      BinaryExpression(node) {
+        const { operator, left, right } = node;
+        let match = false;
+        switch (operator) {
+          case "+":
+            if (isLiteral(left) && typeof left.value === "string")
+              break;
+            if (isLiteral(right) && typeof right.value === "string")
+              break;
+            match = isLiteral(left, 0) || isLiteral(right, 0);
+            break;
+          case "-":
+            match = isLiteral(right, 0);
+            break;
+          case "*":
+            match = isLiteral(left, 1) || isLiteral(right, 1);
+            break;
+          case "/":
+            match = isLiteral(right, 1);
+            break;
+          case "**":
+            match = isLiteral(right, 1);
+            break;
+        }
+        if (match) {
+          context.report({
+            message: `Identity op: \`${operator} ${operator === "+" || operator === "-" ? "0" : "1"}\` has no effect. (clippy::identity_op)`,
+            node
+          });
+        }
+      }
+    };
+  }
+};
+
+// src/rules/single-case-switch.ts
+var single_case_switch_default = {
+  create(context) {
+    return {
+      SwitchStatement(node) {
+        const cases = node.cases;
+        if (!cases)
+          return;
+        const nonDefaultCases = cases.filter((c) => c.test !== null);
+        const defaultCase = cases.find((c) => c.test === null);
+        if (nonDefaultCases.length !== 1)
+          return;
+        const suggestion = defaultCase ? "if/else" : "if";
+        context.report({
+          message: `Single-case switch: this switch has only one case. Use an \`${suggestion}\` statement instead. (clippy::single_match)`,
+          node
+        });
+      }
+    };
+  }
+};
+
+// src/rules/too-many-arguments.ts
+var THRESHOLD = 5;
+function checkParams(node, context) {
+  const params = node.params;
+  if (!params || params.length <= THRESHOLD)
+    return;
+  const name = node.id?.name ?? (node.parent?.type === "VariableDeclarator" ? node.parent.id?.name : null) ?? "<anonymous>";
+  context.report({
+    message: `Too many arguments: \`${name}\` has ${params.length} parameters (max ${THRESHOLD}). Consider using an options object. (clippy::too_many_arguments)`,
+    node
+  });
+}
+var too_many_arguments_default = {
+  create(context) {
+    return {
+      FunctionDeclaration(node) {
+        checkParams(node, context);
+      },
+      FunctionExpression(node) {
+        checkParams(node, context);
+      },
+      ArrowFunctionExpression(node) {
+        checkParams(node, context);
+      }
+    };
+  }
+};
+
+// src/rules/too-many-lines.ts
+var THRESHOLD2 = 100;
+function countLines(node, sourceText) {
+  if (node.loc)
+    return node.loc.end.line - node.loc.start.line + 1;
+  if (node.start != null && node.end != null) {
+    return sourceText.substring(node.start, node.end).split(`
+`).length;
+  }
+  return 0;
+}
+function checkLines(node, context) {
+  const lines = countLines(node, context.sourceCode.text);
+  if (lines <= THRESHOLD2)
+    return;
+  const name = node.id?.name ?? (node.parent?.type === "VariableDeclarator" ? node.parent.id?.name : null) ?? "<anonymous>";
+  context.report({
+    message: `Too many lines: \`${name}\` is ${lines} lines long (max ${THRESHOLD2}). Consider breaking it into smaller functions. (clippy::too_many_lines)`,
+    node
+  });
+}
+var too_many_lines_default = {
+  create(context) {
+    return {
+      FunctionDeclaration(node) {
+        checkLines(node, context);
+      },
+      FunctionExpression(node) {
+        checkLines(node, context);
+      },
+      ArrowFunctionExpression(node) {
+        checkLines(node, context);
+      }
+    };
+  }
+};
+
+// src/rules/filter-then-first.ts
+var filter_then_first_default = {
+  create(context) {
+    return {
+      MemberExpression(node) {
+        if (!node.computed || !isLiteral(node.property, 0))
+          return;
+        const obj = node.object;
+        if (!isMethodCall(obj, "filter"))
+          return;
+        context.report({
+          message: "Filter then first: `.filter(fn)[0]` is less efficient and readable than `.find(fn)`. (clippy::filter_next)",
+          node
+        });
+      }
+    };
+  }
+};
+
+// src/rules/map-void-return.ts
+var map_void_return_default = {
+  create(context) {
+    return {
+      ExpressionStatement(node) {
+        const expr = node.expression;
+        if (!isMethodCall(expr, "map"))
+          return;
+        context.report({
+          message: "Map void return: `.map()` result is unused. Use `.forEach()` for side effects. (clippy::map_unit_fn)",
+          node
+        });
+      }
+    };
+  }
+};
+
+// src/rules/useless-conversion.ts
+var useless_conversion_default = {
+  create(context) {
+    return {
+      CallExpression(node) {
+        const { callee } = node;
+        const args = node.arguments;
+        if (!args || args.length !== 1)
+          return;
+        const arg = args[0];
+        if (isIdentifier(callee, "String") && arg.type === "Literal" && typeof arg.value === "string") {
+          context.report({
+            message: "Useless conversion: `String()` called on a string literal. (clippy::useless_conversion)",
+            node
+          });
+          return;
+        }
+        if (isIdentifier(callee, "Number") && arg.type === "Literal" && typeof arg.value === "number") {
+          context.report({
+            message: "Useless conversion: `Number()` called on a number literal. (clippy::useless_conversion)",
+            node
+          });
+          return;
+        }
+        if (isIdentifier(callee, "Boolean") && arg.type === "Literal" && typeof arg.value === "boolean") {
+          context.report({
+            message: "Useless conversion: `Boolean()` called on a boolean literal. (clippy::useless_conversion)",
+            node
+          });
+          return;
+        }
+        if (isCallOf(node, "Array", "from") && arg.type === "ArrayExpression") {
+          context.report({
+            message: "Useless conversion: `Array.from()` called on an array literal. Use the array directly. (clippy::useless_conversion)",
+            node
+          });
+          return;
+        }
+        if (callee.type === "MemberExpression" && isIdentifier(callee.property, "toString") && callee.object.type === "Literal" && typeof callee.object.value === "string" && args.length === 0) {}
+      },
+      "CallExpression:exit"(node) {
+        const { callee } = node;
+        const args = node.arguments;
+        if (!args || args.length !== 0)
+          return;
+        if (callee.type !== "MemberExpression")
+          return;
+        const obj = callee.object;
+        const method = callee.property;
+        if (method.type !== "Identifier")
+          return;
+        if (obj.type === "Literal" && typeof obj.value === "string" && method.name === "toString") {
+          context.report({
+            message: "Useless conversion: `.toString()` called on a string literal. (clippy::useless_conversion)",
+            node
+          });
+          return;
+        }
+        if (obj.type === "Literal" && typeof obj.value === "number" && method.name === "valueOf") {
+          context.report({
+            message: "Useless conversion: `.valueOf()` called on a number literal. (clippy::useless_conversion)",
+            node
+          });
+        }
+      }
+    };
+  }
+};
+
+// src/rules/manual-clamp.ts
+function isMathCall(node, method) {
+  if (node.type !== "CallExpression")
+    return false;
+  const callee = node.callee;
+  return callee.type === "MemberExpression" && isIdentifier(callee.object, "Math") && isIdentifier(callee.property, method);
+}
+var manual_clamp_default = {
+  create(context) {
+    return {
+      CallExpression(node) {
+        const args = node.arguments;
+        if (!args || args.length !== 2)
+          return;
+        if (isMathCall(node, "max") && isMathCall(args[0], "min")) {
+          context.report({
+            message: "Manual clamp: this `Math.max(min, Math.min(val, max))` pattern is a clamp. Consider extracting a `clamp(val, min, max)` helper. (clippy::manual_clamp)",
+            node
+          });
+          return;
+        }
+        if (isMathCall(node, "max") && isMathCall(args[1], "min")) {
+          context.report({
+            message: "Manual clamp: this `Math.max(Math.min(val, max), min)` pattern is a clamp. Consider extracting a `clamp(val, min, max)` helper. (clippy::manual_clamp)",
+            node
+          });
+          return;
+        }
+        if (isMathCall(node, "min") && isMathCall(args[0], "max")) {
+          context.report({
+            message: "Manual clamp: this `Math.min(max, Math.max(val, min))` pattern is a clamp. Consider extracting a `clamp(val, min, max)` helper. (clippy::manual_clamp)",
+            node
+          });
+          return;
+        }
+        if (isMathCall(node, "min") && isMathCall(args[1], "max")) {
+          context.report({
+            message: "Manual clamp: this `Math.min(Math.max(val, min), max)` pattern is a clamp. Consider extracting a `clamp(val, min, max)` helper. (clippy::manual_clamp)",
+            node
+          });
+          return;
+        }
+      }
+    };
+  }
+};
+
+// src/rules/manual-strip.ts
+function getStringMethodTarget(testExpr, methodName) {
+  if (!isMethodCall(testExpr, methodName))
+    return null;
+  const callee = testExpr.callee;
+  if (callee.object?.type !== "Identifier")
+    return null;
+  if (!testExpr.arguments || testExpr.arguments.length !== 1)
+    return null;
+  const arg = testExpr.arguments[0];
+  if (arg.type !== "Identifier" && arg.type !== "Literal")
+    return null;
+  return {
+    str: callee.object.name,
+    arg: arg.type === "Identifier" ? arg.name : JSON.stringify(arg.value)
+  };
+}
+function bodyContainsSlice(node, strName) {
+  if (!node || typeof node !== "object")
+    return false;
+  if (node.type === "CallExpression" && node.callee?.type === "MemberExpression" && node.callee.object?.type === "Identifier" && node.callee.object.name === strName && node.callee.property?.type === "Identifier" && node.callee.property.name === "slice") {
+    return true;
+  }
+  for (const key of Object.keys(node)) {
+    if (key === "type" || key === "loc" || key === "range" || key === "parent" || key === "start" || key === "end")
+      continue;
+    const val = node[key];
+    if (Array.isArray(val)) {
+      for (const child of val) {
+        if (child && typeof child === "object" && child.type && bodyContainsSlice(child, strName))
+          return true;
+      }
+    } else if (val && typeof val === "object" && val.type && bodyContainsSlice(val, strName)) {
+      return true;
+    }
+  }
+  return false;
+}
+var manual_strip_default = {
+  create(context) {
+    return {
+      IfStatement(node) {
+        const test = node.test;
+        if (!test)
+          return;
+        const startsInfo = getStringMethodTarget(test, "startsWith");
+        if (startsInfo && bodyContainsSlice(node.consequent, startsInfo.str)) {
+          context.report({
+            message: `Manual strip: checking \`startsWith()\` then slicing is a manual prefix strip. Consider extracting a \`stripPrefix\` helper. (clippy::manual_strip)`,
+            node
+          });
+          return;
+        }
+        const endsInfo = getStringMethodTarget(test, "endsWith");
+        if (endsInfo && bodyContainsSlice(node.consequent, endsInfo.str)) {
+          context.report({
+            message: `Manual strip: checking \`endsWith()\` then slicing is a manual suffix strip. Consider extracting a \`stripSuffix\` helper. (clippy::manual_strip)`,
+            node
+          });
+        }
+      }
+    };
+  }
+};
+
+// src/rules/manual-find.ts
+function isReturnOfVar(stmt, varName) {
+  if (stmt.type !== "ReturnStatement")
+    return false;
+  return stmt.argument?.type === "Identifier" && stmt.argument.name === varName;
+}
+function isReturnNullish(stmt) {
+  if (stmt.type !== "ReturnStatement")
+    return false;
+  if (!stmt.argument)
+    return true;
+  if (stmt.argument.type === "Identifier" && stmt.argument.name === "undefined")
+    return true;
+  if (stmt.argument.type === "Literal" && stmt.argument.value === null)
+    return true;
+  return false;
+}
+function checkBody(body, context) {
+  for (let i = 0;i < body.length; i++) {
+    const stmt = body[i];
+    if (stmt.type !== "ForOfStatement")
+      continue;
+    const loopVar = getForOfVar(stmt);
+    if (!loopVar)
+      continue;
+    const inner = unwrapBlock(stmt.body);
+    if (!inner)
+      continue;
+    if (inner.type === "IfStatement" && !inner.alternate) {
+      const consequent = unwrapBlock(inner.consequent);
+      if (consequent && isReturnOfVar(consequent, loopVar)) {
+        const next = body[i + 1];
+        if (next && isReturnNullish(next)) {
+          context.report({
+            message: "Manual find: this loop can be replaced with `.find()`. (clippy::manual_find)",
+            node: stmt
+          });
+        }
+      }
+    }
+  }
+}
+var manual_find_default = {
+  create(context) {
+    function checkFunction(node) {
+      const body = getFunctionBody(node);
+      if (body)
+        checkBody(body, context);
+    }
+    return {
+      FunctionDeclaration: checkFunction,
+      FunctionExpression: checkFunction,
+      ArrowFunctionExpression: checkFunction
+    };
+  }
+};
+
+// src/rules/manual-some.ts
+function checkBody2(body, context) {
+  for (let i = 0;i < body.length; i++) {
+    const stmt = body[i];
+    if (stmt.type !== "ForOfStatement")
+      continue;
+    const inner = unwrapBlock(stmt.body);
+    if (!inner || inner.type !== "IfStatement" || inner.alternate)
+      continue;
+    const consequent = unwrapBlock(inner.consequent);
+    if (!consequent || consequent.type !== "ReturnStatement" || !isLiteral(consequent.argument, true))
+      continue;
+    const next = body[i + 1];
+    if (next && next.type === "ReturnStatement" && isLiteral(next.argument, false)) {
+      context.report({
+        message: "Manual some: this loop can be replaced with `.some()`. (clippy::manual_find)",
+        node: stmt
+      });
+    }
+  }
+}
+var manual_some_default = {
+  create(context) {
+    function checkFunction(node) {
+      const body = getFunctionBody(node);
+      if (body)
+        checkBody2(body, context);
+    }
+    return {
+      FunctionDeclaration: checkFunction,
+      FunctionExpression: checkFunction,
+      ArrowFunctionExpression: checkFunction
+    };
+  }
+};
+
+// src/rules/manual-every.ts
+function checkBody3(body, context) {
+  for (let i = 0;i < body.length; i++) {
+    const stmt = body[i];
+    if (stmt.type !== "ForOfStatement")
+      continue;
+    const inner = unwrapBlock(stmt.body);
+    if (!inner || inner.type !== "IfStatement" || inner.alternate)
+      continue;
+    const consequent = unwrapBlock(inner.consequent);
+    if (!consequent || consequent.type !== "ReturnStatement" || !isLiteral(consequent.argument, false))
+      continue;
+    const next = body[i + 1];
+    if (next && next.type === "ReturnStatement" && isLiteral(next.argument, true)) {
+      context.report({
+        message: "Manual every: this loop can be replaced with `.every()`. (clippy::manual_find)",
+        node: stmt
+      });
+    }
+  }
+}
+var manual_every_default = {
+  create(context) {
+    function checkFunction(node) {
+      const body = getFunctionBody(node);
+      if (body)
+        checkBody3(body, context);
+    }
+    return {
+      FunctionDeclaration: checkFunction,
+      FunctionExpression: checkFunction,
+      ArrowFunctionExpression: checkFunction
+    };
+  }
+};
+
+// src/rules/manual-includes.ts
+function isEqualityCheck(test, varName) {
+  if (test.type !== "BinaryExpression")
+    return false;
+  if (test.operator !== "===" && test.operator !== "==")
+    return false;
+  const left = test.left;
+  const right = test.right;
+  return left.type === "Identifier" && left.name === varName || right.type === "Identifier" && right.name === varName;
+}
+function checkBody4(body, context) {
+  for (let i = 0;i < body.length; i++) {
+    const stmt = body[i];
+    if (stmt.type !== "ForOfStatement")
+      continue;
+    const loopVar = getForOfVar(stmt);
+    if (!loopVar)
+      continue;
+    const inner = unwrapBlock(stmt.body);
+    if (!inner || inner.type !== "IfStatement" || inner.alternate)
+      continue;
+    if (!isEqualityCheck(inner.test, loopVar))
+      continue;
+    const consequent = unwrapBlock(inner.consequent);
+    if (!consequent || consequent.type !== "ReturnStatement" || !isLiteral(consequent.argument, true))
+      continue;
+    const next = body[i + 1];
+    if (next && next.type === "ReturnStatement" && isLiteral(next.argument, false)) {
+      context.report({
+        message: "Manual includes: this loop can be replaced with `.includes()`. (clippy::manual_find)",
+        node: stmt
+      });
+    }
+  }
+}
+var manual_includes_default = {
+  create(context) {
+    function checkFunction(node) {
+      const body = getFunctionBody(node);
+      if (body)
+        checkBody4(body, context);
+    }
+    return {
+      FunctionDeclaration: checkFunction,
+      FunctionExpression: checkFunction,
+      ArrowFunctionExpression: checkFunction
+    };
+  }
+};
+
+// src/rules/cognitive-complexity.ts
+var THRESHOLD3 = 25;
+function calculateComplexity(node) {
+  let complexity = 0;
+  function walk(n, nesting) {
+    if (!n || typeof n !== "object")
+      return;
+    switch (n.type) {
+      case "IfStatement":
+        complexity += 1 + nesting;
+        walk(n.test, nesting);
+        walk(n.consequent, nesting + 1);
+        if (n.alternate) {
+          if (n.alternate.type === "IfStatement") {
+            complexity += 1;
+            walk(n.alternate.test, nesting);
+            walk(n.alternate.consequent, nesting + 1);
+            if (n.alternate.alternate) {
+              walk(n.alternate.alternate, nesting);
+            }
+          } else {
+            complexity += 1;
+            walk(n.alternate, nesting + 1);
+          }
+        }
+        return;
+      case "ForStatement":
+      case "ForInStatement":
+      case "ForOfStatement":
+      case "WhileStatement":
+      case "DoWhileStatement":
+        complexity += 1 + nesting;
+        walkChildren(n, nesting + 1);
+        return;
+      case "CatchClause":
+        complexity += 1 + nesting;
+        walkChildren(n, nesting + 1);
+        return;
+      case "SwitchStatement":
+        complexity += 1 + nesting;
+        walkChildren(n, nesting + 1);
+        return;
+      case "ConditionalExpression":
+        complexity += 1 + nesting;
+        walk(n.test, nesting);
+        walk(n.consequent, nesting + 1);
+        walk(n.alternate, nesting + 1);
+        return;
+      case "LogicalExpression":
+        complexity += 1;
+        walk(n.left, nesting);
+        walk(n.right, nesting);
+        return;
+      case "FunctionDeclaration":
+      case "FunctionExpression":
+      case "ArrowFunctionExpression":
+        return;
+    }
+    walkChildren(n, nesting);
+  }
+  function walkChildren(n, nesting) {
+    for (const key of Object.keys(n)) {
+      if (key === "type" || key === "loc" || key === "range" || key === "parent")
+        continue;
+      const val = n[key];
+      if (Array.isArray(val)) {
+        for (const child of val) {
+          if (child && typeof child === "object" && child.type) {
+            walk(child, nesting);
+          }
+        }
+      } else if (val && typeof val === "object" && val.type) {
+        walk(val, nesting);
+      }
+    }
+  }
+  if (node.body) {
+    if (node.body.type === "BlockStatement") {
+      for (const stmt of node.body.body) {
+        walk(stmt, 0);
+      }
+    } else {
+      walk(node.body, 0);
+    }
+  }
+  return complexity;
+}
+var cognitive_complexity_default = {
+  create(context) {
+    function checkFunction(node) {
+      const complexity = calculateComplexity(node);
+      if (complexity <= THRESHOLD3)
+        return;
+      const name = node.id?.name ?? (node.parent?.type === "VariableDeclarator" ? node.parent.id?.name : null) ?? "<anonymous>";
+      context.report({
+        message: `Cognitive complexity: \`${name}\` has a complexity of ${complexity} (max ${THRESHOLD3}). Consider refactoring into smaller functions. (clippy::cognitive_complexity)`,
+        node
+      });
+    }
+    return {
+      FunctionDeclaration: checkFunction,
+      FunctionExpression: checkFunction,
+      ArrowFunctionExpression: checkFunction
+    };
+  }
+};
+
+// src/rules/float-comparison.ts
+function isFloatLiteral(node) {
+  return node.type === "Literal" && typeof node.value === "number" && !Number.isInteger(node.value);
+}
+function isArithmetic(node) {
+  return node.type === "BinaryExpression" && (node.operator === "+" || node.operator === "-" || node.operator === "*" || node.operator === "/");
+}
+function involvesFloat(node) {
+  if (isFloatLiteral(node))
+    return true;
+  if (isArithmetic(node)) {
+    return involvesFloat(node.left) || involvesFloat(node.right);
+  }
+  return false;
+}
+var float_comparison_default = {
+  create(context) {
+    return {
+      BinaryExpression(node) {
+        if (node.operator !== "===" && node.operator !== "==" && node.operator !== "!==" && node.operator !== "!=")
+          return;
+        if (involvesFloat(node.left) || involvesFloat(node.right)) {
+          context.report({
+            message: "Float comparison: direct equality comparison of floating-point numbers is unreliable. Use `Math.abs(a - b) < Number.EPSILON` instead. (clippy::float_cmp)",
+            node
+          });
+        }
+      }
+    };
+  }
+};
+
+// src/rules/needless-range-loop.ts
+function isZeroInit(init) {
+  if (init.type !== "VariableDeclaration" || init.declarations.length !== 1)
+    return null;
+  const decl = init.declarations[0];
+  if (decl.id?.type !== "Identifier")
+    return null;
+  if (decl.init?.type !== "Literal" || decl.init.value !== 0)
+    return null;
+  return decl.id.name;
+}
+function isLengthTest(test, indexVar) {
+  if (test.type !== "BinaryExpression" || test.operator !== "<")
+    return null;
+  if (test.left?.type !== "Identifier" || test.left.name !== indexVar)
+    return null;
+  if (test.right?.type === "MemberExpression" && test.right.object?.type === "Identifier" && test.right.property?.type === "Identifier" && test.right.property.name === "length") {
+    return test.right.object.name;
+  }
+  return null;
+}
+function isIncrement(update, indexVar) {
+  if (update.type === "UpdateExpression" && update.operator === "++" && update.argument?.type === "Identifier" && update.argument.name === indexVar)
+    return true;
+  if (update.type === "AssignmentExpression" && update.operator === "+=" && update.left?.type === "Identifier" && update.left.name === indexVar && update.right?.type === "Literal" && update.right.value === 1)
+    return true;
+  return false;
+}
+function onlyUsedAsIndex(body, indexVar, arrName) {
+  let onlyIndexAccess = true;
+  function walk(n) {
+    if (!n || typeof n !== "object" || !n.type)
+      return;
+    if (!onlyIndexAccess)
+      return;
+    if (n.type === "Identifier" && n.name === indexVar) {
+      onlyIndexAccess = false;
+      return;
+    }
+    if (n.type === "MemberExpression" && n.computed && n.object?.type === "Identifier" && n.object.name === arrName && n.property?.type === "Identifier" && n.property.name === indexVar) {
+      walk(n.object);
+      return;
+    }
+    for (const key of Object.keys(n)) {
+      if (key === "type" || key === "loc" || key === "range" || key === "parent" || key === "start" || key === "end")
+        continue;
+      const val = n[key];
+      if (Array.isArray(val)) {
+        for (const child of val) {
+          if (child && typeof child === "object" && child.type)
+            walk(child);
+        }
+      } else if (val && typeof val === "object" && val.type) {
+        walk(val);
+      }
+    }
+  }
+  walk(body);
+  return onlyIndexAccess;
+}
+var needless_range_loop_default = {
+  create(context) {
+    return {
+      ForStatement(node) {
+        if (!node.init || !node.test || !node.update)
+          return;
+        const indexVar = isZeroInit(node.init);
+        if (!indexVar)
+          return;
+        const arrName = isLengthTest(node.test, indexVar);
+        if (!arrName)
+          return;
+        if (!isIncrement(node.update, indexVar))
+          return;
+        if (onlyUsedAsIndex(node.body, indexVar, arrName)) {
+          context.report({
+            message: `Needless range loop: \`${indexVar}\` is only used to index \`${arrName}\`. Use \`for (const item of ${arrName})\` instead. (clippy::needless_range_loop)`,
+            node
+          });
+        }
+      }
+    };
+  }
+};
+
+// src/rules/manual-swap.ts
+function exprName(node) {
+  if (node.type === "Identifier")
+    return node.name;
+  if (node.type === "MemberExpression" && !node.computed && node.object?.type === "Identifier" && node.property?.type === "Identifier") {
+    return `${node.object.name}.${node.property.name}`;
+  }
+  return null;
+}
+function checkBody5(body, context) {
+  for (let i = 0;i < body.length - 2; i++) {
+    const s1 = body[i];
+    const s2 = body[i + 1];
+    const s3 = body[i + 2];
+    if (s1.type !== "VariableDeclaration" || s1.declarations.length !== 1)
+      continue;
+    const decl = s1.declarations[0];
+    if (decl.id?.type !== "Identifier" || !decl.init)
+      continue;
+    const tmpName = decl.id.name;
+    const aName = exprName(decl.init);
+    if (!aName)
+      continue;
+    if (s2.type !== "ExpressionStatement" || s2.expression?.type !== "AssignmentExpression" || s2.expression.operator !== "=")
+      continue;
+    const assignLeft = exprName(s2.expression.left);
+    const bName = exprName(s2.expression.right);
+    if (assignLeft !== aName || !bName)
+      continue;
+    if (s3.type !== "ExpressionStatement" || s3.expression?.type !== "AssignmentExpression" || s3.expression.operator !== "=")
+      continue;
+    const assign2Left = exprName(s3.expression.left);
+    const assign2Right = exprName(s3.expression.right);
+    if (assign2Left !== bName || assign2Right !== tmpName)
+      continue;
+    context.report({
+      message: `Manual swap: use destructuring \`[${aName}, ${bName}] = [${bName}, ${aName}]\` instead of a temp variable. (clippy::manual_swap)`,
+      node: s1
+    });
+  }
+}
+var manual_swap_default = {
+  create(context) {
+    return {
+      BlockStatement(node) {
+        if (node.body)
+          checkBody5(node.body, context);
+      },
+      Program(node) {
+        if (node.body)
+          checkBody5(node.body, context);
+      }
+    };
+  }
+};
+
+// src/rules/search-is-some.ts
+function isNullish(node) {
+  if (node.type === "Identifier" && node.name === "undefined")
+    return true;
+  if (node.type === "Literal" && node.value === null)
+    return true;
+  return false;
+}
+function isFindCall(node) {
+  return isMethodCall(node, "find");
+}
+function matchesFindNullish(left, right) {
+  return isFindCall(left) && isNullish(right) || isNullish(left) && isFindCall(right);
+}
+var search_is_some_default = {
+  create(context) {
+    return {
+      BinaryExpression(node) {
+        const { operator, left, right } = node;
+        if (!matchesFindNullish(left, right))
+          return;
+        if (operator === "!==" || operator === "!=") {
+          context.report({
+            message: "Search is some: `.find(fn) !== undefined` can be simplified to `.some(fn)` when you don't need the found value. (clippy::search_is_some)",
+            node
+          });
+        } else if (operator === "===" || operator === "==") {
+          context.report({
+            message: "Search is some: `.find(fn) === undefined` can be simplified to `!.some(fn)` when you don't need the found value. (clippy::search_is_some)",
+            node
+          });
+        }
+      }
+    };
+  }
+};
+
+// src/rules/let-and-return.ts
+function checkBody6(body, context) {
+  if (body.length < 2)
+    return;
+  const last = body[body.length - 1];
+  const secondLast = body[body.length - 2];
+  if (last.type !== "ReturnStatement" || !last.argument || last.argument.type !== "Identifier")
+    return;
+  const returnedName = last.argument.name;
+  if (secondLast.type !== "VariableDeclaration" || secondLast.declarations.length !== 1)
+    return;
+  const decl = secondLast.declarations[0];
+  if (decl.id?.type !== "Identifier" || decl.id.name !== returnedName || !decl.init)
+    return;
+  context.report({
+    message: `Let and return: \`${returnedName}\` is immediately returned. Return the expression directly. (clippy::let_and_return)`,
+    node: secondLast
+  });
+}
+var let_and_return_default = {
+  create(context) {
+    function checkFunction(node) {
+      const body = getFunctionBody(node);
+      if (body)
+        checkBody6(body, context);
+    }
+    return {
+      FunctionDeclaration: checkFunction,
+      FunctionExpression: checkFunction,
+      ArrowFunctionExpression: checkFunction
+    };
+  }
+};
+
+// src/rules/xor-used-as-pow.ts
+function isIntLiteral(node) {
+  return node.type === "Literal" && typeof node.value === "number" && Number.isInteger(node.value);
+}
+var xor_used_as_pow_default = {
+  create(context) {
+    return {
+      BinaryExpression(node) {
+        if (node.operator !== "^")
+          return;
+        if (!isIntLiteral(node.left) || !isIntLiteral(node.right))
+          return;
+        const base = node.left.value;
+        const exp = node.right.value;
+        if (base >= 2 && exp >= 2) {
+          context.report({
+            message: `XOR used as pow: \`${base} ^ ${exp}\` is bitwise XOR (= ${base ^ exp}), not exponentiation. Use \`${base} ** ${exp}\` (= ${base ** exp}) or \`Math.pow(${base}, ${exp})\` instead. (clippy::suspicious_xor_used_as_pow)`,
+            node
+          });
+        }
+      }
+    };
+  }
+};
+
+// src/rules/map-identity.ts
+function isIdentityClosure(node) {
+  if (node.type === "ArrowFunctionExpression" && node.params.length === 1) {
+    const param = node.params[0];
+    const body = node.body;
+    if (param.type === "Identifier" && body.type === "Identifier" && body.name === param.name) {
+      return true;
+    }
+    if (body.type === "BlockStatement" && body.body.length === 1) {
+      const stmt = body.body[0];
+      if (stmt.type === "ReturnStatement" && stmt.argument?.type === "Identifier" && stmt.argument.name === param.name) {
+        return true;
+      }
+    }
+  }
+  if (node.type === "FunctionExpression" && node.params.length === 1) {
+    const param = node.params[0];
+    if (param.type === "Identifier" && node.body.type === "BlockStatement" && node.body.body.length === 1) {
+      const stmt = node.body.body[0];
+      if (stmt.type === "ReturnStatement" && stmt.argument?.type === "Identifier" && stmt.argument.name === param.name) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+var map_identity_default = {
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (!isMethodCall(node, "map"))
+          return;
+        const args = node.arguments;
+        if (!args || args.length !== 1)
+          return;
+        if (isIdentityClosure(args[0])) {
+          context.report({
+            message: "Map identity: `.map(x => x)` is a no-op. Remove it, or use `.slice()` / `[...arr]` to copy. (clippy::map_identity)",
+            node
+          });
+        }
+      }
+    };
+  }
+};
+
+// src/rules/redundant-closure-call.ts
+var redundant_closure_call_default = {
+  create(context) {
+    return {
+      CallExpression(node) {
+        const { callee } = node;
+        if (node.arguments.length !== 0)
+          return;
+        let fn = callee;
+        if (fn.type === "ArrowFunctionExpression" && fn.params.length === 0) {
+          if (fn.body.type !== "BlockStatement") {
+            context.report({
+              message: "Redundant closure call: this IIFE wraps a single expression. Use the expression directly. (clippy::redundant_closure_call)",
+              node
+            });
+            return;
+          }
+          if (fn.body.body.length === 1) {
+            const stmt = fn.body.body[0];
+            if (stmt.type === "ReturnStatement" && stmt.argument) {
+              context.report({
+                message: "Redundant closure call: this IIFE wraps a single return. Use the expression directly. (clippy::redundant_closure_call)",
+                node
+              });
+            }
+          }
+          return;
+        }
+        if (fn.type === "FunctionExpression" && fn.params.length === 0 && fn.body.type === "BlockStatement" && fn.body.body.length === 1) {
+          const stmt = fn.body.body[0];
+          if (stmt.type === "ReturnStatement" && stmt.argument) {
+            context.report({
+              message: "Redundant closure call: this IIFE wraps a single return. Use the expression directly. (clippy::redundant_closure_call)",
+              node
+            });
+          }
+        }
+      }
+    };
+  }
+};
+
+// src/rules/almost-swapped.ts
+function assignTarget(node) {
+  if (node.type !== "ExpressionStatement")
+    return null;
+  const expr = node.expression;
+  if (expr.type !== "AssignmentExpression" || expr.operator !== "=")
+    return null;
+  if (expr.left.type === "Identifier")
+    return expr.left.name;
+  return null;
+}
+function assignSource(node) {
+  if (node.type !== "ExpressionStatement")
+    return null;
+  const expr = node.expression;
+  if (expr.type !== "AssignmentExpression" || expr.operator !== "=")
+    return null;
+  if (expr.right.type === "Identifier")
+    return expr.right.name;
+  return null;
+}
+function checkBody7(body, context) {
+  for (let i = 0;i < body.length - 1; i++) {
+    const s1 = body[i];
+    const s2 = body[i + 1];
+    const t1 = assignTarget(s1);
+    const src1 = assignSource(s1);
+    const t2 = assignTarget(s2);
+    const src2 = assignSource(s2);
+    if (t1 && src1 && t2 && src2 && t1 === src2 && t2 === src1 && t1 !== t2) {
+      context.report({
+        message: `Almost swapped: \`${t1} = ${src1}; ${t2} = ${src2};\` overwrites \`${t1}\` before saving it. Use \`[${t1}, ${t2}] = [${t2}, ${t1}]\`. (clippy::almost_swapped)`,
+        node: s1
+      });
+    }
+  }
+}
+var almost_swapped_default = {
+  create(context) {
+    return {
+      BlockStatement(node) {
+        if (node.body)
+          checkBody7(node.body, context);
+      },
+      Program(node) {
+        if (node.body)
+          checkBody7(node.body, context);
+      }
+    };
+  }
+};
+
+// src/rules/if-same-then-else.ts
+function sourceRange(node, text) {
+  if (node.start != null && node.end != null) {
+    return text.slice(node.start, node.end);
+  }
+  return "";
+}
+var if_same_then_else_default = {
+  create(context) {
+    return {
+      IfStatement(node) {
+        if (!node.alternate)
+          return;
+        if (node.alternate.type === "IfStatement")
+          return;
+        const text = context.sourceCode.text;
+        const consequentSrc = sourceRange(node.consequent, text);
+        const alternateSrc = sourceRange(node.alternate, text);
+        if (consequentSrc && consequentSrc === alternateSrc) {
+          context.report({
+            message: "If same then else: both branches of this if/else are identical. (clippy::if_same_then_else)",
+            node
+          });
+        }
+      }
+    };
+  }
+};
+
+// src/rules/never-loop.ts
+function alwaysExits(node) {
+  if (!node)
+    return false;
+  switch (node.type) {
+    case "ReturnStatement":
+    case "ThrowStatement":
+    case "BreakStatement":
+      return true;
+    case "BlockStatement":
+      return node.body.length > 0 && alwaysExits(node.body[node.body.length - 1]);
+    case "IfStatement":
+      return !!node.alternate && alwaysExits(node.consequent) && alwaysExits(node.alternate);
+    case "ExpressionStatement":
+      return false;
+    default:
+      return false;
+  }
+}
+function checkLoop(node, context) {
+  const body = node.body;
+  if (!body)
+    return;
+  if (alwaysExits(body)) {
+    context.report({
+      message: "Never loop: this loop always exits on the first iteration. Consider replacing with a conditional. (clippy::never_loop)",
+      node
+    });
+  }
+}
+var never_loop_default = {
+  create(context) {
+    return {
+      ForStatement: (node) => checkLoop(node, context),
+      ForOfStatement: (node) => checkLoop(node, context),
+      ForInStatement: (node) => checkLoop(node, context),
+      WhileStatement: (node) => checkLoop(node, context),
+      DoWhileStatement: (node) => checkLoop(node, context)
+    };
+  }
+};
+
+// src/rules/explicit-counter-loop.ts
+function checkBody8(body, context) {
+  for (let i = 0;i < body.length - 1; i++) {
+    const decl = body[i];
+    const loop = body[i + 1];
+    if (decl.type !== "VariableDeclaration" || decl.declarations.length !== 1)
+      continue;
+    const d = decl.declarations[0];
+    if (d.id?.type !== "Identifier" || d.init?.type !== "Literal" || d.init.value !== 0)
+      continue;
+    const counterName = d.id.name;
+    if (loop.type !== "ForOfStatement")
+      continue;
+    if (loop.body?.type !== "BlockStatement" || loop.body.body.length === 0)
+      continue;
+    const stmts = loop.body.body;
+    const last = stmts[stmts.length - 1];
+    const isIncrement2 = last.type === "ExpressionStatement" && last.expression?.type === "UpdateExpression" && last.expression.operator === "++" && last.expression.argument?.type === "Identifier" && last.expression.argument.name === counterName || last.type === "ExpressionStatement" && last.expression?.type === "AssignmentExpression" && last.expression.operator === "+=" && last.expression.left?.type === "Identifier" && last.expression.left.name === counterName && last.expression.right?.type === "Literal" && last.expression.right.value === 1;
+    if (isIncrement2) {
+      context.report({
+        message: `Explicit counter loop: manual counter \`${counterName}\` can be replaced with \`for (const [${counterName}, item] of arr.entries())\`. (clippy::explicit_counter_loop)`,
+        node: loop
+      });
+    }
+  }
+}
+var explicit_counter_loop_default = {
+  create(context) {
+    function checkFunction(node) {
+      const body = getFunctionBody(node);
+      if (body)
+        checkBody8(body, context);
+    }
+    return {
+      FunctionDeclaration: checkFunction,
+      FunctionExpression: checkFunction,
+      ArrowFunctionExpression: checkFunction,
+      Program(node) {
+        if (node.body)
+          checkBody8(node.body, context);
+      }
+    };
+  }
+};
+
+// src/rules/excessive-nesting.ts
+var THRESHOLD4 = 5;
+var NESTING_NODES = new Set([
+  "IfStatement",
+  "ForStatement",
+  "ForInStatement",
+  "ForOfStatement",
+  "WhileStatement",
+  "DoWhileStatement",
+  "SwitchStatement",
+  "TryStatement"
+]);
+var excessive_nesting_default = {
+  create(context) {
+    let reported = false;
+    function walk(node, depth) {
+      if (!node || typeof node !== "object" || !node.type)
+        return;
+      if (reported)
+        return;
+      const isNesting = NESTING_NODES.has(node.type);
+      const newDepth = isNesting ? depth + 1 : depth;
+      if (newDepth > THRESHOLD4 && isNesting) {
+        reported = true;
+        context.report({
+          message: `Excessive nesting: this code is nested ${newDepth} levels deep (max ${THRESHOLD4}). Consider extracting into helper functions. (clippy::excessive_nesting)`,
+          node
+        });
+        return;
+      }
+      if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
+        if (depth > 0)
+          return;
+      }
+      for (const key of Object.keys(node)) {
+        if (key === "type" || key === "loc" || key === "range" || key === "parent" || key === "start" || key === "end")
+          continue;
+        const val = node[key];
+        if (Array.isArray(val)) {
+          for (const child of val) {
+            if (child && typeof child === "object" && child.type)
+              walk(child, newDepth);
+          }
+        } else if (val && typeof val === "object" && val.type) {
+          walk(val, newDepth);
+        }
+      }
+    }
+    return {
+      FunctionDeclaration(node) {
+        reported = false;
+        walk(node.body, 0);
+      },
+      FunctionExpression(node) {
+        reported = false;
+        walk(node.body, 0);
+      },
+      ArrowFunctionExpression(node) {
+        reported = false;
+        walk(node.body, 0);
+      }
+    };
+  }
+};
+
+// src/rules/fn-params-excessive-bools.ts
+var THRESHOLD5 = 3;
+function countBoolParams(node) {
+  const params = node.params;
+  if (!params)
+    return 0;
+  let count = 0;
+  for (const p of params) {
+    if (p.type === "Identifier" && p.typeAnnotation) {
+      const ann = p.typeAnnotation.typeAnnotation ?? p.typeAnnotation;
+      if (ann.type === "TSBooleanKeyword")
+        count++;
+    }
+    if (p.type === "AssignmentPattern" && p.right?.type === "Literal" && typeof p.right.value === "boolean") {
+      count++;
+    }
+  }
+  return count;
+}
+function checkFunction(node, context) {
+  const boolCount = countBoolParams(node);
+  if (boolCount <= THRESHOLD5)
+    return;
+  const name = node.id?.name ?? "<anonymous>";
+  context.report({
+    message: `Excessive bools: \`${name}\` has ${boolCount} boolean parameters (max ${THRESHOLD5}). Consider using an options object. (clippy::fn_params_excessive_bools)`,
+    node
+  });
+}
+var fn_params_excessive_bools_default = {
+  create(context) {
+    return {
+      FunctionDeclaration: (node) => checkFunction(node, context),
+      FunctionExpression: (node) => checkFunction(node, context),
+      ArrowFunctionExpression: (node) => checkFunction(node, context)
+    };
+  }
+};
+
+// src/rules/float-equality-without-abs.ts
+function isEpsilonLike(node) {
+  if (node.type === "MemberExpression" && node.object?.type === "Identifier" && node.object.name === "Number" && node.property?.type === "Identifier" && node.property.name === "EPSILON")
+    return true;
+  if (node.type === "Literal" && typeof node.value === "number" && node.value > 0 && node.value < 1)
+    return true;
+  return false;
+}
+function isSubtraction(node) {
+  return node.type === "BinaryExpression" && node.operator === "-";
+}
+var float_equality_without_abs_default = {
+  create(context) {
+    return {
+      BinaryExpression(node) {
+        if (node.operator !== "<" && node.operator !== "<=")
+          return;
+        if (isSubtraction(node.left) && isEpsilonLike(node.right)) {
+          context.report({
+            message: "Float equality without abs: `(a - b) < epsilon` fails when a < b. Use `Math.abs(a - b) < epsilon`. (clippy::float_equality_without_abs)",
+            node
+          });
+        }
+      }
+    };
+  }
+};
+
+// src/rules/manual-is-finite.ts
+function isInfinityCheck(node, operator) {
+  if (node.type !== "BinaryExpression" || node.operator !== operator)
+    return false;
+  return isInfinityLiteral(node.right) || isInfinityLiteral(node.left);
+}
+function isInfinityLiteral(node) {
+  if (node.type === "Identifier" && node.name === "Infinity")
+    return true;
+  if (node.type === "UnaryExpression" && node.operator === "-" && node.argument?.type === "Identifier" && node.argument.name === "Infinity")
+    return true;
+  return false;
+}
+var manual_is_finite_default = {
+  create(context) {
+    return {
+      LogicalExpression(node) {
+        if (node.operator === "&&" && isInfinityCheck(node.left, "!==") && isInfinityCheck(node.right, "!==")) {
+          context.report({
+            message: "Manual isFinite: this pattern checks for finiteness manually. Use `Number.isFinite(x)` instead. (clippy::manual_is_finite)",
+            node
+          });
+        }
+        if (node.operator === "||" && isInfinityCheck(node.left, "===") && isInfinityCheck(node.right, "===")) {
+          context.report({
+            message: "Manual isInfinite: this pattern checks for infinity manually. Use `!Number.isFinite(x)` instead. (clippy::manual_is_infinite)",
+            node
+          });
+        }
+      }
+    };
+  }
+};
+
+// src/rules/unnecessary-fold.ts
+var unnecessary_fold_default = {
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (!isMethodCall(node, "reduce"))
+          return;
+        const args = node.arguments;
+        if (!args || args.length !== 2)
+          return;
+        const callback = args[0];
+        const initial = args[1];
+        if (callback.type !== "ArrowFunctionExpression" && callback.type !== "FunctionExpression")
+          return;
+        if (callback.params.length !== 2)
+          return;
+        const accParam = callback.params[0];
+        if (accParam.type !== "Identifier")
+          return;
+        const accName = accParam.name;
+        let bodyExpr = null;
+        if (callback.body.type === "BlockStatement") {
+          if (callback.body.body.length === 1 && callback.body.body[0].type === "ReturnStatement") {
+            bodyExpr = callback.body.body[0].argument;
+          }
+        } else {
+          bodyExpr = callback.body;
+        }
+        if (!bodyExpr || bodyExpr.type !== "LogicalExpression")
+          return;
+        if (bodyExpr.operator === "||" && isLiteral(initial, false)) {
+          if (bodyExpr.left.type === "Identifier" && bodyExpr.left.name === accName) {
+            context.report({
+              message: "Unnecessary fold: this `.reduce()` with `||` and initial `false` can be replaced with `.some()`. (clippy::unnecessary_fold)",
+              node
+            });
+          }
+        }
+        if (bodyExpr.operator === "&&" && isLiteral(initial, true)) {
+          if (bodyExpr.left.type === "Identifier" && bodyExpr.left.name === accName) {
+            context.report({
+              message: "Unnecessary fold: this `.reduce()` with `&&` and initial `true` can be replaced with `.every()`. (clippy::unnecessary_fold)",
+              node
+            });
+          }
+        }
+      }
+    };
+  }
+};
+
+// src/rules/needless-late-init.ts
+function checkBody9(body, context) {
+  for (let i = 0;i < body.length - 1; i++) {
+    const decl = body[i];
+    const next = body[i + 1];
+    if (decl.type !== "VariableDeclaration" || decl.declarations.length !== 1)
+      continue;
+    const d = decl.declarations[0];
+    if (d.id?.type !== "Identifier" || d.init !== null)
+      continue;
+    const varName = d.id.name;
+    if (next.type === "ExpressionStatement" && next.expression?.type === "AssignmentExpression" && next.expression.operator === "=" && next.expression.left?.type === "Identifier" && next.expression.left.name === varName) {
+      context.report({
+        message: `Needless late init: \`${varName}\` is declared then immediately assigned. Initialize on declaration with \`const\`. (clippy::needless_late_init)`,
+        node: decl
+      });
+    }
+  }
+}
+var needless_late_init_default = {
+  create(context) {
+    return {
+      BlockStatement(node) {
+        if (node.body)
+          checkBody9(node.body, context);
+      },
+      Program(node) {
+        if (node.body)
+          checkBody9(node.body, context);
+      }
+    };
+  }
+};
+
+// src/rules/single-element-loop.ts
+var single_element_loop_default = {
+  create(context) {
+    return {
+      ForOfStatement(node) {
+        const right = node.right;
+        if (right?.type === "ArrayExpression" && right.elements?.length === 1) {
+          context.report({
+            message: "Single element loop: this loop iterates over a single-element array. Use the value directly. (clippy::single_element_loop)",
+            node
+          });
+        }
+      }
+    };
+  }
+};
+
+// src/rules/int-plus-one.ts
+var int_plus_one_default = {
+  create(context) {
+    return {
+      BinaryExpression(node) {
+        const { operator, left, right } = node;
+        if (operator === ">=" && right.type === "BinaryExpression" && right.operator === "+" && isLiteral(right.right, 1)) {
+          context.report({
+            message: "Int plus one: `x >= y + 1` can be simplified to `x > y`. (clippy::int_plus_one)",
+            node
+          });
+          return;
+        }
+        if (operator === "<=" && left.type === "BinaryExpression" && left.operator === "+" && isLiteral(left.right, 1)) {
+          context.report({
+            message: "Int plus one: `x + 1 <= y` can be simplified to `x < y`. (clippy::int_plus_one)",
+            node
+          });
+          return;
+        }
+        if (operator === ">=" && left.type === "BinaryExpression" && left.operator === "-" && isLiteral(left.right, 1)) {
+          context.report({
+            message: "Int plus one: `x - 1 >= y` can be simplified to `x > y`. (clippy::int_plus_one)",
+            node
+          });
+          return;
+        }
+        if (operator === "<=" && right.type === "BinaryExpression" && right.operator === "-" && isLiteral(right.right, 1)) {
+          context.report({
+            message: "Int plus one: `y <= x - 1` can be simplified to `y < x`. (clippy::int_plus_one)",
+            node
+          });
+        }
+      }
+    };
+  }
+};
+
+// src/rules/zero-divided-by-zero.ts
+function isZero(node) {
+  return node.type === "Literal" && (node.value === 0 || node.value === 0);
+}
+var zero_divided_by_zero_default = {
+  create(context) {
+    return {
+      BinaryExpression(node) {
+        if (node.operator === "/" && isZero(node.left) && isZero(node.right)) {
+          context.report({
+            message: "Zero divided by zero: `0 / 0` is `NaN`. Use `NaN` directly if intentional. (clippy::zero_divided_by_zero)",
+            node
+          });
+        }
+      }
+    };
+  }
+};
+
+// src/rules/redundant-closure.ts
+var SAFE_SINGLE_ARG = new Set([
+  "String",
+  "Number",
+  "Boolean",
+  "BigInt",
+  "parseFloat",
+  "isNaN",
+  "isFinite",
+  "encodeURIComponent",
+  "decodeURIComponent",
+  "encodeURI",
+  "decodeURI"
+]);
+var redundant_closure_default = {
+  create(context) {
+    return {
+      CallExpression(node) {
+        const callee = node.callee;
+        if (callee.type !== "MemberExpression")
+          return;
+        const args = node.arguments;
+        if (!args || args.length !== 1)
+          return;
+        const callback = args[0];
+        let paramName = null;
+        let bodyExpr = null;
+        if (callback.type === "ArrowFunctionExpression" && callback.params.length === 1) {
+          const param = callback.params[0];
+          if (param.type !== "Identifier")
+            return;
+          paramName = param.name;
+          if (callback.body.type === "BlockStatement" && callback.body.body.length === 1) {
+            const stmt = callback.body.body[0];
+            if (stmt.type === "ReturnStatement")
+              bodyExpr = stmt.argument;
+          } else if (callback.body.type !== "BlockStatement") {
+            bodyExpr = callback.body;
+          }
+        } else if (callback.type === "FunctionExpression" && callback.params.length === 1) {
+          const param = callback.params[0];
+          if (param.type !== "Identifier")
+            return;
+          paramName = param.name;
+          if (callback.body.type === "BlockStatement" && callback.body.body.length === 1) {
+            const stmt = callback.body.body[0];
+            if (stmt.type === "ReturnStatement")
+              bodyExpr = stmt.argument;
+          }
+        }
+        if (!paramName || !bodyExpr)
+          return;
+        if (bodyExpr.type !== "CallExpression")
+          return;
+        if (bodyExpr.arguments.length !== 1)
+          return;
+        const innerArg = bodyExpr.arguments[0];
+        if (!isIdentifier(innerArg, paramName))
+          return;
+        const fnCallee = bodyExpr.callee;
+        if (isIdentifier(fnCallee) && SAFE_SINGLE_ARG.has(fnCallee.name)) {
+          context.report({
+            message: `Redundant closure: \`x => ${fnCallee.name}(x)\` can be simplified to \`${fnCallee.name}\`. (clippy::redundant_closure)`,
+            node: callback
+          });
+        }
+      }
+    };
+  }
+};
+
+// src/rules/unnecessary-reduce-collect.ts
+function isEmptyArray(node) {
+  return node.type === "ArrayExpression" && (!node.elements || node.elements.length === 0);
+}
+var unnecessary_reduce_collect_default = {
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (!isMethodCall(node, "reduce"))
+          return;
+        const args = node.arguments;
+        if (!args || args.length !== 2)
+          return;
+        const callback = args[0];
+        const init = args[1];
+        if (!isEmptyArray(init))
+          return;
+        if (callback.type !== "ArrowFunctionExpression" && callback.type !== "FunctionExpression")
+          return;
+        if (callback.params.length !== 2)
+          return;
+        const accParam = callback.params[0];
+        if (accParam.type !== "Identifier")
+          return;
+        const accName = accParam.name;
+        let bodyStmts = null;
+        if (callback.body.type === "BlockStatement") {
+          bodyStmts = callback.body.body;
+        }
+        if (!bodyStmts)
+          return;
+        if (bodyStmts.length === 2) {
+          const pushStmt = bodyStmts[0];
+          const returnStmt = bodyStmts[1];
+          if (returnStmt.type !== "ReturnStatement")
+            return;
+          if (returnStmt.argument?.type !== "Identifier" || returnStmt.argument.name !== accName)
+            return;
+          if (pushStmt.type === "ExpressionStatement" && pushStmt.expression?.type === "CallExpression" && pushStmt.expression.callee?.type === "MemberExpression" && pushStmt.expression.callee.object?.type === "Identifier" && pushStmt.expression.callee.object.name === accName && pushStmt.expression.callee.property?.type === "Identifier" && pushStmt.expression.callee.property.name === "push" && pushStmt.expression.arguments?.length === 1) {
+            context.report({
+              message: "Unnecessary reduce: this `.reduce()` builds an array with `.push()`. Use `.map()` instead. (clippy: prefer combinators)",
+              node
+            });
+            return;
+          }
+        }
+        if (bodyStmts.length === 2) {
+          const ifStmt = bodyStmts[0];
+          const returnStmt = bodyStmts[1];
+          if (returnStmt.type !== "ReturnStatement")
+            return;
+          if (returnStmt.argument?.type !== "Identifier" || returnStmt.argument.name !== accName)
+            return;
+          if (ifStmt.type === "IfStatement" && !ifStmt.alternate) {
+            const consequent = ifStmt.consequent;
+            let pushExpr = null;
+            if (consequent.type === "BlockStatement" && consequent.body.length === 1) {
+              pushExpr = consequent.body[0];
+            } else if (consequent.type === "ExpressionStatement") {
+              pushExpr = consequent;
+            }
+            if (pushExpr?.type === "ExpressionStatement" && pushExpr.expression?.type === "CallExpression" && pushExpr.expression.callee?.type === "MemberExpression" && pushExpr.expression.callee.object?.type === "Identifier" && pushExpr.expression.callee.object.name === accName && pushExpr.expression.callee.property?.type === "Identifier" && pushExpr.expression.callee.property.name === "push") {
+              context.report({
+                message: "Unnecessary reduce: this `.reduce()` conditionally pushes items. Use `.filter()` instead. (clippy: prefer combinators)",
+                node
+              });
+            }
+          }
+        }
+      }
+    };
+  }
+};
+
+// src/rules/prefer-structured-clone.ts
+var prefer_structured_clone_default = {
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (!isCallOf(node, "JSON", "parse"))
+          return;
+        const args = node.arguments;
+        if (!args || args.length !== 1)
+          return;
+        const inner = args[0];
+        if (isCallOf(inner, "JSON", "stringify") && inner.arguments?.length === 1) {
+          context.report({
+            message: "Prefer structuredClone: `JSON.parse(JSON.stringify(x))` can be replaced with `structuredClone(x)`, which handles more types and is more correct. (clippy: don't reinvent stdlib)",
+            node
+          });
+        }
+      }
+    };
+  }
+};
+
+// src/rules/object-keys-values.ts
+var object_keys_values_default = {
+  create(context) {
+    return {
+      CallExpression(node) {
+        const callee = node.callee;
+        if (callee.type !== "MemberExpression")
+          return;
+        const methodName = callee.property;
+        if (methodName?.type !== "Identifier")
+          return;
+        if (methodName.name !== "map" && methodName.name !== "forEach")
+          return;
+        const receiver = callee.object;
+        if (!isCallOf(receiver, "Object", "keys"))
+          return;
+        if (!receiver.arguments || receiver.arguments.length !== 1)
+          return;
+        const objArg = receiver.arguments[0];
+        if (objArg.type !== "Identifier")
+          return;
+        const objName = objArg.name;
+        const args = node.arguments;
+        if (!args || args.length !== 1)
+          return;
+        const callback = args[0];
+        if (callback.type !== "ArrowFunctionExpression" && callback.type !== "FunctionExpression")
+          return;
+        if (callback.params.length !== 1)
+          return;
+        const param = callback.params[0];
+        if (param.type !== "Identifier")
+          return;
+        const keyName = param.name;
+        const bodyStr = context.sourceCode.text.slice(callback.body.start, callback.body.end);
+        const indexPattern = `${objName}[${keyName}]`;
+        if (bodyStr.includes(indexPattern)) {
+          const stripped = bodyStr.replace(new RegExp(`${objName}\\[${keyName}\\]`, "g"), "");
+          const keyStillUsed = new RegExp(`\\b${keyName}\\b`).test(stripped);
+          if (keyStillUsed) {
+            context.report({
+              message: `Object keys+values: \`Object.keys(${objName}).${methodName.name}(${keyName} => ... ${objName}[${keyName}] ...)\` can use \`Object.entries(${objName})\` for clearer access to both key and value. (clippy: for_kv_map)`,
+              node
+            });
+          } else {
+            context.report({
+              message: `Object keys→values: \`Object.keys(${objName}).${methodName.name}(${keyName} => ... ${objName}[${keyName}] ...)\` can be simplified to \`Object.values(${objName}).${methodName.name}(...)\`. (clippy: for_kv_map)`,
+              node
+            });
+          }
+        }
+      }
+    };
+  }
+};
+
+// src/rules/promise-new-resolve.ts
+var promise_new_resolve_default = {
+  create(context) {
+    return {
+      NewExpression(node) {
+        if (!isIdentifier(node.callee, "Promise"))
+          return;
+        if (!node.arguments || node.arguments.length !== 1)
+          return;
+        const callback = node.arguments[0];
+        if (callback.type !== "ArrowFunctionExpression" && callback.type !== "FunctionExpression")
+          return;
+        if (callback.params.length < 1)
+          return;
+        const resolveParam = callback.params[0];
+        const rejectParam = callback.params[1];
+        let bodyExpr = null;
+        if (callback.body.type === "BlockStatement" && callback.body.body.length === 1) {
+          const stmt = callback.body.body[0];
+          if (stmt.type === "ExpressionStatement")
+            bodyExpr = stmt.expression;
+        } else if (callback.body.type !== "BlockStatement") {
+          bodyExpr = callback.body;
+        }
+        if (!bodyExpr || bodyExpr.type !== "CallExpression")
+          return;
+        if (bodyExpr.arguments.length > 1)
+          return;
+        const calledFn = bodyExpr.callee;
+        if (calledFn.type !== "Identifier")
+          return;
+        if (resolveParam.type === "Identifier" && calledFn.name === resolveParam.name) {
+          context.report({
+            message: "Promise constructor wrapping sync value: `new Promise(resolve => resolve(x))` can be simplified to `Promise.resolve(x)`. (clippy: avoid error-prone constructors)",
+            node
+          });
+          return;
+        }
+        if (rejectParam?.type === "Identifier" && calledFn.name === rejectParam.name) {
+          context.report({
+            message: "Promise constructor wrapping sync rejection: `new Promise((_, reject) => reject(x))` can be simplified to `Promise.reject(x)`. (clippy: avoid error-prone constructors)",
+            node
+          });
+        }
+      }
+    };
+  }
+};
+
+// src/rules/similar-names.ts
+var ALLOWED_PAIRS = new Set([
+  "i,j",
+  "j,k",
+  "i,k",
+  "x,y",
+  "y,z",
+  "x,z",
+  "a,b",
+  "b,c",
+  "a,c",
+  "n,m",
+  "r,s"
+]);
+function areSimilar(a, b) {
+  if (Math.abs(a.length - b.length) > 1)
+    return false;
+  if (a.length === b.length) {
+    let diffs2 = 0;
+    let firstDiff = -1;
+    for (let i = 0;i < a.length; i++) {
+      if (a[i] !== b[i]) {
+        if (diffs2 === 0)
+          firstDiff = i;
+        diffs2++;
+        if (diffs2 > 2)
+          return false;
+      }
+    }
+    if (diffs2 <= 1)
+      return diffs2 === 1;
+    if (diffs2 === 2 && a[firstDiff] === b[firstDiff + 1] && a[firstDiff + 1] === b[firstDiff])
+      return true;
+    return false;
+  }
+  const [shorter, longer] = a.length < b.length ? [a, b] : [b, a];
+  let diffs = 0;
+  let si = 0;
+  for (let li = 0;li < longer.length; li++) {
+    if (shorter[si] === longer[li]) {
+      si++;
+    } else {
+      diffs++;
+      if (diffs > 1)
+        return false;
+    }
+  }
+  return true;
+}
+function collectNames(node, names) {
+  if (!node || typeof node !== "object" || !node.type)
+    return;
+  if (node.type === "VariableDeclarator" && node.id?.type === "Identifier") {
+    names.set(node.id.name, node.id);
+  }
+  if (node.type === "FunctionDeclaration" && node.id?.type === "Identifier") {
+    names.set(node.id.name, node.id);
+  }
+  if (node.params) {
+    for (const p of node.params) {
+      if (p.type === "Identifier")
+        names.set(p.name, p);
+      if (p.type === "AssignmentPattern" && p.left?.type === "Identifier")
+        names.set(p.left.name, p.left);
+    }
+  }
+  if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression")
+    return;
+  for (const key of Object.keys(node)) {
+    if (key === "type" || key === "loc" || key === "range" || key === "parent" || key === "start" || key === "end")
+      continue;
+    const val = node[key];
+    if (Array.isArray(val)) {
+      for (const child of val) {
+        if (child && typeof child === "object" && child.type)
+          collectNames(child, names);
+      }
+    } else if (val && typeof val === "object" && val.type) {
+      collectNames(val, names);
+    }
+  }
+}
+var similar_names_default = {
+  create(context) {
+    function checkScope(node) {
+      const names = new Map;
+      if (node.params) {
+        for (const p of node.params) {
+          if (p.type === "Identifier")
+            names.set(p.name, p);
+          if (p.type === "AssignmentPattern" && p.left?.type === "Identifier")
+            names.set(p.left.name, p.left);
+        }
+      }
+      if (node.body?.type === "BlockStatement") {
+        for (const stmt of node.body.body) {
+          collectNames(stmt, names);
+        }
+      }
+      const nameList = [...names.entries()];
+      const reported = new Set;
+      for (let i = 0;i < nameList.length; i++) {
+        for (let j = i + 1;j < nameList.length; j++) {
+          const [nameA] = nameList[i];
+          const [nameB, nodeB] = nameList[j];
+          if (nameA.length < 3 || nameB.length < 3)
+            continue;
+          const pair = [nameA, nameB].sort().join(",");
+          if (ALLOWED_PAIRS.has(pair))
+            continue;
+          if (reported.has(pair))
+            continue;
+          if (areSimilar(nameA.toLowerCase(), nameB.toLowerCase())) {
+            reported.add(pair);
+            context.report({
+              message: `Similar names: \`${nameA}\` and \`${nameB}\` differ by only one character, which is easy to confuse. (clippy::similar_names)`,
+              node: nodeB
+            });
+          }
+        }
+      }
+    }
+    return {
+      FunctionDeclaration: checkScope,
+      FunctionExpression: checkScope,
+      ArrowFunctionExpression: checkScope
+    };
+  }
+};
+
+// src/rules/match-same-arms.ts
+function caseBodySource(caseNode, sourceText) {
+  const stmts = caseNode.consequent;
+  if (!stmts || stmts.length === 0)
+    return "";
+  const meaningful = stmts.filter((s) => s.type !== "BreakStatement");
+  if (meaningful.length === 0)
+    return "";
+  const first = meaningful[0];
+  const last = meaningful[meaningful.length - 1];
+  if (first.start == null || last.end == null)
+    return "";
+  return sourceText.slice(first.start, last.end);
+}
+var match_same_arms_default = {
+  create(context) {
+    return {
+      SwitchStatement(node) {
+        const cases = node.cases;
+        if (!cases || cases.length < 2)
+          return;
+        const seen = new Map;
+        for (const c of cases) {
+          if (c.test === null)
+            continue;
+          const body = caseBodySource(c, context.sourceCode.text);
+          if (!body)
+            continue;
+          const existing = seen.get(body);
+          if (existing) {
+            context.report({
+              message: "Match same arms: multiple switch cases have identical bodies. Consider combining them. (clippy::match_same_arms)",
+              node: c
+            });
+          } else {
+            seen.set(body, c);
+          }
+        }
+      }
+    };
+  }
+};
+
+// src/rules/used-underscore-binding.ts
+var used_underscore_binding_default = {
+  create(context) {
+    const declared = new Map;
+    const used = new Set;
+    return {
+      VariableDeclarator(node) {
+        if (node.id?.type === "Identifier" && node.id.name.startsWith("_") && node.id.name !== "_") {
+          declared.set(node.id.name, node.id);
+        }
+      },
+      Identifier(node) {
+        if (node.name?.startsWith("_") && node.name !== "_") {
+          if (node.parent?.type !== "VariableDeclarator" || node.parent.id !== node) {
+            used.add(node.name);
+          }
+        }
+      },
+      "Program:exit"() {
+        for (const [name, declNode] of declared) {
+          if (used.has(name)) {
+            context.report({
+              message: `Used underscore binding: \`${name}\` starts with \`_\` (conventionally unused) but is actually used. Remove the underscore prefix. (clippy::used_underscore_binding)`,
+              node: declNode
+            });
+          }
+        }
+      }
+    };
+  }
+};
+
+// src/rules/needless-continue.ts
+function checkLoopBody(body, context) {
+  if (body.type !== "BlockStatement" || body.body.length === 0)
+    return;
+  const stmts = body.body;
+  const last = stmts[stmts.length - 1];
+  if (last.type === "ContinueStatement" && !last.label) {
+    context.report({
+      message: "Needless continue: `continue` at the end of a loop body has no effect. (clippy::needless_continue)",
+      node: last
+    });
+    return;
+  }
+  if (last.type === "IfStatement" && last.alternate) {
+    const alt = last.alternate;
+    const altBody = alt.type === "BlockStatement" ? alt.body : [alt];
+    if (altBody.length === 1 && altBody[0].type === "ContinueStatement" && !altBody[0].label) {
+      context.report({
+        message: "Needless continue: `else { continue; }` at the end of a loop is redundant. Remove the else branch. (clippy::needless_continue)",
+        node: altBody[0]
+      });
+    }
+  }
+}
+var needless_continue_default = {
+  create(context) {
+    return {
+      ForStatement: (node) => checkLoopBody(node.body, context),
+      ForOfStatement: (node) => checkLoopBody(node.body, context),
+      ForInStatement: (node) => checkLoopBody(node.body, context),
+      WhileStatement: (node) => checkLoopBody(node.body, context),
+      DoWhileStatement: (node) => checkLoopBody(node.body, context)
+    };
+  }
+};
+
+// src/rules/enum-variant-names.ts
+var enum_variant_names_default = {
+  create(context) {
+    return {
+      TSEnumDeclaration(node) {
+        const enumName = node.id?.name;
+        if (!enumName)
+          return;
+        const members = node.members ?? node.body?.members;
+        if (!members || members.length < 2)
+          return;
+        const names = members.map((m) => m.id?.type === "Identifier" ? m.id.name : null).filter((n) => n !== null);
+        if (names.length < 2)
+          return;
+        const lowerEnum = enumName.toLowerCase();
+        const allPrefixed = names.every((n) => n.toLowerCase().startsWith(lowerEnum));
+        if (allPrefixed) {
+          context.report({
+            message: `Enum variant names: all members of \`${enumName}\` are prefixed with \`${enumName}\`. Remove the redundant prefix. (clippy::enum_variant_names)`,
+            node
+          });
+          return;
+        }
+        const allSuffixed = names.every((n) => n.toLowerCase().endsWith(lowerEnum));
+        if (allSuffixed) {
+          context.report({
+            message: `Enum variant names: all members of \`${enumName}\` are suffixed with \`${enumName}\`. Remove the redundant suffix. (clippy::enum_variant_names)`,
+            node
+          });
+        }
+      }
+    };
+  }
+};
+
+// src/rules/struct-field-names.ts
+function getFieldNames(node) {
+  const body = node.body?.body ?? node.body?.members ?? node.members;
+  if (!Array.isArray(body))
+    return [];
+  return body.map((m) => {
+    if (m.type === "TSPropertySignature" || m.type === "PropertyDefinition") {
+      return m.key?.type === "Identifier" ? m.key.name : null;
+    }
+    return null;
+  }).filter((n) => n !== null);
+}
+function commonPrefix(names) {
+  if (names.length < 2)
+    return "";
+  let prefix = names[0];
+  for (let i = 1;i < names.length; i++) {
+    const name = names[i];
+    let j = 0;
+    while (j < prefix.length && j < name.length && prefix[j].toLowerCase() === name[j].toLowerCase())
+      j++;
+    prefix = prefix.slice(0, j);
+  }
+  if (!prefix)
+    return "";
+  if (prefix.endsWith("_"))
+    return prefix;
+  for (const name of names) {
+    if (name.length > prefix.length) {
+      const nextChar = name[prefix.length];
+      if (nextChar >= "A" && nextChar <= "Z")
+        return prefix;
+      return "";
+    }
+  }
+  return prefix;
+}
+function commonSuffix(names) {
+  if (names.length < 2)
+    return "";
+  let suffix = names[0];
+  for (let i = 1;i < names.length; i++) {
+    const name = names[i];
+    let j = 0;
+    while (j < suffix.length && j < name.length && suffix[suffix.length - 1 - j] === name[name.length - 1 - j])
+      j++;
+    suffix = suffix.slice(suffix.length - j);
+  }
+  if (!suffix)
+    return "";
+  if (suffix[0] >= "A" && suffix[0] <= "Z")
+    return suffix;
+  if (suffix.startsWith("_"))
+    return suffix;
+  return "";
+}
+var struct_field_names_default = {
+  create(context) {
+    function check(node, typeName) {
+      if (!typeName)
+        return;
+      const names = getFieldNames(node);
+      if (names.length < 2)
+        return;
+      const prefix = commonPrefix(names);
+      if (prefix.length >= 3) {
+        context.report({
+          message: `Struct field names: all fields of \`${typeName}\` share the prefix \`${prefix}\`. Remove it — the type name provides context. (clippy::struct_field_names)`,
+          node
+        });
+        return;
+      }
+      const suffix = commonSuffix(names);
+      if (suffix.length >= 3) {
+        context.report({
+          message: `Struct field names: all fields of \`${typeName}\` share the suffix \`${suffix}\`. Consider removing it. (clippy::struct_field_names)`,
+          node
+        });
+      }
+    }
+    return {
+      TSInterfaceDeclaration(node) {
+        check(node, node.id?.name);
+      },
+      TSTypeAliasDeclaration(node) {
+        if (node.typeAnnotation?.type === "TSTypeLiteral") {
+          check(node.typeAnnotation, node.id?.name);
+        }
+      }
+    };
+  }
+};
+
+// src/rules/unreadable-literal.ts
+var INT_THRESHOLD = 1e4;
+var unreadable_literal_default = {
+  create(context) {
+    return {
+      Literal(node) {
+        if (typeof node.value !== "number")
+          return;
+        if (!Number.isFinite(node.value))
+          return;
+        const raw = node.raw;
+        if (!raw)
+          return;
+        if (raw.includes("_"))
+          return;
+        if (raw.startsWith("0x") || raw.startsWith("0o") || raw.startsWith("0b") || raw.startsWith("0X") || raw.startsWith("0O") || raw.startsWith("0B"))
+          return;
+        if (raw.includes("."))
+          return;
+        if (raw.includes("e") || raw.includes("E"))
+          return;
+        const absVal = Math.abs(node.value);
+        if (absVal >= INT_THRESHOLD && Number.isInteger(absVal)) {
+          context.report({
+            message: `Unreadable literal: \`${raw}\` is hard to read. Use numeric separators: \`${formatWithSeparators(raw)}\`. (clippy::unreadable_literal)`,
+            node
+          });
+        }
+      }
+    };
+  }
+};
+function formatWithSeparators(raw) {
+  const negative = raw.startsWith("-");
+  const digits = negative ? raw.slice(1) : raw;
+  const parts = [];
+  for (let i = digits.length;i > 0; i -= 3) {
+    parts.unshift(digits.slice(Math.max(0, i - 3), i));
+  }
+  return (negative ? "-" : "") + parts.join("_");
+}
+
+// src/rules/bool-to-int-with-if.ts
+var bool_to_int_with_if_default = {
+  create(context) {
+    return {
+      ConditionalExpression(node) {
+        const { consequent, alternate } = node;
+        if (isLiteral(consequent, 1) && isLiteral(alternate, 0)) {
+          context.report({
+            message: "Bool to int with if: `cond ? 1 : 0` can be simplified to `Number(cond)` or `+cond`. (clippy::bool_to_int_with_if)",
+            node
+          });
+        } else if (isLiteral(consequent, 0) && isLiteral(alternate, 1)) {
+          context.report({
+            message: "Bool to int with if: `cond ? 0 : 1` can be simplified to `Number(!cond)` or `+!cond`. (clippy::bool_to_int_with_if)",
+            node
+          });
+        }
+      }
+    };
+  }
+};
+
+// src/plugin.ts
+var plugin = {
+  meta: {
+    name: "oxclippy",
+    version: "0.1.0"
+  },
+  rules: {
+    "needless-bool": needless_bool_default,
+    "collapsible-if": collapsible_if_default,
+    "neg-multiply": neg_multiply_default,
+    "bool-comparison": bool_comparison_default,
+    "single-case-switch": single_case_switch_default,
+    "let-and-return": let_and_return_default,
+    "int-plus-one": int_plus_one_default,
+    "needless-late-init": needless_late_init_default,
+    "identity-op": identity_op_default,
+    "manual-clamp": manual_clamp_default,
+    "manual-strip": manual_strip_default,
+    "useless-conversion": useless_conversion_default,
+    "manual-swap": manual_swap_default,
+    "manual-is-finite": manual_is_finite_default,
+    "float-comparison": float_comparison_default,
+    "xor-used-as-pow": xor_used_as_pow_default,
+    "almost-swapped": almost_swapped_default,
+    "if-same-then-else": if_same_then_else_default,
+    "never-loop": never_loop_default,
+    "float-equality-without-abs": float_equality_without_abs_default,
+    "zero-divided-by-zero": zero_divided_by_zero_default,
+    "filter-then-first": filter_then_first_default,
+    "map-void-return": map_void_return_default,
+    "map-identity": map_identity_default,
+    "manual-find": manual_find_default,
+    "manual-some": manual_some_default,
+    "manual-every": manual_every_default,
+    "manual-includes": manual_includes_default,
+    "search-is-some": search_is_some_default,
+    "needless-range-loop": needless_range_loop_default,
+    "redundant-closure-call": redundant_closure_call_default,
+    "explicit-counter-loop": explicit_counter_loop_default,
+    "unnecessary-fold": unnecessary_fold_default,
+    "single-element-loop": single_element_loop_default,
+    "too-many-arguments": too_many_arguments_default,
+    "too-many-lines": too_many_lines_default,
+    "cognitive-complexity": cognitive_complexity_default,
+    "excessive-nesting": excessive_nesting_default,
+    "fn-params-excessive-bools": fn_params_excessive_bools_default,
+    "redundant-closure": redundant_closure_default,
+    "unnecessary-reduce-collect": unnecessary_reduce_collect_default,
+    "prefer-structured-clone": prefer_structured_clone_default,
+    "object-keys-values": object_keys_values_default,
+    "promise-new-resolve": promise_new_resolve_default,
+    "similar-names": similar_names_default,
+    "match-same-arms": match_same_arms_default,
+    "used-underscore-binding": used_underscore_binding_default,
+    "needless-continue": needless_continue_default,
+    "enum-variant-names": enum_variant_names_default,
+    "struct-field-names": struct_field_names_default,
+    "unreadable-literal": unreadable_literal_default,
+    "bool-to-int-with-if": bool_to_int_with_if_default
+  }
+};
+var plugin_default = plugin;
+export {
+  plugin_default as default
+};