@vinicunca/eslint-config 2.2.0 → 2.4.0

package/dist/index.js

@@ -1,126 +1,1206 @@
-// ../node_modules/.pnpm/@vinicunca+perkakas@0.3.6/node_modules/@vinicunca/perkakas/dist/es/guard/is-boolean.js
+// ../node_modules/.pnpm/@vinicunca+perkakas@0.5.3/node_modules/@vinicunca/perkakas/dist/index.mjs
+function purry(fn, args, lazyFactory) {
+  const callArgs = Array.from(args);
+  const diff = fn.length - args.length;
+  if (diff === 0) {
+    return fn(...callArgs);
+  }
+  if (diff === 1) {
+    const ret = (data) => fn(data, ...callArgs);
+    const lazy = lazyFactory ?? fn.lazy;
+    return lazy === void 0 ? ret : Object.assign(ret, { lazy, lazyArgs: args });
+  }
+  throw new Error("Wrong number of arguments");
+}
+function purryOn(isArg, implementation, args) {
+  const callArgs = Array.from(args);
+  return isArg(args[0]) ? (data) => implementation(data, ...callArgs) : implementation(...callArgs);
+}
+function conditional(...args) {
+  return purryOn(isCase, conditionalImplementation, args);
+}
+function conditionalImplementation(data, ...cases) {
+  for (const [when, then] of cases) {
+    if (when(data)) {
+      return then(data);
+    }
+  }
+  throw new Error("conditional: data failed for all cases");
+}
+function isCase(maybeCase) {
+  if (!Array.isArray(maybeCase)) {
+    return false;
+  }
+  const [when, then, ...rest] = maybeCase;
+  return typeof when === "function" && when.length <= 1 && typeof then === "function" && then.length <= 1 && rest.length === 0;
+}
+var trivialDefaultCase = () => void 0;
+((conditional2) => {
+  function defaultCase(then = trivialDefaultCase) {
+    return [() => true, then];
+  }
+  conditional2.defaultCase = defaultCase;
+})(conditional || (conditional = {}));
+function _reduceLazy(array, lazy, isIndexed = false) {
+  const out = [];
+  for (let index = 0; index < array.length; index++) {
+    const item = array[index];
+    const result = isIndexed ? lazy(item, index, array) : lazy(item);
+    if (result.hasMany === true) {
+      out.push(...result.next);
+    } else if (result.hasNext) {
+      out.push(result.next);
+    }
+    if (result.done) {
+      break;
+    }
+  }
+  return out;
+}
+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) => other.every((otherValue) => !isEquals(value, otherValue)) ? { done: false, hasNext: true, next: value } : { done: false, hasNext: false };
+  }
+  differenceWith2.lazy = lazy;
+})(differenceWith || (differenceWith = {}));
+var COMPARATORS = {
+  asc: (x, y) => x > y,
+  desc: (x, y) => x < y
+};
+function purryOrderRules(func, inputArgs) {
+  const [dataOrRule, ...rules] = Array.isArray(inputArgs) ? inputArgs : Array.from(inputArgs);
+  if (!isOrderRule(dataOrRule)) {
+    const compareFn2 = orderRuleComparer(...rules);
+    return func(dataOrRule, compareFn2);
+  }
+  const compareFn = orderRuleComparer(dataOrRule, ...rules);
+  return (data) => func(data, compareFn);
+}
+function orderRuleComparer(primaryRule, secondaryRule, ...otherRules) {
+  const projector = typeof primaryRule === "function" ? primaryRule : primaryRule[0];
+  const direction = typeof primaryRule === "function" ? "asc" : primaryRule[1];
+  const { [direction]: comparator } = COMPARATORS;
+  const nextComparer = secondaryRule === void 0 ? void 0 : orderRuleComparer(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 == null ? void 0 : nextComparer(a, b)) ?? 0;
+  };
+}
+function isOrderRule(x) {
+  if (isProjection(x)) {
+    return true;
+  }
+  if (typeof x !== "object" || !Array.isArray(x)) {
+    return false;
+  }
+  const [maybeProjection, maybeDirection, ...rest] = x;
+  return isProjection(maybeProjection) && maybeDirection in COMPARATORS && rest.length === 0;
+}
+function isProjection(x) {
+  return typeof x === "function" && x.length === 1;
+}
+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 -= 1;
+        return { done: false, hasNext: false };
+      }
+      return { done: false, hasNext: true, next: value };
+    };
+  }
+  drop2.lazy = lazy;
+})(drop || (drop = {}));
+function entries(...args) {
+  return purry(Object.entries, args);
+}
+((entries2) => {
+  entries2.strict = entries2;
+})(entries || (entries = {}));
+function _toLazyIndexed(fn) {
+  return Object.assign(fn, { indexed: true });
+}
+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_$5(indexed) {
+  return (fn) => (value, index, array) => (indexed ? fn(value, index, array) : fn(value)) ? { done: false, hasNext: true, next: value } : { done: false, hasNext: false };
+}
+((filter2) => {
+  function indexed(...args) {
+    return purry(filter_(true), args, filter2.lazyIndexed);
+  }
+  filter2.indexed = indexed;
+  filter2.lazy = lazy_$5(false);
+  filter2.lazyIndexed = _toLazyIndexed(lazy_$5(true));
+})(filter || (filter = {}));
+function _toSingle(fn) {
+  return Object.assign(fn, { single: true });
+}
+function findIndex(...args) {
+  return purry(findIndex_(false), args, findIndex.lazy);
+}
+function findIndex_(indexed) {
+  return (array, fn) => array.findIndex((item, index, input) => indexed ? fn(item, index, input) : fn(item));
+}
+function lazy_$4(indexed) {
+  return (fn) => {
+    let actualIndex = 0;
+    return (value, index, array) => {
+      if (indexed ? fn(value, index, array) : fn(value)) {
+        return { done: true, hasNext: true, next: actualIndex };
+      }
+      actualIndex += 1;
+      return { done: false, hasNext: false };
+    };
+  };
+}
+((findIndex2) => {
+  function indexed(...args) {
+    return purry(findIndex_(true), args, findIndex2.lazyIndexed);
+  }
+  findIndex2.indexed = indexed;
+  findIndex2.lazy = _toSingle(lazy_$4(false));
+  findIndex2.lazyIndexed = _toSingle(_toLazyIndexed(lazy_$4(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];
+      }
+    }
+    return void 0;
+  };
+}
+((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) => array.find((item, index, input) => indexed ? fn(item, index, input) : fn(item));
+}
+function lazy_$3(indexed) {
+  return (fn) => (value, index, array) => (indexed ? fn(value, index, array) : fn(value)) ? { done: true, hasNext: true, next: value } : { done: false, hasNext: false };
+}
+((find2) => {
+  function indexed(...args) {
+    return purry(find_(true), args, find2.lazyIndexed);
+  }
+  find2.indexed = indexed;
+  find2.lazy = _toSingle(lazy_$3(false));
+  find2.lazyIndexed = _toSingle(_toLazyIndexed(lazy_$3(true)));
+})(find || (find = {}));
+function first(...args) {
+  return purry(first_, args, first.lazy);
+}
+function first_([item]) {
+  return item;
+}
+((first2) => {
+  function lazy() {
+    return (value) => ({ done: true, hasNext: true, next: value });
+  }
+  first2.lazy = lazy;
+  ((lazy2) => {
+    lazy2.single = true;
+  })(lazy = first2.lazy || (first2.lazy = {}));
+})(first || (first = {}));
+function flatten(...args) {
+  return purry(flatten_, args, flatten.lazy);
+}
+function flatten_(items) {
+  return _reduceLazy(items, flatten.lazy());
+}
+((flatten2) => {
+  function lazy() {
+    return (item) => (
+      // @ts-expect-error [ts2322] - We need to make LazyMany better so it accommodate the typing here...
+      Array.isArray(item) ? { done: false, hasMany: true, hasNext: true, next: item } : { done: false, hasNext: true, next: item }
+    );
+  }
+  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);
+      return Array.isArray(next) ? { done: false, hasMany: true, hasNext: true, next } : { 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 = [];
+  for (const item of value) {
+    if (Array.isArray(item)) {
+      ret.push(...flattenDeep(item));
+    } else {
+      ret.push(item);
+    }
+  }
+  return ret;
+}
+((flattenDeep2) => {
+  function lazy() {
+    return (value) => {
+      const next = flattenDeepValue_(value);
+      return Array.isArray(next) ? { done: false, hasMany: true, hasNext: true, next } : { done: false, hasNext: true, next };
+    };
+  }
+  flattenDeep2.lazy = lazy;
+})(flattenDeep || (flattenDeep = {}));
+function forEachObj(...args) {
+  return purry(forEachObj_(false), args);
+}
+function forEachObj_(indexed) {
+  return (data, fn) => {
+    for (const key in data) {
+      if (Object.prototype.hasOwnProperty.call(data, key)) {
+        const { [key]: val } = data;
+        if (indexed) {
+          fn(val, key, data);
+        } else {
+          fn(val);
+        }
+      }
+    }
+    return data;
+  };
+}
+((forEachObj2) => {
+  function indexed(...args) {
+    return purry(forEachObj_(true), args);
+  }
+  forEachObj2.indexed = indexed;
+})(forEachObj || (forEachObj = {}));
+function forEach(...args) {
+  return purry(forEach_(false), args, forEach.lazy);
+}
+function forEach_(indexed) {
+  return (array, fn) => _reduceLazy(
+    array,
+    indexed ? forEach.lazyIndexed(fn) : forEach.lazy(fn),
+    indexed
+  );
+}
+function lazy_$2(indexed) {
+  return (fn) => (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 = lazy_$2(false);
+  forEach2.lazyIndexed = _toLazyIndexed(lazy_$2(true));
+})(forEach || (forEach = {}));
+function fromEntries(...args) {
+  return purry(fromEntriesImplementation, args);
+}
+function fromEntriesImplementation(entries2) {
+  const out = {};
+  for (const [key, value] of entries2) {
+    out[key] = value;
+  }
+  return out;
+}
+((fromEntries2) => {
+  fromEntries2.strict = fromEntries2;
+})(fromEntries || (fromEntries = {}));
+function groupBy(...args) {
+  return purry(groupBy_(false), args);
+}
+function groupBy_(indexed) {
+  return (array, fn) => {
+    const ret = {};
+    for (const [index, item] of array.entries()) {
+      const key = indexed ? fn(item, index, array) : fn(item);
+      if (key !== void 0) {
+        const actualKey = String(key);
+        let items = ret[actualKey];
+        if (items === void 0) {
+          items = [];
+          ret[actualKey] = items;
+        }
+        items.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) => {
+    const out = {};
+    for (const [index, item] of array.entries()) {
+      const value = indexed ? fn(item, index, array) : fn(item);
+      const key = String(value);
+      out[key] = item;
+    }
+    return out;
+  };
+}
+function indexByStrict(...args) {
+  return purry(indexByStrict_, args);
+}
+function indexByStrict_(array, fn) {
+  const out = {};
+  for (const item of array) {
+    const key = fn(item);
+    out[key] = item;
+  }
+  return out;
+}
+((indexBy2) => {
+  function indexed(...args) {
+    return purry(indexBy_(true), args);
+  }
+  indexBy2.indexed = indexed;
+  indexBy2.strict = indexByStrict;
+})(indexBy || (indexBy = {}));
+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) => other.some((otherValue) => comparator(value, otherValue)) ? { done: false, hasNext: true, next: value } : { done: false, hasNext: false };
+  }
+  intersectionWith2.lazy = lazy;
+})(intersectionWith || (intersectionWith = {}));
 function isBoolean(data) {
   return typeof data === "boolean";
 }
