eslint-plugin-remeda 1.0.0 → 1.1.0

package/dist/index.cjs

@@ -0,0 +1,3866 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __glob = (map2) => (path2) => {
+  var fn = map2[path2];
+  if (fn) return fn();
+  throw new Error("Module not found in bundle: " + path2);
+};
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// package.json
+var version;
+var init_package = __esm({
+  "package.json"() {
+    version = "0.0.0-development";
+  }
+});
+
+// src/util/getDocsUrl.ts
+function getDocsUrl(ruleName) {
+  return `${REPO_URL}/blob/v${version}/docs/rules/${ruleName}.md`;
+}
+var REPO_URL;
+var init_getDocsUrl = __esm({
+  "src/util/getDocsUrl.ts"() {
+    "use strict";
+    init_package();
+    REPO_URL = "https://github.com/AndreaPontrandolfo/eslint-plugin-remeda";
+  }
+});
+
+// src/util/methodData.ts
+var methodData_exports = {};
+__export(methodData_exports, {
+  add: () => add,
+  after: () => after,
+  ary: () => ary,
+  assign: () => assign,
+  assignIn: () => assignIn,
+  assignInWith: () => assignInWith,
+  assignWith: () => assignWith,
+  at: () => at,
+  attempt: () => attempt,
+  before: () => before,
+  bind: () => bind,
+  bindAll: () => bindAll,
+  bindKey: () => bindKey,
+  camelCase: () => camelCase,
+  capitalize: () => capitalize,
+  castArray: () => castArray,
+  ceil: () => ceil,
+  chain: () => chain,
+  chunk: () => chunk,
+  clamp: () => clamp,
+  clone: () => clone,
+  cloneDeep: () => cloneDeep,
+  cloneDeepWith: () => cloneDeepWith,
+  cloneWith: () => cloneWith,
+  commit: () => commit,
+  concat: () => concat,
+  cond: () => cond,
+  conforms: () => conforms,
+  conformsTo: () => conformsTo,
+  constant: () => constant,
+  countBy: () => countBy,
+  create: () => create,
+  curry: () => curry,
+  curryRight: () => curryRight,
+  debounce: () => debounce,
+  deburr: () => deburr,
+  defaultTo: () => defaultTo,
+  defaults: () => defaults,
+  defaultsDeep: () => defaultsDeep,
+  defer: () => defer,
+  delay: () => delay,
+  difference: () => difference,
+  differenceBy: () => differenceBy,
+  differenceWith: () => differenceWith,
+  divide: () => divide,
+  drop: () => drop,
+  dropRight: () => dropRight,
+  dropRightWhile: () => dropRightWhile,
+  dropWhile: () => dropWhile,
+  endsWith: () => endsWith,
+  eq: () => eq,
+  escape: () => escape,
+  escapeRegExp: () => escapeRegExp,
+  every: () => every,
+  fill: () => fill,
+  filter: () => filter,
+  find: () => find,
+  findIndex: () => findIndex,
+  findKey: () => findKey,
+  findLast: () => findLast,
+  findLastIndex: () => findLastIndex,
+  findLastKey: () => findLastKey,
+  first: () => first,
+  flatMap: () => flatMap,
+  flatMapDeep: () => flatMapDeep,
+  flatMapDepth: () => flatMapDepth,
+  flatten: () => flatten,
+  flattenDeep: () => flattenDeep,
+  flattenDepth: () => flattenDepth,
+  flip: () => flip,
+  floor: () => floor,
+  flow: () => flow,
+  flowRight: () => flowRight,
+  forEach: () => forEach,
+  forEachRight: () => forEachRight,
+  forIn: () => forIn,
+  forInRight: () => forInRight,
+  forOwn: () => forOwn,
+  forOwnRight: () => forOwnRight,
+  fromPairs: () => fromPairs,
+  functions: () => functions,
+  functionsIn: () => functionsIn,
+  get: () => get,
+  groupBy: () => groupBy,
+  gt: () => gt,
+  gte: () => gte,
+  has: () => has,
+  hasIn: () => hasIn,
+  head: () => head,
+  identity: () => identity,
+  inRange: () => inRange,
+  includes: () => includes,
+  indexBy: () => indexBy,
+  indexOf: () => indexOf,
+  initial: () => initial,
+  intersection: () => intersection,
+  intersectionBy: () => intersectionBy,
+  intersectionWith: () => intersectionWith,
+  invert: () => invert,
+  invertBy: () => invertBy,
+  invoke: () => invoke,
+  invokeMap: () => invokeMap,
+  isArguments: () => isArguments,
+  isArray: () => isArray,
+  isArrayBuffer: () => isArrayBuffer,
+  isArrayLike: () => isArrayLike,
+  isArrayLikeObject: () => isArrayLikeObject,
+  isBoolean: () => isBoolean,
+  isBuffer: () => isBuffer,
+  isDate: () => isDate,
+  isElement: () => isElement,
+  isEmpty: () => isEmpty,
+  isEqual: () => isEqual,
+  isEqualWith: () => isEqualWith,
+  isError: () => isError,
+  isFinite: () => isFinite,
+  isFunction: () => isFunction,
+  isInteger: () => isInteger,
+  isLength: () => isLength,
+  isMap: () => isMap,
+  isMatch: () => isMatch,
+  isMatchWith: () => isMatchWith,
+  isNaN: () => isNaN,
+  isNative: () => isNative,
+  isNil: () => isNil,
+  isNull: () => isNull,
+  isNumber: () => isNumber,
+  isObject: () => isObject,
+  isObjectLike: () => isObjectLike,
+  isPlainObject: () => isPlainObject,
+  isRegExp: () => isRegExp,
+  isSafeInteger: () => isSafeInteger,
+  isSet: () => isSet,
+  isString: () => isString,
+  isSymbol: () => isSymbol,
+  isTypedArray: () => isTypedArray,
+  isUndefined: () => isUndefined,
+  isWeakMap: () => isWeakMap,
+  isWeakSet: () => isWeakSet,
+  iteratee: () => iteratee,
+  join: () => join,
+  kebabCase: () => kebabCase,
+  keyBy: () => keyBy,
+  keys: () => keys,
+  keysIn: () => keysIn,
+  last: () => last,
+  lastIndexOf: () => lastIndexOf,
+  lowerCase: () => lowerCase,
+  lowerFirst: () => lowerFirst,
+  lt: () => lt,
+  lte: () => lte,
+  map: () => map,
+  mapKeys: () => mapKeys,
+  mapValues: () => mapValues,
+  matches: () => matches,
+  matchesProperty: () => matchesProperty,
+  max: () => max,
+  maxBy: () => maxBy,
+  mean: () => mean,
+  meanBy: () => meanBy,
+  memoize: () => memoize,
+  merge: () => merge,
+  mergeWith: () => mergeWith,
+  method: () => method,
+  methodOf: () => methodOf,
+  min: () => min,
+  minBy: () => minBy,
+  mixin: () => mixin,
+  multiply: () => multiply,
+  negate: () => negate,
+  next: () => next,
+  noConflict: () => noConflict,
+  noop: () => noop,
+  now: () => now,
+  nth: () => nth,
+  nthArg: () => nthArg,
+  omit: () => omit,
+  omitBy: () => omitBy,
+  once: () => once,
+  orderBy: () => orderBy,
+  over: () => over,
+  overArgs: () => overArgs,
+  overEvery: () => overEvery,
+  overSome: () => overSome,
+  pad: () => pad,
+  padEnd: () => padEnd,
+  padStart: () => padStart,
+  parseInt: () => parseInt2,
+  partial: () => partial,
+  partialRight: () => partialRight,
+  partition: () => partition,
+  pick: () => pick,
+  pickBy: () => pickBy,
+  plant: () => plant,
+  pop: () => pop,
+  property: () => property,
+  propertyOf: () => propertyOf,
+  pull: () => pull,
+  pullAll: () => pullAll,
+  pullAllBy: () => pullAllBy,
+  pullAllWith: () => pullAllWith,
+  pullAt: () => pullAt,
+  push: () => push,
+  random: () => random,
+  range: () => range,
+  rangeRight: () => rangeRight,
+  rearg: () => rearg,
+  reduce: () => reduce,
+  reduceRight: () => reduceRight,
+  reject: () => reject,
+  remove: () => remove,
+  repeat: () => repeat,
+  replace: () => replace,
+  rest: () => rest,
+  result: () => result,
+  reverse: () => reverse,
+  round: () => round,
+  runInContext: () => runInContext,
+  sample: () => sample,
+  sampleSize: () => sampleSize,
+  set: () => set,
+  setWith: () => setWith,
+  shift: () => shift,
+  shuffle: () => shuffle,
+  size: () => size,
+  slice: () => slice,
+  snakeCase: () => snakeCase,
+  some: () => some,
+  sort: () => sort,
+  sortBy: () => sortBy,
+  sortedIndex: () => sortedIndex,
+  sortedIndexBy: () => sortedIndexBy,
+  sortedIndexOf: () => sortedIndexOf,
+  sortedLastIndex: () => sortedLastIndex,
+  sortedLastIndexBy: () => sortedLastIndexBy,
+  sortedLastIndexOf: () => sortedLastIndexOf,
+  sortedUniq: () => sortedUniq,
+  sortedUniqBy: () => sortedUniqBy,
+  splice: () => splice,
+  split: () => split,
+  spread: () => spread,
+  startCase: () => startCase,
+  startsWith: () => startsWith,
+  stubArray: () => stubArray,
+  stubFalse: () => stubFalse,
+  stubObject: () => stubObject,
+  stubString: () => stubString,
+  stubTrue: () => stubTrue,
+  subtract: () => subtract,
+  sum: () => sum,
+  sumBy: () => sumBy,
+  tail: () => tail,
+  take: () => take,
+  takeRight: () => takeRight,
+  takeRightWhile: () => takeRightWhile,
+  takeWhile: () => takeWhile,
+  tap: () => tap,
+  template: () => template,
+  throttle: () => throttle,
+  thru: () => thru,
+  times: () => times,
+  toArray: () => toArray,
+  toFinite: () => toFinite,
+  toInteger: () => toInteger,
+  toLength: () => toLength,
+  toLower: () => toLower,
+  toNumber: () => toNumber,
+  toPairs: () => toPairs,
+  toPairsIn: () => toPairsIn,
+  toPath: () => toPath,
+  toPlainObject: () => toPlainObject,
+  toSafeInteger: () => toSafeInteger,
+  toString: () => toString,
+  toUpper: () => toUpper,
+  transform: () => transform,
+  trim: () => trim,
+  trimEnd: () => trimEnd,
+  trimStart: () => trimStart,
+  truncate: () => truncate,
+  unary: () => unary,
+  unescape: () => unescape,
+  union: () => union,
+  unionBy: () => unionBy,
+  unionWith: () => unionWith,
+  uniq: () => uniq,
+  uniqBy: () => uniqBy,
+  uniqWith: () => uniqWith,
+  uniqueId: () => uniqueId,
+  unset: () => unset,
+  unshift: () => unshift,
+  unzip: () => unzip,
+  unzipWith: () => unzipWith,
+  update: () => update,
+  updateWith: () => updateWith,
+  upperCase: () => upperCase,
+  upperFirst: () => upperFirst,
+  value: () => value,
+  values: () => values,
+  valuesIn: () => valuesIn,
+  without: () => without,
+  words: () => words,
+  wrap: () => wrap,
+  xor: () => xor,
+  xorBy: () => xorBy,
+  xorWith: () => xorWith,
+  zip: () => zip,
+  zipObject: () => zipObject,
+  zipObjectDeep: () => zipObjectDeep,
+  zipWith: () => zipWith
+});
+var add, after, ary, assign, assignIn, assignInWith, assignWith, at, attempt, before, bind, bindAll, bindKey, camelCase, capitalize, castArray, ceil, chain, chunk, clamp, clone, cloneDeep, cloneDeepWith, cloneWith, commit, concat, cond, conforms, conformsTo, constant, countBy, create, curry, curryRight, debounce, deburr, defaultTo, defaults, defaultsDeep, defer, delay, difference, differenceBy, differenceWith, divide, drop, dropRight, dropRightWhile, dropWhile, endsWith, eq, escape, escapeRegExp, every, fill, filter, find, findIndex, findKey, findLast, findLastIndex, findLastKey, flatMap, flatMapDeep, flatMapDepth, flatten, flattenDeep, flattenDepth, flip, floor, flow, flowRight, forEach, forEachRight, forIn, forInRight, forOwn, forOwnRight, fromPairs, functions, functionsIn, get, groupBy, gt, gte, has, hasIn, head, first, identity, inRange, includes, indexBy, indexOf, initial, intersection, intersectionBy, intersectionWith, invert, invertBy, invoke, invokeMap, isArguments, isArray, isArrayBuffer, isArrayLike, isArrayLikeObject, isBoolean, isBuffer, isDate, isElement, isEmpty, isEqual, isEqualWith, isError, isFinite, isFunction, isInteger, isLength, isMap, isMatch, isMatchWith, isNaN, isNative, isNil, isNull, isNumber, isObject, isObjectLike, isPlainObject, isRegExp, isSafeInteger, isSet, isString, isSymbol, isTypedArray, isUndefined, isWeakMap, isWeakSet, iteratee, join, kebabCase, keyBy, keys, keysIn, last, lastIndexOf, lowerCase, lowerFirst, lt, lte, map, mapKeys, mapValues, matches, matchesProperty, max, maxBy, mean, meanBy, memoize, merge, mergeWith, method, methodOf, min, minBy, mixin, multiply, negate, next, noConflict, noop, now, nth, nthArg, omit, omitBy, once, orderBy, over, overArgs, overEvery, overSome, pad, padEnd, padStart, parseInt2, partial, partialRight, partition, pick, pickBy, plant, pop, property, propertyOf, pull, pullAll, pullAllBy, pullAllWith, pullAt, push, random, range, rangeRight, rearg, reduce, reduceRight, reject, remove, repeat, replace, rest, result, reverse, round, runInContext, sample, sampleSize, set, setWith, shift, shuffle, size, slice, snakeCase, some, sort, sortBy, sortedIndex, sortedIndexBy, sortedIndexOf, sortedLastIndex, sortedLastIndexBy, sortedLastIndexOf, sortedUniq, sortedUniqBy, splice, split, spread, startCase, startsWith, stubArray, stubFalse, stubObject, stubString, stubTrue, subtract, sum, sumBy, tail, take, takeRight, takeRightWhile, takeWhile, tap, template, throttle, thru, times, toArray, toFinite, toInteger, toLength, toLower, toNumber, toPairs, toPairsIn, toPath, toPlainObject, toSafeInteger, toString, toUpper, transform, trim, trimEnd, trimStart, truncate, unary, unescape, union, unionBy, unionWith, uniq, uniqBy, uniqWith, uniqueId, unset, unshift, unzip, unzipWith, update, updateWith, upperCase, upperFirst, value, values, valuesIn, without, words, wrap, xor, xorBy, xorWith, zip, zipObject, zipObjectDeep, zipWith;
+var init_methodData = __esm({
+  "src/util/methodData.ts"() {
+    "use strict";
+    add = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 2
+    };
+    after = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 2
+    };
+    ary = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 2
+    };
+    assign = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    assignIn = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    assignInWith = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    assignWith = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    at = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    attempt = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false
+    };
+    before = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 2
+    };
+    bind = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    bindAll = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    bindKey = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    camelCase = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    capitalize = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    castArray = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    ceil = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 2
+    };
+    chain = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    chunk = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 2
+    };
+    clamp = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 3
+    };
+    clone = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    cloneDeep = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    cloneDeepWith = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: true,
+      args: 2
+    };
+    cloneWith = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: true,
+      args: 2
+    };
+    commit = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    concat = {
+      wrapper: true,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    cond = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    conforms = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    conformsTo = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 2
+    };
+    constant = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    countBy = {
+      wrapper: false,
+      shorthand: true,
+      chainable: true,
+      iteratee: true,
+      args: 2
+    };
+    create = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 2
+    };
+    curry = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 2
+    };
+    curryRight = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 2
+    };
+    debounce = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 3
+    };
+    deburr = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    defaultTo = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 2
+    };
+    defaults = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    defaultsDeep = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    defer = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    delay = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    difference = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    differenceBy = {
+      wrapper: false,
+      shorthand: true,
+      chainable: true,
+      iteratee: true
+    };
+    differenceWith = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    divide = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 2
+    };
+    drop = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 2
+    };
+    dropRight = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 2
+    };
+    dropRightWhile = {
+      wrapper: false,
+      shorthand: true,
+      chainable: true,
+      iteratee: true,
+      args: 3
+    };
+    dropWhile = {
+      wrapper: false,
+      shorthand: true,
+      chainable: true,
+      iteratee: true,
+      args: 3
+    };
+    endsWith = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 3
+    };
+    eq = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 2
+    };
+    escape = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    escapeRegExp = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    every = {
+      wrapper: false,
+      shorthand: true,
+      chainable: false,
+      iteratee: true,
+      args: 2
+    };
+    fill = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 4
+    };
+    filter = {
+      wrapper: false,
+      shorthand: true,
+      chainable: true,
+      iteratee: true,
+      args: 2
+    };
+    find = {
+      wrapper: false,
+      shorthand: true,
+      chainable: false,
+      iteratee: true,
+      args: 3
+    };
+    findIndex = {
+      wrapper: false,
+      shorthand: true,
+      chainable: false,
+      iteratee: true,
+      args: 3
+    };
+    findKey = {
+      wrapper: false,
+      shorthand: true,
+      chainable: false,
+      iteratee: true,
+      args: 2
+    };
+    findLast = {
+      wrapper: false,
+      shorthand: true,
+      chainable: false,
+      iteratee: true,
+      args: 3
+    };
+    findLastIndex = {
+      wrapper: false,
+      shorthand: true,
+      chainable: false,
+      iteratee: true,
+      args: 3
+    };
+    findLastKey = {
+      wrapper: false,
+      shorthand: true,
+      chainable: false,
+      iteratee: true,
+      args: 2
+    };
+    flatMap = {
+      wrapper: false,
+      shorthand: true,
+      chainable: true,
+      iteratee: true,
+      args: 2
+    };
+    flatMapDeep = {
+      wrapper: false,
+      shorthand: true,
+      chainable: true,
+      iteratee: true,
+      args: 2
+    };
+    flatMapDepth = {
+      wrapper: false,
+      shorthand: true,
+      chainable: true,
+      iteratee: true,
+      args: 3
+    };
+    flatten = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    flattenDeep = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    flattenDepth = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 2
+    };
+    flip = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    floor = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 2
+    };
+    flow = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    flowRight = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    forEach = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: true,
+      args: 2
+    };
+    forEachRight = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: true,
+      args: 2
+    };
+    forIn = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: true,
+      args: 2
+    };
+    forInRight = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: true,
+      args: 2
+    };
+    forOwn = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: true,
+      args: 2
+    };
+    forOwnRight = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: true,
+      args: 2
+    };
+    fromPairs = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    functions = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    functionsIn = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    get = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 3
+    };
+    groupBy = {
+      wrapper: false,
+      shorthand: true,
+      chainable: true,
+      iteratee: true,
+      args: 2
+    };
+    gt = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 2
+    };
+    gte = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 2
+    };
+    has = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 2
+    };
+    hasIn = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 2
+    };
+    head = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    first = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    identity = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    inRange = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 3
+    };
+    includes = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 3
+    };
+    indexBy = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: true
+    };
+    indexOf = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 3
+    };
+    initial = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    intersection = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    intersectionBy = {
+      wrapper: false,
+      shorthand: true,
+      chainable: true,
+      iteratee: true
+    };
+    intersectionWith = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    invert = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    invertBy = {
+      wrapper: false,
+      shorthand: true,
+      chainable: true,
+      iteratee: true,
+      args: 2
+    };
+    invoke = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false
+    };
+    invokeMap = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    isArguments = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    isArray = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    isArrayBuffer = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    isArrayLike = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    isArrayLikeObject = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    isBoolean = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    isBuffer = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    isDate = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    isElement = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    isEmpty = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    isEqual = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 2
+    };
+    isEqualWith = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 3
+    };
+    isError = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    isFinite = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    isFunction = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    isInteger = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    isLength = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    isMap = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    isMatch = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 2
+    };
+    isMatchWith = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 3
+    };
+    isNaN = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    isNative = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    isNil = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    isNull = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    isNumber = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    isObject = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    isObjectLike = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    isPlainObject = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    isRegExp = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    isSafeInteger = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    isSet = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    isString = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    isSymbol = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    isTypedArray = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    isUndefined = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    isWeakMap = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    isWeakSet = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    iteratee = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    join = {
+      wrapper: true,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 2
+    };
+    kebabCase = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    keyBy = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: true,
+      args: 2
+    };
+    keys = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    keysIn = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    last = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    lastIndexOf = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 3
+    };
+    lowerCase = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    lowerFirst = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    lt = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 2
+    };
+    lte = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 2
+    };
+    map = {
+      wrapper: false,
+      shorthand: true,
+      chainable: true,
+      iteratee: true,
+      args: 2
+    };
+    mapKeys = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: true,
+      args: 2
+    };
+    mapValues = {
+      wrapper: false,
+      shorthand: true,
+      chainable: true,
+      iteratee: true,
+      args: 2
+    };
+    matches = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    matchesProperty = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 2
+    };
+    max = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    maxBy = {
+      wrapper: false,
+      shorthand: true,
+      chainable: false,
+      iteratee: true,
+      args: 2
+    };
+    mean = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    meanBy = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: true,
+      args: 2
+    };
+    memoize = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 2
+    };
+    merge = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    mergeWith = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    method = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    methodOf = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    min = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    minBy = {
+      wrapper: false,
+      shorthand: true,
+      chainable: false,
+      iteratee: true,
+      args: 2
+    };
+    mixin = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 3
+    };
+    multiply = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 2
+    };
+    negate = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    next = {
+      wrapper: true,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 0
+    };
+    noConflict = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 0
+    };
+    noop = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 0
+    };
+    now = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 0
+    };
+    nth = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 2
+    };
+    nthArg = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    omit = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    omitBy = {
+      wrapper: false,
+      shorthand: true,
+      chainable: true,
+      iteratee: true
+    };
+    once = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    orderBy = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 3
+    };
+    over = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    overArgs = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    overEvery = {
+      wrapper: false,
+      shorthand: true,
+      chainable: true,
+      iteratee: true
+    };
+    overSome = {
+      wrapper: false,
+      shorthand: true,
+      chainable: true,
+      iteratee: true
+    };
+    pad = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 3
+    };
+    padEnd = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 3
+    };
+    padStart = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 3
+    };
+    parseInt2 = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 2
+    };
+    partial = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    partialRight = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    partition = {
+      wrapper: false,
+      shorthand: true,
+      chainable: true,
+      iteratee: true,
+      args: 2
+    };
+    pick = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    pickBy = {
+      wrapper: false,
+      shorthand: true,
+      chainable: true,
+      iteratee: true
+    };
+    plant = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    pop = {
+      wrapper: true,
+      shorthand: false,
+      chainable: false,
+      iteratee: false
+    };
+    property = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    propertyOf = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    pull = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    pullAll = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 2
+    };
+    pullAllBy = {
+      wrapper: false,
+      shorthand: true,
+      chainable: true,
+      iteratee: false,
+      iterateeIndex: 2,
+      args: 3
+    };
+    pullAllWith = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 3
+    };
+    pullAt = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    push = {
+      wrapper: true,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    random = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 3
+    };
+    range = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 3
+    };
+    rangeRight = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 3
+    };
+    rearg = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    reduce = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: true,
+      args: 3
+    };
+    reduceRight = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: true,
+      args: 3
+    };
+    reject = {
+      wrapper: false,
+      shorthand: true,
+      chainable: true,
+      iteratee: true,
+      args: 2
+    };
+    remove = {
+      wrapper: false,
+      shorthand: true,
+      chainable: true,
+      iteratee: true,
+      args: 2
+    };
+    repeat = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 2
+    };
+    replace = {
+      wrapper: true,
+      shorthand: false,
+      chainable: false,
+      iteratee: false
+    };
+    rest = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 2
+    };
+    result = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 3
+    };
+    reverse = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    round = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 2
+    };
+    runInContext = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    sample = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    sampleSize = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 2
+    };
+    set = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 3
+    };
+    setWith = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 4
+    };
+    shift = {
+      wrapper: true,
+      shorthand: false,
+      chainable: false,
+      iteratee: false
+    };
+    shuffle = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    size = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    slice = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 3
+    };
+    snakeCase = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    some = {
+      wrapper: false,
+      shorthand: true,
+      chainable: false,
+      iteratee: true,
+      args: 2
+    };
+    sort = {
+      wrapper: true,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    sortBy = {
+      wrapper: false,
+      shorthand: {
+        prop: true
+      },
+      chainable: true,
+      iteratee: true
+    };
+    sortedIndex = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 2
+    };
+    sortedIndexBy = {
+      wrapper: false,
+      shorthand: true,
+      chainable: false,
+      iteratee: false,
+      iterateeIndex: 2,
+      args: 3
+    };
+    sortedIndexOf = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 2
+    };
+    sortedLastIndex = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 2
+    };
+    sortedLastIndexBy = {
+      wrapper: false,
+      shorthand: true,
+      chainable: false,
+      iteratee: false,
+      iterateeIndex: 2,
+      args: 3
+    };
+    sortedLastIndexOf = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 2
+    };
+    sortedUniq = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    sortedUniqBy = {
+      wrapper: false,
+      shorthand: true,
+      chainable: true,
+      iteratee: true,
+      args: 2
+    };
+    splice = {
+      wrapper: true,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    split = {
+      wrapper: true,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 3
+    };
+    spread = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 2
+    };
+    startCase = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    startsWith = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 3
+    };
+    stubArray = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 0
+    };
+    stubFalse = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 0
+    };
+    stubObject = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 0
+    };
+    stubString = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 0
+    };
+    stubTrue = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 0
+    };
+    subtract = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 2
+    };
+    sum = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    sumBy = {
+      wrapper: false,
+      shorthand: true,
+      chainable: false,
+      iteratee: true,
+      args: 2
+    };
+    tail = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    take = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 2
+    };
+    takeRight = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 2
+    };
+    takeRightWhile = {
+      wrapper: false,
+      shorthand: true,
+      chainable: true,
+      iteratee: true,
+      args: 2
+    };
+    takeWhile = {
+      wrapper: false,
+      shorthand: true,
+      chainable: true,
+      iteratee: true,
+      args: 2
+    };
+    tap = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: true,
+      args: 2
+    };
+    template = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 2
+    };
+    throttle = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 3
+    };
+    thru = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: true,
+      args: 2
+    };
+    times = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: true,
+      args: 2
+    };
+    toArray = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    toFinite = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    toInteger = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    toLength = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    toLower = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    toNumber = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    toPairs = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    toPairsIn = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    toPath = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    toPlainObject = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    toSafeInteger = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    toString = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    toUpper = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    transform = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: true,
+      args: 3
+    };
+    trim = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 2
+    };
+    trimEnd = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 2
+    };
+    trimStart = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 2
+    };
+    truncate = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 3
+    };
+    unary = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    unescape = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    union = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    unionBy = {
+      wrapper: false,
+      shorthand: true,
+      chainable: true,
+      iteratee: true
+    };
+    unionWith = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    uniq = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    uniqBy = {
+      wrapper: false,
+      shorthand: true,
+      chainable: true,
+      iteratee: true,
+      args: 2
+    };
+    uniqWith = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 2
+    };
+    uniqueId = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    unset = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 2
+    };
+    unshift = {
+      wrapper: true,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    unzip = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    unzipWith = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: true,
+      args: 2
+    };
+    update = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 3
+    };
+    updateWith = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 4
+    };
+    upperCase = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    upperFirst = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 1
+    };
+    value = {
+      wrapper: true,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 0
+    };
+    values = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    valuesIn = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 1
+    };
+    without = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    words = {
+      wrapper: false,
+      shorthand: false,
+      chainable: false,
+      iteratee: false,
+      args: 2
+    };
+    wrap = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 2
+    };
+    xor = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    xorBy = {
+      wrapper: false,
+      shorthand: true,
+      chainable: true,
+      iteratee: true
+    };
+    xorWith = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    zip = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+    zipObject = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 2
+    };
+    zipObjectDeep = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false,
+      args: 2
+    };
+    zipWith = {
+      wrapper: false,
+      shorthand: false,
+      chainable: true,
+      iteratee: false
+    };
+  }
+});
+
+// src/util/methodDataUtil.ts
+function isCollectionMethod(method2) {
+  return methodSupportsShorthand(method2) || (0, import_lodash.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);
+}
+function getIterateeIndex(method2) {
+  const methodData = methodData_exports[method2];
+  if ((0, import_lodash.has)(methodData, "iterateeIndex")) {
+    return methodData.iterateeIndex;
+  }
+  if (methodData?.iteratee) {
+    return 1;
+  }
+  return -1;
+}
+function getSideEffectIterationMethods() {
+  return sideEffectIterationMethods;
+}
+var import_lodash, sideEffectIterationMethods;
+var init_methodDataUtil = __esm({
+  "src/util/methodDataUtil.ts"() {
+    "use strict";
+    import_lodash = require("lodash");
+    init_methodData();
+    sideEffectIterationMethods = [
+      "forEach",
+      "forEachRight",
+      "forIn",
+      "forInRight",
+      "forOwn",
+      "forOwnRight"
+    ];
+  }
+});
+
+// src/util/astUtil.ts
+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;
+      }
+    }
+  }
+}
+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));
+}
+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;
+    }
+  });
+}
+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;
+    }
+  }
+}
+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 import_lodash2, getCaller, getMethodName, isMethodCall, isFunctionExpression, isFunctionDefinitionWithBlock, getFirstFunctionLine, isPropAccess, getFirstParamName, isReturnStatement, isNegationExpression, isEqEqEq, isMinus, comparisonType, comparisonOperators, isIndexOfCall, isFindIndexCall, astUtil_default;
+var init_astUtil = __esm({
+  "src/util/astUtil.ts"() {
+    "use strict";
+    import_lodash2 = require("lodash");
+    getCaller = (0, import_lodash2.property)(["callee", "object"]);
+    getMethodName = (0, import_lodash2.property)(["callee", "property", "name"]);
+    isMethodCall = (0, import_lodash2.matches)({
+      type: "CallExpression",
+      callee: { type: "MemberExpression" }
+    });
+    isFunctionExpression = (0, import_lodash2.overSome)(
+      (0, import_lodash2.matchesProperty)("type", "FunctionExpression"),
+      (0, import_lodash2.matchesProperty)("type", "FunctionDeclaration")
+    );
+    isFunctionDefinitionWithBlock = (0, import_lodash2.overSome)(
+      isFunctionExpression,
+      (0, import_lodash2.matches)({
+        type: "ArrowFunctionExpression",
+        body: { type: "BlockStatement" }
+      })
+    );
+    getFirstFunctionLine = (0, import_lodash2.cond)([
+      [isFunctionDefinitionWithBlock, (0, import_lodash2.property)(["body", "body", 0])],
+      [(0, import_lodash2.matches)({ type: "ArrowFunctionExpression" }), (0, import_lodash2.property)("body")]
+    ]);
+    isPropAccess = (0, import_lodash2.overSome)(
+      (0, import_lodash2.matches)({ computed: false }),
+      (0, import_lodash2.matchesProperty)(["property", "type"], "Literal")
+    );
+    getFirstParamName = (0, import_lodash2.property)(["params", 0, "name"]);
+    isReturnStatement = (0, import_lodash2.matchesProperty)("type", "ReturnStatement");
+    isNegationExpression = (0, import_lodash2.matches)({
+      type: "UnaryExpression",
+      operator: "!"
+    });
+    isEqEqEq = (0, import_lodash2.matches)({ type: "BinaryExpression", operator: "===" });
+    isMinus = (node) => node.type === "UnaryExpression" && node.operator === "-";
+    comparisonType = {
+      exact: 0,
+      over: 1,
+      under: 2,
+      any: 3
+    };
+    comparisonOperators = ["==", "!=", "===", "!=="];
+    isIndexOfCall = (node) => isMethodCall(node) && getMethodName(node) === "indexOf";
+    isFindIndexCall = (node) => isMethodCall(node) && getMethodName(node) === "findIndex";
+    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/settingsUtil.ts
+function getSettings(context) {
+  return (0, import_lodash3.chain)(context).get(["settings", "remeda"]).clone().defaults({
+    version: 4
+  }).value();
+}
+var import_lodash3;
+var init_settingsUtil = __esm({
+  "src/util/settingsUtil.ts"() {
+    "use strict";
+    import_lodash3 = require("lodash");
+  }
+});
+
+// src/util/importUtil.ts
+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") {
+    return init.arguments[0].value;
+  }
+}
+var import_get, isFullRemedaImport, getMethodImportFromName;
+var init_importUtil = __esm({
+  "src/util/importUtil.ts"() {
+    "use strict";
+    import_get = __toESM(require("lodash/get"), 1);
+    isFullRemedaImport = (str) => /^remeda?(\/)?$/.test(str);
+    getMethodImportFromName = (str) => {
+      const match = /^remeda([./])(\w+)$/.exec(str);
+      return match && match[2];
+    };
+  }
+});
+
+// src/util/RemedaContext.ts
+var isMethodCall2, isCallFromObject2, getCaller2, RemedaContext_default;
+var init_RemedaContext = __esm({
+  "src/util/RemedaContext.ts"() {
+    "use strict";
+    init_settingsUtil();
+    init_astUtil();
+    init_importUtil();
+    ({ isMethodCall: isMethodCall2, isCallFromObject: isCallFromObject2, getCaller: getCaller2 } = astUtil_default);
+    RemedaContext_default = class {
+      context;
+      general;
+      methods;
+      _pragma;
+      /**
+       * Create a Remeda context wrapper from a file's RuleContext
+       * @param {RuleContext} context
+       */
+      constructor(context) {
+        this.context = context;
+        this.general = /* @__PURE__ */ Object.create(null);
+        this.methods = /* @__PURE__ */ Object.create(null);
+      }
+      /**
+       * Gets visitors to collect Remeda declarations in the context
+       * @returns {Object} visitors for everywhere Remeda can be declared
+       */
+      getImportVisitors() {
+        const self = this;
+        return {
+          ImportDeclaration({ source, specifiers }) {
+            if (isFullRemedaImport(source.value)) {
+              specifiers.forEach((spec) => {
+                switch (spec.type) {
+                  case "ImportNamespaceSpecifier":
+                  case "ImportDefaultSpecifier":
+                    self.general[spec.local.name] = true;
+                    break;
+                  case "ImportSpecifier":
+                    self.methods[spec.local.name] = spec.imported.name;
+                    if (spec.imported.name === "chain") {
+                      self.general[spec.local.name] = true;
+                    }
+                    break;
+                }
+              });
+            } else {
+              const method2 = getMethodImportFromName(source.value);
+              if (method2) {
+                self.methods[specifiers[0].local.name] = method2;
+              }
+            }
+          },
+          VariableDeclarator({ init, id }) {
+            const required = getNameFromCjsRequire(init);
+            if (isFullRemedaImport(required)) {
+              if (id.type === "Identifier") {
+                self.general[id.name] = true;
+              } else if (id.type === "ObjectPattern") {
+                id.properties.forEach((prop) => {
+                  self.methods[prop.value.name] = prop.key.name;
+                  if (prop.value.name === "chain") {
+                    self.general[prop.value.name] = true;
+                  }
+                });
+              }
+            } else if (required) {
+              const method2 = getMethodImportFromName(required);
+              if (method2) {
+                self.methods[id.name] = method2;
+              }
+            }
+          }
+        };
+      }
+      /**
+       * Returns whether the node is an imported Remeda in this context
+       * @param node
+       * @returns {boolean|undefined}
+       */
+      isImportedRemeda(node) {
+        if (node && node.type === "Identifier") {
+          return this.general[node.name];
+        }
+      }
+      /**
+       * Returns the name of the Remeda method for this node, if any
+       * @param node
+       * @returns {string|undefined}
+       */
+      getImportedRemedaMethod(node) {
+        if (node && node.type === "CallExpression" && !isMethodCall2(node)) {
+          return this.methods[node.callee.name];
+        }
+      }
+      /**
+       * Returns whether the node is a call from a Remeda object
+       * @param node
+       * @returns {boolean|undefined}
+       */
+      isRemedaCall(node) {
+        return this.pragma && isCallFromObject2(node, this.pragma) || this.isImportedRemeda(getCaller2(node));
+      }
+      /**
+       *
+       * @returns {string|undefined} the current Remeda pragma
+       */
+      get pragma() {
+        if (!this._pragma) {
+          const { pragma } = getSettings(this.context);
+          this._pragma = pragma;
+        }
+        return this._pragma;
+      }
+    };
+  }
+});
+
+// src/util/remedaUtil.ts
+function isCallToMethod(node, method2) {
+  return method2 === astUtil_default.getMethodName(node);
+}
+function getIsTypeMethod(name) {
+  const types = [
+    "number",
+    "boolean",
+    "function",
+    "Function",
+    "string",
+    // "object",
+    // "undefined",
+    "Date",
+    "Array",
+    "Error"
+    // "Element",
+  ];
+  return (0, import_lodash4.includes)(types, name) ? `is${(0, import_lodash4.capitalize)(name)}` : null;
+}
+function getRemedaMethodCallExpVisitor(remedaContext, reporter) {
+  return function(node) {
+    let iterateeIndex;
+    if (remedaContext.isRemedaCall(node)) {
+      const method2 = astUtil_default.getMethodName(node);
+      iterateeIndex = getIterateeIndex(method2);
+      reporter(node, node.arguments[iterateeIndex], {
+        callType: "method",
+        method: method2,
+        remedaContext
+      });
+    } else {
+      const method2 = remedaContext.getImportedRemedaMethod(node);
+      if (method2) {
+        iterateeIndex = getIterateeIndex(method2);
+        reporter(node, node.arguments[iterateeIndex], {
+          method: method2,
+          callType: "single",
+          remedaContext
+        });
+      }
+    }
+  };
+}
+function isRemedaCallToMethod(node, method2, remedaContext) {
+  return remedaContext.isRemedaCall(node) && isCallToMethod(node, method2);
+}
+function isCallToRemedaMethod(node, method2, remedaContext) {
+  if (!node || node.type !== "CallExpression") {
+    return false;
+  }
+  return isRemedaCallToMethod(node, method2, remedaContext) || method2 === remedaContext.getImportedRemedaMethod(node);
+}
+function getRemedaMethodVisitors(context, remedaCallExpVisitor) {
+  const remedaContext = new RemedaContext_default(context);
+  const visitors = remedaContext.getImportVisitors();
+  visitors.CallExpression = getRemedaMethodCallExpVisitor(
+    remedaContext,
+    remedaCallExpVisitor
+  );
+  return visitors;
+}
+function getRemedaContext(context) {
+  return new RemedaContext_default(context);
+}
+var import_lodash4;
+var init_remedaUtil = __esm({
+  "src/util/remedaUtil.ts"() {
+    "use strict";
+    import_lodash4 = require("lodash");
+    init_methodDataUtil();
+    init_astUtil();
+    init_RemedaContext();
+  }
+});
+
+// src/rules/collection-method-value.ts
+var collection_method_value_exports = {};
+__export(collection_method_value_exports, {
+  create: () => create2,
+  meta: () => meta
+});
+function create2(context) {
+  function parentUsesValue(node) {
+    return node.parent.type !== "ExpressionStatement";
+  }
+  function isSideEffectIterationMethod(method2) {
+    return (0, import_includes.default)(getSideEffectIterationMethods(), method2);
+  }
+  function isParentCommit(node, callType) {
+    return callType === "chained" && isCallToMethod(node.parent.parent, "commit");
+  }
+  return getRemedaMethodVisitors(
+    context,
+    (node, iteratee2, { method: method2, callType }) => {
+      if (isCollectionMethod(method2) && !parentUsesValue(node)) {
+        context.report({
+          node,
+          message: `Use value returned from R.${method2}`
+        });
+      } else if (isSideEffectIterationMethod(method2) && parentUsesValue(node) && !isParentCommit(node, callType)) {
+        context.report({
+          node,
+          message: `Do not use value returned from R.${getMethodName2(node)}`
+        });
+      }
+    }
+  );
+}
+var import_includes, getMethodName2, meta;
+var init_collection_method_value = __esm({
+  "src/rules/collection-method-value.ts"() {
+    "use strict";
+    init_getDocsUrl();
+    init_remedaUtil();
+    init_astUtil();
+    init_methodDataUtil();
+    import_includes = __toESM(require("lodash/includes"), 1);
+    ({ getMethodName: getMethodName2 } = astUtil_default);
+    meta = {
+      type: "problem",
+      schema: [],
+      docs: {
+        url: getDocsUrl("collection-method-value")
+      }
+    };
+  }
+});
+
+// src/rules/collection-return.ts
+var collection_return_exports = {};
+__export(collection_return_exports, {
+  create: () => create3,
+  meta: () => meta2
+});
+function create3(context) {
+  const funcInfos = /* @__PURE__ */ new Map();
+  let currFuncInfo;
+  const remedaContext = getRemedaContext(context);
+  return (0, import_assign.default)(
+    {
+      "CallExpression:exit": getRemedaMethodCallExpVisitor(
+        remedaContext,
+        (node, iteratee2, { method: method2 }) => {
+          if (isCollectionMethod(method2) && funcInfos.has(iteratee2)) {
+            const { hasReturn } = funcInfos.get(iteratee2);
+            if (astUtil_default.isFunctionDefinitionWithBlock(iteratee2) && !hasReturn && !iteratee2.async && !iteratee2.generator) {
+              context.report({
+                node,
+                message: `Do not use R.${method2} without returning a value`
+              });
+            }
+          }
+        }
+      ),
+      ReturnStatement() {
+        currFuncInfo.hasReturn = true;
+      },
+      onCodePathStart(codePath, node) {
+        currFuncInfo = {
+          upper: currFuncInfo,
+          codePath,
+          hasReturn: false
+        };
+        funcInfos.set(node, currFuncInfo);
+      },
+      onCodePathEnd() {
+        currFuncInfo = currFuncInfo.upper;
+      }
+    },
+    remedaContext.getImportVisitors()
+  );
+}
+var import_assign, meta2;
+var init_collection_return = __esm({
+  "src/rules/collection-return.ts"() {
+    "use strict";
+    init_getDocsUrl();
+    init_remedaUtil();
+    init_methodDataUtil();
+    init_astUtil();
+    import_assign = __toESM(require("lodash/assign"), 1);
+    meta2 = {
+      type: "problem",
+      schema: [],
+      docs: {
+        url: getDocsUrl("collection-return")
+      }
+    };
+  }
+});
+
+// src/rules/prefer-constant.ts
+var prefer_constant_exports = {};
+__export(prefer_constant_exports, {
+  create: () => create4,
+  meta: () => meta3
+});
+function create4(context) {
+  const shouldCheckArrowFunctions = context.options[0] !== void 0 ? context.options[0] : true;
+  const shouldCheckFunctionDeclarations = context.options[1] !== void 0 ? context.options[1] : false;
+  function isCompletelyLiteral(node) {
+    switch (node.type) {
+      case "Literal":
+        return true;
+      case "BinaryExpression":
+        return isCompletelyLiteral(node.left) && isCompletelyLiteral(node.right);
+      case "UnaryExpression":
+        return isCompletelyLiteral(node.argument);
+      case "ConditionalExpression":
+        return isCompletelyLiteral(node.test) && isCompletelyLiteral(node.consequent) && isCompletelyLiteral(node.alternate);
+      default:
+        return false;
+    }
+  }
+  function reportIfLikeConstant(func, node) {
+    const valueReturnedInFirstLine = func(node);
+    if (valueReturnedInFirstLine && isCompletelyLiteral(valueReturnedInFirstLine)) {
+      context.report({
+        node,
+        message: "Prefer R.constant over a function returning a literal"
+      });
+    }
+  }
+  function handleFunctionDefinition(node) {
+    reportIfLikeConstant(getValueReturnedInFirstStatement2, node);
+  }
+  return {
+    FunctionExpression: handleFunctionDefinition,
+    FunctionDeclaration(node) {
+      if (shouldCheckFunctionDeclarations) {
+        handleFunctionDefinition(node);
+      }
+    },
+    ArrowFunctionExpression(node) {
+      if (shouldCheckArrowFunctions) {
+        handleFunctionDefinition(node);
+      }
+    }
+  };
+}
+var getValueReturnedInFirstStatement2, meta3;
+var init_prefer_constant = __esm({
+  "src/rules/prefer-constant.ts"() {
+    "use strict";
+    init_getDocsUrl();
+    init_astUtil();
+    ({ getValueReturnedInFirstStatement: getValueReturnedInFirstStatement2 } = astUtil_default);
+    meta3 = {
+      type: "problem",
+      docs: {
+        url: getDocsUrl("prefer-constant")
+      },
+      schema: [
+        {
+          type: "boolean"
+        },
+        {
+          type: "boolean"
+        }
+      ]
+    };
+  }
+});
+
+// src/rules/prefer-do-nothing.ts
+var prefer_do_nothing_exports = {};
+__export(prefer_do_nothing_exports, {
+  create: () => create5,
+  meta: () => meta4
+});
+function create5(context) {
+  function reportIfEmptyFunction(node) {
+    if (!getFirstFunctionLine2(node) && node.parent.type !== "MethodDefinition" && !node.generator && !node.async) {
+      context.report({
+        node,
+        message: "Prefer R.doNothing() or R.constant(undefined) over an empty function"
+      });
+    }
+  }
+  return {
+    FunctionExpression: reportIfEmptyFunction,
+    ArrowFunctionExpression: reportIfEmptyFunction
+  };
+}
+var getFirstFunctionLine2, meta4;
+var init_prefer_do_nothing = __esm({
+  "src/rules/prefer-do-nothing.ts"() {
+    "use strict";
+    init_getDocsUrl();
+    init_astUtil();
+    ({ getFirstFunctionLine: getFirstFunctionLine2 } = astUtil_default);
+    meta4 = {
+      type: "problem",
+      schema: [],
+      docs: {
+        url: getDocsUrl("prefer-do-nothing")
+      }
+    };
+  }
+});
+
+// src/rules/prefer-filter.ts
+var prefer_filter_exports = {};
+__export(prefer_filter_exports, {
+  create: () => create6,
+  meta: () => meta5
+});
+function create6(context) {
+  const DEFAULT_MAX_PROPERTY_PATH_LENGTH = 3;
+  const maxLength = parseInt(context.options[0], 10) || DEFAULT_MAX_PROPERTY_PATH_LENGTH;
+  function isIfWithoutElse(statement) {
+    return statement && statement.type === "IfStatement" && !statement.alternate;
+  }
+  function canBeShorthand(exp, paramName) {
+    return isIdentifierWithName2(exp, paramName) || isMemberExpOf2(exp, paramName, { maxLength }) || isNegationOfMemberOf2(exp, paramName, { maxLength }) || isEqEqEqToMemberOf(exp, paramName, { maxLength }) || isNotEqEqToMemberOf(exp, paramName, { maxLength });
+  }
+  function onlyHasSimplifiableIf(func) {
+    const firstLine = getFirstFunctionLine3(func);
+    return func && hasOnlyOneStatement2(func) && func.params.length === 1 && isIfWithoutElse(firstLine) && canBeShorthand(firstLine.test, getFirstParamName2(func));
+  }
+  return getRemedaMethodVisitors(context, (node, iteratee2, { method: method2 }) => {
+    if (method2 === "forEach" && onlyHasSimplifiableIf(iteratee2)) {
+      context.report({
+        node,
+        message: "Prefer R.filter or R.some over an if statement inside a R.forEach"
+      });
+    }
+  });
+}
+var isIdentifierWithName2, isMemberExpOf2, isNegationOfMemberOf2, isEqEqEqToMemberOf, isNotEqEqToMemberOf, getFirstFunctionLine3, hasOnlyOneStatement2, getFirstParamName2, meta5;
+var init_prefer_filter = __esm({
+  "src/rules/prefer-filter.ts"() {
+    "use strict";
+    init_getDocsUrl();
+    init_remedaUtil();
+    init_astUtil();
+    ({
+      isIdentifierWithName: isIdentifierWithName2,
+      isMemberExpOf: isMemberExpOf2,
+      isNegationOfMemberOf: isNegationOfMemberOf2,
+      isEqEqEqToMemberOf,
+      isNotEqEqToMemberOf,
+      getFirstFunctionLine: getFirstFunctionLine3,
+      hasOnlyOneStatement: hasOnlyOneStatement2,
+      getFirstParamName: getFirstParamName2
+    } = astUtil_default);
+    meta5 = {
+      type: "problem",
+      docs: {
+        url: getDocsUrl("prefer-filter")
+      },
+      schema: [
+        {
+          type: "integer"
+        }
+      ]
+    };
+  }
+});
+
+// src/rules/prefer-find.ts
+var prefer_find_exports = {};
+__export(prefer_find_exports, {
+  create: () => create7,
+  meta: () => meta6
+});
+function create7(context) {
+  function isZeroIndexAccess(node) {
+    return node.type === "MemberExpression" && node.property.value === 0;
+  }
+  function isChainedBeforeMethod(callType, node, method2) {
+    return callType === "chained" && isCallToMethod(node.parent.parent, method2);
+  }
+  return getRemedaMethodVisitors(
+    context,
+    (node, iteratee2, { method: method2, callType, remedaContext }) => {
+      if (method2 === "filter") {
+        if (isZeroIndexAccess(node.parent) || isCallToRemedaMethod(node.parent, "first", remedaContext) || isChainedBeforeMethod(callType, node, "first")) {
+          context.report({
+            node,
+            message: "Prefer using `R.find` over selecting the first item of a filtered result"
+          });
+        }
+        if (isCallToRemedaMethod(node.parent, "last", remedaContext) || isChainedBeforeMethod(callType, node, "last")) {
+          context.report({
+            node,
+            message: "Prefer using `R.findLast` over selecting the last item of a filtered result"
+          });
+        }
+      }
+    }
+  );
+}
+var meta6;
+var init_prefer_find = __esm({
+  "src/rules/prefer-find.ts"() {
+    "use strict";
+    init_getDocsUrl();
+    init_remedaUtil();
+    meta6 = {
+      type: "problem",
+      schema: [],
+      docs: {
+        url: getDocsUrl("prefer-find")
+      }
+    };
+  }
+});
+
+// src/rules/prefer-flat-map.ts
+var prefer_flat_map_exports = {};
+__export(prefer_flat_map_exports, {
+  create: () => create8,
+  meta: () => meta7
+});
+function create8(context) {
+  function isChainedMapFlatten(node) {
+    return isCallToMethod(getCaller3(node), "map");
+  }
+  return getRemedaMethodVisitors(
+    context,
+    (node, iteratee2, { method: method2, remedaContext }) => {
+      if (method2 === "flat" && (isChainedMapFlatten(node) || isCallToRemedaMethod(node.arguments[0], "map", remedaContext))) {
+        context.report({
+          node,
+          message: "Prefer R.flatMap over consecutive R.map and R.flat."
+        });
+      }
+    }
+  );
+}
+var getCaller3, meta7;
+var init_prefer_flat_map = __esm({
+  "src/rules/prefer-flat-map.ts"() {
+    "use strict";
+    init_getDocsUrl();
+    init_remedaUtil();
+    init_astUtil();
+    ({ getCaller: getCaller3 } = astUtil_default);
+    meta7 = {
+      type: "problem",
+      schema: [],
+      docs: {
+        url: getDocsUrl("prefer-flat-map")
+      }
+    };
+  }
+});
+
+// src/rules/prefer-is-empty.ts
+var prefer_is_empty_exports = {};
+__export(prefer_is_empty_exports, {
+  create: () => create9,
+  meta: () => meta8
+});
+function create9(context) {
+  const remedaContext = getRemedaContext(context);
+  function getTextOfNode(node) {
+    if (node) {
+      if (node.type === "Identifier") {
+        return node.name;
+      }
+      return context.getSourceCode().getText(node);
+    }
+  }
+  const visitors = remedaContext.getImportVisitors();
+  visitors.BinaryExpression = function(node) {
+    if (node.operator === "===") {
+      if (node.left) {
+        if (node.left.property && node.right) {
+          const leftExpressionMember = node.left.property.name;
+          const rightExpressionMember = node.right.value;
+          if (leftExpressionMember === "length" && rightExpressionMember === 0) {
+            const subjectObject = node.left.object;
+            context.report({
+              node,
+              message: "Prefer isEmpty over manually checking for length value.",
+              fix(fixer) {
+                return fixer.replaceText(
+                  node,
+                  `isEmpty(${getTextOfNode(subjectObject)})`
+                );
+              }
+            });
+          }
+        } else if (node.left.expression && node.right && node.left.expression.property) {
+          const leftExpressionMember = node.left.expression.property.name;
+          const rightExpressionMember = node.right.value;
+          if (leftExpressionMember === "length" && rightExpressionMember === 0) {
+            const subjectObject = node.left.expression.object;
+            context.report({
+              node,
+              message: "Prefer isEmpty over manually checking for length value.",
+              fix(fixer) {
+                return fixer.replaceText(
+                  node,
+                  `isEmpty(${getTextOfNode(subjectObject)})`
+                );
+              }
+            });
+          }
+        }
+      }
+    }
+    if (node.operator === ">") {
+      if (node.left) {
+        if (node.left.property && node.right) {
+          const leftExpressionMember = node.left.property.name;
+          const rightExpressionMember = node.right.value;
+          if (leftExpressionMember === "length" && rightExpressionMember === 0) {
+            const subjectObject = node.left.object;
+            context.report({
+              node,
+              message: "Prefer isEmpty over manually checking for length value.",
+              fix(fixer) {
+                return fixer.replaceText(
+                  node,
+                  `!isEmpty(${getTextOfNode(subjectObject)})`
+                );
+              }
+            });
+          }
+        } else if (node.left.expression && node.right) {
+          const leftExpressionMember = node.left.expression.property.name;
+          const rightExpressionMember = node.right.value;
+          if (leftExpressionMember === "length" && rightExpressionMember === 0) {
+            const subjectObject = node.left.expression.object;
+            context.report({
+              node,
+              message: "Prefer isEmpty over manually checking for length value.",
+              fix(fixer) {
+                return fixer.replaceText(
+                  node,
+                  `!isEmpty(${getTextOfNode(subjectObject)})`
+                );
+              }
+            });
+          }
+        }
+      }
+    }
+  };
+  return visitors;
+}
+var meta8;
+var init_prefer_is_empty = __esm({
+  "src/rules/prefer-is-empty.ts"() {
+    "use strict";
+    init_remedaUtil();
+    init_getDocsUrl();
+    meta8 = {
+      type: "problem",
+      schema: [],
+      docs: {
+        url: getDocsUrl("prefer-is-empty")
+      },
+      fixable: "code"
+    };
+  }
+});
+
+// src/rules/prefer-is-nil.ts
+var prefer_is_nil_exports = {};
+__export(prefer_is_nil_exports, {
+  create: () => create10,
+  meta: () => meta9
+});
+function create10(context) {
+  const remedaContext = getRemedaContext(context);
+  const nilChecks = {
+    null: {
+      isValue: (0, import_lodash5.matches)({ type: "Literal", value: null }),
+      expressionChecks: [
+        getRemedaTypeCheckedBy("isNull"),
+        getValueComparedTo("null")
+      ]
+    },
+    undefined: {
+      isValue: (0, import_lodash5.matches)({ type: "Identifier", name: "undefined" }),
+      expressionChecks: [
+        getRemedaTypeCheckedBy("isUndefined"),
+        getValueComparedTo("undefined"),
+        getValueWithTypeofUndefinedComparison
+      ]
+    }
+  };
+  function getRemedaTypeCheckedBy(typecheck) {
+    return function(node) {
+      return isCallToRemedaMethod(node, typecheck, remedaContext) && node.arguments[0];
+    };
+  }
+  function getValueComparedTo(nil) {
+    return function(node, operator) {
+      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)([
+    [
+      (0, import_lodash5.matches)({ type: "UnaryExpression", operator: "typeof" }),
+      (0, import_lodash5.property)("argument")
+    ]
+  ]);
+  const isUndefinedString = (0, import_lodash5.matches)({
+    type: "Literal",
+    value: "undefined"
+  });
+  function getValueWithTypeofUndefinedComparison(node, operator) {
+    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();
+  }
+  function checkNegatedExpression(nil, node) {
+    return isNegationExpression2(node) && checkExpression(nil, "===", node.argument) || checkExpression(nil, "!==", node);
+  }
+  function isEquivalentExistingExpression(node, leftNil, rightNil) {
+    const leftExp = checkExpression(leftNil, "===", node.left);
+    return leftExp && isEquivalentMemberExp2(
+      leftExp,
+      checkExpression(rightNil, "===", node.right)
+    );
+  }
+  function isEquivalentExistingNegation(node, leftNil, rightNil) {
+    const leftExp = checkNegatedExpression(leftNil, node.left);
+    return leftExp && isEquivalentMemberExp2(
+      leftExp,
+      checkNegatedExpression(rightNil, node.right)
+    );
+  }
+  const visitors = remedaContext.getImportVisitors();
+  visitors.LogicalExpression = function(node) {
+    if (node.operator === "||") {
+      if (isEquivalentExistingExpression(node, "undefined", "null") || isEquivalentExistingExpression(node, "null", "undefined")) {
+        context.report({
+          node,
+          message: "Prefer isNil over checking for undefined or null."
+        });
+      }
+    } else if (isEquivalentExistingNegation(node, "undefined", "null") || isEquivalentExistingNegation(node, "null", "undefined")) {
+      context.report({
+        node,
+        message: "Prefer isNil over checking for undefined or null."
+      });
+    }
+  };
+  return visitors;
+}
+var import_lodash5, isNegationExpression2, isEquivalentMemberExp2, meta9;
+var init_prefer_is_nil = __esm({
+  "src/rules/prefer-is-nil.ts"() {
+    "use strict";
+    init_astUtil();
+    init_getDocsUrl();
+    init_remedaUtil();
+    import_lodash5 = __toESM(require("lodash"), 1);
+    ({ isNegationExpression: isNegationExpression2, isEquivalentMemberExp: isEquivalentMemberExp2 } = astUtil_default);
+    meta9 = {
+      type: "problem",
+      schema: [],
+      docs: {
+        url: getDocsUrl("prefer-is-nil")
+      }
+    };
+  }
+});
+
+// src/rules/prefer-map.ts
+var prefer_map_exports = {};
+__export(prefer_map_exports, {
+  create: () => create11,
+  meta: () => meta10
+});
+function create11(context) {
+  function onlyHasPush(func) {
+    const firstLine = getFirstFunctionLine4(func);
+    const firstParam = (0, import_get2.default)(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)(
+      collectParameterValues2(firstParam),
+      (0, import_get2.default)(exp, "callee.object.name")
+    );
+  }
+  return getRemedaMethodVisitors(context, (node, iteratee2, { method: method2 }) => {
+    if (method2 === "forEach" && onlyHasPush(iteratee2)) {
+      context.report({
+        node,
+        message: "Prefer R.map over a R.forEach with a push to an array inside"
+      });
+    }
+  });
+}
+var import_get2, import_includes2, getFirstFunctionLine4, hasOnlyOneStatement3, getMethodName3, isFunctionDefinitionWithBlock2, collectParameterValues2, meta10;
+var init_prefer_map = __esm({
+  "src/rules/prefer-map.ts"() {
+    "use strict";
+    init_getDocsUrl();
+    init_remedaUtil();
+    init_astUtil();
+    import_get2 = __toESM(require("lodash/get"), 1);
+    import_includes2 = __toESM(require("lodash/includes"), 1);
+    ({
+      getFirstFunctionLine: getFirstFunctionLine4,
+      hasOnlyOneStatement: hasOnlyOneStatement3,
+      getMethodName: getMethodName3,
+      isFunctionDefinitionWithBlock: isFunctionDefinitionWithBlock2,
+      collectParameterValues: collectParameterValues2
+    } = astUtil_default);
+    meta10 = {
+      type: "problem",
+      schema: [],
+      docs: {
+        url: getDocsUrl("prefer-map")
+      }
+    };
+  }
+});
+
+// src/rules/prefer-nullish-coalescing.ts
+var prefer_nullish_coalescing_exports = {};
+__export(prefer_nullish_coalescing_exports, {
+  create: () => create12,
+  meta: () => meta11
+});
+function create12(context) {
+  const remedaContext = getRemedaContext(context);
+  function getTextOfNode(node) {
+    if (node) {
+      if (node.type === "Identifier") {
+        return node.name;
+      }
+      return context.getSourceCode().getText(node);
+    }
+  }
+  const visitors = remedaContext.getImportVisitors();
+  visitors.ConditionalExpression = function(node) {
+    const statement = node.test;
+    if (statement.operator === "!") {
+      if (statement.argument && statement.argument.callee && statement.argument.callee.name && statement.argument.callee.name === "isNullish") {
+        const argument = getTextOfNode(statement.argument.arguments[0]);
+        const consequent = getTextOfNode(node.consequent);
+        const alternate = getTextOfNode(node.alternate);
+        if (argument === consequent) {
+          context.report({
+            node,
+            message: "Prefer nullish coalescing over checking a ternary with !isNullish.",
+            fix(fixer) {
+              return fixer.replaceText(node, `${argument} ?? ${alternate}`);
+            }
+          });
+        }
+      }
+    }
+  };
+  return visitors;
+}
+var meta11;
+var init_prefer_nullish_coalescing = __esm({
+  "src/rules/prefer-nullish-coalescing.ts"() {
+    "use strict";
+    init_getDocsUrl();
+    init_remedaUtil();
+    meta11 = {
+      type: "problem",
+      schema: [],
+      docs: {
+        url: getDocsUrl("prefer-nullish-coalescing")
+      },
+      fixable: "code"
+    };
+  }
+});
+
+// src/rules/prefer-remeda-typecheck.ts
+var prefer_remeda_typecheck_exports = {};
+__export(prefer_remeda_typecheck_exports, {
+  create: () => create13,
+  meta: () => meta12
+});
+function create13(context) {
+  const otherSides = {
+    left: "right",
+    right: "left"
+  };
+  function isTypeOf(node) {
+    return node && node.type === "UnaryExpression" && node.operator === "typeof";
+  }
+  function isStrictComparison(node) {
+    return node.operator === "===" || node.operator === "!==";
+  }
+  function isDeclaredVariable(node) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    const scope = sourceCode.getScope ? sourceCode.getScope(node) : context.getScope();
+    const definedVariables = scope.variables;
+    return (0, import_some.default)(definedVariables, { name: node.name });
+  }
+  function getValueForSide(node, side) {
+    const otherSide = otherSides[side];
+    if (isTypeOf(node[side]) && (node[otherSide].value !== "undefined" || node[side].argument.type !== "Identifier" || isDeclaredVariable(node[side].argument))) {
+      return node[otherSide].value;
+    }
+  }
+  function getTypeofCompareType(node) {
+    if (isStrictComparison(node)) {
+      return getValueForSide(node, "left") || getValueForSide(node, "right");
+    }
+  }
+  const REPORT_MESSAGE = "Prefer 'R.{{method}}' over {{actual}}.";
+  return {
+    BinaryExpression(node) {
+      const typeofCompareType = getTypeofCompareType(node);
+      if (typeofCompareType) {
+        context.report({
+          node,
+          message: REPORT_MESSAGE,
+          data: {
+            method: getIsTypeMethod(typeofCompareType),
+            actual: "'typeof' comparison"
+          }
+        });
+      } else if (node.operator === "instanceof") {
+        const remedaEquivalent = getIsTypeMethod(node.right.name);
+        if (node.right.type === "Identifier" && remedaEquivalent) {
+          context.report({
+            node,
+            message: REPORT_MESSAGE,
+            data: {
+              method: remedaEquivalent,
+              actual: `'instanceof ${node.right.name}'`
+            }
+          });
+        }
+      }
+    }
+  };
+}
+var import_some, meta12;
+var init_prefer_remeda_typecheck = __esm({
+  "src/rules/prefer-remeda-typecheck.ts"() {
+    "use strict";
+    init_getDocsUrl();
+    init_remedaUtil();
+    import_some = __toESM(require("lodash/some"), 1);
+    meta12 = {
+      type: "problem",
+      schema: [],
+      docs: {
+        url: getDocsUrl("prefer-remeda-typecheck")
+      }
+    };
+  }
+});
+
+// src/rules/prefer-some.ts
+var prefer_some_exports = {};
+__export(prefer_some_exports, {
+  create: () => create14,
+  meta: () => meta13
+});
+function create14(context) {
+  const visitors = getRemedaMethodVisitors(
+    context,
+    (node, iteratee2, { method: method2 }) => {
+      if (method2 === "findIndex" && node === getExpressionComparedToInt2(node.parent, -1, true)) {
+        context.report({
+          node,
+          message: "Prefer R.some over findIndex comparison to -1"
+        });
+      }
+    }
+  );
+  return visitors;
+}
+var getExpressionComparedToInt2, meta13;
+var init_prefer_some = __esm({
+  "src/rules/prefer-some.ts"() {
+    "use strict";
+    init_getDocsUrl();
+    init_astUtil();
+    init_remedaUtil();
+    ({ getExpressionComparedToInt: getExpressionComparedToInt2 } = astUtil_default);
+    meta13 = {
+      type: "problem",
+      docs: {
+        url: getDocsUrl("prefer-some")
+      },
+      schema: []
+    };
+  }
+});
+
+// src/rules/prefer-times.ts
+var prefer_times_exports = {};
+__export(prefer_times_exports, {
+  create: () => create15,
+  meta: () => meta14
+});
+function create15(context) {
+  return getRemedaMethodVisitors(context, (node, iteratee2, { method: method2 }) => {
+    if (method2 === "map" && (0, import_lodash6.get)(iteratee2, "params.length") === 0) {
+      context.report({
+        node,
+        message: "Prefer R.times over R.map without using arguments"
+      });
+    }
+  });
+}
+var import_lodash6, meta14;
+var init_prefer_times = __esm({
+  "src/rules/prefer-times.ts"() {
+    "use strict";
+    import_lodash6 = require("lodash");
+    init_getDocsUrl();
+    init_remedaUtil();
+    meta14 = {
+      type: "problem",
+      schema: [],
+      docs: {
+        url: getDocsUrl("prefer-times")
+      }
+    };
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  userFacingConfig: () => userFacingConfig
+});
+module.exports = __toCommonJS(src_exports);
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_lodash7 = __toESM(require("lodash"), 1);
+
+// require("./rules/**/*") in src/index.ts
+var globRequire_rules = __glob({
+  "./rules/collection-method-value.ts": () => (init_collection_method_value(), __toCommonJS(collection_method_value_exports)),
+  "./rules/collection-return.ts": () => (init_collection_return(), __toCommonJS(collection_return_exports)),
+  "./rules/prefer-constant.ts": () => (init_prefer_constant(), __toCommonJS(prefer_constant_exports)),
+  "./rules/prefer-do-nothing.ts": () => (init_prefer_do_nothing(), __toCommonJS(prefer_do_nothing_exports)),
+  "./rules/prefer-filter.ts": () => (init_prefer_filter(), __toCommonJS(prefer_filter_exports)),
+  "./rules/prefer-find.ts": () => (init_prefer_find(), __toCommonJS(prefer_find_exports)),
+  "./rules/prefer-flat-map.ts": () => (init_prefer_flat_map(), __toCommonJS(prefer_flat_map_exports)),
+  "./rules/prefer-is-empty.ts": () => (init_prefer_is_empty(), __toCommonJS(prefer_is_empty_exports)),
+  "./rules/prefer-is-nil.ts": () => (init_prefer_is_nil(), __toCommonJS(prefer_is_nil_exports)),
+  "./rules/prefer-map.ts": () => (init_prefer_map(), __toCommonJS(prefer_map_exports)),
+  "./rules/prefer-nullish-coalescing.ts": () => (init_prefer_nullish_coalescing(), __toCommonJS(prefer_nullish_coalescing_exports)),
+  "./rules/prefer-remeda-typecheck.ts": () => (init_prefer_remeda_typecheck(), __toCommonJS(prefer_remeda_typecheck_exports)),
+  "./rules/prefer-some.ts": () => (init_prefer_some(), __toCommonJS(prefer_some_exports)),
+  "./rules/prefer-times.ts": () => (init_prefer_times(), __toCommonJS(prefer_times_exports))
+});
+
+// src/index.ts
+var rules = import_fs.default.readdirSync(import_path.default.resolve(__dirname, "rules")).map((f) => f.replace(/\.js$/, ""));
+var recommended = {
+  plugins: ["remeda"],
+  rules: {
+    "remeda/prefer-is-empty": 2,
+    "remeda/prefer-is-nil": 2,
+    "remeda/prefer-times": 2,
+    "remeda/prefer-constant": 2,
+    "remeda/prefer-remeda-typecheck": 2,
+    "remeda/prefer-nullish-coalescing": 2,
+    "remeda/prefer-filter": [2, 3],
+    "remeda/collection-method-value": 2,
+    "remeda/collection-return": 2,
+    "remeda/prefer-map": 2,
+    "remeda/prefer-find": 2,
+    "remeda/prefer-some": 2,
+    "remeda/prefer-flat-map": 2,
+    "remeda/prefer-do-nothing": 2
+  }
+};
+var userFacingConfig = {
+  rules: import_lodash7.default.zipObject(
+    rules,
+    rules.map((rule) => globRequire_rules(`./rules/${rule}`))
+  ),
+  configs: {
+    recommended
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  userFacingConfig
+});