@sapphire/iterator-utilities 1.0.3-next.fc35dd86 → 2.0.0-next.1e7d2dec

package/dist/esm/lib/maxBy.mjs

@@ -0,0 +1,24 @@
+import { __name } from '../chunk-PAWJFY3S.mjs';
+import { assertFunction } from './shared/_assertFunction.mjs';
+import { compareIteratorElements, orderingIsLess } from './shared/_compare.mjs';
+import { toIterableIterator } from './toIterableIterator.mjs';
+
+function maxBy(iterable, comparator) {
+  comparator = assertFunction(comparator);
+  const iterator = toIterableIterator(iterable);
+  const first = iterator.next();
+  if (first.done) return null;
+  let maximum = first.value;
+  for (const value of iterator) {
+    const comparison = compareIteratorElements(value, maximum, comparator);
+    if (!orderingIsLess(comparison)) {
+      maximum = value;
+    }
+  }
+  return maximum;
+}
+__name(maxBy, "maxBy");
+
+export { maxBy };
+//# sourceMappingURL=maxBy.mjs.map
+//# sourceMappingURL=maxBy.mjs.map

package/dist/esm/lib/maxBy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/maxBy.ts"],"names":[],"mappings":";;;;;AAgCO,SAAS,KAAA,CACf,UACA,UACqB,EAAA;AACrB,EAAA,UAAA,GAAa,eAAe,UAAU,CAAA,CAAA;AAEtC,EAAM,MAAA,QAAA,GAAW,mBAAmB,QAAQ,CAAA,CAAA;AAC5C,EAAM,MAAA,KAAA,GAAQ,SAAS,IAAK,EAAA,CAAA;AAC5B,EAAI,IAAA,KAAA,CAAM,MAAa,OAAA,IAAA,CAAA;AAEvB,EAAA,IAAI,UAAU,KAAM,CAAA,KAAA,CAAA;AACpB,EAAA,KAAA,MAAW,SAAS,QAAU,EAAA;AAC7B,IAAA,MAAM,UAAa,GAAA,uBAAA,CAAqC,KAAO,EAAA,OAAA,EAAS,UAAU,CAAA,CAAA;AAClF,IAAI,IAAA,CAAC,cAAe,CAAA,UAAU,CAAG,EAAA;AAChC,MAAU,OAAA,GAAA,KAAA,CAAA;AAAA,KACX;AAAA,GACD;AAEA,EAAO,OAAA,OAAA,CAAA;AACR,CAAA;AAnBgB,MAAA,CAAA,KAAA,EAAA,OAAA,CAAA","file":"maxBy.mjs","sourcesContent":["import type { IterableResolvable } from './from';\nimport type { max } from './max';\nimport type { maxByKey } from './maxByKey';\nimport { assertFunction } from './shared/_assertFunction';\nimport { compareIteratorElements, orderingIsLess, type CompareByComparator } from './shared/_compare';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Returns the element that gives the maximum value with respect to the specified comparison function.\n *\n * If several elements are equally maximum, the last element is returned. If the iterator is empty, `null` is returned.\n *\n * @seealso {@link max} for a version that uses the default comparator.\n * @seealso {@link maxByKey} for a version that allows custom key extractors.\n *\n * @param iterable An iterator of number values to determine the maximum value of.\n * @param comparator A function to execute for each element produced by the iterator. It should return a number value.\n * @returns The element that gives the maximum value from the specified function, or `null` if the iterator is empty.\n *\n * @example\n * ```typescript\n * import { ascNumber, maxBy } from '@sapphire/iterator-utilities';\n *\n * const iterable = [-3, 0, 1, 5, -10];\n * console.log(maxBy(iterable, ascNumber));\n * // Output: 5\n * ```\n *\n * @remarks\n *\n * This function consumes the entire iterator.\n */\nexport function maxBy<const ElementType>(\n\titerable: IterableResolvable<ElementType>,\n\tcomparator: CompareByComparator<ElementType>\n): ElementType | null {\n\tcomparator = assertFunction(comparator);\n\n\tconst iterator = toIterableIterator(iterable);\n\tconst first = iterator.next();\n\tif (first.done) return null;\n\n\tlet maximum = first.value;\n\tfor (const value of iterator) {\n\t\tconst comparison = compareIteratorElements<ElementType>(value, maximum, comparator);\n\t\tif (!orderingIsLess(comparison)) {\n\t\t\tmaximum = value;\n\t\t}\n\t}\n\n\treturn maximum;\n}\n"]}

package/dist/esm/lib/maxByKey.d.mts

@@ -0,0 +1,32 @@
+import { IterableResolvable } from './from.mjs';
+import { CompareByComparator } from './shared/_compare.mjs';
+
+/**
+ * Returns the element that gives the maximum value from the specified function.
+ *
+ * If several elements are equally maximum, the last element is returned. If the iterator is empty, `null` is returned.
+ *
+ * @seealso {@link max} for a version that uses the default comparator.
+ * @seealso {@link maxBy} for a version that allows custom comparators.
+ *
+ * @param iterable An iterator of number values to determine the maximum value of.
+ * @param callbackFn A function to execute for each element produced by the iterator, producing a key to compare with.
+ * @param comparator A function to execute for each element produced by the iterator. It should return a number value.
+ * @returns The element that gives the maximum value from the specified function, or `null` if the iterator is empty.
+ *
+ * @example
+ * ```typescript
+ * import { maxByKey } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = [-3, 0, 1, 5, -10];
+ * console.log(maxByKey(iterable, (value) => Math.abs(value)));
+ * // Output: -10
+ * ```
+ *
+ * @remarks
+ *
+ * This function consumes the entire iterator.
+ */
+declare function maxByKey<const ElementType, const MappedType>(iterable: IterableResolvable<ElementType>, callbackFn: (element: ElementType, index: number) => MappedType, comparator?: CompareByComparator<MappedType>): ElementType | null;
+
+export { maxByKey };

package/dist/esm/lib/maxByKey.mjs

@@ -0,0 +1,29 @@
+import { __name } from '../chunk-PAWJFY3S.mjs';
+import { assertFunction } from './shared/_assertFunction.mjs';
+import { compareIteratorElements, orderingIsGreater } from './shared/_compare.mjs';
+import { defaultCompare } from './shared/comparators.mjs';
+import { toIterableIterator } from './toIterableIterator.mjs';
+
+function maxByKey(iterable, callbackFn, comparator = defaultCompare) {
+  callbackFn = assertFunction(callbackFn);
+  const iterator = toIterableIterator(iterable);
+  const first = iterator.next();
+  if (first.done) return null;
+  let maximum = first.value;
+  let maximumKey = callbackFn(maximum, 0);
+  let index = 1;
+  for (const value of iterator) {
+    const key = callbackFn(value, index++);
+    const comparison = compareIteratorElements(maximumKey, key, comparator);
+    if (!orderingIsGreater(comparison)) {
+      maximum = value;
+      maximumKey = key;
+    }
+  }
+  return maximum;
+}
+__name(maxByKey, "maxByKey");
+
+export { maxByKey };
+//# sourceMappingURL=maxByKey.mjs.map
+//# sourceMappingURL=maxByKey.mjs.map

