@vinicunca/eslint-config 2.0.0-beta.9 → 2.0.1

package/dist/index.js

@@ -1,8 +1,61 @@
 // src/base.ts
-import process2 from "process";
+import process3 from "process";
 import { isPackageExists } from "local-pkg";
 
-// ../node_modules/.pnpm/@vinicunca+perkakas@0.0.4/node_modules/@vinicunca/perkakas/dist/es/function/purry.js
+// src/flags.ts
+var ERROR = "error";
+var OFF = "off";
+var WARN = "warn";
+var CONSISTENT = "consistent";
+var NEVER = "never";
+var ALWAYS = "always";
+
+// src/plugins.ts
+import { default as default2 } from "@stylistic/eslint-plugin";
+import { default as default3 } from "@vinicunca/eslint-plugin-vinicunca";
+import { default as default4 } from "@typescript-eslint/eslint-plugin";
+import * as parserTs from "@typescript-eslint/parser";
+import { default as default5 } from "eslint-plugin-eslint-comments";
+import * as pluginImport from "eslint-plugin-i";
+import { default as default6 } from "eslint-plugin-jsdoc";
+import * as pluginJsonc from "eslint-plugin-jsonc";
+import { default as default7 } from "eslint-plugin-markdown";
+import { default as default8 } from "eslint-plugin-n";
+import { default as default9 } from "eslint-plugin-no-only-tests";
+import { default as default10 } from "eslint-plugin-unicorn";
+import { default as default11 } from "eslint-plugin-unused-imports";
+import { default as default12 } from "eslint-plugin-react";
+import { default as default13 } from "eslint-plugin-react-hooks";
+import { default as default14 } from "eslint-plugin-vue";
+import * as pluginYaml from "eslint-plugin-yml";
+import { default as default15 } from "eslint-plugin-vitest";
+import { default as default16 } from "jsonc-eslint-parser";
+import { default as default17 } from "vue-eslint-parser";
+import { default as default18 } from "yaml-eslint-parser";
+
+// src/configs/comments.ts
+function comments() {
+  return [
+    {
+      name: "vinicunca:eslint-comments",
+      plugins: {
+        "eslint-comments": default5
+      },
+      rules: {
+        "eslint-comments/no-aggregating-enable": ERROR,
+        "eslint-comments/no-duplicate-disable": ERROR,
+        "eslint-comments/no-unlimited-disable": ERROR,
+        "eslint-comments/no-unused-enable": ERROR
+      }
+    }
+  ];
+}
+
+// src/configs/ignores.ts
+import fs from "fs";
+import parseGitignore from "parse-gitignore";
+
+// ../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);
@@ -19,13 +72,56 @@ 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";
+function isArray(data) {
+  return Array.isArray(data);
 }
-
-// ../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 toString(value) {
+  return Object.prototype.toString.call(value);
+}
+function isObject(data) {
+  return toString(data) === "[object Object]";
+}
+function isString(data) {
+  return typeof data === "string";
+}
+function isEmpty(data) {
+  if (isArray(data) || isString(data)) {
+    return data.length === 0;
+  }
+  if (isObject(data)) {
+    for (const _ in data) {
+      return false;
+    }
+    return !(data instanceof RegExp);
+  }
+  return false;
+}
+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++) {
@@ -39,25 +135,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,
@@ -67,59 +953,81 @@ function _uniq(array) {
   }
   uniq2.lazy = lazy;
 })(uniq || (uniq = {}));
