@vinicunca/eslint-config 2.2.0 → 2.3.0

package/dist/index.js

@@ -1,9 +1,481 @@
-// ../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;
@@ -11,8 +483,281 @@ function isObject(data) {
   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 "fs";
 import process2 from "process";
@@ -458,10 +1203,10 @@ async function combineConfigs(...configs) {
   const resolved = await Promise.all(configs);
   return resolved.flat();
 }
-function renameRules(rules, map) {
+function renameRules(rules, map2) {
   return Object.fromEntries(
     Object.entries(rules).map(([key, value]) => {
-      for (const [from, to] of Object.entries(map)) {
+      for (const [from, to] of Object.entries(map2)) {
         if (key.startsWith(`${from}/`)) {
           return [to + key.slice(from.length), value];
         }
@@ -470,17 +1215,17 @@ function renameRules(rules, map) {
     })
   );
 }
-function renamePluginInConfigs(configs, map) {
+function renamePluginInConfigs(configs, map2) {
   return configs.map((i) => {
     const clone = { ...i };
     if (clone.rules) {
-      clone.rules = renameRules(clone.rules, map);
+      clone.rules = renameRules(clone.rules, map2);
     }
     if (clone.plugins) {
       clone.plugins = Object.fromEntries(
         Object.entries(clone.plugins).map(([key, value]) => {
-          if (key in map) {
-            return [map[key], value];
+          if (key in map2) {
+            return [map2[key], value];
           }
           return [key, value];
         })
@@ -1824,7 +2569,7 @@ var defaultPluginRenaming = {
   "vitest": "test",
   "yml": "yaml"
 };
-async function vinicuncaESLint(options = {}, ...userConfigs) {
+function vinicuncaESLint(options = {}, ...userConfigs) {
   const {
     autoRenamePlugins = true,
     componentExts = [],
@@ -1953,14 +2698,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);