package/dist/esm/lib/maxByKey.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/maxByKey.ts"],"names":[],"mappings":";;;;;;AAkCO,SAAS,QACf,CAAA,QAAA,EACA,UACA,EAAA,UAAA,GAA8C,cACzB,EAAA;AACrB,EAAA,UAAA,GAAa,eAAe,UAAU,CAAA,CAAA;AAEtC,EAAM,MAAA,QAAA,GAAW,mBAAmB,QAAQ,CAAA,CAAA;AAC5C,EAAM,MAAA,KAAA,GAAQ,SAAS,IAAK,EAAA,CAAA;AAC5B,EAAI,IAAA,KAAA,CAAM,MAAa,OAAA,IAAA,CAAA;AAEvB,EAAA,IAAI,UAAU,KAAM,CAAA,KAAA,CAAA;AACpB,EAAI,IAAA,UAAA,GAAa,UAAW,CAAA,OAAA,EAAS,CAAC,CAAA,CAAA;AACtC,EAAA,IAAI,KAAQ,GAAA,CAAA,CAAA;AACZ,EAAA,KAAA,MAAW,SAAS,QAAU,EAAA;AAC7B,IAAM,MAAA,GAAA,GAAM,UAAW,CAAA,KAAA,EAAO,KAAO,EAAA,CAAA,CAAA;AACrC,IAAA,MAAM,UAAa,GAAA,uBAAA,CAAoC,UAAY,EAAA,GAAA,EAAK,UAAU,CAAA,CAAA;AAElF,IAAI,IAAA,CAAC,iBAAkB,CAAA,UAAU,CAAG,EAAA;AACnC,MAAU,OAAA,GAAA,KAAA,CAAA;AACV,MAAa,UAAA,GAAA,GAAA,CAAA;AAAA,KACd;AAAA,GACD;AAEA,EAAO,OAAA,OAAA,CAAA;AACR,CAAA;AAzBgB,MAAA,CAAA,QAAA,EAAA,UAAA,CAAA","file":"maxByKey.mjs","sourcesContent":["import type { IterableResolvable } from './from';\nimport type { max } from './max';\nimport type { maxBy } from './maxBy';\nimport { assertFunction } from './shared/_assertFunction';\nimport { compareIteratorElements, orderingIsGreater, type CompareByComparator } from './shared/_compare';\nimport { defaultCompare } from './shared/comparators';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Returns the element that gives the maximum value from the specified function.\n *\n * If several elements are equally maximum, the last element is returned. If the iterator is empty, `null` is returned.\n *\n * @seealso {@link max} for a version that uses the default comparator.\n * @seealso {@link maxBy} for a version that allows custom comparators.\n *\n * @param iterable An iterator of number values to determine the maximum value of.\n * @param callbackFn A function to execute for each element produced by the iterator, producing a key to compare with.\n * @param comparator A function to execute for each element produced by the iterator. It should return a number value.\n * @returns The element that gives the maximum value from the specified function, or `null` if the iterator is empty.\n *\n * @example\n * ```typescript\n * import { maxByKey } from '@sapphire/iterator-utilities';\n *\n * const iterable = [-3, 0, 1, 5, -10];\n * console.log(maxByKey(iterable, (value) => Math.abs(value)));\n * // Output: -10\n * ```\n *\n * @remarks\n *\n * This function consumes the entire iterator.\n */\nexport function maxByKey<const ElementType, const MappedType>(\n\titerable: IterableResolvable<ElementType>,\n\tcallbackFn: (element: ElementType, index: number) => MappedType,\n\tcomparator: CompareByComparator<MappedType> = defaultCompare\n): ElementType | null {\n\tcallbackFn = assertFunction(callbackFn);\n\n\tconst iterator = toIterableIterator(iterable);\n\tconst first = iterator.next();\n\tif (first.done) return null;\n\n\tlet maximum = first.value;\n\tlet maximumKey = callbackFn(maximum, 0);\n\tlet index = 1;\n\tfor (const value of iterator) {\n\t\tconst key = callbackFn(value, index++);\n\t\tconst comparison = compareIteratorElements<MappedType>(maximumKey, key, comparator);\n\n\t\tif (!orderingIsGreater(comparison)) {\n\t\t\tmaximum = value;\n\t\t\tmaximumKey = key;\n\t\t}\n\t}\n\n\treturn maximum;\n}\n"]}

package/dist/esm/lib/min.d.mts

@@ -1,8 +1,13 @@
 import { IterableResolvable } from './from.mjs';
-import { NumberResolvable } from './shared/_toNumberOrThrow.mjs';
 
 /**
- * Consumes the iterable and returns the lowest number element. If the iterable is empty, or contains only non-number values, it returns `null`.
+ * Consumes the iterable and returns the lowest number element. If the iterable is empty, it returns `null`.
+ *
+ * This function uses the default comparator (lexicographically), which means it will compare the elements as strings.
+ * If this is undesirable, use {@link minBy} instead.
+ *
+ * @seealso {@link minBy} for a version that allows custom comparators.
+ * @seealso {@link minByKey} for a version that allows custom key extractors.
  *
  * @param iterable An iterator of number values to determine the minimum value of.
  * @returns The minimum value in the input iterator, or `null` if the iterator is empty or contains only non-number values.
@@ -20,6 +25,6 @@ import { NumberResolvable } from './shared/_toNumberOrThrow.mjs';
  *
  * This function consumes the entire iterator.
  */
-declare function min(iterable: IterableResolvable<NumberResolvable>): number | null;
+declare function min<const ElementType>(iterable: IterableResolvable<ElementType>): ElementType | null;
 
 export { min };

package/dist/esm/lib/min.mjs

@@ -1,13 +1,9 @@
 import { __name } from '../chunk-PAWJFY3S.mjs';
-import { map } from './map.mjs';
-import { toNumberOrThrow } from './shared/_toNumberOrThrow.mjs';
+import { minBy } from './minBy.mjs';
+import { defaultCompare } from './shared/comparators.mjs';
 
 function min(iterable) {
-  let min2 = null;
-  for (const value of map(iterable, toNumberOrThrow)) {
-    if (min2 === null || value < min2) min2 = value;
-  }
-  return min2;
+  return minBy(iterable, defaultCompare);
 }
 __name(min, "min");
 

