eslint-plugin-remeda 1.2.0 → 1.3.0

package/dist/index.js

@@ -19,12 +19,14 @@ var package_default = {
   scripts: {
     build: "tsup",
     typecheck: "tsc",
+    lint: "eslint",
     knip: "knip",
     publint: "publint",
     "test:watch": "vitest --ui",
     test: "vitest run",
     attw: "attw --pack .",
     qa: "pnpm typecheck && pnpm test && pnpm knip && pnpm publint && attw",
+    nuke: "rm -rf node_modules pnpm-lock.yaml",
     "semantic-release": "pnpm build && semantic-release"
   },
   files: [
@@ -54,8 +56,10 @@ var package_default = {
     "@types/node": "^20.14.9",
     "@vitest/coverage-v8": "^2.0.3",
     "@vitest/ui": "^2.0.3",
-    eslint: "^9.7.0",
-    "eslint-plugin-eslint-plugin": "^4.2.0",
+    eslint: "9.10.0",
+    "eslint-config-sheriff": "^21.2.0",
+    "eslint-define-config": "^2.1.0",
+    "eslint-plugin-eslint-plugin": "^6.2.0",
     "eslint-vitest-rule-tester": "^0.3.3",
     knip: "^5.29.1",
     prettier: "^3.3.2",
@@ -68,7 +72,7 @@ var package_default = {
   engines: {
     node: ">=20"
   },
-  packageManager: "pnpm@9.7.1",
+  packageManager: "pnpm@9.9.0",
   publishConfig: {
     access: "public"
   },
@@ -87,17 +91,231 @@ var package_default = {
   }
 };
 
+// src/rules/collection-method-value.ts
+import includes5 from "lodash/includes";
+
+// src/util/astUtil.ts
+import {
+  cond,
+  flatMap,
+  get,
+  includes,
+  isEqualWith,
+  isMatch,
+  matches,
+  matchesProperty,
+  overEvery,
+  overSome,
+  property
+} from "lodash";
+var getCaller = property(["callee", "object"]);
+var getMethodName = property(["callee", "property", "name"]);
+var isMethodCall = matches({
+  type: "CallExpression",
+  callee: { type: "MemberExpression" }
+});
+var isFunctionExpression = overSome(
+  matchesProperty("type", "FunctionExpression"),
+  matchesProperty("type", "FunctionDeclaration")
+);
+var isFunctionDefinitionWithBlock = overSome(
+  isFunctionExpression,
+  matches({
+    type: "ArrowFunctionExpression",
+    body: { type: "BlockStatement" }
+  })
+);
+var getFirstFunctionLine = cond([
+  [isFunctionDefinitionWithBlock, property(["body", "body", 0])],
+  [matches({ type: "ArrowFunctionExpression" }), property("body")]
+]);
+var isPropAccess = overSome(
+  matches({ computed: false }),
+  matchesProperty(["property", "type"], "Literal")
+);
+function isMemberExpOf(node, objectName, { maxLength = Number.MAX_VALUE, allowComputed } = {}) {
+  if (objectName) {
+    let curr = node;
+    let depth = maxLength;
+    while (curr && depth) {
+      if (allowComputed || isPropAccess(curr)) {
+        if (curr.type === "MemberExpression" && curr.object.name === objectName) {
+          return true;
+        }
+        curr = curr.object;
+        depth--;
+      } else {
+        return false;
+      }
+    }
+  }
+}
+var getFirstParamName = property(["params", 0, "name"]);
+var isReturnStatement = matchesProperty("type", "ReturnStatement");
+function hasOnlyOneStatement(func) {
+  if (isFunctionDefinitionWithBlock(func)) {
+    return get(func, "body.body.length") === 1;
+  }
+  if (func.type === "ArrowFunctionExpression") {
+    return !get(func, "body.body");
+  }
+}
+function isObjectOfMethodCall(node) {
+  return get(node, "parent.object") === node && get(node, "parent.parent.type") === "CallExpression";
+}
+function isLiteral(node) {
+  return node.type === "Literal";
+}
+function isBinaryExpWithMemberOf(operator, exp, objectName, {
+  maxLength,
+  allowComputed,
+  onlyLiterals
+} = {}) {
+  if (!isMatch(exp, { type: "BinaryExpression", operator })) {
+    return false;
+  }
+  const [left, right] = [exp.left, exp.right].map(
+    (side) => isMemberExpOf(side, objectName, { maxLength, allowComputed })
+  );
+  return left === !right && (!onlyLiterals || isLiteral(exp.left) || isLiteral(exp.right));
+}
+var isNegationExpression = matches({
+  type: "UnaryExpression",
+  operator: "!"
+});
+function isNegationOfMemberOf(exp, objectName, { maxLength } = {}) {
+  return isNegationExpression(exp) && isMemberExpOf(exp.argument, objectName, { maxLength, allowComputed: false });
+}
+function isIdentifierWithName(exp, paramName) {
+  return exp && paramName && exp.type === "Identifier" && exp.name === paramName;
+}
+function getValueReturnedInFirstStatement(func) {
+  const firstLine = getFirstFunctionLine(func);
+  if (func) {
+    if (isFunctionDefinitionWithBlock(func)) {
+      return isReturnStatement(firstLine) ? firstLine.argument : void 0;
+    }
+    if (func.type === "ArrowFunctionExpression") {
+      return firstLine;
+    }
+  }
+}
+function isCallFromObject(node, objName) {
+  return node && objName && node.type === "CallExpression" && get(node, "callee.object.name") === objName;
+}
+function isComputed(node) {
+  return get(node, "computed") && node.property.type !== "Literal";
+}
+function isEquivalentMemberExp(a, b) {
+  return isEqualWith(a, b, (left, right, key) => {
+    if (includes(["loc", "range", "computed", "start", "end", "parent"], key)) {
+      return true;
+    }
+    if (isComputed(left) || isComputed(right)) {
+      return false;
+    }
+    if (key === "property") {
+      const leftValue = left.name || left.value;
+      const rightValue = right.name || right.value;
+      return leftValue === rightValue;
+    }
+  });
+}
+var isEqEqEq = matches({ type: "BinaryExpression", operator: "===" });
+var isMinus = (node) => node.type === "UnaryExpression" && node.operator === "-";
+var comparisonType = {
+  exact: 0,
+  over: 1,
+  under: 2,
+  any: 3
+};
+var comparisonOperators = ["==", "!=", "===", "!=="];
+function getIsValue(value2) {
+  return value2 < 0 ? overEvery(isMinus, matches({ argument: { value: -value2 } })) : matches({ value: value2 });
+}
+function getExpressionComparedToInt(node, value2, checkOver) {
+  const isValue = getIsValue(value2);
+  if (includes(comparisonOperators, node.operator)) {
+    if (isValue(node.right)) {
+      return node.left;
+    }
+    if (isValue(node.left)) {
+      return node.right;
+    }
+  }
+  if (checkOver) {
+    if (node.operator === ">" && isValue(node.right)) {
+      return node.left;
+    }
+    if (node.operator === "<" && isValue(node.left)) {
+      return node.right;
+    }
+    const isNext = getIsValue(value2 + 1);
+    if ((node.operator === ">=" || node.operator === "<") && isNext(node.right)) {
+      return node.left;
+    }
+    if ((node.operator === "<=" || node.operator === ">") && isNext(node.left)) {
+      return node.right;
+    }
+  }
+}
+var isIndexOfCall = (node) => isMethodCall(node) && getMethodName(node) === "indexOf";
+var isFindIndexCall = (node) => isMethodCall(node) && getMethodName(node) === "findIndex";
+function collectParameterValues(node) {
+  switch (node && node.type) {
+    case "Identifier": {
+      return [node.name];
+    }
+    case "ObjectPattern": {
+      return flatMap(
+        node.properties,
+        (prop) => collectParameterValues(prop.value)
+      );
+    }
+    case "ArrayPattern": {
+      return flatMap(node.elements, collectParameterValues);
+    }
+    default: {
+      return [];
+    }
+  }
+}
+var astUtil_default = {
+  getCaller,
+  getMethodName,
+  isMethodCall,
+  getFirstFunctionLine,
+  isMemberExpOf,
+  getFirstParamName,
+  hasOnlyOneStatement,
+  isObjectOfMethodCall,
+  isEqEqEqToMemberOf: isBinaryExpWithMemberOf.bind(null, "==="),
+  isNotEqEqToMemberOf: isBinaryExpWithMemberOf.bind(null, "!=="),
+  isNegationOfMemberOf,
+  isIdentifierWithName,
+  isNegationExpression,
+  getValueReturnedInFirstStatement,
+  isCallFromObject,
+  isComputed,
+  isEquivalentMemberExp,
+  isEqEqEq,
+  comparisonType,
+  getExpressionComparedToInt,
+  isIndexOfCall,
+  isFindIndexCall,
+  isFunctionExpression,
+  isFunctionDefinitionWithBlock,
+  collectParameterValues
+};
+
 // src/util/getDocsUrl.ts
 var REPO_URL = "https://github.com/AndreaPontrandolfo/eslint-plugin-remeda";
 function getDocsUrl(ruleName) {
   return `${REPO_URL}/blob/v${version}/docs/rules/${ruleName}.md`;
 }
 
-// src/util/remedaUtil.ts
-import { includes as includes4, capitalize as capitalize2 } from "lodash";
-
 // src/util/methodDataUtil.ts
-import { includes as includes2, get as get2, isObject as isObject2, has as has2 } from "lodash";
+import { get as get3, has as has2, includes as includes3, isObject as isObject2 } from "lodash";
 
 // src/util/methodData.ts
 var methodData_exports = {};
@@ -128,7 +346,7 @@ __export(methodData_exports, {
   cloneWith: () => cloneWith,
   commit: () => commit,
   concat: () => concat,
-  cond: () => cond,
+  cond: () => cond2,
   conforms: () => conforms,
   conformsTo: () => conformsTo,
   constant: () => constant,
@@ -165,7 +383,7 @@ __export(methodData_exports, {
   findLastIndex: () => findLastIndex,
   findLastKey: () => findLastKey,
   first: () => first,
-  flatMap: () => flatMap,
+  flatMap: () => flatMap2,
   flatMapDeep: () => flatMapDeep,
   flatMapDepth: () => flatMapDepth,
   flatten: () => flatten,
@@ -184,7 +402,7 @@ __export(methodData_exports, {
   fromPairs: () => fromPairs,
   functions: () => functions,
   functionsIn: () => functionsIn,
-  get: () => get,
+  get: () => get2,
   groupBy: () => groupBy,
   gt: () => gt,
   gte: () => gte,
@@ -193,7 +411,7 @@ __export(methodData_exports, {
   head: () => head,
   identity: () => identity,
   inRange: () => inRange,
-  includes: () => includes,
+  includes: () => includes2,
   indexBy: () => indexBy,
   indexOf: () => indexOf,
   initial: () => initial,
@@ -215,14 +433,14 @@ __export(methodData_exports, {
   isElement: () => isElement,
   isEmpty: () => isEmpty,
   isEqual: () => isEqual,
-  isEqualWith: () => isEqualWith,
+  isEqualWith: () => isEqualWith2,
   isError: () => isError,
   isFinite: () => isFinite,
   isFunction: () => isFunction,
   isInteger: () => isInteger,
   isLength: () => isLength,
   isMap: () => isMap,
-  isMatch: () => isMatch,
+  isMatch: () => isMatch2,
   isMatchWith: () => isMatchWith,
   isNaN: () => isNaN,
   isNative: () => isNative,
@@ -256,8 +474,8 @@ __export(methodData_exports, {
   map: () => map,
   mapKeys: () => mapKeys,
   mapValues: () => mapValues,
-  matches: () => matches,
-  matchesProperty: () => matchesProperty,
+  matches: () => matches2,
+  matchesProperty: () => matchesProperty2,
   max: () => max,
   maxBy: () => maxBy,
   mean: () => mean,
@@ -284,8 +502,8 @@ __export(methodData_exports, {
   orderBy: () => orderBy,
   over: () => over,
   overArgs: () => overArgs,
-  overEvery: () => overEvery,
-  overSome: () => overSome,
+  overEvery: () => overEvery2,
+  overSome: () => overSome2,
   pad: () => pad,
   padEnd: () => padEnd,
   padStart: () => padStart,
@@ -297,7 +515,7 @@ __export(methodData_exports, {
   pickBy: () => pickBy,
   plant: () => plant,
   pop: () => pop,
-  property: () => property,
+  property: () => property2,
   propertyOf: () => propertyOf,
   pull: () => pull,
   pullAll: () => pullAll,
@@ -583,7 +801,7 @@ var concat = {
   chainable: true,
   iteratee: false
 };
-var cond = {
+var cond2 = {
   wrapper: false,
   shorthand: false,
   chainable: false,
@@ -828,7 +1046,7 @@ var findLastKey = {
   iteratee: true,
   args: 2
 };
-var flatMap = {
+var flatMap2 = {
   wrapper: false,
   shorthand: true,
   chainable: true,
@@ -959,7 +1177,7 @@ var functionsIn = {
   iteratee: false,
   args: 1
 };
-var get = {
+var get2 = {
   wrapper: false,
   shorthand: false,
   chainable: false,
@@ -1029,7 +1247,7 @@ var inRange = {
   iteratee: false,
   args: 3
 };
-var includes = {
+var includes2 = {
   wrapper: false,
   shorthand: false,
   chainable: false,
@@ -1177,7 +1395,7 @@ var isEqual = {
   iteratee: false,
   args: 2
 };
-var isEqualWith = {
+var isEqualWith2 = {
   wrapper: false,
   shorthand: false,
   chainable: false,
@@ -1226,7 +1444,7 @@ var isMap = {
   iteratee: false,
   args: 1
 };
-var isMatch = {
+var isMatch2 = {
   wrapper: false,
   shorthand: false,
   chainable: false,
@@ -1463,14 +1681,14 @@ var mapValues = {
   iteratee: true,
   args: 2
 };
-var matches = {
+var matches2 = {
   wrapper: false,
   shorthand: false,
   chainable: true,
   iteratee: false,
   args: 1
 };
-var matchesProperty = {
+var matchesProperty2 = {
   wrapper: false,
   shorthand: false,
   chainable: true,
@@ -1651,13 +1869,13 @@ var overArgs = {
   chainable: true,
   iteratee: false
 };
-var overEvery = {
+var overEvery2 = {
   wrapper: false,
   shorthand: true,
   chainable: true,
   iteratee: true
 };
-var overSome = {
+var overSome2 = {
   wrapper: false,
   shorthand: true,
   chainable: true,
@@ -1734,7 +1952,7 @@ var pop = {
   chainable: false,
   iteratee: false
 };
-var property = {
+var property2 = {
   wrapper: false,
   shorthand: false,
   chainable: true,
@@ -2521,10 +2739,10 @@ var zipWith = {
 
 // src/util/methodDataUtil.ts
 function isCollectionMethod(method2) {
-  return methodSupportsShorthand(method2) || includes2(["reduce", "reduceRight"], method2);
+  return methodSupportsShorthand(method2) || includes3(["reduce", "reduceRight"], method2);
 }
 function methodSupportsShorthand(method2, shorthandType) {
-  const methodShorthandData = get2(methodData_exports, [method2, "shorthand"]);
+  const methodShorthandData = get3(methodData_exports, `${method2}.shorthand`);
   return isObject2(methodShorthandData) ? Boolean(shorthandType && methodShorthandData[shorthandType]) : Boolean(methodShorthandData);
 }
 function getIterateeIndex(method2) {
@@ -2532,7 +2750,7 @@ function getIterateeIndex(method2) {
   if (has2(methodData, "iterateeIndex")) {
     return methodData.iterateeIndex;
   }
-  if (methodData?.iteratee) {
+  if (methodData.iteratee) {
     return 1;
   }
   return -1;
@@ -2549,215 +2767,8 @@ function getSideEffectIterationMethods() {
   return sideEffectIterationMethods;
 }
 
-// src/util/astUtil.ts
-import {
-  property as property2,
-  matches as matches2,
-  overSome as overSome2,
-  matchesProperty as matchesProperty2,
-  cond as cond2,
-  get as get3,
-  isMatch as isMatch2,
-  isEqualWith as isEqualWith2,
-  includes as includes3,
-  overEvery as overEvery2,
-  flatMap as flatMap2
-} from "lodash";
-var getCaller = property2(["callee", "object"]);
-var getMethodName = property2(["callee", "property", "name"]);
-var isMethodCall = matches2({
-  type: "CallExpression",
-  callee: { type: "MemberExpression" }
-});
-var isFunctionExpression = overSome2(
-  matchesProperty2("type", "FunctionExpression"),
-  matchesProperty2("type", "FunctionDeclaration")
-);
-var isFunctionDefinitionWithBlock = overSome2(
-  isFunctionExpression,
-  matches2({
-    type: "ArrowFunctionExpression",
-    body: { type: "BlockStatement" }
-  })
-);
-var getFirstFunctionLine = cond2([
-  [isFunctionDefinitionWithBlock, property2(["body", "body", 0])],
-  [matches2({ type: "ArrowFunctionExpression" }), property2("body")]
-]);
-var isPropAccess = overSome2(
-  matches2({ computed: false }),
-  matchesProperty2(["property", "type"], "Literal")
-);
-function isMemberExpOf(node, objectName, { maxLength = Number.MAX_VALUE, allowComputed } = {}) {
-  if (objectName) {
-    let curr = node;
-    let depth = maxLength;
-    while (curr && depth) {
-      if (allowComputed || isPropAccess(curr)) {
-        if (curr.type === "MemberExpression" && curr.object.name === objectName) {
-          return true;
-        }
-        curr = curr.object;
-        depth--;
-      } else {
-        return false;
-      }
-    }
-  }
-}
-var getFirstParamName = property2(["params", 0, "name"]);
-var isReturnStatement = matchesProperty2("type", "ReturnStatement");
-function hasOnlyOneStatement(func) {
-  if (isFunctionDefinitionWithBlock(func)) {
-    return get3(func, "body.body.length") === 1;
-  }
-  if (func.type === "ArrowFunctionExpression") {
-    return !get3(func, "body.body");
-  }
-}
-function isObjectOfMethodCall(node) {
-  return get3(node, "parent.object") === node && get3(node, "parent.parent.type") === "CallExpression";
-}
-function isLiteral(node) {
-  return node.type === "Literal";
-}
-function isBinaryExpWithMemberOf(operator, exp, objectName, {
-  maxLength,
-  allowComputed,
-  onlyLiterals
-} = {}) {
-  if (!isMatch2(exp, { type: "BinaryExpression", operator })) {
-    return false;
-  }
-  const [left, right] = [exp.left, exp.right].map(
-    (side) => isMemberExpOf(side, objectName, { maxLength, allowComputed })
-  );
-  return left === !right && (!onlyLiterals || isLiteral(exp.left) || isLiteral(exp.right));
-}
-var isNegationExpression = matches2({
-  type: "UnaryExpression",
-  operator: "!"
-});
-function isNegationOfMemberOf(exp, objectName, { maxLength } = {}) {
-  return isNegationExpression(exp) && isMemberExpOf(exp.argument, objectName, { maxLength, allowComputed: false });
-}
-function isIdentifierWithName(exp, paramName) {
-  return exp && paramName && exp.type === "Identifier" && exp.name === paramName;
-}
-function getValueReturnedInFirstStatement(func) {
-  const firstLine = getFirstFunctionLine(func);
-  if (func) {
-    if (isFunctionDefinitionWithBlock(func)) {
-      return isReturnStatement(firstLine) ? firstLine.argument : void 0;
-    }
-    if (func.type === "ArrowFunctionExpression") {
-      return firstLine;
-    }
-  }
-}
-function isCallFromObject(node, objName) {
-  return node && objName && node.type === "CallExpression" && get3(node, "callee.object.name") === objName;
-}
-function isComputed(node) {
-  return get3(node, "computed") && node.property.type !== "Literal";
-}
-function isEquivalentMemberExp(a, b) {
-  return isEqualWith2(a, b, (left, right, key) => {
-    if (includes3(["loc", "range", "computed", "start", "end", "parent"], key)) {
-      return true;
-    }
-    if (isComputed(left) || isComputed(right)) {
-      return false;
-    }
-    if (key === "property") {
-      const leftValue = left.name || left.value;
-      const rightValue = right.name || right.value;
-      return leftValue === rightValue;
-    }
-  });
-}
-var isEqEqEq = matches2({ type: "BinaryExpression", operator: "===" });
-var isMinus = (node) => node.type === "UnaryExpression" && node.operator === "-";
-var comparisonType = {
-  exact: 0,
-  over: 1,
-  under: 2,
-  any: 3
-};
-var comparisonOperators = ["==", "!=", "===", "!=="];
-function getIsValue(value2) {
-  return value2 < 0 ? overEvery2(isMinus, matches2({ argument: { value: -value2 } })) : matches2({ value: value2 });
-}
-function getExpressionComparedToInt(node, value2, checkOver) {
-  const isValue = getIsValue(value2);
-  if (includes3(comparisonOperators, node.operator)) {
-    if (isValue(node.right)) {
-      return node.left;
-    }
-    if (isValue(node.left)) {
-      return node.right;
-    }
-  }
-  if (checkOver) {
-    if (node.operator === ">" && isValue(node.right)) {
-      return node.left;
-    }
-    if (node.operator === "<" && isValue(node.left)) {
-      return node.right;
-    }
-    const isNext = getIsValue(value2 + 1);
-    if ((node.operator === ">=" || node.operator === "<") && isNext(node.right)) {
-      return node.left;
-    }
-    if ((node.operator === "<=" || node.operator === ">") && isNext(node.left)) {
-      return node.right;
-    }
-  }
-}
-var isIndexOfCall = (node) => isMethodCall(node) && getMethodName(node) === "indexOf";
-var isFindIndexCall = (node) => isMethodCall(node) && getMethodName(node) === "findIndex";
-function collectParameterValues(node) {
-  switch (node && node.type) {
-    case "Identifier":
-      return [node.name];
-    case "ObjectPattern":
-      return flatMap2(
-        node.properties,
-        (prop) => collectParameterValues(prop.value)
-      );
-    case "ArrayPattern":
-      return flatMap2(node.elements, collectParameterValues);
-    default:
-      return [];
-  }
-}
-var astUtil_default = {
-  getCaller,
-  getMethodName,
-  isMethodCall,
-  getFirstFunctionLine,
-  isMemberExpOf,
-  getFirstParamName,
-  hasOnlyOneStatement,
-  isObjectOfMethodCall,
-  isEqEqEqToMemberOf: isBinaryExpWithMemberOf.bind(null, "==="),
-  isNotEqEqToMemberOf: isBinaryExpWithMemberOf.bind(null, "!=="),
-  isNegationOfMemberOf,
-  isIdentifierWithName,
-  isNegationExpression,
-  getValueReturnedInFirstStatement,
-  isCallFromObject,
-  isComputed,
-  isEquivalentMemberExp,
-  isEqEqEq,
-  comparisonType,
-  getExpressionComparedToInt,
-  isIndexOfCall,
-  isFindIndexCall,
-  isFunctionExpression,
-  isFunctionDefinitionWithBlock,
-  collectParameterValues
-};
+// src/util/remedaUtil.ts
+import { capitalize as capitalize2, includes as includes4 } from "lodash";
 
 // src/util/settingsUtil.ts
 import { chain as chain2, get as get4 } from "lodash";
@@ -2789,7 +2800,8 @@ var RemedaContext_default = class {
   _pragma;
   /**
    * Create a Remeda context wrapper from a file's RuleContext
-   * @param {RuleContext} context
+   *
+   * @param context
    */
   constructor(context) {
     this.context = context;
@@ -2798,7 +2810,8 @@ var RemedaContext_default = class {
   }
   /**
    * Gets visitors to collect Remeda declarations in the context
-   * @returns {Object} visitors for everywhere Remeda can be declared
+   *
+   * @returns visitors for everywhere Remeda can be declared
    */
   getImportVisitors() {
     const self = this;
@@ -2808,15 +2821,17 @@ var RemedaContext_default = class {
           specifiers.forEach((spec) => {
             switch (spec.type) {
               case "ImportNamespaceSpecifier":
-              case "ImportDefaultSpecifier":
+              case "ImportDefaultSpecifier": {
                 self.general[spec.local.name] = true;
                 break;
-              case "ImportSpecifier":
+              }
+              case "ImportSpecifier": {
                 self.methods[spec.local.name] = spec.imported.name;
                 if (spec.imported.name === "chain") {
                   self.general[spec.local.name] = true;
                 }
                 break;
+              }
             }
           });
         } else {
@@ -2850,8 +2865,9 @@ var RemedaContext_default = class {
   }
   /**
    * Returns whether the node is an imported Remeda in this context
+   *
    * @param node
-   * @returns {boolean|undefined}
+   * @returns
    */
   isImportedRemeda(node) {
     if (node && node.type === "Identifier") {
@@ -2860,8 +2876,9 @@ var RemedaContext_default = class {
   }
   /**
    * Returns the name of the Remeda method for this node, if any
+   *
    * @param node
-   * @returns {string|undefined}
+   * @returns
    */
   getImportedRemedaMethod(node) {
     if (node && node.type === "CallExpression" && !isMethodCall2(node)) {
@@ -2870,15 +2887,16 @@ var RemedaContext_default = class {
   }
   /**
    * Returns whether the node is a call from a Remeda object
+   *
    * @param node
-   * @returns {boolean|undefined}
+   * @returns
    */
   isRemedaCall(node) {
     return this.pragma && isCallFromObject2(node, this.pragma) || this.isImportedRemeda(getCaller2(node));
   }
   /**
    *
-   * @returns {string|undefined} the current Remeda pragma
+   * @returns the current Remeda pragma
    */
   get pragma() {
     if (!this._pragma) {
@@ -2956,7 +2974,6 @@ function getRemedaContext(context) {
 }
 
 // src/rules/collection-method-value.ts
-import includes5 from "lodash/includes";
 var { getMethodName: getMethodName2 } = astUtil_default;
 var meta = {
   type: "problem",
@@ -3074,16 +3091,21 @@ function create4(context) {
   const shouldCheckFunctionDeclarations = context.options[1] !== void 0 ? context.options[1] : false;
   function isCompletelyLiteral(node) {
     switch (node.type) {
-      case "Literal":
+      case "Literal": {
         return true;
-      case "BinaryExpression":
+      }
+      case "BinaryExpression": {
         return isCompletelyLiteral(node.left) && isCompletelyLiteral(node.right);
-      case "UnaryExpression":
+      }
+      case "UnaryExpression": {
         return isCompletelyLiteral(node.argument);
-      case "ConditionalExpression":
+      }
+      case "ConditionalExpression": {
         return isCompletelyLiteral(node.test) && isCompletelyLiteral(node.consequent) && isCompletelyLiteral(node.alternate);
-      default:
+      }
+      default: {
         return false;
+      }
     }
   }
   function reportIfLikeConstant(func, node) {
@@ -3380,7 +3402,7 @@ var RULE_NAME8 = "prefer-is-empty";
 var prefer_is_empty_default = rule8;
 
 // src/rules/prefer-is-nil.ts
-import _, { matches as matches3, cond as cond3, property as property3 } from "lodash";
+import _, { cond as cond3, matches as matches3, property as property3 } from "lodash";
 var { isNegationExpression: isNegationExpression2, isEquivalentMemberExp: isEquivalentMemberExp2 } = astUtil_default;
 var meta9 = {
   type: "problem",