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

package/dist/cjs/lib/minBy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/minBy.ts"],"names":["assertFunction","toIterableIterator","compareIteratorElements","orderingIsGreater"],"mappings":";;;;;;;;AAgCO,SAAS,KAAA,CACf,UACA,UACqB,EAAA;AACrB,EAAA,UAAA,GAAaA,mCAAe,UAAU,CAAA,CAAA;AAEtC,EAAM,MAAA,QAAA,GAAWC,0CAAmB,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,GAAAC,oCAAA,CAAqC,KAAO,EAAA,OAAA,EAAS,UAAU,CAAA,CAAA;AAElF,IAAI,IAAA,CAACC,8BAAkB,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.cjs","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/cjs/lib/minBy.d.cts

@@ -0,0 +1,31 @@
+import { IterableResolvable } from './from.cjs';
+import { CompareByComparator } from './shared/_compare.js';
+
+/**
+ * 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/cjs/lib/minByKey.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var _assertFunction_cjs = require('./shared/_assertFunction.cjs');
+var _compare_cjs = require('./shared/_compare.cjs');
+var comparators_cjs = require('./shared/comparators.cjs');
+var toIterableIterator_cjs = require('./toIterableIterator.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function minByKey(iterable, callbackFn, comparator = comparators_cjs.defaultCompare) {
+  callbackFn = _assertFunction_cjs.assertFunction(callbackFn);
+  const iterator = toIterableIterator_cjs.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 = _compare_cjs.compareIteratorElements(minimumKey, key, comparator);
+    if (!_compare_cjs.orderingIsLess(comparison)) {
+      minimum = value;
+      minimumKey = key;
+    }
+  }
+  return minimum;
+}
+__name(minByKey, "minByKey");
+
+exports.minByKey = minByKey;
+//# sourceMappingURL=minByKey.cjs.map
+//# sourceMappingURL=minByKey.cjs.map

package/dist/cjs/lib/minByKey.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/minByKey.ts"],"names":["defaultCompare","assertFunction","toIterableIterator","compareIteratorElements","orderingIsLess"],"mappings":";;;;;;;;;AAiCO,SAAS,QACf,CAAA,QAAA,EACA,UACA,EAAA,UAAA,GAA8CA,8BACzB,EAAA;AACrB,EAAA,UAAA,GAAaC,mCAAe,UAAU,CAAA,CAAA;AAEtC,EAAM,MAAA,QAAA,GAAWC,0CAAmB,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,GAAAC,oCAAA,CAAoC,UAAY,EAAA,GAAA,EAAK,UAAU,CAAA,CAAA;AAElF,IAAI,IAAA,CAACC,2BAAe,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.cjs","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/cjs/lib/minByKey.d.cts

@@ -0,0 +1,31 @@
+import { IterableResolvable } from './from.cjs';
+import { CompareByComparator } from './shared/_compare.js';
+
+/**
+ * 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/cjs/lib/notEqual.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var equal_cjs = require('./equal.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function notEqual(iterable, other) {
+  return !equal_cjs.equal(iterable, other);
+}
+__name(notEqual, "notEqual");
+
+exports.ne = notEqual;
+exports.notEqual = notEqual;
+//# sourceMappingURL=notEqual.cjs.map
+//# sourceMappingURL=notEqual.cjs.map

package/dist/cjs/lib/notEqual.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/notEqual.ts"],"names":["equal"],"mappings":";;;;;;AAwBO,SAAS,QAAA,CAA4B,UAA2C,KAAiD,EAAA;AACvI,EAAO,OAAA,CAACA,eAAM,CAAA,QAAA,EAAU,KAAK,CAAA,CAAA;AAC9B,CAAA;AAFgB,MAAA,CAAA,QAAA,EAAA,UAAA,CAAA","file":"notEqual.cjs","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/cjs/lib/notEqual.d.cts

@@ -0,0 +1,26 @@
+import { IterableResolvable } from './from.cjs';
+
+/**
+ * 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/cjs/lib/nth.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var at_cjs = require('./at.cjs');
+
+
+
+Object.defineProperty(exports, "nth", {
+  enumerable: true,
+  get: function () { return at_cjs.at; }
+});
+//# sourceMappingURL=nth.cjs.map
+//# sourceMappingURL=nth.cjs.map

package/dist/cjs/lib/nth.cjs.map

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

package/dist/cjs/lib/nth.d.cts

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

package/dist/cjs/lib/position.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var indexOf_cjs = require('./indexOf.cjs');
+
+
+
+Object.defineProperty(exports, "position", {
+  enumerable: true,
+  get: function () { return indexOf_cjs.indexOf; }
+});
+//# sourceMappingURL=position.cjs.map
+//# sourceMappingURL=position.cjs.map

package/dist/cjs/lib/position.cjs.map

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

package/dist/cjs/lib/position.d.cts

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

package/dist/cjs/lib/reverse.cjs

@@ -1,14 +1,11 @@
 'use strict';
 
-var toIterableIterator_cjs = require('./toIterableIterator.cjs');
+var collect_cjs = require('./collect.cjs');
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 function* reverse(iterable) {
-  const items = [];
-  for (const item of toIterableIterator_cjs.toIterableIterator(iterable)) {
-    items.push(item);
-  }
+  const items = collect_cjs.collect(iterable);
   for (let i = items.length - 1; i >= 0; i--) {
     yield items[i];
   }

package/dist/cjs/lib/reverse.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/reverse.ts"],"names":["toIterableIterator"],"mappings":";;;;;;AAwBO,UAAU,QAA2B,QAA0E,EAAA;AACrH,EAAA,MAAM,QAAuB,EAAC,CAAA;AAC9B,EAAW,KAAA,MAAA,IAAA,IAAQA,yCAAmB,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.cjs","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":["collect"],"mappings":";;;;;;AAwBO,UAAU,QAA2B,QAA0E,EAAA;AACrH,EAAM,MAAA,KAAA,GAAQA,oBAAQ,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.cjs","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/cjs/lib/shared/_compare.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// 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");
+
+exports.compareIteratorElements = compareIteratorElements;
+exports.orderingIsEqual = orderingIsEqual;
+exports.orderingIsGreater = orderingIsGreater;
+exports.orderingIsLess = orderingIsLess;
+//# sourceMappingURL=_compare.cjs.map
+//# sourceMappingURL=_compare.cjs.map

package/dist/cjs/lib/shared/_compare.cjs.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.cjs","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/cjs/lib/shared/_compare.d.cts

@@ -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/cjs/lib/shared/comparators.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// 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);
+
+exports.ascNumber = ascNumber;
+exports.ascString = defaultCompare;
+exports.defaultCompare = defaultCompare;
+exports.descNumber = descNumber;
+exports.descString = descString;
+//# sourceMappingURL=comparators.cjs.map
+//# sourceMappingURL=comparators.cjs.map

package/dist/cjs/lib/shared/comparators.cjs.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.cjs","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/cjs/lib/shared/comparators.d.cts

@@ -0,0 +1,34 @@
+import { LexicographicComparison, CompareByComparator } from './_compare.js';
+
+/**
+ * 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/cjs/lib/skip.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var drop_cjs = require('./drop.cjs');
+
+
+
+Object.defineProperty(exports, "skip", {
+  enumerable: true,
+  get: function () { return drop_cjs.drop; }
+});
+//# sourceMappingURL=skip.cjs.map
+//# sourceMappingURL=skip.cjs.map

package/dist/cjs/lib/skip.cjs.map

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

package/dist/cjs/lib/skip.d.cts

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

package/dist/cjs/lib/skipLast.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var dropLast_cjs = require('./dropLast.cjs');
+
+
+
+Object.defineProperty(exports, "skipLast", {
+  enumerable: true,
+  get: function () { return dropLast_cjs.dropLast; }
+});
+//# sourceMappingURL=skipLast.cjs.map
+//# sourceMappingURL=skipLast.cjs.map

package/dist/cjs/lib/skipLast.cjs.map

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

package/dist/cjs/lib/skipLast.d.cts

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

package/dist/cjs/lib/skipWhile.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var dropWhile_cjs = require('./dropWhile.cjs');
+
+
+
+Object.defineProperty(exports, "skipWhile", {
+  enumerable: true,
+  get: function () { return dropWhile_cjs.dropWhile; }
+});
+//# sourceMappingURL=skipWhile.cjs.map
+//# sourceMappingURL=skipWhile.cjs.map

package/dist/cjs/lib/skipWhile.cjs.map

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

package/dist/cjs/lib/skipWhile.d.cts

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

package/dist/cjs/lib/stepBy.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+var from_cjs = require('./from.cjs');
+var _assertPositive_cjs = require('./shared/_assertPositive.cjs');
+var _makeIterableIterator_cjs = require('./shared/_makeIterableIterator.cjs');
+var _toIntegerOrInfinityOrThrow_cjs = require('./shared/_toIntegerOrInfinityOrThrow.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function stepBy(iterable, step) {
+  step = _assertPositive_cjs.assertPositive(_toIntegerOrInfinityOrThrow_cjs.toIntegerOrInfinityOrThrow(step), step);
+  const iterator = from_cjs.from(iterable);
+  return _makeIterableIterator_cjs.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");
+
+exports.stepBy = stepBy;
+//# sourceMappingURL=stepBy.cjs.map
+//# sourceMappingURL=stepBy.cjs.map

package/dist/cjs/lib/stepBy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/stepBy.ts"],"names":["assertPositive","toIntegerOrInfinityOrThrow","from","makeIterableIterator","result"],"mappings":";;;;;;;;;AAwBO,SAAS,MAAA,CAA0B,UAA2C,IAA6C,EAAA;AACjI,EAAA,IAAA,GAAOA,kCAAe,CAAAC,0DAAA,CAA2B,IAAI,CAAA,EAAG,IAAI,CAAA,CAAA;AAE5D,EAAM,MAAA,QAAA,GAAWC,cAAK,QAAQ,CAAA,CAAA;AAC9B,EAAA,OAAOC,+CAAkC,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,MAAMC,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.cjs","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"]}

package/dist/cjs/lib/stepBy.d.cts

@@ -0,0 +1,24 @@
+import { IterableResolvable } from './from.cjs';
+
+/**
+ * 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/cjs/lib/takeWhile.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var filter_cjs = require('./filter.cjs');
+
+
+
+Object.defineProperty(exports, "takeWhile", {
+  enumerable: true,
+  get: function () { return filter_cjs.filter; }
+});
+//# sourceMappingURL=takeWhile.cjs.map
+//# sourceMappingURL=takeWhile.cjs.map

package/dist/cjs/lib/takeWhile.cjs.map

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

package/dist/cjs/lib/takeWhile.d.cts

@@ -0,0 +1,2 @@
+export { filter as takeWhile } from './filter.cjs';
+import './from.cjs';

package/dist/esm/index.d.mts

@@ -1,21 +1,28 @@
+export { every as all, every } from './lib/every.mjs';
+export { some as any, some } from './lib/some.mjs';
 export { concat as append, concat } from './lib/append.mjs';
-export { at } from './lib/at.mjs';
+export { at, at as nth } from './lib/at.mjs';
 export { average } from './lib/average.mjs';
 export { chain } from './lib/chain.mjs';
 export { chunk } from './lib/chunk.mjs';
+export { toArray as collect, toArray } from './lib/toArray.mjs';
+export { collectInto } from './lib/collectInto.mjs';
 export { compact } from './lib/compact.mjs';
+export { compare } from './lib/compare.mjs';
+export { compareBy } from './lib/compareBy.mjs';
 export { compress } from './lib/compress.mjs';
 export { contains } from './lib/contains.mjs';
 export { count } from './lib/count.mjs';
 export { cycle } from './lib/cycle.mjs';
 export { except as difference, except, except as omit } from './lib/difference.mjs';
-export { skip as drop, skip } from './lib/drop.mjs';
-export { skipLast as dropLast, skipLast } from './lib/dropLast.mjs';
-export { skipWhile as dropWhile, skipWhile } from './lib/dropWhile.mjs';
+export { drop, drop as skip } from './lib/drop.mjs';
+export { dropLast, dropLast as skipLast } from './lib/dropLast.mjs';
+export { dropWhile, dropWhile as skipWhile } from './lib/dropWhile.mjs';
 export { empty } from './lib/empty.mjs';
 export { enumerate } from './lib/enumerate.mjs';
-export { every } from './lib/every.mjs';
-export { takeWhile as filter, takeWhile } from './lib/filter.mjs';
+export { eq, eq as equal } from './lib/equal.mjs';
+export { eqBy, eqBy as equalBy } from './lib/equalBy.mjs';
+export { filter, filter as takeWhile } from './lib/filter.mjs';
 export { find } from './lib/find.mjs';
 export { findIndex } from './lib/findIndex.mjs';
 export { first } from './lib/first.mjs';
@@ -23,13 +30,28 @@ export { flat } from './lib/flat.mjs';
 export { flatMap } from './lib/flatMap.mjs';
 export { forEach } from './lib/forEach.mjs';
 export { IterableResolvable, IterableResolved, from } from './lib/from.mjs';
-export { position as indexOf, position } from './lib/indexOf.mjs';
+export { fuse } from './lib/fuse.mjs';
+export { ge, ge as greaterOrEqualThan } from './lib/greaterOrEqualThan.mjs';
+export { gt as greaterThan, gt } from './lib/greaterThan.mjs';
+export { indexOf, indexOf as position } from './lib/indexOf.mjs';
+export { inspect } from './lib/inspect.mjs';
 export { intersect } from './lib/intersect.mjs';
+export { intersperse } from './lib/intersperse.mjs';
 export { isEmpty } from './lib/isEmpty.mjs';
+export { isSorted } from './lib/isSorted.mjs';
+export { isSortedBy } from './lib/isSortedBy.mjs';
+export { isSortedByKey } from './lib/isSortedByKey.mjs';
 export { last } from './lib/last.mjs';
+export { le, le as lessOrEqualThan } from './lib/lessOrEqualThan.mjs';
+export { lt as lessThan, lt } from './lib/lessThan.mjs';
 export { map } from './lib/map.mjs';
 export { max } from './lib/max.mjs';
+export { maxBy } from './lib/maxBy.mjs';
+export { maxByKey } from './lib/maxByKey.mjs';
 export { min } from './lib/min.mjs';
+export { minBy } from './lib/minBy.mjs';
+export { minByKey } from './lib/minByKey.mjs';
+export { ne, ne as notEqual } from './lib/notEqual.mjs';
 export { partition } from './lib/partition.mjs';
 export { Peekable, peekable } from './lib/peekable.mjs';
 export { prepend } from './lib/prepend.mjs';
@@ -38,16 +60,17 @@ export { range } from './lib/range.mjs';
 export { reduce } from './lib/reduce.mjs';
 export { repeat } from './lib/repeat.mjs';
 export { reverse } from './lib/reverse.mjs';
+export { CompareByComparator, LexicographicComparison } from './lib/shared/_compare.mjs';
 export { NumberResolvable } from './lib/shared/_toNumberOrThrow.mjs';
+export { ascNumber, ascString, ascString as defaultCompare, descNumber, descString } from './lib/shared/comparators.mjs';
 export { slice } from './lib/slice.mjs';
-export { some } from './lib/some.mjs';
 export { sorted } from './lib/sorted.mjs';
 export { StarMapParameters, starMap } from './lib/starMap.mjs';
+export { stepBy } from './lib/stepBy.mjs';
 export { sum } from './lib/sum.mjs';
 export { take } from './lib/take.mjs';
 export { takeLast } from './lib/takeLast.mjs';
 export { tee } from './lib/tee.mjs';
-export { toArray } from './lib/toArray.mjs';
 export { toIterableIterator } from './lib/toIterableIterator.mjs';
 export { union } from './lib/union.mjs';
 export { unique } from './lib/unique.mjs';