package/dist/esm/lib/min.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/min.ts"],"names":["min"],"mappings":";;;;AAuBO,SAAS,IAAI,QAA+D,EAAA;AAClF,EAAA,IAAIA,IAAqB,GAAA,IAAA,CAAA;AACzB,EAAA,KAAA,MAAW,KAAS,IAAA,GAAA,CAAI,QAAU,EAAA,eAAe,CAAG,EAAA;AACnD,IAAA,IAAIA,IAAQ,KAAA,IAAA,IAAQ,KAAQA,GAAAA,IAAAA,EAAKA,IAAM,GAAA,KAAA,CAAA;AAAA,GACxC;AAEA,EAAOA,OAAAA,IAAAA,CAAAA;AACR,CAAA;AAPgB,MAAA,CAAA,GAAA,EAAA,KAAA,CAAA","file":"min.mjs","sourcesContent":["import type { IterableResolvable } from './from';\nimport { map } from './map';\nimport { toNumberOrThrow, type NumberResolvable } from './shared/_toNumberOrThrow';\n\n/**\n * Consumes the iterable and returns the lowest number element. If the iterable is empty, or contains only non-number values, it returns `null`.\n *\n * @param iterable An iterator of number values to determine the minimum value of.\n * @returns The minimum value in the input iterator, or `null` if the iterator is empty or contains only non-number values.\n *\n * @example\n * ```typescript\n * import { min } from '@sapphire/iterator-utilities';\n *\n * const iterable = [1, 2, 3, 4, 5];\n * console.log(min(iterable));\n * // Output: 1\n * ```\n *\n * @remarks\n *\n * This function consumes the entire iterator.\n */\nexport function min(iterable: IterableResolvable<NumberResolvable>): number | null {\n\tlet min: number | null = null;\n\tfor (const value of map(iterable, toNumberOrThrow)) {\n\t\tif (min === null || value < min) min = value;\n\t}\n\n\treturn min;\n}\n"]}
+{"version":3,"sources":["../../../src/lib/min.ts"],"names":[],"mappings":";;;;AA8BO,SAAS,IAAuB,QAA+D,EAAA;AACrG,EAAO,OAAA,KAAA,CAAM,UAAU,cAAc,CAAA,CAAA;AACtC,CAAA;AAFgB,MAAA,CAAA,GAAA,EAAA,KAAA,CAAA","file":"min.mjs","sourcesContent":["import type { IterableResolvable } from './from';\nimport { minBy } from './minBy';\nimport type { minByKey } from './minByKey';\nimport { defaultCompare } from './shared/comparators';\n\n/**\n * Consumes the iterable and returns the lowest number element. If the iterable is empty, it returns `null`.\n *\n * This function uses the default comparator (lexicographically), which means it will compare the elements as strings.\n * If this is undesirable, use {@link minBy} instead.\n *\n * @seealso {@link minBy} for a version that allows custom comparators.\n * @seealso {@link minByKey} for a version that allows custom key extractors.\n *\n * @param iterable An iterator of number values to determine the minimum value of.\n * @returns The minimum value in the input iterator, or `null` if the iterator is empty or contains only non-number values.\n *\n * @example\n * ```typescript\n * import { min } from '@sapphire/iterator-utilities';\n *\n * const iterable = [1, 2, 3, 4, 5];\n * console.log(min(iterable));\n * // Output: 1\n * ```\n *\n * @remarks\n *\n * This function consumes the entire iterator.\n */\nexport function min<const ElementType>(iterable: IterableResolvable<ElementType>): ElementType | null {\n\treturn minBy(iterable, defaultCompare);\n}\n"]}

package/dist/esm/lib/minBy.d.mts

@@ -0,0 +1,31 @@
+import { IterableResolvable } from './from.mjs';
+import { CompareByComparator } from './shared/_compare.mjs';
+
+/**
+ * Returns the element that gives the minimum value with respect to the specified comparison function.
+ *
+ * If several elements are equally minimum, the last element is returned. If the iterator is empty, `null` is returned.
+ *
+ * @seealso {@link min} for a version that uses the default comparator.
+ * @seealso {@link minByKey} for a version that allows custom key extractors.
+ *
+ * @param iterable An iterator of number values to determine the minimum value of.
+ * @param callbackFn A function to execute for each element produced by the iterator. It should return a number value.
+ * @returns The element that gives the minimum value from the specified function, or `null` if the iterator is empty.
+ *
+ * @example
+ * ```typescript
+ * import { ascNumber, minBy } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = [-3, 0, 1, 5, -10];
+ * console.log(minBy(iterable, ascNumber));
+ * // Output: -10
+ * ```
+ *
+ * @remarks
+ *
+ * This function consumes the entire iterator.
+ */
+declare function minBy<const ElementType>(iterable: IterableResolvable<ElementType>, comparator: CompareByComparator<ElementType>): ElementType | null;
+
+export { minBy };

package/dist/esm/lib/minBy.mjs

@@ -0,0 +1,24 @@
+import { __name } from '../chunk-PAWJFY3S.mjs';
+import { assertFunction } from './shared/_assertFunction.mjs';
+import { compareIteratorElements, orderingIsGreater } from './shared/_compare.mjs';
+import { toIterableIterator } from './toIterableIterator.mjs';
+
+function minBy(iterable, comparator) {
+  comparator = assertFunction(comparator);
+  const iterator = toIterableIterator(iterable);
+  const first = iterator.next();
+  if (first.done) return null;
+  let minimum = first.value;
+  for (const value of iterator) {
+    const comparison = compareIteratorElements(value, minimum, comparator);
+    if (!orderingIsGreater(comparison)) {
+      minimum = value;
+    }
+  }
+  return minimum;
+}
+__name(minBy, "minBy");
+
+export { minBy };
+//# sourceMappingURL=minBy.mjs.map
+//# sourceMappingURL=minBy.mjs.map

package/dist/esm/lib/minBy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/minBy.ts"],"names":[],"mappings":";;;;;AAgCO,SAAS,KAAA,CACf,UACA,UACqB,EAAA;AACrB,EAAA,UAAA,GAAa,eAAe,UAAU,CAAA,CAAA;AAEtC,EAAM,MAAA,QAAA,GAAW,mBAAmB,QAAQ,CAAA,CAAA;AAC5C,EAAM,MAAA,KAAA,GAAQ,SAAS,IAAK,EAAA,CAAA;AAC5B,EAAI,IAAA,KAAA,CAAM,MAAa,OAAA,IAAA,CAAA;AAEvB,EAAA,IAAI,UAAU,KAAM,CAAA,KAAA,CAAA;AACpB,EAAA,KAAA,MAAW,SAAS,QAAU,EAAA;AAC7B,IAAA,MAAM,UAAa,GAAA,uBAAA,CAAqC,KAAO,EAAA,OAAA,EAAS,UAAU,CAAA,CAAA;AAElF,IAAI,IAAA,CAAC,iBAAkB,CAAA,UAAU,CAAG,EAAA;AACnC,MAAU,OAAA,GAAA,KAAA,CAAA;AAAA,KACX;AAAA,GACD;AAEA,EAAO,OAAA,OAAA,CAAA;AACR,CAAA;AApBgB,MAAA,CAAA,KAAA,EAAA,OAAA,CAAA","file":"minBy.mjs","sourcesContent":["import type { IterableResolvable } from './from';\nimport type { min } from './min';\nimport type { minByKey } from './minByKey';\nimport { assertFunction } from './shared/_assertFunction';\nimport { compareIteratorElements, orderingIsGreater, type CompareByComparator } from './shared/_compare';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Returns the element that gives the minimum value with respect to the specified comparison function.\n *\n * If several elements are equally minimum, the last element is returned. If the iterator is empty, `null` is returned.\n *\n * @seealso {@link min} for a version that uses the default comparator.\n * @seealso {@link minByKey} for a version that allows custom key extractors.\n *\n * @param iterable An iterator of number values to determine the minimum value of.\n * @param callbackFn A function to execute for each element produced by the iterator. It should return a number value.\n * @returns The element that gives the minimum value from the specified function, or `null` if the iterator is empty.\n *\n * @example\n * ```typescript\n * import { ascNumber, minBy } from '@sapphire/iterator-utilities';\n *\n * const iterable = [-3, 0, 1, 5, -10];\n * console.log(minBy(iterable, ascNumber));\n * // Output: -10\n * ```\n *\n * @remarks\n *\n * This function consumes the entire iterator.\n */\nexport function minBy<const ElementType>(\n\titerable: IterableResolvable<ElementType>,\n\tcomparator: CompareByComparator<ElementType>\n): ElementType | null {\n\tcomparator = assertFunction(comparator);\n\n\tconst iterator = toIterableIterator(iterable);\n\tconst first = iterator.next();\n\tif (first.done) return null;\n\n\tlet minimum = first.value;\n\tfor (const value of iterator) {\n\t\tconst comparison = compareIteratorElements<ElementType>(value, minimum, comparator);\n\n\t\tif (!orderingIsGreater(comparison)) {\n\t\t\tminimum = value;\n\t\t}\n\t}\n\n\treturn minimum;\n}\n"]}

