@vinicunca/eslint-config 2.6.2 → 2.7.0-beta.1

package/dist/index.cjs

@@ -64,6 +64,7 @@ __export(src_exports, {
   javascript: () => javascript,
   jsdoc: () => jsdoc,
   jsonc: () => jsonc,
+  jsx: () => jsx,
   markdown: () => markdown,
   node: () => node,
   parserPlain: () => parserPlain,
@@ -95,763 +96,17 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
-// ../node_modules/.pnpm/@vinicunca+perkakas@0.5.4/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;
+// ../node_modules/.pnpm/@vinicunca+perkakas@1.0.2/node_modules/@vinicunca/perkakas/dist/chunk-HLL46USD.js
+function r(e2) {
+  if (typeof e2 != "object" || e2 === null) return false;
+  let o = Object.getPrototypeOf(e2);
+  return o === null || o === Object.prototype;
 }
-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";
-}
-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;
-}
-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;
+
+// ../node_modules/.pnpm/@vinicunca+perkakas@1.0.2/node_modules/@vinicunca/perkakas/dist/chunk-AZUJCNUP.js
+function e(o) {
+  return typeof o == "boolean";
 }
-((zip2) => {
-  zip2.strict = zip2;
-})(zip || (zip = {}));
 
 // src/base.ts
 var import_eslint_flat_config_utils = require("eslint-flat-config-utils");
