@vinicunca/eslint-config 2.1.3 → 2.1.6

package/dist/index.js

@@ -1,964 +1,20 @@
-// ../node_modules/.pnpm/@vinicunca+perkakas@0.0.11/node_modules/@vinicunca/perkakas/dist/index.js
-function purry(fn, args, lazy) {
-  const diff = fn.length - args.length;
-  const arrayArgs = Array.from(args);
-  if (diff === 0) {
-    return fn(...arrayArgs);
-  }
-  if (diff === 1) {
-    const ret = (data) => fn(data, ...arrayArgs);
-    if (lazy || fn.lazy) {
-      ret.lazy = lazy || fn.lazy;
-      ret.lazyArgs = args;
-    }
-    return ret;
-  }
-  throw new Error("Wrong number of arguments");
-}
+// ../node_modules/.pnpm/@vinicunca+perkakas@0.3.6/node_modules/@vinicunca/perkakas/dist/es/guard/is-boolean.js
 function isBoolean(data) {
   return typeof data === "boolean";
 }
-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);
-}
+
+// ../node_modules/.pnpm/@vinicunca+perkakas@0.3.6/node_modules/@vinicunca/perkakas/dist/es/guard/is-object.js
 function isObject(data) {
-  return toString(data) === "[object Object]";
-}
-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++) {
-    const item = array[index];
-    const result = indexed ? lazy(item, index, array) : lazy(item);
-    if (result.hasMany === true) {
-      newArray.push(...result.next);
-    } else if (result.hasNext) {
-      newArray.push(result.next);
-    }
-  }
-  return newArray;
-}
-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) {
+  if (typeof data !== "object" || data === null) {
     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);
+  const proto = Object.getPrototypeOf(data);
+  return proto === null || proto === Object.prototype;
 }