package/dist/esm/lib/minByKey.d.mts

@@ -0,0 +1,31 @@
+import { IterableResolvable } from './from.mjs';
+import { CompareByComparator } from './shared/_compare.mjs';
+
+/**
+ * Returns the element that gives the minimum value from the specified function.
+ *
+ * If several elements are equally minimum, the last element is returned. If the iterator is empty, `null` is returned.
+ *
+ * @seealso {@link min} for a version that uses the default comparator.
+ * @seealso {@link minBy} for a version that allows custom comparators.
+ *
+ * @param iterable An iterator of number values to determine the minimum value of.
+ * @param callbackFn A function to execute for each element produced by the iterator. It should return a number value.
+ * @returns The element that gives the minimum value from the specified function, or `null` if the iterator is empty.
+ *
+ * @example
+ * ```typescript
+ * import { minByKey } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = [-3, 0, 1, 5, -10];
+ * console.log(minByKey(iterable, (value) => Math.abs(value)));
+ * // Output: 0
+ * ```
+ *
+ * @remarks
+ *
+ * This function consumes the entire iterator.
+ */
+declare function minByKey<const ElementType, const MappedType>(iterable: IterableResolvable<ElementType>, callbackFn: (element: ElementType, index: number) => MappedType, comparator?: CompareByComparator<MappedType>): ElementType | null;
+
+export { minByKey };

package/dist/esm/lib/minByKey.mjs

@@ -0,0 +1,29 @@
+import { __name } from '../chunk-PAWJFY3S.mjs';
+import { assertFunction } from './shared/_assertFunction.mjs';
+import { compareIteratorElements, orderingIsLess } from './shared/_compare.mjs';
+import { defaultCompare } from './shared/comparators.mjs';
+import { toIterableIterator } from './toIterableIterator.mjs';
+
+function minByKey(iterable, callbackFn, comparator = defaultCompare) {
+  callbackFn = assertFunction(callbackFn);
+  const iterator = toIterableIterator(iterable);
+  const first = iterator.next();
+  if (first.done) return null;
+  let minimum = first.value;
+  let minimumKey = callbackFn(minimum, 0);
+  let index = 1;
+  for (const value of iterator) {
+    const key = callbackFn(value, index++);
+    const comparison = compareIteratorElements(minimumKey, key, comparator);
+    if (!orderingIsLess(comparison)) {
+      minimum = value;
+      minimumKey = key;
+    }
+  }
+  return minimum;
+}
+__name(minByKey, "minByKey");
+
+export { minByKey };
+//# sourceMappingURL=minByKey.mjs.map
+//# sourceMappingURL=minByKey.mjs.map

package/dist/esm/lib/minByKey.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/minByKey.ts"],"names":[],"mappings":";;;;;;AAiCO,SAAS,QACf,CAAA,QAAA,EACA,UACA,EAAA,UAAA,GAA8C,cACzB,EAAA;AACrB,EAAA,UAAA,GAAa,eAAe,UAAU,CAAA,CAAA;AAEtC,EAAM,MAAA,QAAA,GAAW,mBAAmB,QAAQ,CAAA,CAAA;AAC5C,EAAM,MAAA,KAAA,GAAQ,SAAS,IAAK,EAAA,CAAA;AAC5B,EAAI,IAAA,KAAA,CAAM,MAAa,OAAA,IAAA,CAAA;AAEvB,EAAA,IAAI,UAAU,KAAM,CAAA,KAAA,CAAA;AACpB,EAAI,IAAA,UAAA,GAAa,UAAW,CAAA,OAAA,EAAS,CAAC,CAAA,CAAA;AACtC,EAAA,IAAI,KAAQ,GAAA,CAAA,CAAA;AACZ,EAAA,KAAA,MAAW,SAAS,QAAU,EAAA;AAC7B,IAAM,MAAA,GAAA,GAAM,UAAW,CAAA,KAAA,EAAO,KAAO,EAAA,CAAA,CAAA;AACrC,IAAA,MAAM,UAAa,GAAA,uBAAA,CAAoC,UAAY,EAAA,GAAA,EAAK,UAAU,CAAA,CAAA;AAElF,IAAI,IAAA,CAAC,cAAe,CAAA,UAAU,CAAG,EAAA;AAChC,MAAU,OAAA,GAAA,KAAA,CAAA;AACV,MAAa,UAAA,GAAA,GAAA,CAAA;AAAA,KACd;AAAA,GACD;AAEA,EAAO,OAAA,OAAA,CAAA;AACR,CAAA;AAzBgB,MAAA,CAAA,QAAA,EAAA,UAAA,CAAA","file":"minByKey.mjs","sourcesContent":["import type { IterableResolvable } from './from';\nimport type { min } from './min';\nimport type { minBy } from './minBy';\nimport { assertFunction } from './shared/_assertFunction';\nimport { compareIteratorElements, orderingIsLess, type CompareByComparator } from './shared/_compare';\nimport { defaultCompare } from './shared/comparators';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Returns the element that gives the minimum value from the specified function.\n *\n * If several elements are equally minimum, the last element is returned. If the iterator is empty, `null` is returned.\n *\n * @seealso {@link min} for a version that uses the default comparator.\n * @seealso {@link minBy} for a version that allows custom comparators.\n *\n * @param iterable An iterator of number values to determine the minimum value of.\n * @param callbackFn A function to execute for each element produced by the iterator. It should return a number value.\n * @returns The element that gives the minimum value from the specified function, or `null` if the iterator is empty.\n *\n * @example\n * ```typescript\n * import { minByKey } from '@sapphire/iterator-utilities';\n *\n * const iterable = [-3, 0, 1, 5, -10];\n * console.log(minByKey(iterable, (value) => Math.abs(value)));\n * // Output: 0\n * ```\n *\n * @remarks\n *\n * This function consumes the entire iterator.\n */\nexport function minByKey<const ElementType, const MappedType>(\n\titerable: IterableResolvable<ElementType>,\n\tcallbackFn: (element: ElementType, index: number) => MappedType,\n\tcomparator: CompareByComparator<MappedType> = defaultCompare\n): ElementType | null {\n\tcallbackFn = assertFunction(callbackFn);\n\n\tconst iterator = toIterableIterator(iterable);\n\tconst first = iterator.next();\n\tif (first.done) return null;\n\n\tlet minimum = first.value;\n\tlet minimumKey = callbackFn(minimum, 0);\n\tlet index = 1;\n\tfor (const value of iterator) {\n\t\tconst key = callbackFn(value, index++);\n\t\tconst comparison = compareIteratorElements<MappedType>(minimumKey, key, comparator);\n\n\t\tif (!orderingIsLess(comparison)) {\n\t\t\tminimum = value;\n\t\t\tminimumKey = key;\n\t\t}\n\t}\n\n\treturn minimum;\n}\n"]}

