eslint-plugin-remeda 1.0.0 → 1.2.0

package/dist/index.cjs

@@ -0,0 +1,3768 @@
+"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 __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);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  default: () => src_default
+});
+module.exports = __toCommonJS(src_exports);
+var import_lodash7 = __toESM(require("lodash"), 1);
+
+// package.json
+var version = "0.0.0-development";
+var package_default = {
+  name: "eslint-plugin-remeda",
+  version,
+  author: "Andrea Pontrandolfo <andrea.pontra@gmail.com>",
+  description: "ESLint plugin for Remeda library.",
+  type: "module",
+  main: "dist/index.js",
+  scripts: {
+    build: "tsup",
+    typecheck: "tsc",
+    knip: "knip",
+    publint: "publint",
+    "test:watch": "vitest --ui",
+    test: "vitest run",
+    attw: "attw --pack .",
+    qa: "pnpm typecheck && pnpm test && pnpm knip && pnpm publint && attw",
+    "semantic-release": "pnpm build && semantic-release"
+  },
+  files: [
+    "README.md",
+    "dist",
+    "docs"
+  ],
+  exports: {
+    "./package.json": "./package.json",
+    ".": {
+      import: "./dist/index.js",
+      default: "./dist/index.cjs"
+    }
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/AndreaPontrandolfo/eslint-plugin-remeda.git"
+  },
+  homepage: "https://github.com/AndreaPontrandolfo/eslint-plugin-remeda",
+  bugs: "https://github.com/AndreaPontrandolfo/eslint-plugin-remeda/issues",
+  peerDependencies: {
+    eslint: ">=9.0.0"
+  },
+  devDependencies: {
+    "@arethetypeswrong/cli": "^0.15.4",
+    "@types/lodash": "^4.17.7",
+    "@types/node": "^20.14.9",
+    "@vitest/coverage-v8": "^2.0.3",
+    "@vitest/ui": "^2.0.3",
+    eslint: "^9.7.0",
+    "eslint-plugin-eslint-plugin": "^4.2.0",
+    "eslint-vitest-rule-tester": "^0.3.3",
+    knip: "^5.29.1",
+    prettier: "^3.3.2",
+    publint: "^0.2.10",
+    "semantic-release": "^24.0.0",
+    tsup: "^8.2.4",
+    typescript: "^5.5.2",
+    vitest: "^2.0.3"
+  },
+  engines: {
+    node: ">=20"
+  },
+  packageManager: "pnpm@9.7.1",
+  publishConfig: {
+    access: "public"
+  },
+  keywords: [
+    "eslint",
+    "eslint-plugin",
+    "eslint plugin",
+    "eslintplugin",
+    "remeda",
+    "functional",
+    "fp"
+  ],
+  license: "MIT",
+  dependencies: {
+    lodash: "^4.17.21"
+  }
+};
+
+// src/util/getDocsUrl.ts
+var REPO_URL = "https://github.com/AndreaPontrandolfo/eslint-plugin-remeda";
+function getDocsUrl(ruleName) {
+  return `${REPO_URL}/blob/v${version}/docs/rules/${ruleName}.md`;
+}
+
+// src/util/remedaUtil.ts
+var import_lodash4 = require("lodash");
+
+// src/util/methodDataUtil.ts
+var import_lodash = require("lodash");
+
+// 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 = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 2
+};
+var after = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 2
+};
+var ary = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 2
+};
+var assign = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var assignIn = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var assignInWith = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var assignWith = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var at = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var attempt = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false
+};
+var before = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 2
+};
+var bind = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var bindAll = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var bindKey = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var camelCase = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var capitalize = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var castArray = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var ceil = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 2
+};
+var chain = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var chunk = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 2
+};
+var clamp = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 3
+};
+var clone = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var cloneDeep = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var cloneDeepWith = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: true,
+  args: 2
+};
+var cloneWith = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: true,
+  args: 2
+};
+var commit = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var concat = {
+  wrapper: true,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var cond = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var conforms = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var conformsTo = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 2
+};
+var constant = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var countBy = {
+  wrapper: false,
+  shorthand: true,
+  chainable: true,
+  iteratee: true,
+  args: 2
+};
+var create = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 2
+};
+var curry = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 2
+};
+var curryRight = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 2
+};
+var debounce = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 3
+};
+var deburr = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var defaultTo = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 2
+};
+var defaults = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var defaultsDeep = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var defer = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var delay = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var difference = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var differenceBy = {
+  wrapper: false,
+  shorthand: true,
+  chainable: true,
+  iteratee: true
+};
+var differenceWith = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var divide = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 2
+};
+var drop = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 2
+};
+var dropRight = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 2
+};
+var dropRightWhile = {
+  wrapper: false,
+  shorthand: true,
+  chainable: true,
+  iteratee: true,
+  args: 3
+};
+var dropWhile = {
+  wrapper: false,
+  shorthand: true,
+  chainable: true,
+  iteratee: true,
+  args: 3
+};
+var endsWith = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 3
+};
+var eq = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 2
+};
+var escape = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var escapeRegExp = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var every = {
+  wrapper: false,
+  shorthand: true,
+  chainable: false,
+  iteratee: true,
+  args: 2
+};
+var fill = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 4
+};
+var filter = {
+  wrapper: false,
+  shorthand: true,
+  chainable: true,
+  iteratee: true,
+  args: 2
+};
+var find = {
+  wrapper: false,
+  shorthand: true,
+  chainable: false,
+  iteratee: true,
+  args: 3
+};
+var findIndex = {
+  wrapper: false,
+  shorthand: true,
+  chainable: false,
+  iteratee: true,
+  args: 3
+};
+var findKey = {
+  wrapper: false,
+  shorthand: true,
+  chainable: false,
+  iteratee: true,
+  args: 2
+};
+var findLast = {
+  wrapper: false,
+  shorthand: true,
+  chainable: false,
+  iteratee: true,
+  args: 3
+};
+var findLastIndex = {
+  wrapper: false,
+  shorthand: true,
+  chainable: false,
+  iteratee: true,
+  args: 3
+};
+var findLastKey = {
+  wrapper: false,
+  shorthand: true,
+  chainable: false,
+  iteratee: true,
+  args: 2
+};
+var flatMap = {
+  wrapper: false,
+  shorthand: true,
+  chainable: true,
+  iteratee: true,
+  args: 2
+};
+var flatMapDeep = {
+  wrapper: false,
+  shorthand: true,
+  chainable: true,
+  iteratee: true,
+  args: 2
+};
+var flatMapDepth = {
+  wrapper: false,
+  shorthand: true,
+  chainable: true,
+  iteratee: true,
+  args: 3
+};
+var flatten = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var flattenDeep = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var flattenDepth = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 2
+};
+var flip = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var floor = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 2
+};
+var flow = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var flowRight = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var forEach = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: true,
+  args: 2
+};
+var forEachRight = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: true,
+  args: 2
+};
+var forIn = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: true,
+  args: 2
+};
+var forInRight = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: true,
+  args: 2
+};
+var forOwn = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: true,
+  args: 2
+};
+var forOwnRight = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: true,
+  args: 2
+};
+var fromPairs = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var functions = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var functionsIn = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var get = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 3
+};
+var groupBy = {
+  wrapper: false,
+  shorthand: true,
+  chainable: true,
+  iteratee: true,
+  args: 2
+};
+var gt = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 2
+};
+var gte = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 2
+};
+var has = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 2
+};
+var hasIn = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 2
+};
+var head = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var first = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var identity = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var inRange = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 3
+};
+var includes = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 3
+};
+var indexBy = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: true
+};
+var indexOf = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 3
+};
+var initial = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var intersection = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var intersectionBy = {
+  wrapper: false,
+  shorthand: true,
+  chainable: true,
+  iteratee: true
+};
+var intersectionWith = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var invert = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var invertBy = {
+  wrapper: false,
+  shorthand: true,
+  chainable: true,
+  iteratee: true,
+  args: 2
+};
+var invoke = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false
+};
+var invokeMap = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var isArguments = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var isArray = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var isArrayBuffer = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var isArrayLike = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var isArrayLikeObject = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var isBoolean = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var isBuffer = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var isDate = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var isElement = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var isEmpty = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var isEqual = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 2
+};
+var isEqualWith = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 3
+};
+var isError = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var isFinite = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var isFunction = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var isInteger = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var isLength = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var isMap = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var isMatch = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 2
+};
+var isMatchWith = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 3
+};
+var isNaN = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var isNative = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var isNil = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var isNull = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var isNumber = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var isObject = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var isObjectLike = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var isPlainObject = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var isRegExp = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var isSafeInteger = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var isSet = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var isString = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var isSymbol = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var isTypedArray = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var isUndefined = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var isWeakMap = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var isWeakSet = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var iteratee = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var join = {
+  wrapper: true,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 2
+};
+var kebabCase = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var keyBy = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: true,
+  args: 2
+};
+var keys = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var keysIn = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var last = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var lastIndexOf = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 3
+};
+var lowerCase = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var lowerFirst = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var lt = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 2
+};
+var lte = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 2
+};
+var map = {
+  wrapper: false,
+  shorthand: true,
+  chainable: true,
+  iteratee: true,
+  args: 2
+};
+var mapKeys = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: true,
+  args: 2
+};
+var mapValues = {
+  wrapper: false,
+  shorthand: true,
+  chainable: true,
+  iteratee: true,
+  args: 2
+};
+var matches = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var matchesProperty = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 2
+};
+var max = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var maxBy = {
+  wrapper: false,
+  shorthand: true,
+  chainable: false,
+  iteratee: true,
+  args: 2
+};
+var mean = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var meanBy = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: true,
+  args: 2
+};
+var memoize = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 2
+};
+var merge = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var mergeWith = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var method = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var methodOf = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var min = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var minBy = {
+  wrapper: false,
+  shorthand: true,
+  chainable: false,
+  iteratee: true,
+  args: 2
+};
+var mixin = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 3
+};
+var multiply = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 2
+};
+var negate = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var next = {
+  wrapper: true,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 0
+};
+var noConflict = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 0
+};
+var noop = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 0
+};
+var now = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 0
+};
+var nth = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 2
+};
+var nthArg = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var omit = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var omitBy = {
+  wrapper: false,
+  shorthand: true,
+  chainable: true,
+  iteratee: true
+};
+var once = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var orderBy = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 3
+};
+var over = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var overArgs = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var overEvery = {
+  wrapper: false,
+  shorthand: true,
+  chainable: true,
+  iteratee: true
+};
+var overSome = {
+  wrapper: false,
+  shorthand: true,
+  chainable: true,
+  iteratee: true
+};
+var pad = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 3
+};
+var padEnd = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 3
+};
+var padStart = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 3
+};
+var parseInt2 = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 2
+};
+var partial = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var partialRight = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var partition = {
+  wrapper: false,
+  shorthand: true,
+  chainable: true,
+  iteratee: true,
+  args: 2
+};
+var pick = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var pickBy = {
+  wrapper: false,
+  shorthand: true,
+  chainable: true,
+  iteratee: true
+};
+var plant = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var pop = {
+  wrapper: true,
+  shorthand: false,
+  chainable: false,
+  iteratee: false
+};
+var property = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var propertyOf = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var pull = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var pullAll = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 2
+};
+var pullAllBy = {
+  wrapper: false,
+  shorthand: true,
+  chainable: true,
+  iteratee: false,
+  iterateeIndex: 2,
+  args: 3
+};
+var pullAllWith = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 3
+};
+var pullAt = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var push = {
+  wrapper: true,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var random = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 3
+};
+var range = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 3
+};
+var rangeRight = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 3
+};
+var rearg = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var reduce = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: true,
+  args: 3
+};
+var reduceRight = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: true,
+  args: 3
+};
+var reject = {
+  wrapper: false,
+  shorthand: true,
+  chainable: true,
+  iteratee: true,
+  args: 2
+};
+var remove = {
+  wrapper: false,
+  shorthand: true,
+  chainable: true,
+  iteratee: true,
+  args: 2
+};
+var repeat = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 2
+};
+var replace = {
+  wrapper: true,
+  shorthand: false,
+  chainable: false,
+  iteratee: false
+};
+var rest = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 2
+};
+var result = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 3
+};
+var reverse = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var round = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 2
+};
+var runInContext = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var sample = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var sampleSize = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 2
+};
+var set = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 3
+};
+var setWith = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 4
+};
+var shift = {
+  wrapper: true,
+  shorthand: false,
+  chainable: false,
+  iteratee: false
+};
+var shuffle = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var size = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var slice = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 3
+};
+var snakeCase = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var some = {
+  wrapper: false,
+  shorthand: true,
+  chainable: false,
+  iteratee: true,
+  args: 2
+};
+var sort = {
+  wrapper: true,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var sortBy = {
+  wrapper: false,
+  shorthand: {
+    prop: true
+  },
+  chainable: true,
+  iteratee: true
+};
+var sortedIndex = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 2
+};
+var sortedIndexBy = {
+  wrapper: false,
+  shorthand: true,
+  chainable: false,
+  iteratee: false,
+  iterateeIndex: 2,
+  args: 3
+};
+var sortedIndexOf = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 2
+};
+var sortedLastIndex = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 2
+};
+var sortedLastIndexBy = {
+  wrapper: false,
+  shorthand: true,
+  chainable: false,
+  iteratee: false,
+  iterateeIndex: 2,
+  args: 3
+};
+var sortedLastIndexOf = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 2
+};
+var sortedUniq = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var sortedUniqBy = {
+  wrapper: false,
+  shorthand: true,
+  chainable: true,
+  iteratee: true,
+  args: 2
+};
+var splice = {
+  wrapper: true,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var split = {
+  wrapper: true,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 3
+};
+var spread = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 2
+};
+var startCase = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var startsWith = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 3
+};
+var stubArray = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 0
+};
+var stubFalse = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 0
+};
+var stubObject = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 0
+};
+var stubString = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 0
+};
+var stubTrue = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 0
+};
+var subtract = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 2
+};
+var sum = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var sumBy = {
+  wrapper: false,
+  shorthand: true,
+  chainable: false,
+  iteratee: true,
+  args: 2
+};
+var tail = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var take = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 2
+};
+var takeRight = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 2
+};
+var takeRightWhile = {
+  wrapper: false,
+  shorthand: true,
+  chainable: true,
+  iteratee: true,
+  args: 2
+};
+var takeWhile = {
+  wrapper: false,
+  shorthand: true,
+  chainable: true,
+  iteratee: true,
+  args: 2
+};
+var tap = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: true,
+  args: 2
+};
+var template = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 2
+};
+var throttle = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 3
+};
+var thru = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: true,
+  args: 2
+};
+var times = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: true,
+  args: 2
+};
+var toArray = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var toFinite = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var toInteger = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var toLength = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var toLower = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var toNumber = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var toPairs = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var toPairsIn = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var toPath = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var toPlainObject = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var toSafeInteger = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var toString = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var toUpper = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var transform = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: true,
+  args: 3
+};
+var trim = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 2
+};
+var trimEnd = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 2
+};
+var trimStart = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 2
+};
+var truncate = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 3
+};
+var unary = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var unescape = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var union = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var unionBy = {
+  wrapper: false,
+  shorthand: true,
+  chainable: true,
+  iteratee: true
+};
+var unionWith = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var uniq = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var uniqBy = {
+  wrapper: false,
+  shorthand: true,
+  chainable: true,
+  iteratee: true,
+  args: 2
+};
+var uniqWith = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 2
+};
+var uniqueId = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var unset = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 2
+};
+var unshift = {
+  wrapper: true,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var unzip = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var unzipWith = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: true,
+  args: 2
+};
+var update = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 3
+};
+var updateWith = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 4
+};
+var upperCase = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var upperFirst = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 1
+};
+var value = {
+  wrapper: true,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 0
+};
+var values = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var valuesIn = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 1
+};
+var without = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var words = {
+  wrapper: false,
+  shorthand: false,
+  chainable: false,
+  iteratee: false,
+  args: 2
+};
+var wrap = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 2
+};
+var xor = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var xorBy = {
+  wrapper: false,
+  shorthand: true,
+  chainable: true,
+  iteratee: true
+};
+var xorWith = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var zip = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false
+};
+var zipObject = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 2
+};
+var zipObjectDeep = {
+  wrapper: false,
+  shorthand: false,
+  chainable: true,
+  iteratee: false,
+  args: 2
+};
+var 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;
+}
+var sideEffectIterationMethods = [
+  "forEach",
+  "forEachRight",
+  "forIn",
+  "forInRight",
+  "forOwn",
+  "forOwnRight"
+];
+function getSideEffectIterationMethods() {
+  return sideEffectIterationMethods;
+}
+
+// src/util/astUtil.ts
+var import_lodash2 = require("lodash");
+var getCaller = (0, import_lodash2.property)(["callee", "object"]);
+var getMethodName = (0, import_lodash2.property)(["callee", "property", "name"]);
+var isMethodCall = (0, import_lodash2.matches)({
+  type: "CallExpression",
+  callee: { type: "MemberExpression" }
+});
+var isFunctionExpression = (0, import_lodash2.overSome)(
+  (0, import_lodash2.matchesProperty)("type", "FunctionExpression"),
+  (0, import_lodash2.matchesProperty)("type", "FunctionDeclaration")
+);
+var isFunctionDefinitionWithBlock = (0, import_lodash2.overSome)(
+  isFunctionExpression,
+  (0, import_lodash2.matches)({
+    type: "ArrowFunctionExpression",
+    body: { type: "BlockStatement" }
+  })
+);
+var getFirstFunctionLine = (0, import_lodash2.cond)([
+  [isFunctionDefinitionWithBlock, (0, import_lodash2.property)(["body", "body", 0])],
+  [(0, import_lodash2.matches)({ type: "ArrowFunctionExpression" }), (0, import_lodash2.property)("body")]
+]);
+var isPropAccess = (0, import_lodash2.overSome)(
+  (0, import_lodash2.matches)({ computed: false }),
+  (0, import_lodash2.matchesProperty)(["property", "type"], "Literal")
+);
+function isMemberExpOf(node, objectName, { maxLength = Number.MAX_VALUE, allowComputed } = {}) {
+  if (objectName) {
+    let curr = node;
+    let depth = maxLength;
+    while (curr && depth) {
+      if (allowComputed || isPropAccess(curr)) {
+        if (curr.type === "MemberExpression" && curr.object.name === objectName) {
+          return true;
+        }
+        curr = curr.object;
+        depth--;
+      } else {
+        return false;
+      }
+    }
+  }
+}
+var getFirstParamName = (0, import_lodash2.property)(["params", 0, "name"]);
+var isReturnStatement = (0, import_lodash2.matchesProperty)("type", "ReturnStatement");
+function hasOnlyOneStatement(func) {
+  if (isFunctionDefinitionWithBlock(func)) {
+    return (0, import_lodash2.get)(func, "body.body.length") === 1;
+  }
+  if (func.type === "ArrowFunctionExpression") {
+    return !(0, import_lodash2.get)(func, "body.body");
+  }
+}
+function isObjectOfMethodCall(node) {
+  return (0, import_lodash2.get)(node, "parent.object") === node && (0, import_lodash2.get)(node, "parent.parent.type") === "CallExpression";
+}
+function isLiteral(node) {
+  return node.type === "Literal";
+}
+function isBinaryExpWithMemberOf(operator, exp, objectName, {
+  maxLength,
+  allowComputed,
+  onlyLiterals
+} = {}) {
+  if (!(0, import_lodash2.isMatch)(exp, { type: "BinaryExpression", operator })) {
+    return false;
+  }
+  const [left, right] = [exp.left, exp.right].map(
+    (side) => isMemberExpOf(side, objectName, { maxLength, allowComputed })
+  );
+  return left === !right && (!onlyLiterals || isLiteral(exp.left) || isLiteral(exp.right));
+}
+var isNegationExpression = (0, import_lodash2.matches)({
+  type: "UnaryExpression",
+  operator: "!"
+});
+function isNegationOfMemberOf(exp, objectName, { maxLength } = {}) {
+  return isNegationExpression(exp) && isMemberExpOf(exp.argument, objectName, { maxLength, allowComputed: false });
+}
+function isIdentifierWithName(exp, paramName) {
+  return exp && paramName && exp.type === "Identifier" && exp.name === paramName;
+}
+function getValueReturnedInFirstStatement(func) {
+  const firstLine = getFirstFunctionLine(func);
+  if (func) {
+    if (isFunctionDefinitionWithBlock(func)) {
+      return isReturnStatement(firstLine) ? firstLine.argument : void 0;
+    }
+    if (func.type === "ArrowFunctionExpression") {
+      return firstLine;
+    }
+  }
+}
+function isCallFromObject(node, objName) {
+  return node && objName && node.type === "CallExpression" && (0, import_lodash2.get)(node, "callee.object.name") === objName;
+}
+function isComputed(node) {
+  return (0, import_lodash2.get)(node, "computed") && node.property.type !== "Literal";
+}
+function isEquivalentMemberExp(a, b) {
+  return (0, import_lodash2.isEqualWith)(a, b, (left, right, key) => {
+    if ((0, import_lodash2.includes)(["loc", "range", "computed", "start", "end", "parent"], key)) {
+      return true;
+    }
+    if (isComputed(left) || isComputed(right)) {
+      return false;
+    }
+    if (key === "property") {
+      const leftValue = left.name || left.value;
+      const rightValue = right.name || right.value;
+      return leftValue === rightValue;
+    }
+  });
+}
+var isEqEqEq = (0, import_lodash2.matches)({ type: "BinaryExpression", operator: "===" });
+var isMinus = (node) => node.type === "UnaryExpression" && node.operator === "-";
+var comparisonType = {
+  exact: 0,
+  over: 1,
+  under: 2,
+  any: 3
+};
+var comparisonOperators = ["==", "!=", "===", "!=="];
+function getIsValue(value2) {
+  return value2 < 0 ? (0, import_lodash2.overEvery)(isMinus, (0, import_lodash2.matches)({ argument: { value: -value2 } })) : (0, import_lodash2.matches)({ value: value2 });
+}
+function getExpressionComparedToInt(node, value2, checkOver) {
+  const isValue = getIsValue(value2);
+  if ((0, import_lodash2.includes)(comparisonOperators, node.operator)) {
+    if (isValue(node.right)) {
+      return node.left;
+    }
+    if (isValue(node.left)) {
+      return node.right;
+    }
+  }
+  if (checkOver) {
+    if (node.operator === ">" && isValue(node.right)) {
+      return node.left;
+    }
+    if (node.operator === "<" && isValue(node.left)) {
+      return node.right;
+    }
+    const isNext = getIsValue(value2 + 1);
+    if ((node.operator === ">=" || node.operator === "<") && isNext(node.right)) {
+      return node.left;
+    }
+    if ((node.operator === "<=" || node.operator === ">") && isNext(node.left)) {
+      return node.right;
+    }
+  }
+}
+var isIndexOfCall = (node) => isMethodCall(node) && getMethodName(node) === "indexOf";
+var isFindIndexCall = (node) => isMethodCall(node) && getMethodName(node) === "findIndex";
+function collectParameterValues(node) {
+  switch (node && node.type) {
+    case "Identifier":
+      return [node.name];
+    case "ObjectPattern":
+      return (0, import_lodash2.flatMap)(
+        node.properties,
+        (prop) => collectParameterValues(prop.value)
+      );
+    case "ArrayPattern":
+      return (0, import_lodash2.flatMap)(node.elements, collectParameterValues);
+    default:
+      return [];
+  }
+}
+var astUtil_default = {
+  getCaller,
+  getMethodName,
+  isMethodCall,
+  getFirstFunctionLine,
+  isMemberExpOf,
+  getFirstParamName,
+  hasOnlyOneStatement,
+  isObjectOfMethodCall,
+  isEqEqEqToMemberOf: isBinaryExpWithMemberOf.bind(null, "==="),
+  isNotEqEqToMemberOf: isBinaryExpWithMemberOf.bind(null, "!=="),
+  isNegationOfMemberOf,
+  isIdentifierWithName,
+  isNegationExpression,
+  getValueReturnedInFirstStatement,
+  isCallFromObject,
+  isComputed,
+  isEquivalentMemberExp,
+  isEqEqEq,
+  comparisonType,
+  getExpressionComparedToInt,
+  isIndexOfCall,
+  isFindIndexCall,
+  isFunctionExpression,
+  isFunctionDefinitionWithBlock,
+  collectParameterValues
+};
+
+// src/util/settingsUtil.ts
+var import_lodash3 = require("lodash");
+function getSettings(context) {
+  return (0, import_lodash3.chain)(context).get(["settings", "remeda"]).clone().defaults({
+    version: 4
+  }).value();
+}
+
+// src/util/importUtil.ts
+var import_get = __toESM(require("lodash/get"), 1);
+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 isFullRemedaImport = (str) => /^remeda?(\/)?$/.test(str);
+var getMethodImportFromName = (str) => {
+  const match = /^remeda([./])(\w+)$/.exec(str);
+  return match && match[2];
+};
+
+// src/util/RemedaContext.ts
+var { isMethodCall: isMethodCall2, isCallFromObject: isCallFromObject2, getCaller: getCaller2 } = astUtil_default;
+var 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);
+}
+
+// src/rules/collection-method-value.ts
+var import_includes = __toESM(require("lodash/includes"), 1);
+var { getMethodName: getMethodName2 } = astUtil_default;
+var meta = {
+  type: "problem",
+  schema: [],
+  docs: {
+    url: getDocsUrl("collection-method-value")
+  }
+};
+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 rule = {
+  create: create2,
+  meta
+};
+var RULE_NAME = "collection-method-value";
+var collection_method_value_default = rule;
+
+// src/rules/collection-return.ts
+var import_assign = __toESM(require("lodash/assign"), 1);
+var meta2 = {
+  type: "problem",
+  schema: [],
+  docs: {
+    url: getDocsUrl("collection-return")
+  }
+};
+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 rule2 = {
+  create: create3,
+  meta: meta2
+};
+var RULE_NAME2 = "collection-return";
+var collection_return_default = rule2;
+
+// src/rules/prefer-constant.ts
+var { getValueReturnedInFirstStatement: getValueReturnedInFirstStatement2 } = astUtil_default;
+var meta3 = {
+  type: "problem",
+  docs: {
+    url: getDocsUrl("prefer-constant")
+  },
+  schema: [
+    {
+      type: "boolean"
+    },
+    {
+      type: "boolean"
+    }
+  ]
+};
+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 rule3 = {
+  create: create4,
+  meta: meta3
+};
+var RULE_NAME3 = "prefer-constant";
+var prefer_constant_default = rule3;
+
+// src/rules/prefer-do-nothing.ts
+var { getFirstFunctionLine: getFirstFunctionLine2 } = astUtil_default;
+var meta4 = {
+  type: "problem",
+  schema: [],
+  docs: {
+    url: getDocsUrl("prefer-do-nothing")
+  }
+};
+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 rule4 = {
+  create: create5,
+  meta: meta4
+};
+var RULE_NAME4 = "prefer-do-nothing";
+var prefer_do_nothing_default = rule4;
+
+// src/rules/prefer-filter.ts
+var {
+  isIdentifierWithName: isIdentifierWithName2,
+  isMemberExpOf: isMemberExpOf2,
+  isNegationOfMemberOf: isNegationOfMemberOf2,
+  isEqEqEqToMemberOf,
+  isNotEqEqToMemberOf,
+  getFirstFunctionLine: getFirstFunctionLine3,
+  hasOnlyOneStatement: hasOnlyOneStatement2,
+  getFirstParamName: getFirstParamName2
+} = astUtil_default;
+var meta5 = {
+  type: "problem",
+  docs: {
+    url: getDocsUrl("prefer-filter")
+  },
+  schema: [
+    {
+      type: "integer"
+    }
+  ]
+};
+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 rule5 = {
+  create: create6,
+  meta: meta5
+};
+var RULE_NAME5 = "prefer-filter";
+var prefer_filter_default = rule5;
+
+// src/rules/prefer-find.ts
+var meta6 = {
+  type: "problem",
+  schema: [],
+  docs: {
+    url: getDocsUrl("prefer-find")
+  }
+};
+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 rule6 = {
+  create: create7,
+  meta: meta6
+};
+var RULE_NAME6 = "prefer-find";
+var prefer_find_default = rule6;
+
+// src/rules/prefer-flat-map.ts
+var { getCaller: getCaller3 } = astUtil_default;
+var meta7 = {
+  type: "problem",
+  schema: [],
+  docs: {
+    url: getDocsUrl("prefer-flat-map")
+  }
+};
+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 rule7 = {
+  create: create8,
+  meta: meta7
+};
+var RULE_NAME7 = "prefer-flat-map";
+var prefer_flat_map_default = rule7;
+
+// src/rules/prefer-is-empty.ts
+var meta8 = {
+  type: "problem",
+  schema: [],
+  docs: {
+    url: getDocsUrl("prefer-is-empty")
+  },
+  fixable: "code"
+};
+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 rule8 = {
+  create: create9,
+  meta: meta8
+};
+var RULE_NAME8 = "prefer-is-empty";
+var prefer_is_empty_default = rule8;
+
+// src/rules/prefer-is-nil.ts
+var import_lodash5 = __toESM(require("lodash"), 1);
+var { isNegationExpression: isNegationExpression2, isEquivalentMemberExp: isEquivalentMemberExp2 } = astUtil_default;
+var meta9 = {
+  type: "problem",
+  schema: [],
+  docs: {
+    url: getDocsUrl("prefer-is-nil")
+  }
+};
+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 rule9 = {
+  create: create10,
+  meta: meta9
+};
+var RULE_NAME9 = "prefer-is-nil";
+var prefer_is_nil_default = rule9;
+
+// src/rules/prefer-map.ts
+var import_get2 = __toESM(require("lodash/get"), 1);
+var import_includes2 = __toESM(require("lodash/includes"), 1);
+var {
+  getFirstFunctionLine: getFirstFunctionLine4,
+  hasOnlyOneStatement: hasOnlyOneStatement3,
+  getMethodName: getMethodName3,
+  isFunctionDefinitionWithBlock: isFunctionDefinitionWithBlock2,
+  collectParameterValues: collectParameterValues2
+} = astUtil_default;
+var meta10 = {
+  type: "problem",
+  schema: [],
+  docs: {
+    url: getDocsUrl("prefer-map")
+  }
+};
+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 rule10 = {
+  create: create11,
+  meta: meta10
+};
+var RULE_NAME10 = "prefer-map";
+var prefer_map_default = rule10;
+
+// src/rules/prefer-nullish-coalescing.ts
+var meta11 = {
+  type: "problem",
+  schema: [],
+  docs: {
+    url: getDocsUrl("prefer-nullish-coalescing")
+  },
+  fixable: "code"
+};
+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 rule11 = {
+  create: create12,
+  meta: meta11
+};
+var RULE_NAME11 = "prefer-nullish-coalescing";
+var prefer_nullish_coalescing_default = rule11;
+
+// src/rules/prefer-remeda-typecheck.ts
+var import_some = __toESM(require("lodash/some"), 1);
+var meta12 = {
+  type: "problem",
+  schema: [],
+  docs: {
+    url: getDocsUrl("prefer-remeda-typecheck")
+  }
+};
+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?.(node);
+    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 rule12 = {
+  create: create13,
+  meta: meta12
+};
+var RULE_NAME12 = "prefer-remeda-typecheck";
+var prefer_remeda_typecheck_default = rule12;
+
+// src/rules/prefer-some.ts
+var { getExpressionComparedToInt: getExpressionComparedToInt2 } = astUtil_default;
+var meta13 = {
+  type: "problem",
+  docs: {
+    url: getDocsUrl("prefer-some")
+  },
+  schema: []
+};
+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 rule13 = {
+  create: create14,
+  meta: meta13
+};
+var RULE_NAME13 = "prefer-some";
+var prefer_some_default = rule13;
+
+// src/rules/prefer-times.ts
+var import_lodash6 = require("lodash");
+var meta14 = {
+  type: "problem",
+  schema: [],
+  docs: {
+    url: getDocsUrl("prefer-times")
+  }
+};
+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 rule14 = {
+  create: create15,
+  meta: meta14
+};
+var RULE_NAME14 = "prefer-times";
+var prefer_times_default = rule14;
+
+// src/rules/index.ts
+var rules = {
+  [RULE_NAME]: collection_method_value_default,
+  [RULE_NAME2]: collection_return_default,
+  [RULE_NAME3]: prefer_constant_default,
+  [RULE_NAME4]: prefer_do_nothing_default,
+  [RULE_NAME5]: prefer_filter_default,
+  [RULE_NAME6]: prefer_find_default,
+  [RULE_NAME7]: prefer_flat_map_default,
+  [RULE_NAME8]: prefer_is_empty_default,
+  [RULE_NAME9]: prefer_is_nil_default,
+  [RULE_NAME10]: prefer_map_default,
+  [RULE_NAME11]: prefer_nullish_coalescing_default,
+  [RULE_NAME12]: prefer_remeda_typecheck_default,
+  [RULE_NAME13]: prefer_some_default,
+  [RULE_NAME14]: prefer_times_default
+};
+
+// src/index.ts
+var plugin = {
+  meta: { name: package_default.name, version: package_default.version },
+  // @ts-expect-error
+  rules,
+  configs: {},
+  processors: {}
+};
+var pluginShortName = import_lodash7.default.last(plugin.meta.name.split("-"));
+Object.assign(plugin.configs, {
+  recommended: {
+    plugins: {
+      [pluginShortName]: plugin
+    },
+    rules: {
+      [`${pluginShortName}/prefer-is-empty`]: 2,
+      [`${pluginShortName}/prefer-is-nil`]: 2,
+      [`${pluginShortName}/prefer-times`]: 2,
+      [`${pluginShortName}/prefer-constant`]: 2,
+      [`${pluginShortName}/prefer-remeda-typecheck`]: 2,
+      [`${pluginShortName}/prefer-nullish-coalescing`]: 2,
+      [`${pluginShortName}/prefer-filter`]: [2, 3],
+      [`${pluginShortName}/collection-method-value`]: 2,
+      [`${pluginShortName}/collection-return`]: 2,
+      [`${pluginShortName}/prefer-map`]: 2,
+      [`${pluginShortName}/prefer-find`]: 2,
+      [`${pluginShortName}/prefer-some`]: 2,
+      [`${pluginShortName}/prefer-flat-map`]: 2,
+      [`${pluginShortName}/prefer-do-nothing`]: 2
+    }
+  }
+});
+var src_default = plugin;