eslint-plugin-remeda 1.2.0 → 1.3.1

package/dist/index.cjs

@@ -33,7 +33,7 @@ __export(src_exports, {
   default: () => src_default
 });
 module.exports = __toCommonJS(src_exports);
-var import_lodash7 = __toESM(require("lodash"), 1);
+var import_lodash12 = require("lodash");
 
 // package.json
 var version = "0.0.0-development";
@@ -47,12 +47,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: [
@@ -82,8 +84,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",
@@ -96,7 +100,7 @@ var package_default = {
   engines: {
     node: ">=20"
   },
-  packageManager: "pnpm@9.7.1",
+  packageManager: "pnpm@9.9.0",
   publishConfig: {
     access: "public"
   },
@@ -115,17 +119,219 @@ var package_default = {
   }
 };
 
+// src/rules/collection-method-value.ts
+var import_lodash6 = require("lodash");
+
+// src/util/astUtil.ts
+var import_lodash = require("lodash");
+var getCaller = (0, import_lodash.property)(["callee", "object"]);
+var getMethodName = (0, import_lodash.property)(["callee", "property", "name"]);
+var isMethodCall = (0, import_lodash.matches)({
+  type: "CallExpression",
+  callee: { type: "MemberExpression" }
+});
+var isFunctionExpression = (0, import_lodash.overSome)(
+  (0, import_lodash.matchesProperty)("type", "FunctionExpression"),
+  (0, import_lodash.matchesProperty)("type", "FunctionDeclaration")
+);
+var isFunctionDefinitionWithBlock = (0, import_lodash.overSome)(
+  isFunctionExpression,
+  (0, import_lodash.matches)({
+    type: "ArrowFunctionExpression",
+    body: { type: "BlockStatement" }
+  })
+);
+var getFirstFunctionLine = (0, import_lodash.cond)([
+  [isFunctionDefinitionWithBlock, (0, import_lodash.property)(["body", "body", 0])],
+  [(0, import_lodash.matches)({ type: "ArrowFunctionExpression" }), (0, import_lodash.property)("body")]
+]);
+var isPropAccess = (0, import_lodash.overSome)(
+  (0, import_lodash.matches)({ computed: false }),
+  (0, import_lodash.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 = (0, import_lodash.property)(["params", 0, "name"]);
+var isReturnStatement = (0, import_lodash.matchesProperty)("type", "ReturnStatement");
+function hasOnlyOneStatement(func) {
+  if (isFunctionDefinitionWithBlock(func)) {
+    return (0, import_lodash.get)(func, "body.body.length") === 1;
+  }
+  if (func.type === "ArrowFunctionExpression") {
+    return !(0, import_lodash.get)(func, "body.body");
+  }
+}
+function isObjectOfMethodCall(node) {
+  return (0, import_lodash.get)(node, "parent.object") === node && (0, import_lodash.get)(node, "parent.parent.type") === "CallExpression";
+}
+function isLiteral(node) {
+  return node.type === "Literal";
+}
+function isBinaryExpWithMemberOf(operator, exp, objectName, {
+  maxLength,
+  allowComputed,
+  onlyLiterals
+} = {}) {
+  if (!(0, import_lodash.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 = (0, import_lodash.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" && (0, import_lodash.get)(node, "callee.object.name") === objName;
+}
+function isComputed(node) {
+  return (0, import_lodash.get)(node, "computed") && node.property.type !== "Literal";
+}
+function isEquivalentMemberExp(a, b) {
+  return (0, import_lodash.isEqualWith)(a, b, (left, right, key) => {
+    if ((0, import_lodash.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 = (0, import_lodash.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 ? (0, import_lodash.overEvery)(isMinus, (0, import_lodash.matches)({ argument: { value: -value2 } })) : (0, import_lodash.matches)({ value: value2 });
+}
+function getExpressionComparedToInt(node, value2, checkOver) {
+  const isValue = getIsValue(value2);
+  if ((0, import_lodash.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 (0, import_lodash.flatMap)(
+        node.properties,
+        (prop) => collectParameterValues(prop.value)
+      );
+    }
+    case "ArrayPattern": {
+      return (0, import_lodash.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
-var import_lodash4 = require("lodash");
-
 // src/util/methodDataUtil.ts
-var import_lodash = require("lodash");
+var import_lodash2 = require("lodash");
 
 // src/util/methodData.ts
 var methodData_exports = {};
@@ -156,7 +362,7 @@ __export(methodData_exports, {
   cloneWith: () => cloneWith,
   commit: () => commit,
   concat: () => concat,
-  cond: () => cond,
+  cond: () => cond2,
   conforms: () => conforms,
   conformsTo: () => conformsTo,
   constant: () => constant,
@@ -193,7 +399,7 @@ __export(methodData_exports, {
   findLastIndex: () => findLastIndex,
   findLastKey: () => findLastKey,
   first: () => first,
-  flatMap: () => flatMap,
+  flatMap: () => flatMap2,
   flatMapDeep: () => flatMapDeep,
   flatMapDepth: () => flatMapDepth,
   flatten: () => flatten,
@@ -212,7 +418,7 @@ __export(methodData_exports, {
   fromPairs: () => fromPairs,
   functions: () => functions,
   functionsIn: () => functionsIn,
-  get: () => get,
+  get: () => get2,
   groupBy: () => groupBy,
   gt: () => gt,
   gte: () => gte,
@@ -221,7 +427,7 @@ __export(methodData_exports, {
   head: () => head,
   identity: () => identity,
   inRange: () => inRange,
-  includes: () => includes,
+  includes: () => includes2,
   indexBy: () => indexBy,
   indexOf: () => indexOf,
   initial: () => initial,
@@ -243,14 +449,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,
@@ -284,8 +490,8 @@ __export(methodData_exports, {
   map: () => map,
   mapKeys: () => mapKeys,
   mapValues: () => mapValues,
-  matches: () => matches,
-  matchesProperty: () => matchesProperty,
+  matches: () => matches2,
+  matchesProperty: () => matchesProperty2,
   max: () => max,
   maxBy: () => maxBy,
   mean: () => mean,
@@ -312,8 +518,8 @@ __export(methodData_exports, {
   orderBy: () => orderBy,
   over: () => over,
   overArgs: () => overArgs,
-  overEvery: () => overEvery,
-  overSome: () => overSome,
+  overEvery: () => overEvery2,
+  overSome: () => overSome2,
   pad: () => pad,
   padEnd: () => padEnd,
   padStart: () => padStart,
@@ -325,7 +531,7 @@ __export(methodData_exports, {
   pickBy: () => pickBy,
   plant: () => plant,
   pop: () => pop,
-  property: () => property,
+  property: () => property2,
   propertyOf: () => propertyOf,
   pull: () => pull,
   pullAll: () => pullAll,
@@ -611,7 +817,7 @@ var concat = {
   chainable: true,
   iteratee: false
 };
-var cond = {
+var cond2 = {
   wrapper: false,
   shorthand: false,
   chainable: false,
@@ -856,7 +1062,7 @@ var findLastKey = {
   iteratee: true,
   args: 2
 };
-var flatMap = {
+var flatMap2 = {
   wrapper: false,
   shorthand: true,
   chainable: true,
@@ -987,7 +1193,7 @@ var functionsIn = {
   iteratee: false,
   args: 1
 };
-var get = {
+var get2 = {
   wrapper: false,
   shorthand: false,
   chainable: false,
@@ -1057,7 +1263,7 @@ var inRange = {
   iteratee: false,
   args: 3
 };
-var includes = {
+var includes2 = {
   wrapper: false,
   shorthand: false,
   chainable: false,
@@ -1205,7 +1411,7 @@ var isEqual = {
   iteratee: false,
   args: 2
 };
-var isEqualWith = {
+var isEqualWith2 = {
   wrapper: false,
   shorthand: false,
   chainable: false,
@@ -1254,7 +1460,7 @@ var isMap = {
   iteratee: false,
   args: 1
 };
-var isMatch = {
+var isMatch2 = {
   wrapper: false,
   shorthand: false,
   chainable: false,
@@ -1491,14 +1697,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,
@@ -1679,13 +1885,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,
@@ -1762,7 +1968,7 @@ var pop = {
   chainable: false,
   iteratee: false
 };
-var property = {
+var property2 = {
   wrapper: false,
   shorthand: false,
   chainable: true,
@@ -2549,19 +2755,21 @@ var zipWith = {
 
 // src/util/methodDataUtil.ts
 function isCollectionMethod(method2) {
-  return methodSupportsShorthand(method2) || (0, import_lodash.includes)(["reduce", "reduceRight"], method2);
+  return methodSupportsShorthand(method2) || (0, import_lodash2.includes)(["reduce", "reduceRight"], method2);
 }
 function methodSupportsShorthand(method2, shorthandType) {
-  const methodShorthandData = (0, import_lodash.get)(methodData_exports, [method2, "shorthand"]);
-  return (0, import_lodash.isObject)(methodShorthandData) ? Boolean(shorthandType && methodShorthandData[shorthandType]) : Boolean(methodShorthandData);
+  const methodShorthandData = (0, import_lodash2.get)(methodData_exports, `${method2}.shorthand`);
+  return (0, import_lodash2.isObject)(methodShorthandData) ? Boolean(shorthandType && methodShorthandData[shorthandType]) : Boolean(methodShorthandData);
 }
 function getIterateeIndex(method2) {
   const methodData = methodData_exports[method2];
-  if ((0, import_lodash.has)(methodData, "iterateeIndex")) {
-    return methodData.iterateeIndex;
-  }
-  if (methodData?.iteratee) {
-    return 1;
+  if (methodData) {
+    if ((0, import_lodash2.has)(methodData, "iterateeIndex")) {
+      return methodData.iterateeIndex;
+    }
+    if (methodData.iteratee) {
+      return 1;
+    }
   }
   return -1;
 }
@@ -2577,203 +2785,8 @@ function getSideEffectIterationMethods() {
   return sideEffectIterationMethods;
 }
 
-// src/util/astUtil.ts
-var import_lodash2 = require("lodash");
-var getCaller = (0, import_lodash2.property)(["callee", "object"]);
-var getMethodName = (0, import_lodash2.property)(["callee", "property", "name"]);
-var isMethodCall = (0, import_lodash2.matches)({
-  type: "CallExpression",
-  callee: { type: "MemberExpression" }
-});
-var isFunctionExpression = (0, import_lodash2.overSome)(
-  (0, import_lodash2.matchesProperty)("type", "FunctionExpression"),
-  (0, import_lodash2.matchesProperty)("type", "FunctionDeclaration")
-);
-var isFunctionDefinitionWithBlock = (0, import_lodash2.overSome)(
-  isFunctionExpression,
-  (0, import_lodash2.matches)({
-    type: "ArrowFunctionExpression",
-    body: { type: "BlockStatement" }
-  })
-);
-var getFirstFunctionLine = (0, import_lodash2.cond)([
-  [isFunctionDefinitionWithBlock, (0, import_lodash2.property)(["body", "body", 0])],
-  [(0, import_lodash2.matches)({ type: "ArrowFunctionExpression" }), (0, import_lodash2.property)("body")]
-]);
-var isPropAccess = (0, import_lodash2.overSome)(
-  (0, import_lodash2.matches)({ computed: false }),
-  (0, import_lodash2.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 = (0, import_lodash2.property)(["params", 0, "name"]);
-var isReturnStatement = (0, import_lodash2.matchesProperty)("type", "ReturnStatement");
-function hasOnlyOneStatement(func) {
-  if (isFunctionDefinitionWithBlock(func)) {
-    return (0, import_lodash2.get)(func, "body.body.length") === 1;
-  }
-  if (func.type === "ArrowFunctionExpression") {
-    return !(0, import_lodash2.get)(func, "body.body");
-  }
-}
-function isObjectOfMethodCall(node) {
-  return (0, import_lodash2.get)(node, "parent.object") === node && (0, import_lodash2.get)(node, "parent.parent.type") === "CallExpression";
-}
-function isLiteral(node) {
-  return node.type === "Literal";
-}
-function isBinaryExpWithMemberOf(operator, exp, objectName, {
-  maxLength,
-  allowComputed,
-  onlyLiterals
-} = {}) {
-  if (!(0, import_lodash2.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 = (0, import_lodash2.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" && (0, import_lodash2.get)(node, "callee.object.name") === objName;
-}
-function isComputed(node) {
-  return (0, import_lodash2.get)(node, "computed") && node.property.type !== "Literal";
-}
-function isEquivalentMemberExp(a, b) {
-  return (0, import_lodash2.isEqualWith)(a, b, (left, right, key) => {
-    if ((0, import_lodash2.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 = (0, import_lodash2.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 ? (0, import_lodash2.overEvery)(isMinus, (0, import_lodash2.matches)({ argument: { value: -value2 } })) : (0, import_lodash2.matches)({ value: value2 });
-}
-function getExpressionComparedToInt(node, value2, checkOver) {
-  const isValue = getIsValue(value2);
-  if ((0, import_lodash2.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 (0, import_lodash2.flatMap)(
-        node.properties,
-        (prop) => collectParameterValues(prop.value)
-      );
-    case "ArrayPattern":
-      return (0, import_lodash2.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/remedaUtil.ts
+var import_lodash5 = require("lodash");
 
 // src/util/settingsUtil.ts
 var import_lodash3 = require("lodash");
@@ -2784,9 +2797,9 @@ function getSettings(context) {
 }
 
 // src/util/importUtil.ts
-var import_get = __toESM(require("lodash/get"), 1);
+var import_lodash4 = require("lodash");
 function getNameFromCjsRequire(init) {
-  if ((0, import_get.default)(init, "callee.name") === "require" && (0, import_get.default)(init, "arguments.length") === 1 && init.arguments[0].type === "Literal") {
+  if ((0, import_lodash4.get)(init, "callee.name") === "require" && (0, import_lodash4.get)(init, "arguments.length") === 1 && init.arguments[0].type === "Literal") {
     return init.arguments[0].value;
   }
 }
@@ -2805,7 +2818,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;
@@ -2814,7 +2828,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;
@@ -2824,15 +2839,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 {
@@ -2866,8 +2883,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") {
@@ -2876,8 +2894,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)) {
@@ -2886,15 +2905,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) {
@@ -2923,7 +2943,7 @@ function getIsTypeMethod(name) {
     "Error"
     // "Element",
   ];
-  return (0, import_lodash4.includes)(types, name) ? `is${(0, import_lodash4.capitalize)(name)}` : null;
+  return (0, import_lodash5.includes)(types, name) ? `is${(0, import_lodash5.capitalize)(name)}` : null;
 }
 function getRemedaMethodCallExpVisitor(remedaContext, reporter) {
   return function(node) {
@@ -2972,7 +2992,6 @@ function getRemedaContext(context) {
 }
 
 // src/rules/collection-method-value.ts
-var import_includes = __toESM(require("lodash/includes"), 1);
 var { getMethodName: getMethodName2 } = astUtil_default;
 var meta = {
   type: "problem",
@@ -2986,7 +3005,7 @@ function create2(context) {
     return node.parent.type !== "ExpressionStatement";
   }
   function isSideEffectIterationMethod(method2) {
-    return (0, import_includes.default)(getSideEffectIterationMethods(), method2);
+    return (0, import_lodash6.includes)(getSideEffectIterationMethods(), method2);
   }
   function isParentCommit(node, callType) {
     return callType === "chained" && isCallToMethod(node.parent.parent, "commit");
@@ -3016,7 +3035,7 @@ var RULE_NAME = "collection-method-value";
 var collection_method_value_default = rule;
 
 // src/rules/collection-return.ts
-var import_assign = __toESM(require("lodash/assign"), 1);
+var import_lodash7 = require("lodash");
 var meta2 = {
   type: "problem",
   schema: [],
@@ -3028,7 +3047,7 @@ function create3(context) {
   const funcInfos = /* @__PURE__ */ new Map();
   let currFuncInfo;
   const remedaContext = getRemedaContext(context);
-  return (0, import_assign.default)(
+  return (0, import_lodash7.assign)(
     {
       "CallExpression:exit": getRemedaMethodCallExpVisitor(
         remedaContext,
@@ -3090,16 +3109,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) {
@@ -3396,7 +3420,7 @@ var RULE_NAME8 = "prefer-is-empty";
 var prefer_is_empty_default = rule8;
 
 // src/rules/prefer-is-nil.ts
-var import_lodash5 = __toESM(require("lodash"), 1);
+var import_lodash8 = __toESM(require("lodash"), 1);
 var { isNegationExpression: isNegationExpression2, isEquivalentMemberExp: isEquivalentMemberExp2 } = astUtil_default;
 var meta9 = {
   type: "problem",
@@ -3409,14 +3433,14 @@ function create10(context) {
   const remedaContext = getRemedaContext(context);
   const nilChecks = {
     null: {
-      isValue: (0, import_lodash5.matches)({ type: "Literal", value: null }),
+      isValue: (0, import_lodash8.matches)({ type: "Literal", value: null }),
       expressionChecks: [
         getRemedaTypeCheckedBy("isNull"),
         getValueComparedTo("null")
       ]
     },
     undefined: {
-      isValue: (0, import_lodash5.matches)({ type: "Identifier", name: "undefined" }),
+      isValue: (0, import_lodash8.matches)({ type: "Identifier", name: "undefined" }),
       expressionChecks: [
         getRemedaTypeCheckedBy("isUndefined"),
         getValueComparedTo("undefined"),
@@ -3434,13 +3458,13 @@ function create10(context) {
       return node.type === "BinaryExpression" && node.operator === operator && (nilChecks[nil].isValue(node.right) && node.left || nilChecks[nil].isValue(node.left) && node.right);
     };
   }
-  const getTypeofArgument = (0, import_lodash5.cond)([
+  const getTypeofArgument = (0, import_lodash8.cond)([
     [
-      (0, import_lodash5.matches)({ type: "UnaryExpression", operator: "typeof" }),
-      (0, import_lodash5.property)("argument")
+      (0, import_lodash8.matches)({ type: "UnaryExpression", operator: "typeof" }),
+      (0, import_lodash8.property)("argument")
     ]
   ]);
-  const isUndefinedString = (0, import_lodash5.matches)({
+  const isUndefinedString = (0, import_lodash8.matches)({
     type: "Literal",
     value: "undefined"
   });
@@ -3448,7 +3472,7 @@ function create10(context) {
     return node.type === "BinaryExpression" && node.operator === operator && (isUndefinedString(node.right) && getTypeofArgument(node.left) || isUndefinedString(node.left) && getTypeofArgument(node.right));
   }
   function checkExpression(nil, operator, node) {
-    return (0, import_lodash5.default)(nilChecks[nil].expressionChecks).map((check) => check(node, operator)).find();
+    return (0, import_lodash8.default)(nilChecks[nil].expressionChecks).map((check) => check(node, operator)).find();
   }
   function checkNegatedExpression(nil, node) {
     return isNegationExpression2(node) && checkExpression(nil, "===", node.argument) || checkExpression(nil, "!==", node);
@@ -3493,8 +3517,7 @@ var RULE_NAME9 = "prefer-is-nil";
 var prefer_is_nil_default = rule9;
 
 // src/rules/prefer-map.ts
-var import_get2 = __toESM(require("lodash/get"), 1);
-var import_includes2 = __toESM(require("lodash/includes"), 1);
+var import_lodash9 = require("lodash");
 var {
   getFirstFunctionLine: getFirstFunctionLine4,
   hasOnlyOneStatement: hasOnlyOneStatement3,
@@ -3512,14 +3535,14 @@ var meta10 = {
 function create11(context) {
   function onlyHasPush(func) {
     const firstLine = getFirstFunctionLine4(func);
-    const firstParam = (0, import_get2.default)(func, "params[0]");
+    const firstParam = (0, import_lodash9.get)(func, "params[0]");
     const exp = func && !isFunctionDefinitionWithBlock2(func) ? firstLine : (
       //@ts-expect-error
       firstLine?.expression
     );
-    return func && hasOnlyOneStatement3(func) && getMethodName3(exp) === "push" && !(0, import_includes2.default)(
+    return func && hasOnlyOneStatement3(func) && getMethodName3(exp) === "push" && !(0, import_lodash9.includes)(
       collectParameterValues2(firstParam),
-      (0, import_get2.default)(exp, "callee.object.name")
+      (0, import_lodash9.get)(exp, "callee.object.name")
     );
   }
   return getRemedaMethodVisitors(context, (node, iteratee2, { method: method2 }) => {
@@ -3587,7 +3610,7 @@ var RULE_NAME11 = "prefer-nullish-coalescing";
 var prefer_nullish_coalescing_default = rule11;
 
 // src/rules/prefer-remeda-typecheck.ts
-var import_some = __toESM(require("lodash/some"), 1);
+var import_lodash10 = require("lodash");
 var meta12 = {
   type: "problem",
   schema: [],
@@ -3610,7 +3633,7 @@ function create13(context) {
     const sourceCode = context.sourceCode ?? context.getSourceCode();
     const scope = sourceCode?.getScope?.(node);
     const definedVariables = scope.variables;
-    return (0, import_some.default)(definedVariables, { name: node.name });
+    return (0, import_lodash10.some)(definedVariables, { name: node.name });
   }
   function getValueForSide(node, side) {
     const otherSide = otherSides[side];
@@ -3690,7 +3713,7 @@ var RULE_NAME13 = "prefer-some";
 var prefer_some_default = rule13;
 
 // src/rules/prefer-times.ts
-var import_lodash6 = require("lodash");
+var import_lodash11 = require("lodash");
 var meta14 = {
   type: "problem",
   schema: [],
@@ -3700,7 +3723,7 @@ var meta14 = {
 };
 function create15(context) {
   return getRemedaMethodVisitors(context, (node, iteratee2, { method: method2 }) => {
-    if (method2 === "map" && (0, import_lodash6.get)(iteratee2, "params.length") === 0) {
+    if (method2 === "map" && (0, import_lodash11.get)(iteratee2, "params.length") === 0) {
       context.report({
         node,
         message: "Prefer R.times over R.map without using arguments"
@@ -3741,7 +3764,7 @@ var plugin = {
   configs: {},
   processors: {}
 };
-var pluginShortName = import_lodash7.default.last(plugin.meta.name.split("-"));
+var pluginShortName = (0, import_lodash12.last)(plugin.meta.name.split("-"));
 Object.assign(plugin.configs, {
   recommended: {
     plugins: {