package/dist/esm/lib/notEqual.d.mts

@@ -0,0 +1,26 @@
+import { IterableResolvable } from './from.mjs';
+
+/**
+ * Determines if the elements of both iterators are not equal.
+ *
+ * @param iterable The iterator to compare.
+ * @param other The iterator to compare against.
+ * @returns Whether the two iterators are not equal.
+ *
+ * @example
+ * ```typescript
+ * import { notEqual } from '@sapphire/iterator-utilities';
+ *
+ * console.log(notEqual([1], [1]));
+ * // Output: false
+ * console.log(notEqual([1], [1, 2]));
+ * // Output: true
+ * ```
+ *
+ * @remarks
+ *
+ * This function consumes the entire iterator.
+ */
+declare function notEqual<const ElementType>(iterable: IterableResolvable<ElementType>, other: IterableResolvable<ElementType>): boolean;
+
+export { notEqual as ne, notEqual };

package/dist/esm/lib/notEqual.mjs

@@ -0,0 +1,11 @@
+import { __name } from '../chunk-PAWJFY3S.mjs';
+import { equal } from './equal.mjs';
+
+function notEqual(iterable, other) {
+  return !equal(iterable, other);
+}
+__name(notEqual, "notEqual");
+
+export { notEqual as ne, notEqual };
+//# sourceMappingURL=notEqual.mjs.map
+//# sourceMappingURL=notEqual.mjs.map

package/dist/esm/lib/notEqual.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/notEqual.ts"],"names":[],"mappings":";;;AAwBO,SAAS,QAAA,CAA4B,UAA2C,KAAiD,EAAA;AACvI,EAAO,OAAA,CAAC,KAAM,CAAA,QAAA,EAAU,KAAK,CAAA,CAAA;AAC9B,CAAA;AAFgB,MAAA,CAAA,QAAA,EAAA,UAAA,CAAA","file":"notEqual.mjs","sourcesContent":["import { equal } from './equal';\nimport type { IterableResolvable } from './from';\n\n/**\n * Determines if the elements of both iterators are not equal.\n *\n * @param iterable The iterator to compare.\n * @param other The iterator to compare against.\n * @returns Whether the two iterators are not equal.\n *\n * @example\n * ```typescript\n * import { notEqual } from '@sapphire/iterator-utilities';\n *\n * console.log(notEqual([1], [1]));\n * // Output: false\n * console.log(notEqual([1], [1, 2]));\n * // Output: true\n * ```\n *\n * @remarks\n *\n * This function consumes the entire iterator.\n */\nexport function notEqual<const ElementType>(iterable: IterableResolvable<ElementType>, other: IterableResolvable<ElementType>): boolean {\n\treturn !equal(iterable, other);\n}\n\nexport { notEqual as ne };\n"]}

package/dist/esm/lib/nth.d.mts

@@ -0,0 +1,2 @@
+export { at as nth } from './at.mjs';
+import './from.mjs';

package/dist/esm/lib/nth.mjs

@@ -0,0 +1,4 @@
+import '../chunk-PAWJFY3S.mjs';
+export { at as nth } from './at.mjs';
+//# sourceMappingURL=nth.mjs.map
+//# sourceMappingURL=nth.mjs.map

package/dist/esm/lib/nth.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"nth.mjs","sourcesContent":[]}

package/dist/esm/lib/position.d.mts

@@ -0,0 +1,2 @@
+export { indexOf as position } from './indexOf.mjs';
+import './from.mjs';

package/dist/esm/lib/position.mjs

@@ -0,0 +1,4 @@
+import '../chunk-PAWJFY3S.mjs';
+export { indexOf as position } from './indexOf.mjs';
+//# sourceMappingURL=position.mjs.map
+//# sourceMappingURL=position.mjs.map

package/dist/esm/lib/position.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"position.mjs","sourcesContent":[]}

package/dist/esm/lib/reverse.mjs

@@ -1,11 +1,8 @@
 import { __name } from '../chunk-PAWJFY3S.mjs';