-
-// ../node_modules/.pnpm/@vinicunca+perkakas@0.3.6/node_modules/@vinicunca/perkakas/dist/es/guard/is-object.js
+function isDefined(data) {
+  return data !== void 0 && data !== null;
+}
+((isDefined2) => {
+  function strict(data) {
+    return data !== void 0;
+  }
+  isDefined2.strict = strict;
+})(isDefined || (isDefined = {}));
 function isObject(data) {
   if (typeof data !== "object" || data === null) {
     return false;
   }
-  const proto = Object.getPrototypeOf(data);
-  return proto === null || proto === Object.prototype;
-}
-
-// src/base.ts
-import { isPackageExists } from "local-pkg";
-import fs from "fs";
-import process2 from "process";
-
-// 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 "@vinicunca/eslint-plugin-vinicunca";
-import { default as default3 } from "eslint-plugin-eslint-comments";
-import * as pluginImport from "eslint-plugin-import-x";
-import { default as default4 } from "eslint-plugin-n";
-import { default as default5 } from "eslint-plugin-perfectionist";
-import { default as default6 } from "eslint-plugin-unicorn";
-import { default as default7 } from "eslint-plugin-unused-imports";
-
-// src/configs/comments.ts
-async function comments() {
-  return [
-    {
-      name: "vinicunca:eslint-comments",
-      plugins: {
-        "eslint-comments": default3
+  const proto = Object.getPrototypeOf(data);
+  return proto === null || proto === Object.prototype;
+}
+function keys(...args) {
+  return purry(Object.keys, args);
+}
+((keys2) => {
+  keys2.strict = keys2;
+})(keys || (keys = {}));
+function mapToObj(...args) {
+  return purry(mapToObj_(false), args);
+}
+function mapToObj_(indexed) {
+  return (array, fn) => {
+    const out = {};
+    for (const [index, element] of array.entries()) {
+      const [key, value] = indexed ? fn(element, index, array) : fn(element);
+      out[key] = value;
+    }
+    return out;
+  };
+}
+((mapToObj2) => {
+  function indexed(...args) {
+    return purry(mapToObj_(true), args);
+  }
+  mapToObj2.indexed = indexed;
+})(mapToObj || (mapToObj = {}));
+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 lazy_$1(indexed) {
+  return (fn) => (value, index, array) => ({
+    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 = lazy_$1(false);
+  map2.lazyIndexed = _toLazyIndexed(lazy_$1(true));
+  map2.strict = map2;
+})(map || (map = {}));
+function meanBy_(indexed) {
+  return (array, fn) => {
+    if (array.length === 0) {
+      return Number.NaN;
+    }
+    let sum = 0;
+    for (const [index, item] of array.entries()) {
+      sum += indexed ? fn(item, index, 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 partition(...args) {
+  return purry(partition_(false), args);
+}
+function partition_(indexed) {
+  return (array, fn) => {
+    const ret = [[], []];
+    for (const [index, item] of array.entries()) {
+      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 sortBy(...args) {
+  return purryOrderRules(_sortBy, args);
+}
+function _sortBy(data, compareFn) {
+  return data.slice().sort(compareFn);
+}
+((sortBy2) => {
+  sortBy2.strict = sortBy2;
+})(sortBy || (sortBy = {}));
+function sort(...args) {
+  return purry(sort_, args);
+}
+function sort_(items, cmp) {
+  const ret = items.slice();
+  ret.sort(cmp);
+  return ret;
+}
+((sort2) => {
+  sort2.strict = sort2;
+})(sort || (sort = {}));
+function _binarySearchCutoffIndex(array, predicate) {
+  let lowIndex = 0;
+  let highIndex = array.length;
+  while (lowIndex < highIndex) {
+    const pivotIndex = lowIndex + highIndex >>> 1;
+    const pivot = array[pivotIndex];
+    if (predicate(pivot, pivotIndex)) {
+      lowIndex = pivotIndex + 1;
+    } else {
+      highIndex = pivotIndex;
+    }
+  }
+  return highIndex;
+}
+function sortedIndexBy(...args) {
+  return purry(sortedIndexByImplementation, args);
+}
+((sortedIndexBy2) => {
+  function indexed(...args) {
+    return purry(sortedIndexByImplementation, args);
+  }
+  sortedIndexBy2.indexed = indexed;
+})(sortedIndexBy || (sortedIndexBy = {}));
+function sortedIndexByImplementation(array, item, valueFunction) {
+  const value = valueFunction(item);
+  return _binarySearchCutoffIndex(
+    array,
+    (pivot, index) => valueFunction(pivot, index) < value
+  );
+}
+function sortedIndexWith(...args) {
+  return purry(_binarySearchCutoffIndex, args);
+}
+((sortedIndexWith2) => {
+  function indexed(...args) {
+    return purry(_binarySearchCutoffIndex, args);
+  }
+  sortedIndexWith2.indexed = indexed;
+})(sortedIndexWith || (sortedIndexWith = {}));
+function sortedLastIndexBy(...args) {
+  return purry(sortedLastIndexByImplementation, args);
+}
+((sortedLastIndexBy2) => {
+  function indexed(...args) {
+    return purry(sortedLastIndexByImplementation, args);
+  }
+  sortedLastIndexBy2.indexed = indexed;
+})(sortedLastIndexBy || (sortedLastIndexBy = {}));
+function sortedLastIndexByImplementation(array, item, valueFunction) {
+  const value = valueFunction(item);
+  return _binarySearchCutoffIndex(
+    array,
+    // The only difference between the regular implementation and the "last"
+    // variation is that we consider the pivot with equality too, so that we
+    // skip all equal values in addition to the lower ones.
+    (pivot, index) => valueFunction(pivot, index) <= value
+  );
+}
+function sumBy_(indexed) {
+  return (array, fn) => {
+    let sum = 0;
+    for (const [index, item] of array.entries()) {
+      const summand = indexed ? fn(item, index, 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) {
+    if (n <= 0) {
+      return () => ({ done: true, hasNext: false });
+    }
+    let remaining = n;
+    return (value) => {
+      remaining -= 1;
+      return { done: remaining <= 0, hasNext: true, next: value };
+    };
+  }
+  take2.lazy = lazy;
+})(take || (take = {}));
+function uniqueWith(...args) {
+  return purry(uniqueWithImplementation, args, uniqueWith.lazy);
+}
+function uniqueWithImplementation(array, isEquals) {
+  const lazy = uniqueWith.lazy(isEquals);
+  return _reduceLazy(array, lazy, true);
+}
+function lazy_(isEquals) {
+  return (value, index, array) => array !== void 0 && array.findIndex((otherValue) => isEquals(value, otherValue)) === index ? { done: false, hasNext: true, next: value } : { done: false, hasNext: false };
+}
+((uniqueWith2) => {
+  uniqueWith2.lazy = _toLazyIndexed(lazy_);
+})(uniqueWith || (uniqueWith = {}));
+function unique(...args) {
+  return purry(uniqueImplementation, args, unique.lazy);
+}
+function uniqueImplementation(array) {
+  return _reduceLazy(array, unique.lazy());
+}
+((unique2) => {
+  function lazy() {
+    const set = /* @__PURE__ */ new Set();
+    return (value) => {
+      if (set.has(value)) {
+        return { done: false, hasNext: false };
+      }
+      set.add(value);
+      return { done: false, hasNext: true, next: value };
+    };
+  }
+  unique2.lazy = lazy;
+})(unique || (unique = {}));
+function zip(...args) {
+  return purry(zip_, args);
+}
+function zip_(first2, second) {
+  const resultLength = first2.length > second.length ? second.length : first2.length;
+  const result = [];
+  for (let i = 0; i < resultLength; i++) {
+    result.push([first2[i], second[i]]);
+  }
+  return result;
+}
+((zip2) => {
+  zip2.strict = zip2;
+})(zip || (zip = {}));
+
+// src/base.ts
+import { FlatConfigPipeline } from "eslint-flat-config-utils";
+import { isPackageExists } from "local-pkg";
+import fs from "node:fs";
+import process2 from "node:process";
+
+// 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 "@vinicunca/eslint-plugin-vinicunca";
+import { default as default3 } from "eslint-plugin-eslint-comments";
+import * as pluginImport from "eslint-plugin-import-x";
+import { default as default4 } from "eslint-plugin-n";
+import { default as default5 } from "eslint-plugin-perfectionist";
+import { default as default6 } from "eslint-plugin-unicorn";
+import { default as default7 } from "eslint-plugin-unused-imports";
+
+// src/configs/comments.ts
+async function comments() {
+  return [
+    {
+      name: "vinicunca:eslint-comments",
+      plugins: {
+        "eslint-comments": default3
+      },
+      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/globs.ts
+var GLOB_SRC = "**/*.?([cm])[jt]s?(x)";
+var GLOB_SRC_EXT = "?([cm])[jt]s?(x)";
+var GLOB_JS = "**/*.?([cm])js";
+var GLOB_JSX = "**/*.?([cm])jsx";
+var GLOB_TS = "**/*.?([cm])ts";
+var GLOB_TSX = "**/*.?([cm])tsx";
+var GLOB_STYLE = "**/*.{c,le,sc}ss";
+var GLOB_CSS = "**/*.css";
+var GLOB_POSTCSS = "**/*.{p,post}css";
+var GLOB_LESS = "**/*.less";
+var GLOB_SCSS = "**/*.scss";
+var GLOB_JSON = "**/*.json";
+var GLOB_JSON5 = "**/*.json5";
+var GLOB_JSONC = "**/*.jsonc";
+var GLOB_MARKDOWN = "**/*.md";
+var GLOB_MARKDOWN_IN_MARKDOWN = "**/*.md/*.md";
+var GLOB_VUE = "**/*.vue";
+var GLOB_YAML = "**/*.y?(a)ml";
+var GLOB_HTML = "**/*.htm?(l)";
+var GLOB_MARKDOWN_CODE = `${GLOB_MARKDOWN}/${GLOB_SRC}`;
+var GLOB_TESTS = [
+  `**/__tests__/**/*.${GLOB_SRC_EXT}`,
+  `**/*.spec.${GLOB_SRC_EXT}`,
+  `**/*.test.${GLOB_SRC_EXT}`,
+  `**/*.bench.${GLOB_SRC_EXT}`,
+  `**/*.benchmark.${GLOB_SRC_EXT}`
+];
+var GLOB_ALL_SRC = [
+  GLOB_SRC,
+  GLOB_STYLE,
+  GLOB_JSON,
+  GLOB_JSON5,
+  GLOB_MARKDOWN,
+  GLOB_VUE,
+  GLOB_YAML,
+  GLOB_HTML
+];
+var GLOB_EXCLUDE = [
+  "**/node_modules",
+  "**/dist",
+  "**/package-lock.json",
+  "**/yarn.lock",
+  "**/pnpm-lock.yaml",
+  "**/bun.lockb",
+  "**/output",
+  "**/coverage",
+  "**/temp",
+  "**/.temp",
+  "**/tmp",
+  "**/.tmp",
+  "**/.history",
+  "**/.vitepress/cache",
+  "**/.nuxt",
+  "**/.next",
+  "**/.vercel",
+  "**/.changeset",
+  "**/.idea",
+  "**/.cache",
+  "**/.output",
+  "**/.vite-inspect",
+  "**/CHANGELOG*.md",
+  "**/*.min.*",
+  "**/LICENSE*",
+  "**/__snapshots__",
+  "**/auto-import?(s).d.ts",
+  "**/components.d.ts"
+];
+
+// src/utils.ts
+async function combineConfigs(...configs) {
+  const resolved = await Promise.all(configs);
+  return resolved.flat();
+}
+function renameRules(rules, map2) {
+  return Object.fromEntries(
+    Object.entries(rules).map(([key, value]) => {
+      for (const [from, to] of Object.entries(map2)) {
+        if (key.startsWith(`${from}/`)) {
+          return [to + key.slice(from.length), value];
+        }
+      }
+      return [key, value];
+    })
+  );
+}
+function renamePluginInConfigs(configs, map2) {
+  return configs.map((i) => {
+    const clone = { ...i };
+    if (clone.rules) {
+      clone.rules = renameRules(clone.rules, map2);
+    }
+    if (clone.plugins) {
+      clone.plugins = Object.fromEntries(
+        Object.entries(clone.plugins).map(([key, value]) => {
+          if (key in map2) {
+            return [map2[key], value];
+          }
+          return [key, value];
+        })
+      );
+    }
+    return clone;
+  });
+}
+async function interopDefault(m) {
+  const resolved = await m;
+  return resolved.default || resolved;
+}
+var parserPlain = {
+  meta: {
+    name: "parser-plain"
+  },
+  parseForESLint: (code) => ({
+    ast: {
+      body: [],
+      comments: [],
+      loc: { end: code.length, start: 0 },
+      range: [0, code.length],
+      tokens: [],
+      type: "Program"
+    },
+    scopeManager: null,
+    services: { isPlain: true },
+    visitorKeys: {
+      Program: []
+    }
+  })
+};
+function toArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+
+// src/configs/stylistic.ts
+var STR_PARENS_NEW_LINE = "parens-new-line";
+var STYLISTIC_CONFIG_DEFAULTS = {
+  indent: 2,
+  jsx: true,
+  quotes: "single",
+  semi: true
+};
+async function stylistic(options = {}) {
+  const {
+    indent,
+    jsx,
+    overrides = {},
+    quotes,
+    semi
+  } = {
+    ...STYLISTIC_CONFIG_DEFAULTS,
+    ...options
+  };
+  const pluginStylistic = await interopDefault(import("@stylistic/eslint-plugin"));
+  const config = pluginStylistic.configs.customize({
+    flat: true,
+    indent,
+    jsx,
+    pluginName: "style",
+    quotes,
+    semi
+  });
+  return [
+    {
+      name: "vinicunca:stylistic",
+      plugins: {
+        style: pluginStylistic,
+        vinicunca: default2
+      },
+      rules: {
+        ...config.rules,
+        "curly": [ERROR, "all"],
+        "style/array-bracket-newline": [ERROR, CONSISTENT],
+        "style/array-bracket-spacing": [ERROR, NEVER],
+        "style/array-element-newline": [ERROR, CONSISTENT],
+        "style/arrow-parens": [ERROR, ALWAYS],
+        "style/brace-style": [ERROR],
+        "style/func-call-spacing": [ERROR, NEVER],
+        "style/jsx-child-element-spacing": OFF,
+        "style/jsx-closing-bracket-location": [ERROR, "line-aligned"],
+        "style/jsx-closing-tag-location": ERROR,
+        "style/jsx-curly-brace-presence": [ERROR, { children: NEVER, props: NEVER }],
+        "style/jsx-curly-newline": [ERROR, {
+          multiline: "consistent",
+          singleline: "consistent"
+        }],
+        "style/jsx-curly-spacing": [ERROR, {
+          children: true,
+          spacing: {
+            objectLiterals: NEVER
+          },
+          when: "always"
+        }],
+        "style/jsx-equals-spacing": [ERROR, NEVER],
+        "style/jsx-first-prop-new-line": [ERROR, "multiline-multiprop"],
+        "style/jsx-indent": [ERROR, 2],
+        "style/jsx-indent-props": [ERROR, 2],
+        "style/jsx-max-props-per-line": [ERROR, { maximum: 1, when: "multiline" }],
+        "style/jsx-newline": ERROR,
+        "style/jsx-one-expression-per-line": [ERROR, { allow: "single-child" }],
+        "style/jsx-props-no-multi-spaces": ERROR,
+        // Turned off to avoid conflicts with Perfectionist. https://eslint-plugin-perfectionist.azat.io/rules/sort-jsx-props
+        "style/jsx-sort-props": [OFF],
+        "style/jsx-tag-spacing": [ERROR, {
+          afterOpening: NEVER,
+          beforeClosing: NEVER,
+          beforeSelfClosing: "always",
+          closingSlash: NEVER
+        }],
+        "style/jsx-wrap-multilines": [ERROR, {
+          arrow: STR_PARENS_NEW_LINE,
+          assignment: STR_PARENS_NEW_LINE,
+          condition: STR_PARENS_NEW_LINE,
+          declaration: STR_PARENS_NEW_LINE,
+          logical: STR_PARENS_NEW_LINE,
+          prop: STR_PARENS_NEW_LINE,
+          return: STR_PARENS_NEW_LINE
+        }],
+        "style/member-delimiter-style": [ERROR],
+        "style/object-curly-newline": [ERROR, { consistent: true, multiline: true }],
+        "style/object-curly-spacing": [ERROR, ALWAYS],
+        "style/object-property-newline": [ERROR, { allowMultiplePropertiesPerLine: true }],
+        "style/operator-linebreak": [ERROR, "before"],
+        "style/padded-blocks": [ERROR, { blocks: NEVER, classes: NEVER, switches: NEVER }],
+        "style/quote-props": [ERROR, "consistent-as-needed"],
+        "style/quotes": [ERROR, quotes],
+        "style/rest-spread-spacing": [ERROR, NEVER],
+        "style/semi": [ERROR, semi ? ALWAYS : NEVER],
+        "style/semi-spacing": [ERROR, { after: true, before: false }],
+        "vinicunca/consistent-list-newline": ERROR,
+        "vinicunca/if-newline": ERROR,
+        "vinicunca/top-level-function": ERROR,
+        ...overrides
+      }
+    },
+    {
+      files: [GLOB_JSX, GLOB_TSX],
+      rules: {
+        "vinicunca/consistent-list-newline": OFF
+      }
+    }
+  ];
+}
+
+// src/configs/formatters.ts
+async function formatters(options = {}, stylistic2 = {}) {
+  if (options === true) {
+    options = {
+      css: true,
+      graphql: true,
+      html: true,
+      markdown: true
+    };
+  }
+  const {
+    indent,
+    quotes,
+    semi
+  } = {
+    ...STYLISTIC_CONFIG_DEFAULTS,
+    ...stylistic2
+  };
+  const prettierOptions = Object.assign(
+    {
+      endOfLine: "auto",
+      semi,
+      singleQuote: quotes === "single",
+      tabWidth: typeof indent === "number" ? indent : 2,
+      trailingComma: "all",
+      useTabs: indent === "tab"
+    },
+    options.prettierOptions || {}
+  );
+  const dprintOptions = Object.assign(
+    {
+      indentWidth: typeof indent === "number" ? indent : 2,
+      quoteStyle: quotes === "single" ? "preferSingle" : "preferDouble",
+      useTabs: indent === "tab"
+    },
+    options.dprintOptions || {}
+  );
+  const pluginFormat = await interopDefault(import("eslint-plugin-format"));
+  const configs = [
+    {
+      name: "vinicunca:formatters:setup",
+      plugins: {
+        format: pluginFormat
+      }
+    }
+  ];
+  if (options.css) {
+    configs.push(
+      {
+        files: [GLOB_CSS, GLOB_POSTCSS],
+        languageOptions: {
+          parser: parserPlain
+        },
+        name: "vinicunca:formatters:css",
+        rules: {
+          "format/prettier": [
+            "error",
+            {
+              ...prettierOptions,
+              parser: "css"
+            }
+          ]
+        }
+      },
+      {
+        files: [GLOB_SCSS],
+        languageOptions: {
+          parser: parserPlain
+        },
+        name: "vinicunca:formatters:scss",
+        rules: {
+          "format/prettier": [
+            "error",
+            {
+              ...prettierOptions,
+              parser: "scss"
+            }
+          ]
+        }
+      },
+      {
+        files: [GLOB_LESS],
+        languageOptions: {
+          parser: parserPlain
+        },
+        name: "vinicunca:formatters:less",
+        rules: {
+          "format/prettier": [
+            "error",
+            {
+              ...prettierOptions,
+              parser: "less"
+            }
+          ]
+        }
+      }
+    );
+  }
+  if (options.html) {
+    configs.push({
+      files: ["**/*.html"],
+      languageOptions: {
+        parser: parserPlain
       },
+      name: "vinicunca:formatters:html",
       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
+        "format/prettier": [
+          "error",
+          {
+            ...prettierOptions,
+            parser: "html"
+          }
+        ]
       }
-    }
-  ];
+    });
+  }
+  if (options.markdown) {
+    const formater = options.markdown === true ? "prettier" : options.markdown;
+    configs.push({
+      files: [GLOB_MARKDOWN],
+      languageOptions: {
+        parser: parserPlain
+      },
+      name: "vinicunca:formatters:markdown",
+      rules: {
+        [`format/${formater}`]: [
+          "error",
+          formater === "prettier" ? {
+            printWidth: 120,
+            ...prettierOptions,
+            embeddedLanguageFormatting: "off",
+            parser: "markdown"
+          } : {
+            ...dprintOptions,
+            language: "markdown"
+          }
+        ]
+      }
+    });
+  }
+  if (options.graphql) {
+    configs.push({
+      files: ["**/*.graphql"],
+      languageOptions: {
+        parser: parserPlain
+      },
+      name: "vinicunca:formatters:graphql",
+      rules: {
+        "format/prettier": [
+          "error",
+          {
+            ...prettierOptions,
+            parser: "graphql"
+          }
+        ]
+      }
+    });
+  }
+  return configs;
 }
 
-// src/globs.ts
-var GLOB_SRC = "**/*.?([cm])[jt]s?(x)";
-var GLOB_SRC_EXT = "?([cm])[jt]s?(x)";
-var GLOB_JS = "**/*.?([cm])js";
-var GLOB_JSX = "**/*.?([cm])jsx";
-var GLOB_TS = "**/*.?([cm])ts";
-var GLOB_TSX = "**/*.?([cm])tsx";
-var GLOB_STYLE = "**/*.{c,le,sc}ss";
-var GLOB_CSS = "**/*.css";
-var GLOB_POSTCSS = "**/*.{p,post}css";
-var GLOB_LESS = "**/*.less";
-var GLOB_SCSS = "**/*.scss";
-var GLOB_JSON = "**/*.json";
-var GLOB_JSON5 = "**/*.json5";
-var GLOB_JSONC = "**/*.jsonc";
-var GLOB_MARKDOWN = "**/*.md";
-var GLOB_MARKDOWN_IN_MARKDOWN = "**/*.md/*.md";
-var GLOB_VUE = "**/*.vue";
-var GLOB_YAML = "**/*.y?(a)ml";
-var GLOB_HTML = "**/*.htm?(l)";
-var GLOB_MARKDOWN_CODE = `${GLOB_MARKDOWN}/${GLOB_SRC}`;
-var GLOB_TESTS = [
-  `**/__tests__/**/*.${GLOB_SRC_EXT}`,
-  `**/*.spec.${GLOB_SRC_EXT}`,
-  `**/*.test.${GLOB_SRC_EXT}`,
-  `**/*.bench.${GLOB_SRC_EXT}`,
-  `**/*.benchmark.${GLOB_SRC_EXT}`
-];
-var GLOB_ALL_SRC = [
-  GLOB_SRC,
-  GLOB_STYLE,
-  GLOB_JSON,
-  GLOB_JSON5,
-  GLOB_MARKDOWN,
-  GLOB_VUE,
-  GLOB_YAML,
-  GLOB_HTML
-];
-var GLOB_EXCLUDE = [
-  "**/node_modules",
-  "**/dist",
-  "**/package-lock.json",
-  "**/yarn.lock",
-  "**/pnpm-lock.yaml",
-  "**/bun.lockb",
-  "**/output",
-  "**/coverage",
-  "**/temp",
-  "**/.temp",
-  "**/tmp",
-  "**/.tmp",
-  "**/.history",
-  "**/.vitepress/cache",
-  "**/.nuxt",
-  "**/.next",
-  "**/.vercel",
-  "**/.changeset",
-  "**/.idea",
-  "**/.cache",
-  "**/.output",
-  "**/.vite-inspect",
-  "**/CHANGELOG*.md",
-  "**/*.min.*",
-  "**/LICENSE*",
-  "**/__snapshots__",
-  "**/auto-import?(s).d.ts",
-  "**/components.d.ts"
-];
-
 // src/configs/ignores.ts
 async function ignores() {
   return [
@@ -193,7 +1273,6 @@ async function javascript(options = {}) {
       },
       name: "vinicunca:javascript",
       plugins: {
-        "perfectionist": default5,
         "unused-imports": default7,
         "vinicunca": default2
       },
@@ -415,106 +1494,18 @@ async function javascript(options = {}) {
         }],
         "vars-on-top": ERROR,
         "yoda": [ERROR, NEVER],
-        ...default2.configs.recommended.rules,
-        ...default5.configs["recommended-natural"].rules,
-        "perfectionist/sort-imports": [
-          ERROR,
-          {
-            "groups": [
-              "type",
-              ["builtin", "external"],
-              "internal-type",
-              "internal",
-              ["parent-type", "sibling-type", "index-type"],
-              ["parent", "sibling", "index"],
-              "object",
-              "unknown"
-            ],
-            "internal-pattern": [
-              "~/**",
-              "~~/**"
-            ],
-            "newlines-between": "always",
-            "order": "asc",
-            "type": "natural"
-          }
-        ],
-        "perfectionist/sort-vue-attributes": [OFF],
-        ...overrides
-      }
-    },
-    {
-      files: [`**/scripts/${GLOB_SRC}`, `**/cli.${GLOB_SRC_EXT}`],
-      name: "vinicunca:javascript:overrides",
-      rules: {
-        "no-console": OFF
-      }
-    }
-  ];
-}
-
-// src/utils.ts
-async function combineConfigs(...configs) {
-  const resolved = await Promise.all(configs);
-  return resolved.flat();
-}
-function renameRules(rules, map) {
-  return Object.fromEntries(
-    Object.entries(rules).map(([key, value]) => {
-      for (const [from, to] of Object.entries(map)) {
-        if (key.startsWith(`${from}/`)) {
-          return [to + key.slice(from.length), value];
-        }
-      }
-      return [key, value];
-    })
-  );
-}
-function renamePluginInConfigs(configs, map) {
-  return configs.map((i) => {
-    const clone = { ...i };
-    if (clone.rules) {
-      clone.rules = renameRules(clone.rules, map);
-    }
-    if (clone.plugins) {
-      clone.plugins = Object.fromEntries(
-        Object.entries(clone.plugins).map(([key, value]) => {
-          if (key in map) {
-            return [map[key], value];
-          }
-          return [key, value];
-        })
-      );
-    }
-    return clone;
-  });
-}
-async function interopDefault(m) {
-  const resolved = await m;
-  return resolved.default || resolved;
-}
-var parserPlain = {
-  meta: {
-    name: "parser-plain"
-  },
-  parseForESLint: (code) => ({
-    ast: {
-      body: [],
-      comments: [],
-      loc: { end: code.length, start: 0 },
-      range: [0, code.length],
-      tokens: [],
-      type: "Program"
+        ...default2.configs.recommended.rules,
+        ...overrides
+      }
     },
-    scopeManager: null,
-    services: { isPlain: true },
-    visitorKeys: {
-      Program: []
+    {
+      files: [`**/scripts/${GLOB_SRC}`, `**/cli.${GLOB_SRC_EXT}`],
+      name: "vinicunca:javascript:overrides",
+      rules: {
+        "no-console": OFF
+      }
     }
-  })
-};
-function toArray(value) {
-  return Array.isArray(value) ? value : [value];
+  ];
 }
 
 // src/configs/jsdoc.ts
@@ -751,6 +1742,44 @@ async function node() {
   ];
 }
 
+// src/configs/perfectionist.ts
+async function perfectionist() {
+  return [
+    {
+      name: "vinicunca:perfectionist",
+      plugins: {
+        perfectionist: default5
+      },
+      rules: {
+        ...default5.configs["recommended-natural"].rules,
+        "perfectionist/sort-imports": [
+          ERROR,
+          {
+            "groups": [
+              "type",
+              ["builtin", "external"],
+              "internal-type",
+              "internal",
+              ["parent-type", "sibling-type", "index-type"],
+              ["parent", "sibling", "index"],
+              "object",
+              "unknown"
+            ],
+            "internal-pattern": [
+              "~/**",
+              "~~/**"
+            ],
+            "newlines-between": "always",
+            "order": "asc",
+            "type": "natural"
+          }
+        ],
+        "perfectionist/sort-vue-attributes": [OFF]
+      }
+    }
+  ];
+}
+
 // src/configs/react.ts
 async function react(options = {}) {
   const {
@@ -954,211 +1983,101 @@ function sortTsconfig() {
               "composite",
               "tsBuildInfoFile",
               "disableSourceOfProjectReferenceRedirect",
-              "disableSolutionSearching",
-              "disableReferencedProjectLoad",
-              /* Language and Environment */
-              "target",
-              "jsx",
-              "jsxFactory",
-              "jsxFragmentFactory",
-              "jsxImportSource",
-              "lib",
-              "moduleDetection",
-              "noLib",
-              "reactNamespace",
-              "useDefineForClassFields",
-              "emitDecoratorMetadata",
-              "experimentalDecorators",
-              /* Modules */
-              "baseUrl",
-              "rootDir",
-              "rootDirs",
-              "customConditions",
-              "module",
-              "moduleResolution",
-              "moduleSuffixes",
-              "noResolve",
-              "paths",
-              "resolveJsonModule",
-              "resolvePackageJsonExports",
-              "resolvePackageJsonImports",
-              "typeRoots",
-              "types",
-              "allowArbitraryExtensions",
-              "allowImportingTsExtensions",
-              "allowUmdGlobalAccess",
-              /* JavaScript Support */
-              "allowJs",
-              "checkJs",
-              "maxNodeModuleJsDepth",
-              /* Type Checking */
-              "strict",
-              "strictBindCallApply",
-              "strictFunctionTypes",
-              "strictNullChecks",
-              "strictPropertyInitialization",
-              "allowUnreachableCode",
-              "allowUnusedLabels",
-              "alwaysStrict",
-              "exactOptionalPropertyTypes",
-              "noFallthroughCasesInSwitch",
-              "noImplicitAny",
-              "noImplicitOverride",
-              "noImplicitReturns",
-              "noImplicitThis",
-              "noPropertyAccessFromIndexSignature",
-              "noUncheckedIndexedAccess",
-              "noUnusedLocals",
-              "noUnusedParameters",
-              "useUnknownInCatchVariables",
-              /* Emit */
-              "declaration",
-              "declarationDir",
-              "declarationMap",
-              "downlevelIteration",
-              "emitBOM",
-              "emitDeclarationOnly",
-              "importHelpers",
-              "importsNotUsedAsValues",
-              "inlineSourceMap",
-              "inlineSources",
-              "mapRoot",
-              "newLine",
-              "noEmit",
-              "noEmitHelpers",
-              "noEmitOnError",
-              "outDir",
-              "outFile",
-              "preserveConstEnums",
-              "preserveValueImports",
-              "removeComments",
-              "sourceMap",
-              "sourceRoot",
-              "stripInternal",
-              /* Interop Constraints */
-              "allowSyntheticDefaultImports",
-              "esModuleInterop",
-              "forceConsistentCasingInFileNames",
-              "isolatedModules",
-              "preserveSymlinks",
-              "verbatimModuleSyntax",
-              /* Completeness */
-              "skipDefaultLibCheck",
-              "skipLibCheck"
-            ],
-            pathPattern: "^compilerOptions$"
-          }
-        ]
-      }
-    }
-  ];
-}
-
-// src/configs/stylistic.ts
-var STR_PARENS_NEW_LINE = "parens-new-line";
-var STYLISTIC_CONFIG_DEFAULTS = {
-  indent: 2,
-  jsx: true,
-  quotes: "single",
-  semi: true
-};
-async function stylistic(options = {}) {
-  const {
-    indent,
-    jsx,
-    overrides = {},
-    quotes,
-    semi
-  } = {
-    ...STYLISTIC_CONFIG_DEFAULTS,
-    ...options
-  };
-  const pluginStylistic = await interopDefault(import("@stylistic/eslint-plugin"));
-  const config = pluginStylistic.configs.customize({
-    flat: true,
-    indent,
-    jsx,
-    pluginName: "style",
-    quotes,
-    semi
-  });
-  return [
-    {
-      name: "vinicunca:stylistic",
-      plugins: {
-        style: pluginStylistic,
-        vinicunca: default2
-      },
-      rules: {
-        ...config.rules,
-        "curly": [ERROR, "all"],
-        "style/array-bracket-newline": [ERROR, CONSISTENT],
-        "style/array-bracket-spacing": [ERROR, NEVER],
-        "style/array-element-newline": [ERROR, CONSISTENT],
-        "style/arrow-parens": [ERROR, ALWAYS],
-        "style/brace-style": [ERROR],
-        "style/func-call-spacing": [ERROR, NEVER],
-        "style/jsx-child-element-spacing": OFF,
-        "style/jsx-closing-bracket-location": [ERROR, "line-aligned"],
-        "style/jsx-closing-tag-location": ERROR,
-        "style/jsx-curly-brace-presence": [ERROR, { children: NEVER, props: NEVER }],
-        "style/jsx-curly-newline": [ERROR, {
-          multiline: "consistent",
-          singleline: "consistent"
-        }],
-        "style/jsx-curly-spacing": [ERROR, {
-          children: true,
-          spacing: {
-            objectLiterals: NEVER
-          },
-          when: "always"
-        }],
-        "style/jsx-equals-spacing": [ERROR, NEVER],
-        "style/jsx-first-prop-new-line": [ERROR, "multiline-multiprop"],
-        "style/jsx-indent": [ERROR, 2],
-        "style/jsx-indent-props": [ERROR, 2],
-        "style/jsx-max-props-per-line": [ERROR, { maximum: 1, when: "multiline" }],
-        "style/jsx-newline": ERROR,
-        "style/jsx-one-expression-per-line": [ERROR, { allow: "single-child" }],
-        "style/jsx-props-no-multi-spaces": ERROR,
-        // Turned off to avoid conflicts with Perfectionist. https://eslint-plugin-perfectionist.azat.io/rules/sort-jsx-props
-        "style/jsx-sort-props": [OFF],
-        "style/jsx-tag-spacing": [ERROR, {
-          afterOpening: NEVER,
-          beforeClosing: NEVER,
-          beforeSelfClosing: "always",
-          closingSlash: NEVER
-        }],
-        "style/jsx-wrap-multilines": [ERROR, {
-          arrow: STR_PARENS_NEW_LINE,
-          assignment: STR_PARENS_NEW_LINE,
-          condition: STR_PARENS_NEW_LINE,
-          declaration: STR_PARENS_NEW_LINE,
-          logical: STR_PARENS_NEW_LINE,
-          prop: STR_PARENS_NEW_LINE,
-          return: STR_PARENS_NEW_LINE
-        }],
-        "style/member-delimiter-style": [ERROR],
-        "style/object-curly-newline": [ERROR, { consistent: true, multiline: true }],
-        "style/object-curly-spacing": [ERROR, ALWAYS],
-        "style/object-property-newline": [ERROR, { allowMultiplePropertiesPerLine: true }],
-        "style/operator-linebreak": [ERROR, "before"],
-        "style/padded-blocks": [ERROR, { blocks: NEVER, classes: NEVER, switches: NEVER }],
-        "style/quote-props": [ERROR, "consistent-as-needed"],
-        "style/quotes": [ERROR, quotes],
-        "style/rest-spread-spacing": [ERROR, NEVER],
-        "style/semi": [ERROR, semi ? ALWAYS : NEVER],
-        "style/semi-spacing": [ERROR, { after: true, before: false }],
-        "vinicunca/consistent-list-newline": ERROR,
-        "vinicunca/if-newline": ERROR,
-        "vinicunca/top-level-function": ERROR,
-        ...overrides
-      }
-    },
-    {
-      files: [GLOB_JSX, GLOB_TSX],
-      rules: {
-        "vinicunca/consistent-list-newline": OFF
+              "disableSolutionSearching",
+              "disableReferencedProjectLoad",
+              /* Language and Environment */
+              "target",
+              "jsx",
+              "jsxFactory",
+              "jsxFragmentFactory",
+              "jsxImportSource",
+              "lib",
+              "moduleDetection",
+              "noLib",
+              "reactNamespace",
+              "useDefineForClassFields",
+              "emitDecoratorMetadata",
+              "experimentalDecorators",
+              /* Modules */
+              "baseUrl",
+              "rootDir",
+              "rootDirs",
+              "customConditions",
+              "module",
+              "moduleResolution",
+              "moduleSuffixes",
+              "noResolve",
+              "paths",
+              "resolveJsonModule",
+              "resolvePackageJsonExports",
+              "resolvePackageJsonImports",
+              "typeRoots",
+              "types",
+              "allowArbitraryExtensions",
+              "allowImportingTsExtensions",
+              "allowUmdGlobalAccess",
+              /* JavaScript Support */
+              "allowJs",
+              "checkJs",
+              "maxNodeModuleJsDepth",
+              /* Type Checking */
+              "strict",
+              "strictBindCallApply",
+              "strictFunctionTypes",
+              "strictNullChecks",
+              "strictPropertyInitialization",
+              "allowUnreachableCode",
+              "allowUnusedLabels",
+              "alwaysStrict",
+              "exactOptionalPropertyTypes",
+              "noFallthroughCasesInSwitch",
+              "noImplicitAny",
+              "noImplicitOverride",
+              "noImplicitReturns",
+              "noImplicitThis",
+              "noPropertyAccessFromIndexSignature",
+              "noUncheckedIndexedAccess",
+              "noUnusedLocals",
+              "noUnusedParameters",
+              "useUnknownInCatchVariables",
+              /* Emit */
+              "declaration",
+              "declarationDir",
+              "declarationMap",
+              "downlevelIteration",
+              "emitBOM",
+              "emitDeclarationOnly",
+              "importHelpers",
+              "importsNotUsedAsValues",
+              "inlineSourceMap",
+              "inlineSources",
+              "mapRoot",
+              "newLine",
+              "noEmit",
+              "noEmitHelpers",
+              "noEmitOnError",
+              "outDir",
+              "outFile",
+              "preserveConstEnums",
+              "preserveValueImports",
+              "removeComments",
+              "sourceMap",
+              "sourceRoot",
+              "stripInternal",
+              /* Interop Constraints */
+              "allowSyntheticDefaultImports",
+              "esModuleInterop",
+              "forceConsistentCasingInFileNames",
+              "isolatedModules",
+              "preserveSymlinks",
+              "verbatimModuleSyntax",
+              /* Completeness */
+              "skipDefaultLibCheck",
+              "skipLibCheck"
+            ],
+            pathPattern: "^compilerOptions$"
+          }
+        ]
       }
     }
   ];
@@ -1210,7 +2129,7 @@ async function test(options = {}) {
 }
 
 // src/configs/typescript.ts
-import process from "process";
+import process from "node:process";
 async function typescript(options = {}) {
   const {
     componentExts = [],
@@ -1637,167 +2556,6 @@ async function yaml(options = {}) {
   ];
 }
 
-// src/configs/formatters.ts
-async function formatters(options = {}, stylistic2 = {}) {
-  if (options === true) {
-    options = {
-      css: true,
-      graphql: true,
-      html: true,
-      markdown: true
-    };
-  }
-  const {
-    indent,
-    quotes,
-    semi
-  } = {
-    ...STYLISTIC_CONFIG_DEFAULTS,
-    ...stylistic2
-  };
-  const prettierOptions = Object.assign(
-    {
-      endOfLine: "auto",
-      semi,
-      singleQuote: quotes === "single",
-      tabWidth: typeof indent === "number" ? indent : 2,
-      trailingComma: "all",
-      useTabs: indent === "tab"
-    },
-    options.prettierOptions || {}
-  );
-  const dprintOptions = Object.assign(
-    {
-      indentWidth: typeof indent === "number" ? indent : 2,
-      quoteStyle: quotes === "single" ? "preferSingle" : "preferDouble",
-      useTabs: indent === "tab"
-    },
-    options.dprintOptions || {}
-  );
-  const pluginFormat = await interopDefault(import("eslint-plugin-format"));
-  const configs = [
-    {
-      name: "vinicunca:formatters:setup",
-      plugins: {
-        format: pluginFormat
-      }
-    }
-  ];
-  if (options.css) {
-    configs.push(
-      {
-        files: [GLOB_CSS, GLOB_POSTCSS],
-        languageOptions: {
-          parser: parserPlain
-        },
-        name: "vinicunca:formatters:css",
-        rules: {
-          "format/prettier": [
-            "error",
-            {
-              ...prettierOptions,
-              parser: "css"
-            }
-          ]
-        }
-      },
-      {
-        files: [GLOB_SCSS],
-        languageOptions: {
-          parser: parserPlain
-        },
-        name: "vinicunca:formatters:scss",
-        rules: {
-          "format/prettier": [
-            "error",
-            {
-              ...prettierOptions,
-              parser: "scss"
-            }
-          ]
-        }
-      },
-      {
-        files: [GLOB_LESS],
-        languageOptions: {
-          parser: parserPlain
-        },
-        name: "vinicunca:formatters:less",
-        rules: {
-          "format/prettier": [
-            "error",
-            {
-              ...prettierOptions,
-              parser: "less"
-            }
-          ]
-        }
-      }
-    );
-  }
-  if (options.html) {
-    configs.push({
-      files: ["**/*.html"],
-      languageOptions: {
-        parser: parserPlain
-      },
-      name: "vinicunca:formatters:html",
-      rules: {
-        "format/prettier": [
-          "error",
-          {
-            ...prettierOptions,
-            parser: "html"
-          }
-        ]
-      }
-    });
-  }
-  if (options.markdown) {
-    const formater = options.markdown === true ? "prettier" : options.markdown;
-    configs.push({
-      files: [GLOB_MARKDOWN],
-      languageOptions: {
-        parser: parserPlain
-      },
-      name: "vinicunca:formatters:markdown",
-      rules: {
-        [`format/${formater}`]: [
-          "error",
-          formater === "prettier" ? {
-            printWidth: 120,
-            ...prettierOptions,
-            embeddedLanguageFormatting: "off",
-            parser: "markdown"
-          } : {
-            ...dprintOptions,
-            language: "markdown"
-          }
-        ]
-      }
-    });
-  }
-  if (options.graphql) {
-    configs.push({
-      files: ["**/*.graphql"],
-      languageOptions: {
-        parser: parserPlain
-      },
-      name: "vinicunca:formatters:graphql",
-      rules: {
-        "format/prettier": [
-          "error",
-          {
-            ...prettierOptions,
-            parser: "graphql"
-          }
-        ]
-      }
-    });
-  }
-  return configs;
-}
-
 // src/base.ts
 var flatConfigProps = [
   "name",
@@ -1824,7 +2582,7 @@ var defaultPluginRenaming = {
   "vitest": "test",
   "yml": "yaml"
 };
-async function vinicuncaESLint(options = {}, ...userConfigs) {
+function vinicuncaESLint(options = {}, ...userConfigs) {
   const {
     autoRenamePlugins = true,
     componentExts = [],
@@ -1866,7 +2624,8 @@ async function vinicuncaESLint(options = {}, ...userConfigs) {
       stylistic: stylisticOptions
     }),
     imports(),
-    unicorn()
+    unicorn(),
+    perfectionist()
   );
   if (enableVue) {
     componentExts.push("vue");
@@ -1953,14 +2712,15 @@ async function vinicuncaESLint(options = {}, ...userConfigs) {
     configs.push([fusedConfig]);
   }
   ;
-  const merged = await combineConfigs(
+  let pipeline = new FlatConfigPipeline();
+  pipeline = pipeline.append(
     ...configs,
     ...userConfigs
   );
   if (autoRenamePlugins) {
-    return renamePluginInConfigs(merged, defaultPluginRenaming);
+    pipeline = pipeline.renamePlugins(defaultPluginRenaming);
   }
-  return merged;
+  return pipeline;
 }
 function getOverrides(options, key) {
   const sub = resolveSubOptions(options, key);
@@ -1999,6 +2759,7 @@ export {
   combineConfigs,
   comments,
   defaultPluginRenaming,
+  formatters,
   ignores,
   imports,
   interopDefault,
@@ -2008,6 +2769,7 @@ export {
   markdown,
   node,
   parserPlain,
+  perfectionist,
   default3 as pluginComments,
   pluginImport,
   default4 as pluginNode,