@vinicunca/eslint-config 2.0.0-beta.8 → 2.0.0

package/dist/index.cjs

@@ -94,7 +94,7 @@ module.exports = __toCommonJS(src_exports);
 var import_node_process2 = __toESM(require("process"), 1);
 var import_local_pkg = require("local-pkg");
 
-// ../node_modules/.pnpm/@vinicunca+perkakas@0.0.4/node_modules/@vinicunca/perkakas/dist/es/function/purry.js
+// ../node_modules/.pnpm/@vinicunca+perkakas@0.0.10/node_modules/@vinicunca/perkakas/dist/index.js
 function purry(fn, args, lazy) {
   const diff = fn.length - args.length;
   const arrayArgs = Array.from(args);
@@ -111,13 +111,35 @@ function purry(fn, args, lazy) {
   }
   throw new Error("Wrong number of arguments");
 }
-
-// ../node_modules/.pnpm/@vinicunca+perkakas@0.0.4/node_modules/@vinicunca/perkakas/dist/es/guard/is-boolean.js
 function isBoolean(data) {
   return typeof data === "boolean";
 }
-
-// ../node_modules/.pnpm/@vinicunca+perkakas@0.0.4/node_modules/@vinicunca/perkakas/dist/es/utils/reduce-lazy.js
+function isDefined(data) {
+  return typeof data !== "undefined" && data !== null;
+}
+((isDefined2) => {
+  function strict(data) {
+    return data !== void 0;
+  }
+  isDefined2.strict = strict;
+})(isDefined || (isDefined = {}));
+function _countBy(indexed) {
+  return (array, fn) => {
+    return array.reduce((ret, item, index) => {
+      const value = indexed ? fn(item, index, array) : fn(item);
+      return ret + (value ? 1 : 0);
+    }, 0);
+  };
+}
+function countBy(...args) {
+  return purry(_countBy(false), args);
+}
+((countBy2) => {
+  function indexed(...args) {
+    return purry(_countBy(true), args);
+  }
+  countBy2.indexed = indexed;
+})(countBy || (countBy = {}));
 function _reduceLazy(array, lazy, indexed) {
   const newArray = [];
   for (let index = 0; index < array.length; index++) {
@@ -131,25 +153,815 @@ function _reduceLazy(array, lazy, indexed) {
   }
   return newArray;
 }
-
-// ../node_modules/.pnpm/@vinicunca+perkakas@0.0.4/node_modules/@vinicunca/perkakas/dist/es/array/uniq.js
-function uniq() {
-  return purry(_uniq, arguments, uniq.lazy);
+function differenceWith(...args) {
+  return purry(_differenceWith, args, differenceWith.lazy);
+}
+function _differenceWith(array, other, isEquals) {
+  const lazy = differenceWith.lazy(other, isEquals);
+  return _reduceLazy(array, lazy);
+}
+((differenceWith2) => {
+  function lazy(other, isEquals) {
+    return (value) => {
+      if (other.every((otherValue) => !isEquals(value, otherValue))) {
+        return {
+          done: false,
+          hasNext: true,
+          next: value
+        };
+      }
+      return {
+        done: false,
+        hasNext: false
+      };
+    };
+  }
+  differenceWith2.lazy = lazy;
+})(differenceWith || (differenceWith = {}));
+function difference(...args) {
+  return purry(_difference, args, difference.lazy);
+}
+function _difference(array, other) {
+  const lazy = difference.lazy(other);
+  return _reduceLazy(array, lazy);
+}
+((difference2) => {
+  function lazy(other) {
+    const set2 = new Set(other);
+    return (value) => {
+      if (!set2.has(value)) {
+        return {
+          done: false,
+          hasNext: true,
+          next: value
+        };
+      }
+      return {
+        done: false,
+        hasNext: false
+      };
+    };
+  }
+  difference2.lazy = lazy;
+})(difference || (difference = {}));
+function drop(...args) {
+  return purry(_drop, args, drop.lazy);
+}
+function _drop(array, n) {
+  return _reduceLazy(array, drop.lazy(n));
+}
+((drop2) => {
+  function lazy(n) {
+    let left = n;
+    return (value) => {
+      if (left > 0) {
+        left--;
+        return {
+          done: false,
+          hasNext: false
+        };
+      }
+      return {
+        done: false,
+        hasNext: true,
+        next: value
+      };
+    };
+  }
+  drop2.lazy = lazy;
+})(drop || (drop = {}));
+function toLazyIndexed(fn) {
+  fn.indexed = true;
+  return fn;
+}
+function filter(...args) {
+  return purry(_filter(false), args, filter.lazy);
+}
+function _filter(indexed) {
+  return (array, fn) => {
+    return _reduceLazy(
+      array,
+      indexed ? filter.lazyIndexed(fn) : filter.lazy(fn),
+      indexed
+    );
+  };
+}
+function _lazy(indexed) {
+  return (fn) => {
+    return (value, index, array) => {
+      const valid = indexed ? fn(value, index, array) : fn(value);
+      if (valid) {
+        return {
+          done: false,
+          hasNext: true,
+          next: value
+        };
+      }
+      return {
+        done: false,
+        hasNext: false
+      };
+    };
+  };
+}
+((filter2) => {
+  function indexed(...args) {
+    return purry(_filter(true), args, filter2.lazyIndexed);
+  }
+  filter2.indexed = indexed;
+  filter2.lazy = _lazy(false);
+  filter2.lazyIndexed = toLazyIndexed(_lazy(true));
+})(filter || (filter = {}));
+function toSingle(fn) {
+  fn.single = true;
+  return fn;
+}
+function findIndex(...args) {
+  return purry(_findIndex(false), args, findIndex.lazy);
+}
+function _findIndex(indexed) {
+  return (array, fn) => {
+    if (indexed) {
+      return array.findIndex(fn);
+    }
+    return array.findIndex((x) => fn(x));
+  };
+}
+function _lazy2(indexed) {
+  return (fn) => {
+    let i = 0;
+    return (value, index, array) => {
+      const valid = indexed ? fn(value, index, array) : fn(value);
+      if (valid) {
+        return {
+          done: true,
+          hasNext: true,
+          next: i
+        };
+      }
+      i++;
+      return {
+        done: false,
+        hasNext: false
+      };
+    };
+  };
+}
+((findIndex2) => {
+  function indexed(...args) {
+    return purry(_findIndex(true), args, findIndex2.lazyIndexed);
+  }
+  findIndex2.indexed = indexed;
+  findIndex2.lazy = toSingle(_lazy2(false));
+  findIndex2.lazyIndexed = toSingle(toLazyIndexed(_lazy2(true)));
+})(findIndex || (findIndex = {}));
+function findLastIndex(...args) {
+  return purry(_findLastIndex(false), args);
+}
+function _findLastIndex(indexed) {
+  return (array, fn) => {
+    for (let i = array.length - 1; i >= 0; i--) {
+      if (indexed ? fn(array[i], i, array) : fn(array[i])) {
+        return i;
+      }
+    }
+    return -1;
+  };
+}
+((findLastIndex2) => {
+  function indexed(...args) {
+    return purry(_findLastIndex(true), args);
+  }
+  findLastIndex2.indexed = indexed;
+})(findLastIndex || (findLastIndex = {}));
+function findLast(...args) {
+  return purry(_findLast(false), args);
+}
+function _findLast(indexed) {
+  return (array, fn) => {
+    for (let i = array.length - 1; i >= 0; i--) {
+      if (indexed ? fn(array[i], i, array) : fn(array[i])) {
+        return array[i];
+      }
+    }
+  };
+}
+((findLast2) => {
+  function indexed(...args) {
+    return purry(_findLast(true), args);
+  }
+  findLast2.indexed = indexed;
+})(findLast || (findLast = {}));
+function find(...args) {
+  return purry(_find(false), args, find.lazy);
+}
+function _find(indexed) {
+  return (array, fn) => {
+    if (indexed) {
+      return array.find(fn);
+    }
+    return array.find((x) => fn(x));
+  };
+}
+function _lazy3(indexed) {
+  return (fn) => {
+    return (value, index, array) => {
+      const valid = indexed ? fn(value, index, array) : fn(value);
+      return {
+        done: valid,
+        hasNext: valid,
+        next: value
+      };
+    };
+  };
+}
+((find2) => {
+  function indexed(...args) {
+    return purry(_find(true), args, find2.lazyIndexed);
+  }
+  find2.indexed = indexed;
+  find2.lazy = toSingle(_lazy3(false));
+  find2.lazyIndexed = toSingle(toLazyIndexed(_lazy3(true)));
+})(find || (find = {}));
+function first(...args) {
+  return purry(_first, args, first.lazy);
+}
+function _first([first2]) {
+  return first2;
+}
+((first2) => {
+  function lazy() {
+    return (value) => {
+      return {
+        done: true,
+        hasNext: true,
+        next: value
+      };
+    };
+  }
+  first2.lazy = lazy;
+  ((lazy2) => {
+    lazy2.single = true;
+  })(lazy = first2.lazy || (first2.lazy = {}));
+})(first || (first = {}));
+function flatMapToObj(...args) {
+  return purry(_flatMapToObj(false), args);
+}
+function _flatMapToObj(indexed) {
+  return (array, fn) => {
+    return array.reduce((result, element, index) => {
+      const items = indexed ? fn(element, index, array) : fn(element);
+      items.forEach(([key, value]) => {
+        result[key] = value;
+      });
+      return result;
+    }, {});
+  };
+}
+((flatMapToObj2) => {
+  function indexed(...args) {
+    return purry(_flatMapToObj(true), args);
+  }
+  flatMapToObj2.indexed = indexed;
+})(flatMapToObj || (flatMapToObj = {}));
+function flatten(...args) {
+  return purry(_flatten, args, flatten.lazy);
+}
+function _flatten(items) {
+  return _reduceLazy(items, flatten.lazy());
+}
+((flatten2) => {
+  function lazy() {
+    return (next) => {
+      if (Array.isArray(next)) {
+        return {
+          done: false,
+          hasNext: true,
+          hasMany: true,
+          next
+        };
+      }
+      return {
+        done: false,
+        hasNext: true,
+        next
+      };
+    };
+  }
+  flatten2.lazy = lazy;
+})(flatten || (flatten = {}));
+function flatMap(...args) {
+  return purry(_flatMap, args, flatMap.lazy);
+}
+function _flatMap(array, fn) {
+  return flatten(array.map((item) => fn(item)));
+}
+((flatMap2) => {
+  function lazy(fn) {
+    return (value) => {
+      const next = fn(value);
+      if (Array.isArray(next)) {
+        return {
+          done: false,
+          hasNext: true,
+          hasMany: true,
+          next
+        };
+      }
+      return {
+        done: false,
+        hasNext: true,
+        next
+      };
+    };
+  }
+  flatMap2.lazy = lazy;
+})(flatMap || (flatMap = {}));
+function flattenDeep(...args) {
+  return purry(_flattenDeep, args, flattenDeep.lazy);
+}
+function _flattenDeep(items) {
+  return _reduceLazy(items, flattenDeep.lazy());
+}
+function _flattenDeepValue(value) {
+  if (!Array.isArray(value)) {
+    return value;
+  }
+  const ret = [];
+  value.forEach((item) => {
+    if (Array.isArray(item)) {
+      ret.push(...flattenDeep(item));
+    } else {
+      ret.push(item);
+    }
+  });
+  return ret;
+}
+((flattenDeep2) => {
+  function lazy() {
+    return (value) => {
+      const next = _flattenDeepValue(value);
+      if (Array.isArray(next)) {
+        return {
+          done: false,
+          hasNext: true,
+          hasMany: true,
+          next
+        };
+      }
+      return {
+        done: false,
+        hasNext: true,
+        next
+      };
+    };
+  }
+  flattenDeep2.lazy = lazy;
+})(flattenDeep || (flattenDeep = {}));
+function forEach(...args) {
+  return purry(_forEach(false), args, forEach.lazy);
+}
+function _forEach(indexed) {
+  return (array, fn) => {
+    return _reduceLazy(
+      array,
+      indexed ? forEach.lazyIndexed(fn) : forEach.lazy(fn),
+      indexed
+    );
+  };
+}
+function _lazy4(indexed) {
+  return (fn) => {
+    return (value, index, array) => {
+      if (indexed) {
+        fn(value, index, array);
+      } else {
+        fn(value);
+      }
+      return {
+        done: false,
+        hasNext: true,
+        next: value
+      };
+    };
+  };
+}
+((forEach2) => {
+  function indexed(...args) {
+    return purry(_forEach(true), args, forEach2.lazyIndexed);
+  }
+  forEach2.indexed = indexed;
+  forEach2.lazy = _lazy4(false);
+  forEach2.lazyIndexed = toLazyIndexed(_lazy4(true));
+})(forEach || (forEach = {}));
+function groupBy(...args) {
+  return purry(_groupBy(false), args);
+}
+function _groupBy(indexed) {
+  return (array, fn) => {
+    const ret = {};
+    array.forEach((item, index) => {
+      const key = indexed ? fn(item, index, array) : fn(item);
+      if (key !== void 0) {
+        const actualKey = String(key);
+        if (!ret[actualKey]) {
+          ret[actualKey] = [];
+        }
+        ret[actualKey].push(item);
+      }
+    });
+    return ret;
+  };
+}
+((groupBy2) => {
+  function indexed(...args) {
+    return purry(_groupBy(true), args);
+  }
+  groupBy2.indexed = indexed;
+  groupBy2.strict = groupBy2;
+})(groupBy || (groupBy = {}));
+function indexBy(...args) {
+  return purry(_indexBy(false), args);
+}
+function _indexBy(indexed) {
+  return (array, fn) => {
+    return array.reduce((ret, item, index) => {
+      const value = indexed ? fn(item, index, array) : fn(item);
+      const key = String(value);
+      ret[key] = item;
+      return ret;
+    }, {});
+  };
+}
+((indexBy2) => {
+  function indexed(...args) {
+    return purry(_indexBy(true), args);
+  }
+  indexBy2.indexed = indexed;
+})(indexBy || (indexBy = {}));
+function intersection(...args) {
+  return purry(_intersection, args, intersection.lazy);
+}
+function _intersection(array, other) {
+  const lazy = intersection.lazy(other);
+  return _reduceLazy(array, lazy);
+}
+((intersection2) => {
+  function lazy(other) {
+    return (value) => {
+      const set2 = new Set(other);
+      if (set2.has(value)) {
+        return {
+          done: false,
+          hasNext: true,
+          next: value
+        };
+      }
+      return {
+        done: false,
+        hasNext: false
+      };
+    };
+  }
+  intersection2.lazy = lazy;
+})(intersection || (intersection = {}));
+function intersectionWith(...args) {
+  return purry(_intersectionWith, args, intersectionWith.lazy);
+}
+function _intersectionWith(array, other, comparator) {
+  const lazy = intersectionWith.lazy(other, comparator);
+  return _reduceLazy(array, lazy);
+}
+((intersectionWith2) => {
+  function lazy(other, comparator) {
+    return (value) => {
+      if (other.some((otherValue) => comparator(value, otherValue))) {
+        return {
+          done: false,
+          hasNext: true,
+          next: value
+        };
+      }
+      return {
+        done: false,
+        hasNext: false
+      };
+    };
+  }
+  intersectionWith2.lazy = lazy;
+})(intersectionWith || (intersectionWith = {}));
+function map(...args) {
+  return purry(_map(false), args, map.lazy);
+}
+function _map(indexed) {
+  return (array, fn) => {
+    return _reduceLazy(
+      array,
+      indexed ? map.lazyIndexed(fn) : map.lazy(fn),
+      indexed
+    );
+  };
+}
+function _lazy5(indexed) {
+  return (fn) => {
+    return (value, index, array) => {
+      return {
+        done: false,
+        hasNext: true,
+        next: indexed ? fn(value, index, array) : fn(value)
+      };
+    };
+  };
+}
+((map2) => {
+  function indexed(...args) {
+    return purry(_map(true), args, map2.lazyIndexed);
+  }
+  map2.indexed = indexed;
+  map2.lazy = _lazy5(false);
+  map2.lazyIndexed = toLazyIndexed(_lazy5(true));
+  map2.strict = map2;
+})(map || (map = {}));
+function mapToObj(...args) {
+  return purry(_mapToObj(false), args);
+}
+function _mapToObj(indexed) {
+  return (array, fn) => {
+    return array.reduce((result, element, index) => {
+      const [key, value] = indexed ? fn(element, index, array) : fn(element);
+      result[key] = value;
+      return result;
+    }, {});
+  };
+}
+((mapToObj2) => {
+  function indexed(...args) {
+    return purry(_mapToObj(true), args);
+  }
+  mapToObj2.indexed = indexed;
+})(mapToObj || (mapToObj = {}));
+function _maxBy(indexed) {
+  return (array, fn) => {
+    let ret;
+    let retMax;
+    array.forEach((item, i) => {
+      const max = indexed ? fn(item, i, array) : fn(item);
+      if (retMax === void 0 || max > retMax) {
+        ret = item;
+        retMax = max;
+      }
+    });
+    return ret;
+  };
+}
+function maxBy(...args) {
+  return purry(_maxBy(false), args);
+}
+((maxBy2) => {
+  function indexed(...args) {
+    return purry(_maxBy(true), args);
+  }
+  maxBy2.indexed = indexed;
+})(maxBy || (maxBy = {}));
+function _meanBy(indexed) {
+  return (array, fn) => {
+    if (array.length === 0) {
+      return Number.NaN;
+    }
+    let sum = 0;
+    array.forEach((item, i) => {
+      sum += indexed ? fn(item, i, array) : fn(item);
+    });
+    return sum / array.length;
+  };
+}
+function meanBy(...args) {
+  return purry(_meanBy(false), args);
+}
+((meanBy2) => {
+  function indexed(...args) {
+    return purry(_meanBy(true), args);
+  }
+  meanBy2.indexed = indexed;
+})(meanBy || (meanBy = {}));
+function _minBy(indexed) {
+  return (array, fn) => {
+    let ret;
+    let retMin;
+    array.forEach((item, i) => {
+      const min = indexed ? fn(item, i, array) : fn(item);
+      if (retMin === void 0 || min < retMin) {
+        ret = item;
+        retMin = min;
+      }
+    });
+    return ret;
+  };
+}
+function minBy(...args) {
+  return purry(_minBy(false), args);
+}
+((minBy2) => {
+  function indexed(...args) {
+    return purry(_minBy(true), args);
+  }
+  minBy2.indexed = indexed;
+})(minBy || (minBy = {}));
+function partition(...args) {
+  return purry(_partition(false), args);
+}
+function _partition(indexed) {
+  return (array, fn) => {
+    const ret = [[], []];
+    array.forEach((item, index) => {
+      const matches = indexed ? fn(item, index, array) : fn(item);
+      ret[matches ? 0 : 1].push(item);
+    });
+    return ret;
+  };
+}
+((partition2) => {
+  function indexed(...args) {
+    return purry(_partition(true), args);
+  }
+  partition2.indexed = indexed;
+})(partition || (partition = {}));
+function reduce(...args) {
+  return purry(_reduce(false), args);
+}
+function _reduce(indexed) {
+  return (items, fn, initialValue) => {
+    return items.reduce(
+      (acc, item, index) => indexed ? fn(acc, item, index, items) : fn(acc, item),
+      initialValue
+    );
+  };
+}
+((reduce2) => {
+  function indexed(...args) {
+    return purry(_reduce(true), args);
+  }
+  reduce2.indexed = indexed;
+})(reduce || (reduce = {}));
+function reject(...args) {
+  return purry(_reject(false), args, reject.lazy);
+}
+function _reject(indexed) {
+  return (array, fn) => {
+    return _reduceLazy(
+      array,
+      indexed ? reject.lazyIndexed(fn) : reject.lazy(fn),
+      indexed
+    );
+  };
+}
+function _lazy6(indexed) {
+  return (fn) => {
+    return (value, index, array) => {
+      const valid = indexed ? fn(value, index, array) : fn(value);
+      if (!valid) {
+        return {
+          done: false,
+          hasNext: true,
+          next: value
+        };
+      }
+      return {
+        done: false,
+        hasNext: false
+      };
+    };
+  };
+}
+((reject2) => {
+  function indexed(...args) {
+    return purry(_reject(true), args, reject2.lazyIndexed);
+  }
+  reject2.indexed = indexed;
+  reject2.lazy = _lazy6(false);
+  reject2.lazyIndexed = toLazyIndexed(_lazy6(true));
+})(reject || (reject = {}));
+function sort(...args) {
+  return purry(_sort, args);
+}
+function _sort(items, cmp) {
+  const ret = [...items];
+  ret.sort(cmp);
+  return ret;
+}
+((sort2) => {
+  sort2.strict = sort2;
+})(sort || (sort = {}));
+var ALL_DIRECTIONS = ["asc", "desc"];
+var COMPARATOR = {
+  asc: (x, y) => x > y,
+  desc: (x, y) => x < y
+};
+function sortBy(arrayOrSortRule, ...sortRules) {
+  const args = isSortRule(arrayOrSortRule) ? [[arrayOrSortRule, ...sortRules]] : [arrayOrSortRule, sortRules];
+  return purry(_sortBy, args);
+}
+function isSortRule(x) {
+  if (typeof x === "function") {
+    return true;
+  }
+  const [maybeProjection, maybeDirection, ...rest] = x;
+  if (rest.length > 0) {
+    return false;
+  }
+  return typeof maybeProjection === "function" && ALL_DIRECTIONS.includes(maybeDirection);
+}
+function _sortBy(array, sorts) {
+  return [...array].sort(comparer(...sorts));
+}
+function comparer(primaryRule, secondaryRule, ...otherRules) {
+  const projector = typeof primaryRule === "function" ? primaryRule : primaryRule[0];
+  const direction = typeof primaryRule === "function" ? "asc" : primaryRule[1];
+  const comparator = COMPARATOR[direction];
+  const nextComparer = secondaryRule === void 0 ? void 0 : comparer(secondaryRule, ...otherRules);
+  return (a, b) => {
+    const projectedA = projector(a);
+    const projectedB = projector(b);
+    if (comparator(projectedA, projectedB)) {
+      return 1;
+    }
+    if (comparator(projectedB, projectedA)) {
+      return -1;
+    }
+    return nextComparer?.(a, b) ?? 0;
+  };
+}
+((sortBy2) => {
+  sortBy2.strict = sortBy2;
+})(sortBy || (sortBy = {}));
+function _sumBy(indexed) {
+  return (array, fn) => {
+    let sum = 0;
+    array.forEach((item, i) => {
+      const summand = indexed ? fn(item, i, array) : fn(item);
+      sum += summand;
+    });
+    return sum;
+  };
+}
+function sumBy(...args) {
+  return purry(_sumBy(false), args);
+}
+((sumBy2) => {
+  function indexed(...args) {
+    return purry(_sumBy(true), args);
+  }
+  sumBy2.indexed = indexed;
+})(sumBy || (sumBy = {}));
+function take(...args) {
+  return purry(_take, args, take.lazy);
+}
+function _take(array, n) {
+  return _reduceLazy(array, take.lazy(n));
+}
+((take2) => {
+  function lazy(n) {
+    return (value) => {
+      if (n === 0) {
+        return {
+          done: true,
+          hasNext: false
+        };
+      }
+      n--;
+      if (n === 0) {
+        return {
+          done: true,
+          hasNext: true,
+          next: value
+        };
+      }
+      return {
+        done: false,
+        hasNext: true,
+        next: value
+      };
+    };
+  }
+  take2.lazy = lazy;
+})(take || (take = {}));
+function uniq(...args) {
+  return purry(_uniq, args, uniq.lazy);
 }
 function _uniq(array) {
   return _reduceLazy(array, uniq.lazy());
 }
-(function(uniq2) {
+((uniq2) => {
   function lazy() {
-    const set = /* @__PURE__ */ new Set();
+    const set2 = /* @__PURE__ */ new Set();
     return (value) => {
-      if (set.has(value)) {
+      if (set2.has(value)) {
         return {
           done: false,
           hasNext: false
         };
       }
-      set.add(value);
+      set2.add(value);
       return {
         done: false,
         hasNext: true,
@@ -159,6 +971,81 @@ function _uniq(array) {
   }
   uniq2.lazy = lazy;
 })(uniq || (uniq = {}));
+function uniqWith(...args) {
+  return purry(_uniqWith, args, uniqWith.lazy);
+}
+function _uniqWith(array, isEquals) {
+  const lazy = uniqWith.lazy(isEquals);
+  return _reduceLazy(array, lazy, true);
+}
+function _lazy7(isEquals) {
+  return (value, index, array) => {
+    if (array && array.findIndex((otherValue) => isEquals(value, otherValue)) === index) {
+      return {
+        done: false,
+        hasNext: true,
+        next: value
+      };
+    }
+    return {
+      done: false,
+      hasNext: false
+    };
+  };
+}
+((uniqWith2) => {
+  uniqWith2.lazy = toLazyIndexed(_lazy7);
+})(uniqWith || (uniqWith = {}));
+var isArray2 = Array.isArray;
+function forEachObj(...args) {
+  return purry(_forEachObj(false), args);
+}
+function _forEachObj(indexed) {
+  return (object, fn) => {
+    for (const key in object) {
+      if (Object.prototype.hasOwnProperty.call(object, key)) {
+        const val = object[key];
+        if (indexed) {
+          fn(val, key, object);
+        } else {
+          fn(val);
+        }
+      }
+    }
+    return object;
+  };
+}
+((forEachObj2) => {
+  function indexed(...args) {
+    return purry(_forEachObj(true), args);
+  }
+  forEachObj2.indexed = indexed;
+})(forEachObj || (forEachObj = {}));
+function fromPairs(entries) {
+  const out = {};
+  for (const [key, value] of entries) {
+    out[key] = value;
+  }
+  return out;
+}
+((fromPairs2) => {
+  fromPairs2.strict = fromPairs2;
+})(fromPairs || (fromPairs = {}));
+function keys(source) {
+  return Object.keys(source);
+}
+((keys2) => {
+  keys2.strict = keys2;
+})(keys || (keys = {}));
+function toPairs(object) {
+  return Object.entries(object);
+}
+((toPairs2) => {
+  function strict(object) {
+    return Object.entries(object);
+  }
+  toPairs2.strict = strict;
+})(toPairs || (toPairs = {}));
 
 // src/flags.ts
 var ERROR = "error";
@@ -586,6 +1473,7 @@ function javascript(options = {}) {
           argsIgnorePattern: "^_",
           ignoreRestSiblings: true
         }],
+        ...import_eslint_plugin_vinicunca.default.configs.recommended.rules,
         ...overrides
       }
     },