-import { toIterableIterator } from './toIterableIterator.mjs';
+import { collect } from './collect.mjs';
 
 function* reverse(iterable) {
-  const items = [];
-  for (const item of toIterableIterator(iterable)) {
-    items.push(item);
-  }
+  const items = collect(iterable);
   for (let i = items.length - 1; i >= 0; i--) {
     yield items[i];
   }

package/dist/esm/lib/reverse.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/reverse.ts"],"names":[],"mappings":";;;AAwBO,UAAU,QAA2B,QAA0E,EAAA;AACrH,EAAA,MAAM,QAAuB,EAAC,CAAA;AAC9B,EAAW,KAAA,MAAA,IAAA,IAAQ,kBAAmB,CAAA,QAAQ,CAAG,EAAA;AAChD,IAAA,KAAA,CAAM,KAAK,IAAI,CAAA,CAAA;AAAA,GAChB;AAEA,EAAA,KAAA,IAAS,IAAI,KAAM,CAAA,MAAA,GAAS,CAAG,EAAA,CAAA,IAAK,GAAG,CAAK,EAAA,EAAA;AAC3C,IAAA,MAAM,MAAM,CAAC,CAAA,CAAA;AAAA,GACd;AACD,CAAA;AATiB,MAAA,CAAA,OAAA,EAAA,SAAA,CAAA","file":"reverse.mjs","sourcesContent":["import type { IterableResolvable } from './from';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Consumes the iterable and returns a new iterable with the elements in reverse order.\n *\n * @param iterable The iterator to reverse.\n * @returns An iterator whose element correspond to the elements of the provided iterator in reverse order.\n *\n * @example\n * ```typescript\n * import { reverse } from '@sapphire/iterator-utilities';\n *\n * console.log([...reverse([1, 2, 3, 4, 5])]);\n * // Output: [5, 4, 3, 2, 1]\n *\n * console.log([...reverse('hello')]);\n * // Output: ['o', 'l', 'l', 'e', 'h']\n * ```\n *\n * @remarks\n *\n * This function collects all elements of the provided iterator into an array before yielding them in reverse order.\n */\nexport function* reverse<const ElementType>(iterable: IterableResolvable<ElementType>): IterableIterator<ElementType> {\n\tconst items: ElementType[] = [];\n\tfor (const item of toIterableIterator(iterable)) {\n\t\titems.push(item);\n\t}\n\n\tfor (let i = items.length - 1; i >= 0; i--) {\n\t\tyield items[i];\n\t}\n}\n"]}
+{"version":3,"sources":["../../../src/lib/reverse.ts"],"names":[],"mappings":";;;AAwBO,UAAU,QAA2B,QAA0E,EAAA;AACrH,EAAM,MAAA,KAAA,GAAQ,QAAQ,QAAQ,CAAA,CAAA;AAC9B,EAAA,KAAA,IAAS,IAAI,KAAM,CAAA,MAAA,GAAS,CAAG,EAAA,CAAA,IAAK,GAAG,CAAK,EAAA,EAAA;AAC3C,IAAA,MAAM,MAAM,CAAC,CAAA,CAAA;AAAA,GACd;AACD,CAAA;AALiB,MAAA,CAAA,OAAA,EAAA,SAAA,CAAA","file":"reverse.mjs","sourcesContent":["import { collect } from './collect';\nimport type { IterableResolvable } from './from';\n\n/**\n * Consumes the iterable and returns a new iterable with the elements in reverse order.\n *\n * @param iterable The iterator to reverse.\n * @returns An iterator whose element correspond to the elements of the provided iterator in reverse order.\n *\n * @example\n * ```typescript\n * import { reverse } from '@sapphire/iterator-utilities';\n *\n * console.log([...reverse([1, 2, 3, 4, 5])]);\n * // Output: [5, 4, 3, 2, 1]\n *\n * console.log([...reverse('hello')]);\n * // Output: ['o', 'l', 'l', 'e', 'h']\n * ```\n *\n * @remarks\n *\n * This function collects all elements of the provided iterator into an array before yielding them in reverse order.\n */\nexport function* reverse<const ElementType>(iterable: IterableResolvable<ElementType>): IterableIterator<ElementType> {\n\tconst items = collect(iterable);\n\tfor (let i = items.length - 1; i >= 0; i--) {\n\t\tyield items[i];\n\t}\n}\n"]}

package/dist/esm/lib/shared/_compare.d.mts

@@ -0,0 +1,20 @@
+/**
+ * Represents the result of a lexicographic comparison.
+ *
+ * The operations are as follows:
+ *
+ * - Two iterators are compared element by element.
+ * - The first pair of unequal elements determines the result.
+ * - If one sequence is a prefix of the other, the shorter sequence is lexicographically less than the other.
+ * - If two sequences have the same elements in the same order, they are lexicographically equal.
+ * - An empty sequence is lexicographically less than any non-empty sequence.
+ * - Two empty sequences are lexicographically equal.
+ */
+type LexicographicComparison = -1 | 0 | 1;
+type CompareByComparator<ElementType> = (x: Exclude<ElementType, undefined>, y: Exclude<ElementType, undefined>) => number;
+declare function compareIteratorElements<const ElementType>(x: ElementType | undefined, y: ElementType | undefined, comparator: CompareByComparator<ElementType>): number;
+declare function orderingIsLess(ordering: number): boolean;
+declare function orderingIsEqual(ordering: number): boolean;
+declare function orderingIsGreater(ordering: number): boolean;
+
+export { type CompareByComparator, type LexicographicComparison, compareIteratorElements, orderingIsEqual, orderingIsGreater, orderingIsLess };

package/dist/esm/lib/shared/_compare.mjs

@@ -0,0 +1,30 @@
+import { __name } from '../../chunk-PAWJFY3S.mjs';
+
+// src/lib/shared/_compare.ts
+function compareIteratorElements(x, y, comparator) {
+  if (typeof x === "undefined") {
+    if (typeof y === "undefined") return 0;
+    return 1;
+  }
+  if (typeof y === "undefined") {
+    return -1;
+  }
+  return comparator(x, y);
+}
+__name(compareIteratorElements, "compareIteratorElements");
+function orderingIsLess(ordering) {
+  return ordering < 0;
+}
+__name(orderingIsLess, "orderingIsLess");
+function orderingIsEqual(ordering) {
+  return ordering === 0;
+}
+__name(orderingIsEqual, "orderingIsEqual");
+function orderingIsGreater(ordering) {
+  return ordering > 0;
+}
+__name(orderingIsGreater, "orderingIsGreater");
+
+export { compareIteratorElements, orderingIsEqual, orderingIsGreater, orderingIsLess };
+//# sourceMappingURL=_compare.mjs.map
+//# sourceMappingURL=_compare.mjs.map

package/dist/esm/lib/shared/_compare.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/shared/_compare.ts"],"names":[],"mappings":";;;AAgBO,SAAS,uBAAA,CACf,CACA,EAAA,CAAA,EACA,UACS,EAAA;AAET,EAAI,IAAA,OAAO,MAAM,WAAa,EAAA;AAE7B,IAAI,IAAA,OAAO,CAAM,KAAA,WAAA,EAAoB,OAAA,CAAA,CAAA;AAErC,IAAO,OAAA,CAAA,CAAA;AAAA,GACR;AAEA,EAAI,IAAA,OAAO,MAAM,WAAa,EAAA;AAE7B,IAAO,OAAA,CAAA,CAAA,CAAA;AAAA,GACR;AAEA,EAAO,OAAA,UAAA,CAAW,GAAsC,CAAoC,CAAA,CAAA;AAC7F,CAAA;AAnBgB,MAAA,CAAA,uBAAA,EAAA,yBAAA,CAAA,CAAA;AAqBT,SAAS,eAAe,QAAkB,EAAA;AAChD,EAAA,OAAO,QAAW,GAAA,CAAA,CAAA;AACnB,CAAA;AAFgB,MAAA,CAAA,cAAA,EAAA,gBAAA,CAAA,CAAA;AAIT,SAAS,gBAAgB,QAAkB,EAAA;AACjD,EAAA,OAAO,QAAa,KAAA,CAAA,CAAA;AACrB,CAAA;AAFgB,MAAA,CAAA,eAAA,EAAA,iBAAA,CAAA,CAAA;AAIT,SAAS,kBAAkB,QAAkB,EAAA;AACnD,EAAA,OAAO,QAAW,GAAA,CAAA,CAAA;AACnB,CAAA;AAFgB,MAAA,CAAA,iBAAA,EAAA,mBAAA,CAAA","file":"_compare.mjs","sourcesContent":["/**\n * Represents the result of a lexicographic comparison.\n *\n * The operations are as follows:\n *\n * - Two iterators are compared element by element.\n * - The first pair of unequal elements determines the result.\n * - If one sequence is a prefix of the other, the shorter sequence is lexicographically less than the other.\n * - If two sequences have the same elements in the same order, they are lexicographically equal.\n * - An empty sequence is lexicographically less than any non-empty sequence.\n * - Two empty sequences are lexicographically equal.\n */\nexport type LexicographicComparison = -1 | 0 | 1;\n\nexport type CompareByComparator<ElementType> = (x: Exclude<ElementType, undefined>, y: Exclude<ElementType, undefined>) => number;\n\nexport function compareIteratorElements<const ElementType>(\n\tx: ElementType | undefined,\n\ty: ElementType | undefined,\n\tcomparator: CompareByComparator<ElementType>\n): number {\n\t// 23.1.3.30.2 CompareArrayElements (https://tc39.es/ecma262/#sec-comparearrayelements)\n\tif (typeof x === 'undefined') {\n\t\t// 1. If x and y are both `undefined`, return +0.\n\t\tif (typeof y === 'undefined') return 0;\n\t\t// 2. If x is `undefined`, return +1.\n\t\treturn 1;\n\t}\n\n\tif (typeof y === 'undefined') {\n\t\t// 3. If y is `undefined`, return -1.\n\t\treturn -1;\n\t}\n\n\treturn comparator(x as Exclude<ElementType, undefined>, y as Exclude<ElementType, undefined>);\n}\n\nexport function orderingIsLess(ordering: number) {\n\treturn ordering < 0;\n}\n\nexport function orderingIsEqual(ordering: number) {\n\treturn ordering === 0;\n}\n\nexport function orderingIsGreater(ordering: number) {\n\treturn ordering > 0;\n}\n"]}

package/dist/esm/lib/shared/comparators.d.mts

@@ -0,0 +1,34 @@
+import { LexicographicComparison, CompareByComparator } from './_compare.mjs';
+
+/**
+ * Compares two elements lexicographically using the default comparison algorithm.
+ * @seealso 23.1.3.30.2 CompareArrayElements ({@link https://tc39.es/ecma262/#sec-comparearrayelements})
+ *
+ * @param x The first element to compare.
+ * @param y The second element to compare.
+ * @returns The lexicographic comparison of the two elements.
+ *
+ * @remarks
+ *
+ * This function is used as the comparison algorithm for {@link compareBy}.
+ */
+declare function defaultCompare<const ElementType>(x: ElementType, y: ElementType): LexicographicComparison;
+
+declare const descString: <const ElementType>(x: Exclude<ElementType, undefined>, y: Exclude<ElementType, undefined>) => number;
+/**
+ * Compares two elements using the default comparison algorithm.
+ *
+ * @param x The first element to compare.
+ * @param y The second element to compare.
+ * @returns The numeric comparison of the two elements.
+ *
+ * @privateRemarks
+ *
+ * The implementation of this function is based on the optimized version of the
+ * starship operator in Rust. The subtraction is intentional and is used to
+ * determine the ordering of the two elements.
+ */
+declare function ascNumber(x: number | bigint | string, y: number | bigint | string): LexicographicComparison;
+declare const descNumber: CompareByComparator<string | number | bigint>;
+
+export { ascNumber, defaultCompare as ascString, defaultCompare, descNumber, descString };

package/dist/esm/lib/shared/comparators.mjs

@@ -0,0 +1,21 @@
+import { __name } from '../../chunk-PAWJFY3S.mjs';
+
+// src/lib/shared/comparators.ts
+function swap(cb) {
+  return (x, y) => 0 - cb(x, y);
+}
+__name(swap, "swap");
+function defaultCompare(x, y) {
+  return ascNumber(String(x), String(y));
+}
+__name(defaultCompare, "defaultCompare");
+var descString = swap(defaultCompare);
+function ascNumber(x, y) {
+  return (x > y) - (x < y);
+}
+__name(ascNumber, "ascNumber");
+var descNumber = swap(ascNumber);
+
+export { ascNumber, defaultCompare as ascString, defaultCompare, descNumber, descString };
+//# sourceMappingURL=comparators.mjs.map
+//# sourceMappingURL=comparators.mjs.map

package/dist/esm/lib/shared/comparators.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/shared/comparators.ts"],"names":[],"mappings":";;;AAEA,SAAS,KAAwB,EAAwE,EAAA;AACxG,EAAA,OAAO,CAAC,CAAG,EAAA,CAAA,KAAO,CAAI,GAAA,EAAA,CAAG,GAAG,CAAC,CAAA,CAAA;AAC9B,CAAA;AAFS,MAAA,CAAA,IAAA,EAAA,MAAA,CAAA,CAAA;AAgBF,SAAS,cAAA,CAAkC,GAAgB,CAAyC,EAAA;AAI1G,EAAA,OAAO,UAAU,MAAO,CAAA,CAAC,CAAG,EAAA,MAAA,CAAO,CAAC,CAAC,CAAA,CAAA;AACtC,CAAA;AALgB,MAAA,CAAA,cAAA,EAAA,gBAAA,CAAA,CAAA;AAQH,IAAA,UAAA,GAAa,KAAK,cAAc,EAAA;AAetC,SAAS,SAAA,CAAU,GAA6B,CAAsD,EAAA;AAE5G,EAAS,OAAA,CAAA,CAAA,GAAI,MAAM,CAAI,GAAA,CAAA,CAAA,CAAA;AACxB,CAAA;AAHgB,MAAA,CAAA,SAAA,EAAA,WAAA,CAAA,CAAA;AAIH,IAAA,UAAA,GAAa,KAAK,SAAS","file":"comparators.mjs","sourcesContent":["import type { CompareByComparator, LexicographicComparison } from './_compare';\n\nfunction swap<const ElementType>(cb: CompareByComparator<ElementType>): CompareByComparator<ElementType> {\n\treturn (x, y) => (0 - cb(x, y)) as LexicographicComparison;\n}\n\n/**\n * Compares two elements lexicographically using the default comparison algorithm.\n * @seealso 23.1.3.30.2 CompareArrayElements ({@link https://tc39.es/ecma262/#sec-comparearrayelements})\n *\n * @param x The first element to compare.\n * @param y The second element to compare.\n * @returns The lexicographic comparison of the two elements.\n *\n * @remarks\n *\n * This function is used as the comparison algorithm for {@link compareBy}.\n */\nexport function defaultCompare<const ElementType>(x: ElementType, y: ElementType): LexicographicComparison {\n\t// 5. Let xString be ? ToString(x).\n\t// 6. Let yString be ? ToString(y).\n\t// Steps 7-11 are optimized away by the usage of `ascNumber`.\n\treturn ascNumber(String(x), String(y));\n}\n\nexport { defaultCompare as ascString };\nexport const descString = swap(defaultCompare);\n\n/**\n * Compares two elements using the default comparison algorithm.\n *\n * @param x The first element to compare.\n * @param y The second element to compare.\n * @returns The numeric comparison of the two elements.\n *\n * @privateRemarks\n *\n * The implementation of this function is based on the optimized version of the\n * starship operator in Rust. The subtraction is intentional and is used to\n * determine the ordering of the two elements.\n */\nexport function ascNumber(x: number | bigint | string, y: number | bigint | string): LexicographicComparison {\n\t// @ts-expect-error: The subtraction is intentional\n\treturn ((x > y) - (x < y)) as LexicographicComparison;\n}\nexport const descNumber = swap(ascNumber);\n"]}

package/dist/esm/lib/skip.d.mts

@@ -0,0 +1,2 @@
+export { drop as skip } from './drop.mjs';
+import './from.mjs';

package/dist/esm/lib/skip.mjs

@@ -0,0 +1,4 @@
+import '../chunk-PAWJFY3S.mjs';
+export { drop as skip } from './drop.mjs';
+//# sourceMappingURL=skip.mjs.map
+//# sourceMappingURL=skip.mjs.map

package/dist/esm/lib/skip.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"skip.mjs","sourcesContent":[]}

package/dist/esm/lib/skipLast.d.mts

@@ -0,0 +1,2 @@
+export { dropLast as skipLast } from './dropLast.mjs';
+import './from.mjs';

package/dist/esm/lib/skipLast.mjs

@@ -0,0 +1,4 @@
+import '../chunk-PAWJFY3S.mjs';
+export { dropLast as skipLast } from './dropLast.mjs';
+//# sourceMappingURL=skipLast.mjs.map
+//# sourceMappingURL=skipLast.mjs.map

package/dist/esm/lib/skipLast.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"skipLast.mjs","sourcesContent":[]}

package/dist/esm/lib/skipWhile.d.mts

@@ -0,0 +1,2 @@
+export { dropWhile as skipWhile } from './dropWhile.mjs';
+import './from.mjs';

package/dist/esm/lib/skipWhile.mjs

@@ -0,0 +1,4 @@
+import '../chunk-PAWJFY3S.mjs';
+export { dropWhile as skipWhile } from './dropWhile.mjs';
+//# sourceMappingURL=skipWhile.mjs.map
+//# sourceMappingURL=skipWhile.mjs.map

package/dist/esm/lib/skipWhile.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"skipWhile.mjs","sourcesContent":[]}