-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());
-}
-((uniq2) => {
-  function lazy() {
-    const set2 = /* @__PURE__ */ new Set();
-    return (value) => {
-      if (set2.has(value)) {
-        return {
-          done: false,
-          hasNext: false
-        };
-      }
-      set2.add(value);
-      return {
-        done: false,
-        hasNext: true,
-        next: value
-      };
-    };
-  }
-  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/base.ts
 import { isPackageExists } from "local-pkg";
+import fs from "fs";
 import process2 from "process";
 
 // src/flags.ts
@@ -996,10 +52,6 @@ async function comments() {
   ];
 }
 
-// src/configs/ignores.ts
-import fs from "fs";
-import parseGitignore from "parse-gitignore";
-
 // src/globs.ts
 var GLOB_SRC = "**/*.?([cm])[jt]s?(x)";
 var GLOB_SRC_EXT = "?([cm])[jt]s?(x)";
@@ -1070,33 +122,10 @@ var GLOB_EXCLUDE = [
 ];
 
 // src/configs/ignores.ts
-async function ignores({
-  enableGitignore = true,
-  items = [],
-  replace = false
-} = {}) {
-  const ignoreList = [];
-  if (enableGitignore && fs.existsSync(".gitignore")) {
-    const gitignoreContent = fs.readFileSync(".gitignore", "utf8");
-    const parsed = parseGitignore(gitignoreContent);
-    const globs = parsed.globs();
-    for (const glob of globs) {
-      if (glob.type === "ignore") {
-        ignoreList.push(...glob.patterns);
-      } else if (glob.type === "unignore") {
-        ignoreList.push(...glob.patterns.map((pattern) => `!${pattern}`));
-      }
-      ;
-    }
-  }
-  if (replace) {
-    ignoreList.push(...items);
-  } else {
-    ignoreList.push(...GLOB_EXCLUDE, ...items);
-  }
+async function ignores() {
   return [
     {
-      ignores: uniq(ignoreList)
+      ignores: GLOB_EXCLUDE
     }
   ];
 }
@@ -2157,6 +1186,8 @@ async function typescript(options = {}) {
     ...componentExts.map((ext) => `**/*.${ext}`)
   ];
   const filesTypeAware = options.filesTypeAware ?? [GLOB_TS, GLOB_TSX];
+  const tsconfigPath = options?.tsconfigPath ? toArray(options.tsconfigPath) : void 0;
+  const isTypeAware = !!tsconfigPath;
   const typeAwareRules = {
     "dot-notation": OFF,
     "no-implied-eval": OFF,
@@ -2172,7 +1203,6 @@ async function typescript(options = {}) {
     "ts/restrict-plus-operands": ERROR,
     "ts/restrict-template-expressions": ERROR
   };
-  const tsconfigPath = options?.tsconfigPath ? toArray(options.tsconfigPath) : void 0;
   const [
     pluginTs,
     parserTs
@@ -2180,29 +1210,41 @@ async function typescript(options = {}) {
     interopDefault(import("@typescript-eslint/eslint-plugin")),
     interopDefault(import("@typescript-eslint/parser"))
   ]);
-  return [
-    {
-      // Install the plugins without globs, so they can be configured separately.
-      name: "vinicunca:typescript:setup",
-      plugins: {
-        ts: pluginTs,
-        vinicunca: default2
-      }
-    },
-    {
-      files,
+  function makeParser({ files: files2, ignores: ignores2, typeAware }) {
+    return {
+      files: files2,
+      ...ignores2 ? { ignores: ignores2 } : {},
       languageOptions: {
         parser: parserTs,
         parserOptions: {
           extraFileExtensions: componentExts.map((ext) => `.${ext}`),
           sourceType: "module",
-          ...tsconfigPath ? {
+          ...typeAware ? {
             project: tsconfigPath,
             tsconfigRootDir: process.cwd()
           } : {},
           ...parserOptions
         }
       },
+      name: `vinicunca:typescript:${typeAware ? "type-aware-parser" : "parser"}`
+    };
+  }
+  return [
+    {
+      // Install the plugins without globs, so they can be configured separately.
+      name: "vinicunca:typescript:setup",
+      plugins: {
+        ts: pluginTs,
+        vinicunca: default2
+      }
+    },
+    // assign type-aware parser for type-aware files and type-unaware parser for the rest
+    ...isTypeAware ? [
+      makeParser({ files: filesTypeAware, typeAware: true }),
+      makeParser({ files, ignores: filesTypeAware, typeAware: false })
+    ] : [makeParser({ files, typeAware: false })],
+    {
+      files,
       name: "vinicunca:typescript:rules",
       rules: {
         ...renameRules(
@@ -2222,6 +1264,7 @@ async function typescript(options = {}) {
         "no-unused-vars": OFF,
         "no-use-before-define": OFF,
         "no-useless-constructor": OFF,
+        "ts/array-type": [ERROR, { default: "generic" }],
         "ts/ban-ts-comment": [ERROR, { "ts-ignore": "allow-with-description" }],
         "ts/ban-types": [ERROR, { types: { Function: false } }],
         "ts/consistent-type-definitions": [ERROR, "interface"],
@@ -2229,6 +1272,8 @@ async function typescript(options = {}) {
         "ts/explicit-function-return-type": OFF,
         "ts/explicit-member-accessibility": OFF,
         "ts/explicit-module-boundary-types": OFF,
+        // https://www.totaltypescript.com/method-shorthand-syntax-considered-harmful
+        "ts/method-signature-style": ["error", "property"],
         "ts/naming-convention": OFF,
         "ts/no-dupe-class-members": ERROR,
         "ts/no-empty-function": OFF,
@@ -2611,7 +1656,7 @@ async function formatters(options = {}, stylistic2 = {}) {
         languageOptions: {
           parser: parserPlain
         },
-        name: "vinicunca:formatter:css",
+        name: "vinicunca:formatters:css",
         rules: {
           "format/prettier": [
             "error",
@@ -2627,7 +1672,7 @@ async function formatters(options = {}, stylistic2 = {}) {
         languageOptions: {
           parser: parserPlain
         },
-        name: "vinicunca:formatter:scss",
+        name: "vinicunca:formatters:scss",
         rules: {
           "format/prettier": [
             "error",
@@ -2643,7 +1688,7 @@ async function formatters(options = {}, stylistic2 = {}) {
         languageOptions: {
           parser: parserPlain
         },
-        name: "vinicunca:formatter:less",
+        name: "vinicunca:formatters:less",
         rules: {
           "format/prettier": [
             "error",
@@ -2662,7 +1707,7 @@ async function formatters(options = {}, stylistic2 = {}) {
       languageOptions: {
         parser: parserPlain
       },
-      name: "vinicunca:formatter:html",
+      name: "vinicunca:formatters:html",
       rules: {
         "format/prettier": [
           "error",
@@ -2681,7 +1726,7 @@ async function formatters(options = {}, stylistic2 = {}) {
       languageOptions: {
         parser: parserPlain
       },
-      name: "vinicunca:formatter:markdown",
+      name: "vinicunca:formatters:markdown",
       rules: {
         [`format/${formater}`]: [
           "error",
@@ -2704,7 +1749,7 @@ async function formatters(options = {}, stylistic2 = {}) {
       languageOptions: {
         parser: parserPlain
       },
-      name: "vinicunca:formatter:graphql",
+      name: "vinicunca:formatters:graphql",
       rules: {
         "format/prettier": [
           "error",
@@ -2721,6 +1766,7 @@ async function formatters(options = {}, stylistic2 = {}) {
 
 // src/base.ts
 var flatConfigProps = [
+  "name",
   "files",
   "ignores",
   "languageOptions",
@@ -2739,6 +1785,7 @@ var VuePackages = [
 async function vinicuncaESLint(options = {}, ...userConfigs) {
   const {
     componentExts = [],
+    gitignore: enableGitignore = true,
     isInEditor = !!((process2.env.VSCODE_PID || process2.env.JETBRAINS_IDE || process2.env.VIM) && !process2.env.CI),
     react: enableReact = false,
     typescript: enableTypeScript = isPackageExists("typescript"),
@@ -2755,8 +1802,17 @@ async function vinicuncaESLint(options = {}, ...userConfigs) {
     };
   }
   const configs = [];
+  if (enableGitignore) {
+    if (typeof enableGitignore !== "boolean") {
+      configs.push(interopDefault(import("eslint-config-flat-gitignore")).then((r) => [r(enableGitignore)]));
+    } else {
+      if (fs.existsSync(".gitignore")) {
+        configs.push(interopDefault(import("eslint-config-flat-gitignore")).then((r) => [r()]));
+      }
+    }
+  }
   configs.push(
-    ignores(options.ignores),
+    ignores(),
     javascript({
       isInEditor,
       overrides: getOverrides(options, "javascript")