-
-// src/flags.ts
-var ERROR = "error";
-var OFF = "off";
-var WARN = "warn";
-var CONSISTENT = "consistent";
-var NEVER = "never";
-var ALWAYS = "always";
-
-// src/plugins.ts
-import { default as default2 } from "@stylistic/eslint-plugin";
-import { default as default3 } from "@vinicunca/eslint-plugin-vinicunca";
-import { default as default4 } from "@typescript-eslint/eslint-plugin";
-import * as parserTs from "@typescript-eslint/parser";
-import { default as default5 } from "eslint-plugin-eslint-comments";
-import * as pluginImport from "eslint-plugin-i";
-import { default as default6 } from "eslint-plugin-jsdoc";
-import * as pluginJsonc from "eslint-plugin-jsonc";
-import { default as default7 } from "eslint-plugin-markdown";
-import { default as default8 } from "eslint-plugin-n";
-import { default as default9 } from "eslint-plugin-no-only-tests";
-import { default as default10 } from "eslint-plugin-unicorn";
-import { default as default11 } from "eslint-plugin-unused-imports";
-import { default as default12 } from "eslint-plugin-react";
-import { default as default13 } from "eslint-plugin-react-hooks";
-import { default as default14 } from "eslint-plugin-vue";
-import * as pluginYaml from "eslint-plugin-yml";
-import { default as default15 } from "eslint-plugin-vitest";
-import { default as default16 } from "jsonc-eslint-parser";
-import { default as default17 } from "vue-eslint-parser";
-import { default as default18 } from "yaml-eslint-parser";
-
-// src/configs/comments.ts
-function comments() {
-  return [
-    {
-      name: "vinicunca:eslint-comments",
-      plugins: {
-        "eslint-comments": default5
-      },
-      rules: {
-        "eslint-comments/no-aggregating-enable": ERROR,
-        "eslint-comments/no-duplicate-disable": ERROR,
-        "eslint-comments/no-unlimited-disable": ERROR,
-        "eslint-comments/no-unused-enable": ERROR
+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;
+  };
 }
-
-// src/configs/ignores.ts
-import fs from "fs";
-import parseGitignore from "parse-gitignore";
+((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/globs.ts
 var GLOB_JS = "**/*.?([cm])js";
@@ -494,6 +1402,7 @@ function javascript(options = {}) {
           argsIgnorePattern: "^_",
           ignoreRestSiblings: true
         }],
+        ...default3.configs.recommended.rules,
         ...overrides
       }
     },
@@ -1204,7 +2113,7 @@ function typescript(options) {
     componentExts = [],
     overrides = {},
     parserOptions = {},
-    tsconfigPath
+    tsconfigPath = []
   } = options ?? {};
   const typeAwareRules = {
     "dot-notation": OFF,
@@ -1217,16 +2126,19 @@ function typescript(options) {
     "ts/no-implied-eval": ERROR,
     "ts/no-misused-promises": ERROR,
     "ts/no-throw-literal": ERROR,
-    "ts/no-unnecessary-type-assertion": ERROR,
-    "ts/no-unsafe-argument": ERROR,
-    "ts/no-unsafe-assignment": ERROR,
-    "ts/no-unsafe-call": ERROR,
-    "ts/no-unsafe-member-access": ERROR,
-    "ts/no-unsafe-return": ERROR,
     "ts/restrict-plus-operands": ERROR,
     "ts/restrict-template-expressions": ERROR,
     "ts/unbound-method": ERROR
   };
+  let tsConfigOptions = {};
+  let additionalTypeAwareRules = {};
+  if (!isEmpty(tsconfigPath)) {
+    tsConfigOptions = {
+      project: tsconfigPath,
+      tsconfigRootDir: process.cwd()
+    };
+    additionalTypeAwareRules = typeAwareRules;
+  }
   return [
     {
       // Install the plugins without globs, so they can be configured separately.
@@ -1247,10 +2159,7 @@ function typescript(options) {
         parser: parserTs,
         parserOptions: {
           sourceType: "module",
-          ...tsconfigPath ? {
-            project: [tsconfigPath],
-            tsconfigRootDir: process.cwd()
-          } : {},
+          ...tsConfigOptions,
           ...parserOptions
         }
       },
@@ -1304,7 +2213,7 @@ function typescript(options) {
         "vinicunca/named-tuple-spacing": ERROR,
         "vinicunca/no-cjs-exports": ERROR,
         "vinicunca/no-ts-export-equal": ERROR,
-        ...tsconfigPath ? typeAwareRules : {},
+        ...additionalTypeAwareRules,
         ...overrides
       }
     },
@@ -1367,10 +2276,20 @@ function unicorn(options = {}) {
 }
 
 // src/configs/vue.ts
+import process2 from "process";
 function vue(options = {}) {
   const {
+    typescript: typescript2 = {},
     overrides = {}
   } = options;
+  let tsConfigOptions = {};
+  const tsconfigPath = typescript2.tsconfigPath ?? [];
+  if (!isEmpty(tsconfigPath)) {
+    tsConfigOptions = {
+      project: tsconfigPath,
+      tsconfigRootDir: process2.cwd()
+    };
+  }
   return [
     {
       name: "vinicunca:vue:setup",
@@ -1388,8 +2307,9 @@ function vue(options = {}) {
             jsx: true
           },
           extraFileExtensions: [".vue"],
-          parser: options.typescript ? parserTs : null,
-          sourceType: "module"
+          parser: typescript2.enabled ? parserTs : void 0,
+          sourceType: "module",
+          ...tsConfigOptions
         }
       },
       processor: default14.processors[".vue"],
@@ -1542,9 +2462,9 @@ var VuePackages = [
 ];
 function vinicuncaESLint({ options = {}, userConfigs = [] } = {}) {
   const {
-    isInEditor = !!((process2.env.VSCODE_PID || process2.env.JETBRAINS_IDE) && !process2.env.CI),
+    isInEditor = !!((process3.env.VSCODE_PID || process3.env.JETBRAINS_IDE) && !process3.env.CI),
     vue: enableVue = VuePackages.some((i) => isPackageExists(i)),
-    typescript: enableTypeScript = isPackageExists("typescript"),
+    typescript: tsOptions = {},
     stylistic: enableStylistic = true,
     test: enableTest = true,
     jsonc: enableJsonc = true,
@@ -1569,9 +2489,13 @@ function vinicuncaESLint({ options = {}, userConfigs = [] } = {}) {
   if (enableVue) {
     componentExts.push("vue");
   }
-  if (enableTypeScript) {
+  const {
+    enabled: tsEnabled = isPackageExists("typescript"),
+    ...tsParams
+  } = tsOptions;
+  if (tsEnabled) {
     configs.push(typescript({
-      ...!isBoolean(enableTypeScript) ? enableTypeScript : {},
+      ...tsParams,
       componentExts,
       overrides: overrides.typescript
     }));
@@ -1588,7 +2512,10 @@ function vinicuncaESLint({ options = {}, userConfigs = [] } = {}) {
   ;
   if (enableVue) {
     configs.push(vue({
-      typescript: !!enableTypeScript,
+      typescript: {
+        enabled: tsEnabled,
+        ...tsParams
+      },
       overrides: overrides.vue
     }));
   }