package/dist/esm/lib/stepBy.d.mts

@@ -0,0 +1,24 @@
+import { IterableResolvable } from './from.mjs';
+
+/**
+ * Creates an iterator starting at the same point, but stepping by the given amount at each iteration.
+ *
+ * @param iterable An iterator to map over.
+ * @param step A positive integer representing the step to take at each iteration.
+ *
+ * @example
+ * ```typescript
+ * import { stepBy } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = [0, 1, 2, 3, 4, 5];
+ * console.log([...stepBy(iterable, 2)]);
+ * // Output: [0, 2, 4]
+ * ```
+ *
+ * @remarks
+ *
+ * The first element of the iterator will always be returned, regardless of the step given.
+ */
+declare function stepBy<const ElementType>(iterable: IterableResolvable<ElementType>, step: number): IterableIterator<ElementType>;
+
+export { stepBy };

package/dist/esm/lib/stepBy.mjs

@@ -0,0 +1,26 @@
+import { __name } from '../chunk-PAWJFY3S.mjs';
+import { from } from './from.mjs';
+import { assertPositive } from './shared/_assertPositive.mjs';
+import { makeIterableIterator } from './shared/_makeIterableIterator.mjs';
+import { toIntegerOrInfinityOrThrow } from './shared/_toIntegerOrInfinityOrThrow.mjs';
+
+function stepBy(iterable, step) {
+  step = assertPositive(toIntegerOrInfinityOrThrow(step), step);
+  const iterator = from(iterable);
+  return makeIterableIterator(() => {
+    const result = iterator.next();
+    if (result.done) {
+      return { done: true, value: void 0 };
+    }
+    for (let i = 0; i < step - 1; i++) {
+      const result2 = iterator.next();
+      if (result2.done) break;
+    }
+    return { done: false, value: result.value };
+  });
+}
+__name(stepBy, "stepBy");
+
+export { stepBy };
+//# sourceMappingURL=stepBy.mjs.map
+//# sourceMappingURL=stepBy.mjs.map