@@ -956,6 +211,8 @@ var GLOB_EXCLUDE = [
   "**/.cache",
   "**/.output",
   "**/.vite-inspect",
+  "**/.yarn",
+  "**/vite.config.*.timestamp-*",
   "**/CHANGELOG*.md",
   "**/*.min.*",
   "**/LICENSE*",
@@ -969,10 +226,10 @@ async function combineConfigs(...configs2) {
   const resolved = await Promise.all(configs2);
   return resolved.flat();
 }
-function renameRules(rules, map2) {
+function renameRules(rules, map) {
   return Object.fromEntries(
     Object.entries(rules).map(([key, value]) => {
-      for (const [from, to] of Object.entries(map2)) {
+      for (const [from, to] of Object.entries(map)) {
         if (key.startsWith(`${from}/`)) {
           return [to + key.slice(from.length), value];
         }
@@ -981,17 +238,17 @@ function renameRules(rules, map2) {
     })
   );
 }
-function renamePluginInConfigs(configs2, map2) {
+function renamePluginInConfigs(configs2, map) {
   return configs2.map((i) => {
     const clone = { ...i };
     if (clone.rules) {
-      clone.rules = renameRules(clone.rules, map2);
+      clone.rules = renameRules(clone.rules, map);
     }
     if (clone.plugins) {
       clone.plugins = Object.fromEntries(
         Object.entries(clone.plugins).map(([key, value]) => {
-          if (key in map2) {
-            return [map2[key], value];
+          if (key in map) {
+            return [map[key], value];
           }
           return [key, value];
         })
@@ -1039,7 +296,7 @@ var STYLISTIC_CONFIG_DEFAULTS = {
 async function stylistic(options = {}) {
   const {
     indent,
-    jsx,
+    jsx: jsx2,
     overrides = {},
     quotes,
     semi
@@ -1051,7 +308,7 @@ async function stylistic(options = {}) {
   const config = pluginStylistic.configs.customize({
     flat: true,
     indent,
-    jsx,
+    jsx: jsx2,
     pluginName: "style",
     quotes,
     semi
@@ -1360,6 +617,9 @@ async function javascript(options = {}) {
       linterOptions: {
         reportUnusedDisableDirectives: true
       },
+      name: "vinicunca/javascript/setup"
+    },
+    {
       name: "vinicunca/javascript/rules",
       plugins: {
         "antfu": import_eslint_plugin_antfu.default,
@@ -1645,7 +905,7 @@ async function jsonc(options = {}) {
   } = options;
   const {
     indent = 2
-  } = isBoolean(stylistic2) ? {} : stylistic2;
+  } = e(stylistic2) ? {} : stylistic2;
   const [
     pluginJsonc,
     parserJsonc
@@ -1711,6 +971,23 @@ async function jsonc(options = {}) {
   ];
 }
 
+// src/configs/jsx.ts
+async function jsx() {
+  return [
+    {
+      files: [GLOB_JSX, GLOB_TSX],
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true
+          }
+        }
+      },
+      name: "vinicunca/jsx/setup"
+    }
+  ];
+}
+
 // src/configs/markdown.ts
 var import_eslint_merge_processors = require("eslint-merge-processors");
 async function markdown(options = {}) {
@@ -1781,25 +1058,6 @@ async function markdown(options = {}) {
         "unicode-bom": OFF,
         "unused-imports/no-unused-imports": OFF,
         "unused-imports/no-unused-vars": OFF,
-        // Type aware rules
-        ...{
-          "ts/await-thenable": OFF,
-          "ts/dot-notation": OFF,
-          "ts/no-floating-promises": OFF,
-          "ts/no-for-in-array": OFF,
-          "ts/no-implied-eval": OFF,
-          "ts/no-misused-promises": OFF,
-          "ts/no-throw-literal": OFF,
-          "ts/no-unnecessary-type-assertion": OFF,
-          "ts/no-unsafe-argument": OFF,
-          "ts/no-unsafe-assignment": OFF,
-          "ts/no-unsafe-call": OFF,
-          "ts/no-unsafe-member-access": OFF,
-          "ts/no-unsafe-return": OFF,
-          "ts/restrict-plus-operands": OFF,
-          "ts/restrict-template-expressions": OFF,
-          "ts/unbound-method": OFF
-        },
         ...overrides
       }
     }
@@ -1870,7 +1128,7 @@ async function perfectionist() {
 // src/configs/react.ts
 async function react(options = {}) {
   const {
-    files = [GLOB_JS, GLOB_JSX, GLOB_TS, GLOB_TSX],
+    files = [GLOB_SRC],
     overrides = {}
   } = options;
   const [
@@ -2006,6 +1264,7 @@ async function sortPackageJson() {
               "packageManager",
               "description",
               "author",
+              "contributors",
               "license",
               "funding",
               "homepage",
@@ -2271,12 +1530,14 @@ async function typescript(options = {}) {
     ...componentExts.map((ext) => `**/*.${ext}`)
   ];
   const filesTypeAware = options.filesTypeAware ?? [GLOB_TS, GLOB_TSX];
+  const ignoresTypeAware = options.ignoresTypeAware ?? [
+    `${GLOB_MARKDOWN}/**`
+  ];
   const tsconfigPath = options?.tsconfigPath ? toArray(options.tsconfigPath) : void 0;
   const isTypeAware = !!tsconfigPath;
   const typeAwareRules = {
     "dot-notation": OFF,
     "no-implied-eval": OFF,
-    "no-throw-literal": OFF,
     "ts/await-thenable": ERROR,
     "ts/dot-notation": [ERROR, { allowKeywords: true }],
     "ts/no-floating-promises": ERROR,
@@ -2284,16 +1545,18 @@ async function typescript(options = {}) {
     "ts/no-implied-eval": ERROR,
     // Temporary turning it off due to performance
     "ts/no-misused-promises": OFF,
-    "ts/no-throw-literal": ERROR,
     "ts/no-unnecessary-type-assertion": ERROR,
     "ts/no-unsafe-argument": ERROR,
     "ts/no-unsafe-assignment": ERROR,
     "ts/no-unsafe-call": ERROR,
     "ts/no-unsafe-member-access": ERROR,
     "ts/no-unsafe-return": ERROR,
+    "ts/promise-function-async": "error",
     "ts/restrict-plus-operands": ERROR,
     "ts/restrict-template-expressions": ERROR,
-    "ts/strict-boolean-expressions": ERROR,
+    "ts/return-await": [ERROR, "in-try-catch"],
+    "ts/strict-boolean-expressions": [ERROR, { allowNullableBoolean: true, allowNullableObject: true }],
+    "ts/switch-exhaustiveness-check": ERROR,
     "ts/unbound-method": ERROR
   };
   const [
@@ -2313,7 +1576,10 @@ async function typescript(options = {}) {
           extraFileExtensions: componentExts.map((ext) => `.${ext}`),
           sourceType: "module",
           ...typeAware ? {
-            project: tsconfigPath,
+            projectService: {
+              allowDefaultProject: ["./*.js"],
+              defaultProject: tsconfigPath
+            },
             tsconfigRootDir: import_node_process.default.cwd()
           } : {},
           ...parserOptions
@@ -2333,9 +1599,11 @@ async function typescript(options = {}) {
     },
     // assign type-aware parser for type-aware files and type-unaware parser for the rest
     ...isTypeAware ? [
-      makeParser({ files: filesTypeAware, typeAware: true }),
+      makeParser({ files: filesTypeAware, ignores: ignoresTypeAware, typeAware: true }),
       makeParser({ files, ignores: filesTypeAware, typeAware: false })
-    ] : [makeParser({ files, typeAware: false })],
+    ] : [
+      makeParser({ files, typeAware: false })
+    ],
     {
       files,
       name: "vinicunca/typescript/rules",
@@ -2357,7 +1625,6 @@ async function typescript(options = {}) {
         "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"],
         "ts/consistent-type-imports": [ERROR, { disallowTypeAnnotations: false, prefer: "type-imports" }],
         "ts/explicit-function-return-type": OFF,
@@ -2398,8 +1665,14 @@ async function typescript(options = {}) {
         ...overrides
       }
     },
+    ...isTypeAware ? [{
+      files: filesTypeAware,
+      ignores: ignoresTypeAware,
+      name: "vinicunca/typescript/rules-type-aware",
+      rules: typeAwareRules
+    }] : [],
     {
-      files: ["**/*.d.ts"],
+      files: ["**/*.d.?([cm])ts"],
       name: "vinicunca/typescript/disables/dts",
       rules: {
         "eslint-comments/no-unlimited-disable": OFF,
@@ -2494,7 +1767,7 @@ async function vue(options = {}) {
   const sfcBlocks = options.sfcBlocks === true ? {} : options.sfcBlocks ?? {};
   const {
     indent = 2
-  } = isBoolean(stylistic2) ? {} : stylistic2;
+  } = e(stylistic2) ? {} : stylistic2;
   const [
     pluginVue,
     parserVue,
@@ -2645,7 +1918,7 @@ async function yaml(options = {}) {
   const {
     indent = 2,
     quotes = "single"
-  } = isBoolean(stylistic2) ? {} : stylistic2;
+  } = e(stylistic2) ? {} : stylistic2;
   const [
     pluginYaml,
     parserYaml
@@ -2726,7 +1999,8 @@ function vinicuncaESLint(options = {}, ...userConfigs) {
     autoRenamePlugins = true,
     componentExts = [],
     gitignore: enableGitignore = true,
-    isInEditor = !!((import_node_process2.default.env.VSCODE_PID || import_node_process2.default.env.JETBRAINS_IDE || import_node_process2.default.env.VIM) && !import_node_process2.default.env.CI),
+    isInEditor = !!((import_node_process2.default.env.VSCODE_PID || import_node_process2.default.env.VSCODE_CWD || import_node_process2.default.env.JETBRAINS_IDE || import_node_process2.default.env.VIM || import_node_process2.default.env.NVIM) && !import_node_process2.default.env.CI),
+    jsx: enableJsx = true,
     react: enableReact = false,
     regexp: enableRegexp = true,
     typescript: enableTypeScript = (0, import_local_pkg.isPackageExists)("typescript"),
@@ -2736,19 +2010,22 @@ function vinicuncaESLint(options = {}, ...userConfigs) {
   let stylisticOptions = {};
   if (options.stylistic === false) {
     stylisticOptions = false;
-  } else if (isObject(options.stylistic)) {
+  } else if (r(options.stylistic)) {
     stylisticOptions = {
       ...options.stylistic,
       jsx: options.jsx ?? true
     };
   }
+  if (stylisticOptions && !("jsx" in stylisticOptions)) {
+    stylisticOptions.jsx = enableJsx;
+  }
   const configs2 = [];
   if (enableGitignore) {
     if (typeof enableGitignore !== "boolean") {
-      configs2.push(interopDefault(import("eslint-config-flat-gitignore")).then((r) => [r(enableGitignore)]));
+      configs2.push(interopDefault(import("eslint-config-flat-gitignore")).then((r2) => [r2(enableGitignore)]));
     } else {
       if (import_node_fs.default.existsSync(".gitignore")) {
-        configs2.push(interopDefault(import("eslint-config-flat-gitignore")).then((r) => [r()]));
+        configs2.push(interopDefault(import("eslint-config-flat-gitignore")).then((r2) => [r2()]));
       }
     }
   }
@@ -2773,6 +2050,9 @@ function vinicuncaESLint(options = {}, ...userConfigs) {
   if (enableVue) {
     componentExts.push("vue");
   }
+  if (enableJsx) {
+    configs2.push(jsx());
+  }
   if (enableTypeScript) {
     configs2.push(typescript({
       ...typescriptOptions,
@@ -2875,7 +2155,7 @@ function getOverrides(options, key) {
   };
 }
 function resolveSubOptions(options, key) {
-  return isBoolean(options[key]) ? {} : options[key] || {};
+  return e(options[key]) ? {} : options[key] || {};
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -2913,6 +2193,7 @@ function resolveSubOptions(options, key) {
   javascript,
   jsdoc,
   jsonc,
+  jsx,
   markdown,
   node,
   parserPlain,