package/dist/esm/lib/stepBy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/stepBy.ts"],"names":["result"],"mappings":";;;;;;AAwBO,SAAS,MAAA,CAA0B,UAA2C,IAA6C,EAAA;AACjI,EAAA,IAAA,GAAO,cAAe,CAAA,0BAAA,CAA2B,IAAI,CAAA,EAAG,IAAI,CAAA,CAAA;AAE5D,EAAM,MAAA,QAAA,GAAW,KAAK,QAAQ,CAAA,CAAA;AAC9B,EAAA,OAAO,qBAAkC,MAAM;AAC9C,IAAM,MAAA,MAAA,GAAS,SAAS,IAAK,EAAA,CAAA;AAC7B,IAAA,IAAI,OAAO,IAAM,EAAA;AAChB,MAAA,OAAO,EAAE,IAAA,EAAM,IAAM,EAAA,KAAA,EAAO,KAAU,CAAA,EAAA,CAAA;AAAA,KACvC;AAEA,IAAA,KAAA,IAAS,CAAI,GAAA,CAAA,EAAG,CAAI,GAAA,IAAA,GAAO,GAAG,CAAK,EAAA,EAAA;AAClC,MAAMA,MAAAA,OAAAA,GAAS,SAAS,IAAK,EAAA,CAAA;AAC7B,MAAA,IAAIA,QAAO,IAAM,EAAA,MAAA;AAAA,KAClB;AAEA,IAAA,OAAO,EAAE,IAAA,EAAM,KAAO,EAAA,KAAA,EAAO,OAAO,KAAM,EAAA,CAAA;AAAA,GAC1C,CAAA,CAAA;AACF,CAAA;AAjBgB,MAAA,CAAA,MAAA,EAAA,QAAA,CAAA","file":"stepBy.mjs","sourcesContent":["import { from, type IterableResolvable } from './from';\nimport { assertPositive } from './shared/_assertPositive';\nimport { makeIterableIterator } from './shared/_makeIterableIterator';\nimport { toIntegerOrInfinityOrThrow } from './shared/_toIntegerOrInfinityOrThrow';\n\n/**\n * Creates an iterator starting at the same point, but stepping by the given amount at each iteration.\n *\n * @param iterable An iterator to map over.\n * @param step A positive integer representing the step to take at each iteration.\n *\n * @example\n * ```typescript\n * import { stepBy } from '@sapphire/iterator-utilities';\n *\n * const iterable = [0, 1, 2, 3, 4, 5];\n * console.log([...stepBy(iterable, 2)]);\n * // Output: [0, 2, 4]\n * ```\n *\n * @remarks\n *\n * The first element of the iterator will always be returned, regardless of the step given.\n */\nexport function stepBy<const ElementType>(iterable: IterableResolvable<ElementType>, step: number): IterableIterator<ElementType> {\n\tstep = assertPositive(toIntegerOrInfinityOrThrow(step), step);\n\n\tconst iterator = from(iterable);\n\treturn makeIterableIterator<ElementType>(() => {\n\t\tconst result = iterator.next();\n\t\tif (result.done) {\n\t\t\treturn { done: true, value: undefined };\n\t\t}\n\n\t\tfor (let i = 0; i < step - 1; i++) {\n\t\t\tconst result = iterator.next();\n\t\t\tif (result.done) break;\n\t\t}\n\n\t\treturn { done: false, value: result.value };\n\t});\n}\n"]}