@sapphire/iterator-utilities 1.0.0

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

@@ -0,0 +1,26 @@
+import { IterableResolvable } from './from.mjs';
+
+/**
+ * Creates an iterable with the elements that are in both input iterables.
+ *
+ * @param first An iterator to return elements from.
+ * @param second An iterator that contains elements to include in the result.
+ *
+ * @example
+ * ```typescript
+ * import { intersect } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = intersect([1, 2, 3, 4, 5], [3, 4, 5, 6, 7]);
+ * console.log([...iterable]);
+ * // Output: [3, 4, 5]
+ * ```
+ *
+ * @remarks
+ *
+ * This function consumes the entire `second` iterator to build the set of elements to intersect with `first`.
+ *
+ * @seealso {@link difference} for the opposite behavior.
+ */
+declare function intersect<const ElementType>(first: IterableResolvable<ElementType>, second: IterableResolvable<ElementType>): IterableIterator<ElementType>;
+
+export { intersect };

package/dist/esm/lib/intersect.mjs

@@ -0,0 +1,13 @@
+import { __name } from '../chunk-G5GHKT7C.mjs';
+import { filter } from './filter.mjs';
+import { toIterableIterator } from './toIterableIterator.mjs';
+
+function intersect(first, second) {
+  const set = new Set(toIterableIterator(second));
+  return filter(first, (value) => set.has(value));
+}
+__name(intersect, "intersect");
+
+export { intersect };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=intersect.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/intersect.ts"],"names":[],"mappings":";;;;;AAAA,SAAS,cAAc;AAEvB,SAAS,0BAA0B;AAuB5B,SAAS,UACf,OACA,QACgC;AAChC,QAAM,MAAM,IAAI,IAAI,mBAAmB,MAAM,CAAC;AAC9C,SAAO,OAAO,OAAO,CAAC,UAAU,IAAI,IAAI,KAAK,CAAC;AAC/C;AANgB","sourcesContent":["import { filter } from './filter';\nimport type { IterableResolvable } from './from';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Creates an iterable with the elements that are in both input iterables.\n *\n * @param first An iterator to return elements from.\n * @param second An iterator that contains elements to include in the result.\n *\n * @example\n * ```typescript\n * import { intersect } from '@sapphire/iterator-utilities';\n *\n * const iterable = intersect([1, 2, 3, 4, 5], [3, 4, 5, 6, 7]);\n * console.log([...iterable]);\n * // Output: [3, 4, 5]\n * ```\n *\n * @remarks\n *\n * This function consumes the entire `second` iterator to build the set of elements to intersect with `first`.\n *\n * @seealso {@link difference} for the opposite behavior.\n */\nexport function intersect<const ElementType>(\n\tfirst: IterableResolvable<ElementType>,\n\tsecond: IterableResolvable<ElementType>\n): IterableIterator<ElementType> {\n\tconst set = new Set(toIterableIterator(second));\n\treturn filter(first, (value) => set.has(value));\n}\n"]}

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

@@ -0,0 +1,26 @@
+import { IterableResolvable } from './from.mjs';
+
+/**
+ * Advances the iterable once, returning `true` if it's exhausted and `false` otherwise.
+ *
+ * @param iterable The iterator to check for emptiness.
+ * @returns `true` if the iterator is empty; otherwise, `false`.
+ *
+ * @example
+ * ```typescript
+ * import { isEmpty } from '@sapphire/iterator-utilities';
+ *
+ * console.log(isEmpty([]));
+ * // Output: true
+ *
+ * console.log(isEmpty([1, 2, 3, 4, 5]));
+ * // Output: false
+ * ```
+ *
+ * @remarks
+ *
+ * This function consumes the first value of the iterator.
+ */
+declare function isEmpty<const ElementType>(iterable: IterableResolvable<ElementType>): boolean;
+
+export { isEmpty };

package/dist/esm/lib/isEmpty.mjs

@@ -0,0 +1,11 @@
+import { __name } from '../chunk-G5GHKT7C.mjs';
+import { from } from './from.mjs';
+
+function isEmpty(iterable) {
+  return from(iterable).next().done ?? false;
+}
+__name(isEmpty, "isEmpty");
+
+export { isEmpty };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=isEmpty.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/isEmpty.ts"],"names":[],"mappings":";;;;;AAAA,SAAS,YAAqC;AAuBvC,SAAS,QAA2B,UAAoD;AAC9F,SAAO,KAAK,QAAQ,EAAE,KAAK,EAAE,QAAQ;AACtC;AAFgB","sourcesContent":["import { from, type IterableResolvable } from './from';\n\n/**\n * Advances the iterable once, returning `true` if it's exhausted and `false` otherwise.\n *\n * @param iterable The iterator to check for emptiness.\n * @returns `true` if the iterator is empty; otherwise, `false`.\n *\n * @example\n * ```typescript\n * import { isEmpty } from '@sapphire/iterator-utilities';\n *\n * console.log(isEmpty([]));\n * // Output: true\n *\n * console.log(isEmpty([1, 2, 3, 4, 5]));\n * // Output: false\n * ```\n *\n * @remarks\n *\n * This function consumes the first value of the iterator.\n */\nexport function isEmpty<const ElementType>(iterable: IterableResolvable<ElementType>): boolean {\n\treturn from(iterable).next().done ?? false;\n}\n"]}

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

@@ -0,0 +1,24 @@
+import { IterableResolvable } from './from.mjs';
+
+/**
+ * Consumes the iterable until it's exhausted, returning the last element.
+ *
+ * @param iterable An iterator to return the last value of.
+ * @returns The value at the last position in the source iterator, or `undefined` if the iterator is empty.
+ *
+ * @example
+ * ```typescript
+ * import { last } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = [1, 2, 3, 4, 5];
+ * console.log(last(iterable));
+ * // Output: 5
+ * ```
+ *
+ * @remarks
+ *
+ * This function consumes the entire iterator to find the last value.
+ */
+declare function last<const ElementType>(iterable: IterableResolvable<ElementType>): ElementType | undefined;
+
+export { last };

package/dist/esm/lib/last.mjs

@@ -0,0 +1,15 @@
+import { __name } from '../chunk-G5GHKT7C.mjs';
+import { toIterableIterator } from './toIterableIterator.mjs';
+
+function last(iterable) {
+  let last2;
+  for (const value of toIterableIterator(iterable)) {
+    last2 = value;
+  }
+  return last2;
+}
+__name(last, "last");
+
+export { last };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=last.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/last.ts"],"names":["last"],"mappings":";;;;;AACA,SAAS,0BAA0B;AAqB5B,SAAS,KAAwB,UAAoE;AAC3G,MAAIA;AACJ,aAAW,SAAS,mBAAmB,QAAQ,GAAG;AACjD,IAAAA,QAAO;AAAA,EACR;AAEA,SAAOA;AACR;AAPgB","sourcesContent":["import type { IterableResolvable } from './from';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Consumes the iterable until it's exhausted, returning the last element.\n *\n * @param iterable An iterator to return the last value of.\n * @returns The value at the last position in the source iterator, or `undefined` if the iterator is empty.\n *\n * @example\n * ```typescript\n * import { last } from '@sapphire/iterator-utilities';\n *\n * const iterable = [1, 2, 3, 4, 5];\n * console.log(last(iterable));\n * // Output: 5\n * ```\n *\n * @remarks\n *\n * This function consumes the entire iterator to find the last value.\n */\nexport function last<const ElementType>(iterable: IterableResolvable<ElementType>): ElementType | undefined {\n\tlet last: ElementType | undefined;\n\tfor (const value of toIterableIterator(iterable)) {\n\t\tlast = value;\n\t}\n\n\treturn last;\n}\n"]}

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

@@ -0,0 +1,20 @@
+import { IterableResolvable } from './from.mjs';
+
+/**
+ * Creates an iterable with the results of calling a provided function on each element.
+ *
+ * @param iterable An iterator to map over.
+ * @param callbackFn A function to execute for each element produced by the iterator. Its return value is yielded by the iterator helper.
+ *
+ * @example
+ * ```typescript
+ * import { map } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = [1, 2, 3, 4, 5];
+ * console.log([...map(iterable, (value) => value * 2)]);
+ * // Output: [2, 4, 6, 8, 10]
+ * ```
+ */
+declare function map<const ElementType, const MappedType>(iterable: IterableResolvable<ElementType>, callbackFn: (element: ElementType, index: number) => MappedType): IterableIterator<MappedType>;
+
+export { map };

package/dist/esm/lib/map.mjs

@@ -0,0 +1,16 @@
+import { __name } from '../chunk-G5GHKT7C.mjs';
+import { assertFunction } from './shared/_assertFunction.mjs';
+import { toIterableIterator } from './toIterableIterator.mjs';
+
+function* map(iterable, callbackFn) {
+  callbackFn = assertFunction(callbackFn);
+  let index = 0;
+  for (const element of toIterableIterator(iterable)) {
+    yield callbackFn(element, index++);
+  }
+}
+__name(map, "map");
+
+export { map };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=map.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/map.ts"],"names":[],"mappings":";;;;;AACA,SAAS,sBAAsB;AAC/B,SAAS,0BAA0B;AAiB5B,UAAU,IAChB,UACA,YAC+B;AAC/B,eAAa,eAAe,UAAU;AAEtC,MAAI,QAAQ;AACZ,aAAW,WAAW,mBAAmB,QAAQ,GAAG;AACnD,UAAM,WAAW,SAAS,OAAO;AAAA,EAClC;AACD;AAViB","sourcesContent":["import type { IterableResolvable } from './from';\nimport { assertFunction } from './shared/_assertFunction';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Creates an iterable with the results of calling a provided function on each element.\n *\n * @param iterable An iterator to map over.\n * @param callbackFn A function to execute for each element produced by the iterator. Its return value is yielded by the iterator helper.\n *\n * @example\n * ```typescript\n * import { map } from '@sapphire/iterator-utilities';\n *\n * const iterable = [1, 2, 3, 4, 5];\n * console.log([...map(iterable, (value) => value * 2)]);\n * // Output: [2, 4, 6, 8, 10]\n * ```\n */\nexport function* map<const ElementType, const MappedType>(\n\titerable: IterableResolvable<ElementType>,\n\tcallbackFn: (element: ElementType, index: number) => MappedType\n): IterableIterator<MappedType> {\n\tcallbackFn = assertFunction(callbackFn);\n\n\tlet index = 0;\n\tfor (const element of toIterableIterator(iterable)) {\n\t\tyield callbackFn(element, index++);\n\t}\n}\n"]}

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

@@ -0,0 +1,25 @@
+import { IterableResolvable } from './from.mjs';
+import { NumberResolvable } from './shared/_toNumberOrThrow.mjs';
+
+/**
+ * Consumes the iterable and returns the highest number element. If the iterable is empty, or contains only non-number values, it returns `null`.
+ *
+ * @param iterable An iterator of number values to determine the maximum value of.
+ * @returns The maximum value in the input iterator, or `null` if the iterator is empty or contains only non-number values.
+ *
+ * @example
+ * ```typescript
+ * import { max } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = [1, 2, 3, 4, 5];
+ * console.log(max(iterable));
+ * // Output: 5
+ * ```
+ *
+ * @remarks
+ *
+ * This function consumes the entire iterator.
+ */
+declare function max(iterable: IterableResolvable<NumberResolvable>): number | null;
+
+export { max };

package/dist/esm/lib/max.mjs

@@ -0,0 +1,17 @@
+import { __name } from '../chunk-G5GHKT7C.mjs';
+import { map } from './map.mjs';
+import { toNumberOrThrow } from './shared/_toNumberOrThrow.mjs';
+
+function max(iterable) {
+  let max2 = null;
+  for (const value of map(iterable, toNumberOrThrow)) {
+    if (max2 === null || value > max2)
+      max2 = value;
+  }
+  return max2;
+}
+__name(max, "max");
+
+export { max };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=max.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/max.ts"],"names":["max"],"mappings":";;;;;AACA,SAAS,WAAW;AACpB,SAAS,uBAA8C;AAqBhD,SAAS,IAAI,UAA+D;AAClF,MAAIA,OAAqB;AACzB,aAAW,SAAS,IAAI,UAAU,eAAe,GAAG;AACnD,QAAIA,SAAQ,QAAQ,QAAQA;AAAK,MAAAA,OAAM;AAAA,EACxC;AAEA,SAAOA;AACR;AAPgB","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 highest 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 maximum value of.\n * @returns The maximum 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 { max } from '@sapphire/iterator-utilities';\n *\n * const iterable = [1, 2, 3, 4, 5];\n * console.log(max(iterable));\n * // Output: 5\n * ```\n *\n * @remarks\n *\n * This function consumes the entire iterator.\n */\nexport function max(iterable: IterableResolvable<NumberResolvable>): number | null {\n\tlet max: number | null = null;\n\tfor (const value of map(iterable, toNumberOrThrow)) {\n\t\tif (max === null || value > max) max = value;\n\t}\n\n\treturn max;\n}\n"]}

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

@@ -0,0 +1,25 @@
+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`.
+ *
+ * @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.
+ *
+ * @example
+ * ```typescript
+ * import { min } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = [1, 2, 3, 4, 5];
+ * console.log(min(iterable));
+ * // Output: 1
+ * ```
+ *
+ * @remarks
+ *
+ * This function consumes the entire iterator.
+ */
+declare function min(iterable: IterableResolvable<NumberResolvable>): number | null;
+
+export { min };

package/dist/esm/lib/min.mjs

@@ -0,0 +1,17 @@
+import { __name } from '../chunk-G5GHKT7C.mjs';
+import { map } from './map.mjs';
+import { toNumberOrThrow } from './shared/_toNumberOrThrow.mjs';
+
+function min(iterable) {
+  let min2 = null;
+  for (const value of map(iterable, toNumberOrThrow)) {
+    if (min2 === null || value < min2)
+      min2 = value;
+  }
+  return min2;
+}
+__name(min, "min");
+
+export { min };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=min.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/min.ts"],"names":["min"],"mappings":";;;;;AACA,SAAS,WAAW;AACpB,SAAS,uBAA8C;AAqBhD,SAAS,IAAI,UAA+D;AAClF,MAAIA,OAAqB;AACzB,aAAW,SAAS,IAAI,UAAU,eAAe,GAAG;AACnD,QAAIA,SAAQ,QAAQ,QAAQA;AAAK,MAAAA,OAAM;AAAA,EACxC;AAEA,SAAOA;AACR;AAPgB","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"]}

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

@@ -0,0 +1,33 @@
+import { IterableResolvable } from './from.mjs';
+
+/**
+ * Consumes the iterable and creates two arrays, one with the elements that pass the test and another with the elements that don't.
+ *
+ * @param iterable An iterator to partition.
+ * @param predicate A function that determines which partition an element belongs to.
+ * @returns An array containing two iterators. The first iterator contains elements that satisfy the predicate, and the
+ * second iterator contains elements that do not.
+ *
+ * @example
+ * ```typescript
+ * import { partition } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = [1, 2, 3, 4, 5];
+ * const [even, odd] = partition(iterable, (value) => value % 2 === 0);
+ *
+ * console.log(even);
+ * // Output: [2, 4]
+ *
+ * console.log(odd);
+ * // Output: [1, 3, 5]
+ * ```
+ *
+ * @remarks
+ *
+ * This function collects all elements of the provided iterator into two arrays based on the predicate before returning
+ * them, which may not be desirable for large iterators.
+ */
+declare function partition<const ElementType, const FilteredType extends ElementType>(iterable: IterableResolvable<ElementType>, predicate: (value: ElementType, index: number) => value is FilteredType): [FilteredType[], Exclude<ElementType, FilteredType>[]];
+declare function partition<const ElementType>(iterable: IterableResolvable<ElementType>, predicate: (value: ElementType, index: number) => boolean): [ElementType[], ElementType[]];
+
+export { partition };

package/dist/esm/lib/partition.mjs

@@ -0,0 +1,23 @@
+import { __name } from '../chunk-G5GHKT7C.mjs';
+import { assertFunction } from './shared/_assertFunction.mjs';
+import { toIterableIterator } from './toIterableIterator.mjs';
+
+function partition(iterable, predicate) {
+  predicate = assertFunction(predicate);
+  const bufferLeft = [];
+  const bufferRight = [];
+  let index = 0;
+  for (const value of toIterableIterator(iterable)) {
+    if (predicate(value, index++)) {
+      bufferLeft.push(value);
+    } else {
+      bufferRight.push(value);
+    }
+  }
+  return [bufferLeft, bufferRight];
+}
+__name(partition, "partition");
+
+export { partition };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=partition.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/partition.ts"],"names":[],"mappings":";;;;;AACA,SAAS,sBAAsB;AAC/B,SAAS,0BAA0B;AAsC5B,SAAS,UACf,UACA,WACiC;AACjC,cAAY,eAAe,SAAS;AAEpC,QAAM,aAA4B,CAAC;AACnC,QAAM,cAA6B,CAAC;AAEpC,MAAI,QAAQ;AACZ,aAAW,SAAS,mBAAmB,QAAQ,GAAG;AACjD,QAAI,UAAU,OAAO,OAAO,GAAG;AAC9B,iBAAW,KAAK,KAAK;AAAA,IACtB,OAAO;AACN,kBAAY,KAAK,KAAK;AAAA,IACvB;AAAA,EACD;AAEA,SAAO,CAAC,YAAY,WAAW;AAChC;AAnBgB","sourcesContent":["import type { IterableResolvable } from './from';\nimport { assertFunction } from './shared/_assertFunction';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Consumes the iterable and creates two arrays, one with the elements that pass the test and another with the elements that don't.\n *\n * @param iterable An iterator to partition.\n * @param predicate A function that determines which partition an element belongs to.\n * @returns An array containing two iterators. The first iterator contains elements that satisfy the predicate, and the\n * second iterator contains elements that do not.\n *\n * @example\n * ```typescript\n * import { partition } from '@sapphire/iterator-utilities';\n *\n * const iterable = [1, 2, 3, 4, 5];\n * const [even, odd] = partition(iterable, (value) => value % 2 === 0);\n *\n * console.log(even);\n * // Output: [2, 4]\n *\n * console.log(odd);\n * // Output: [1, 3, 5]\n * ```\n *\n * @remarks\n *\n * This function collects all elements of the provided iterator into two arrays based on the predicate before returning\n * them, which may not be desirable for large iterators.\n */\nexport function partition<const ElementType, const FilteredType extends ElementType>(\n\titerable: IterableResolvable<ElementType>,\n\tpredicate: (value: ElementType, index: number) => value is FilteredType\n): [FilteredType[], Exclude<ElementType, FilteredType>[]];\nexport function partition<const ElementType>(\n\titerable: IterableResolvable<ElementType>,\n\tpredicate: (value: ElementType, index: number) => boolean\n): [ElementType[], ElementType[]];\n\nexport function partition<const ElementType>(\n\titerable: IterableResolvable<ElementType>,\n\tpredicate: (value: ElementType, index: number) => boolean\n): [ElementType[], ElementType[]] {\n\tpredicate = assertFunction(predicate);\n\n\tconst bufferLeft: ElementType[] = [];\n\tconst bufferRight: ElementType[] = [];\n\n\tlet index = 0;\n\tfor (const value of toIterableIterator(iterable)) {\n\t\tif (predicate(value, index++)) {\n\t\t\tbufferLeft.push(value);\n\t\t} else {\n\t\t\tbufferRight.push(value);\n\t\t}\n\t}\n\n\treturn [bufferLeft, bufferRight];\n}\n"]}

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

@@ -0,0 +1,35 @@
+import { IterableResolvable } from './from.mjs';
+
+/**
+ * Creates an iterator that allows you to peek at the next element without advancing the iterator.
+ *
+ * @template ElementType The type of elements in the iterable.
+ * @param iterable The iterable to create a peekable iterator from.
+ * @returns A new peekable iterator.
+ *
+ * @example
+ * ```typescript
+ * import { peekable } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = [1, 2, 3, 4, 5];
+ * const peekableIterator = peekable(iterable);
+ *
+ * console.log(peekableIterator.next());
+ * // Output: { value: 1, done: false }
+ *
+ * console.log(peekableIterator.peek());
+ * // Output: { value: 2, done: false }
+ *
+ * console.log(peekableIterator.next());
+ * // Output: { value: 2, done: false }
+ *
+ * console.log(peekableIterator.next());
+ * // Output: { value: 3, done: false }
+ * ```
+ */
+declare function peekable<const ElementType>(iterable: IterableResolvable<ElementType>): Peekable<ElementType>;
+interface Peekable<T> extends IterableIterator<T> {
+    peek(): IteratorResult<T> | undefined;
+}
+
+export { type Peekable, peekable };

package/dist/esm/lib/peekable.mjs

@@ -0,0 +1,29 @@
+import { __name } from '../chunk-G5GHKT7C.mjs';
+import { from } from './from.mjs';
+
+function peekable(iterable) {
+  const resolvedIterable = from(iterable);
+  let peeked;
+  return {
+    next() {
+      if (peeked) {
+        const value = peeked;
+        peeked = void 0;
+        return value;
+      }
+      return resolvedIterable.next();
+    },
+    peek() {
+      peeked = peeked ?? resolvedIterable.next();
+      return peeked;
+    },
+    [Symbol.iterator]() {
+      return this;
+    }
+  };
+}
+__name(peekable, "peekable");
+
+export { peekable };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=peekable.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/peekable.ts"],"names":[],"mappings":";;;;;AAAA,SAAS,YAAqC;AA6BvC,SAAS,SAA4B,UAAkE;AAC7G,QAAM,mBAAmB,KAAK,QAAQ;AACtC,MAAI;AACJ,SAAO;AAAA,IACN,OAAO;AACN,UAAI,QAAQ;AACX,cAAM,QAAQ;AACd,iBAAS;AACT,eAAO;AAAA,MACR;AAEA,aAAO,iBAAiB,KAAK;AAAA,IAC9B;AAAA,IACA,OAAO;AACN,eAAS,UAAU,iBAAiB,KAAK;AACzC,aAAO;AAAA,IACR;AAAA,IACA,CAAC,OAAO,QAAQ,IAAI;AACnB,aAAO;AAAA,IACR;AAAA,EACD;AACD;AArBgB","sourcesContent":["import { from, type IterableResolvable } from './from';\n\n/**\n * Creates an iterator that allows you to peek at the next element without advancing the iterator.\n *\n * @template ElementType The type of elements in the iterable.\n * @param iterable The iterable to create a peekable iterator from.\n * @returns A new peekable iterator.\n *\n * @example\n * ```typescript\n * import { peekable } from '@sapphire/iterator-utilities';\n *\n * const iterable = [1, 2, 3, 4, 5];\n * const peekableIterator = peekable(iterable);\n *\n * console.log(peekableIterator.next());\n * // Output: { value: 1, done: false }\n *\n * console.log(peekableIterator.peek());\n * // Output: { value: 2, done: false }\n *\n * console.log(peekableIterator.next());\n * // Output: { value: 2, done: false }\n *\n * console.log(peekableIterator.next());\n * // Output: { value: 3, done: false }\n * ```\n */\nexport function peekable<const ElementType>(iterable: IterableResolvable<ElementType>): Peekable<ElementType> {\n\tconst resolvedIterable = from(iterable);\n\tlet peeked: IteratorResult<ElementType> | undefined;\n\treturn {\n\t\tnext() {\n\t\t\tif (peeked) {\n\t\t\t\tconst value = peeked;\n\t\t\t\tpeeked = undefined;\n\t\t\t\treturn value;\n\t\t\t}\n\n\t\t\treturn resolvedIterable.next();\n\t\t},\n\t\tpeek() {\n\t\t\tpeeked = peeked ?? resolvedIterable.next();\n\t\t\treturn peeked;\n\t\t},\n\t\t[Symbol.iterator]() {\n\t\t\treturn this as IterableIterator<ElementType>;\n\t\t}\n\t};\n}\n\nexport interface Peekable<T> extends IterableIterator<T> {\n\tpeek(): IteratorResult<T> | undefined;\n}\n"]}

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

@@ -0,0 +1,22 @@
+import { IterableResolvable } from './from.mjs';
+
+/**
+ * Creates an iterator with the provided iterables prepended to the first iterable.
+ *
+ * @param iterable The iterator to prepend values to.
+ * @param iterables The iterables to prepend to the iterator.
+ * @returns An iterator that yields the values of the provided iterator followed by the values of the provided iterables.
+ *
+ * @example
+ * ```typescript
+ * import { prepend } from '@sapphire/iterator-utilities';
+ *
+ * console.log([...prepend([3, 4, 5], [1, 2])]);
+ * // Output: [1, 2, 3, 4, 5]
+ * ```
+ *
+ * @seealso {@link append} to append values to the end of an iterator.
+ */
+declare function prepend<const ElementType>(iterable: IterableResolvable<ElementType>, ...iterables: IterableResolvable<ElementType>[]): IterableIterator<ElementType>;
+
+export { prepend };

package/dist/esm/lib/prepend.mjs

@@ -0,0 +1,14 @@
+import { __name } from '../chunk-G5GHKT7C.mjs';
+import { toIterableIterator } from './toIterableIterator.mjs';
+
+function* prepend(iterable, ...iterables) {
+  for (const iterable2 of iterables) {
+    yield* toIterableIterator(iterable2);
+  }
+  yield* toIterableIterator(iterable);
+}
+__name(prepend, "prepend");
+
+export { prepend };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=prepend.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/prepend.ts"],"names":["iterable"],"mappings":";;;;;AACA,SAAS,0BAA0B;AAmB5B,UAAU,QAChB,aACG,WAC6B;AAChC,aAAWA,aAAY,WAAW;AACjC,WAAO,mBAAmBA,SAAQ;AAAA,EACnC;AAEA,SAAO,mBAAmB,QAAQ;AACnC;AATiB","sourcesContent":["import type { IterableResolvable } from './from';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Creates an iterator with the provided iterables prepended to the first iterable.\n *\n * @param iterable The iterator to prepend values to.\n * @param iterables The iterables to prepend to the iterator.\n * @returns An iterator that yields the values of the provided iterator followed by the values of the provided iterables.\n *\n * @example\n * ```typescript\n * import { prepend } from '@sapphire/iterator-utilities';\n *\n * console.log([...prepend([3, 4, 5], [1, 2])]);\n * // Output: [1, 2, 3, 4, 5]\n * ```\n *\n * @seealso {@link append} to append values to the end of an iterator.\n */\nexport function* prepend<const ElementType>(\n\titerable: IterableResolvable<ElementType>,\n\t...iterables: IterableResolvable<ElementType>[]\n): IterableIterator<ElementType> {\n\tfor (const iterable of iterables) {\n\t\tyield* toIterableIterator(iterable);\n\t}\n\n\tyield* toIterableIterator(iterable);\n}\n"]}

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

@@ -0,0 +1,24 @@
+import { IterableResolvable } from './from.mjs';
+
+/**
+ * Consumes the iterable and returns the product of all the elements. If the iterable is empty, it returns `1`.
+ *
+ * @param iterable An iterator to calculate the product of.
+ * @returns The product of the elements in the input iterator.
+ *
+ * @example
+ * ```typescript
+ * import { product } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = [1, 2, 3, 4, 5];
+ * console.log(product(iterable));
+ * // Output: 120
+ *
+ * const iterable = [1, 2, 3, 4, 5, 0];
+ * console.log(product(iterable));
+ * // Output: 0
+ * ```
+ */
+declare function product(iterable: IterableResolvable<number>): number;
+
+export { product };

package/dist/esm/lib/product.mjs

@@ -0,0 +1,16 @@
+import { __name } from '../chunk-G5GHKT7C.mjs';
+import { map } from './map.mjs';
+import { toNumberOrThrow } from './shared/_toNumberOrThrow.mjs';
+
+function product(iterable) {
+  let result = 1;
+  for (const value of map(iterable, toNumberOrThrow)) {
+    result *= value;
+  }
+  return result;
+}
+__name(product, "product");
+
+export { product };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=product.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/product.ts"],"names":[],"mappings":";;;;;AACA,SAAS,WAAW;AACpB,SAAS,uBAAuB;AAqBzB,SAAS,QAAQ,UAA8C;AACrE,MAAI,SAAS;AACb,aAAW,SAAS,IAAI,UAAU,eAAe,GAAG;AACnD,cAAU;AAAA,EACX;AAEA,SAAO;AACR;AAPgB","sourcesContent":["import type { IterableResolvable } from './from';\nimport { map } from './map';\nimport { toNumberOrThrow } from './shared/_toNumberOrThrow';\n\n/**\n * Consumes the iterable and returns the product of all the elements. If the iterable is empty, it returns `1`.\n *\n * @param iterable An iterator to calculate the product of.\n * @returns The product of the elements in the input iterator.\n *\n * @example\n * ```typescript\n * import { product } from '@sapphire/iterator-utilities';\n *\n * const iterable = [1, 2, 3, 4, 5];\n * console.log(product(iterable));\n * // Output: 120\n *\n * const iterable = [1, 2, 3, 4, 5, 0];\n * console.log(product(iterable));\n * // Output: 0\n * ```\n */\nexport function product(iterable: IterableResolvable<number>): number {\n\tlet result = 1;\n\tfor (const value of map(iterable, toNumberOrThrow)) {\n\t\tresult *= value;\n\t}\n\n\treturn result;\n}\n"]}

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

@@ -0,0 +1,33 @@
+/**
+ * Creates an iterable with the numbers from `start` to `stop` (exclusive) with an optional step.
+ *
+ * @param start The value of the first number in the range.
+ * @param end The end value of the range.
+ * @param step The amount to increment the range by.
+ *
+ * @example
+ * ```typescript
+ * import { range } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = range(0, 5);
+ * console.log([...iterable]);
+ * // Output: [0, 1, 2, 3, 4]
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const iterable = range(5, 0);
+ * console.log([...iterable]);
+ * // Output: [5, 4, 3, 2, 1]
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const iterable = range(0, 5, 2);
+ * console.log([...iterable]);
+ * // Output: [0, 2, 4]
+ * ```
+ */
+declare function range(start: number, end: number, step?: number | undefined): IterableIterator<number>;
+
+export { range };

package/dist/esm/lib/range.mjs

@@ -0,0 +1,34 @@
+import { __name } from '../chunk-G5GHKT7C.mjs';
+import { toNumberOrThrow } from './shared/_toNumberOrThrow.mjs';
+
+function* range(start, end, step) {
+  start = toNumberOrThrow(start);
+  end = toNumberOrThrow(end);
+  if (step === void 0) {
+    step = start < end ? 1 : -1;
+  } else {
+    step = toNumberOrThrow(step);
+    if (step === 0) {
+      throw new RangeError("Step cannot be zero");
+    }
+    if (step > 0 && start > end) {
+      throw new RangeError("Start must be less than end when step is positive");
+    } else if (step < 0 && start < end) {
+      throw new RangeError("Start must be greater than end when step is negative");
+    }
+  }
+  if (start < end) {
+    for (let i = start; i < end; i += step) {
+      yield i;
+    }
+  } else {
+    for (let i = start; i > end; i += step) {
+      yield i;
+    }
+  }
+}
+__name(range, "range");
+
+export { range };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=range.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/range.ts"],"names":[],"mappings":";;;;;AAAA,SAAS,uBAAuB;AAgCzB,UAAU,MAAM,OAAe,KAAa,MAAqD;AACvG,UAAQ,gBAAgB,KAAK;AAC7B,QAAM,gBAAgB,GAAG;AAEzB,MAAI,SAAS,QAAW;AACvB,WAAO,QAAQ,MAAM,IAAI;AAAA,EAC1B,OAAO;AACN,WAAO,gBAAgB,IAAI;AAG3B,QAAI,SAAS,GAAG;AACf,YAAM,IAAI,WAAW,qBAAqB;AAAA,IAC3C;AAGA,QAAI,OAAO,KAAK,QAAQ,KAAK;AAC5B,YAAM,IAAI,WAAW,mDAAmD;AAAA,IACzE,WAAW,OAAO,KAAK,QAAQ,KAAK;AACnC,YAAM,IAAI,WAAW,sDAAsD;AAAA,IAC5E;AAAA,EACD;AAEA,MAAI,QAAQ,KAAK;AAChB,aAAS,IAAI,OAAO,IAAI,KAAK,KAAK,MAAM;AACvC,YAAM;AAAA,IACP;AAAA,EACD,OAAO;AACN,aAAS,IAAI,OAAO,IAAI,KAAK,KAAK,MAAM;AACvC,YAAM;AAAA,IACP;AAAA,EACD;AACD;AA/BiB","sourcesContent":["import { toNumberOrThrow } from './shared/_toNumberOrThrow';\n\n/**\n * Creates an iterable with the numbers from `start` to `stop` (exclusive) with an optional step.\n *\n * @param start The value of the first number in the range.\n * @param end The end value of the range.\n * @param step The amount to increment the range by.\n *\n * @example\n * ```typescript\n * import { range } from '@sapphire/iterator-utilities';\n *\n * const iterable = range(0, 5);\n * console.log([...iterable]);\n * // Output: [0, 1, 2, 3, 4]\n * ```\n *\n * @example\n * ```typescript\n * const iterable = range(5, 0);\n * console.log([...iterable]);\n * // Output: [5, 4, 3, 2, 1]\n * ```\n *\n * @example\n * ```typescript\n * const iterable = range(0, 5, 2);\n * console.log([...iterable]);\n * // Output: [0, 2, 4]\n * ```\n */\nexport function* range(start: number, end: number, step?: number | undefined): IterableIterator<number> {\n\tstart = toNumberOrThrow(start);\n\tend = toNumberOrThrow(end);\n\n\tif (step === undefined) {\n\t\tstep = start < end ? 1 : -1;\n\t} else {\n\t\tstep = toNumberOrThrow(step);\n\n\t\t// Prevent infinite loops.\n\t\tif (step === 0) {\n\t\t\tthrow new RangeError('Step cannot be zero');\n\t\t}\n\n\t\t// If the step is positive, the start must be less than the end.\n\t\tif (step > 0 && start > end) {\n\t\t\tthrow new RangeError('Start must be less than end when step is positive');\n\t\t} else if (step < 0 && start < end) {\n\t\t\tthrow new RangeError('Start must be greater than end when step is negative');\n\t\t}\n\t}\n\n\tif (start < end) {\n\t\tfor (let i = start; i < end; i += step) {\n\t\t\tyield i;\n\t\t}\n\t} else {\n\t\tfor (let i = start; i > end; i += step) {\n\t\t\tyield i;\n\t\t}\n\t}\n}\n"]}

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

@@ -0,0 +1,33 @@
+import { IterableResolvable } from './from.mjs';
+
+/**
+ * Consumes the iterable and reduces it to the reducer function's result.
+ *
+ * @param iterable An iterator to reduce.
+ * @param callbackFn A function to execute for each element produced by the iterator. Its return value becomes the value
+ * of the `accumulator` parameter on the next invocation of `callbackFn`. For the last invocation, the return value
+ * becomes the return value of `reduce()`.
+ * @param initialValue A value to which `accumulator` is initialized the first time the callback is called. If
+ * `initialValue` is specified, `callbackFn` starts executing with the first element as `currentValue`. If
+ * `initialValue` is not specified, `accumulator` is initialized to the first element, and `callbackFn` starts executing
+ * with the second element as `currentValue`. In this case, if the iterator is empty (so that there's no first value to
+ * return as `accumulator`), an error is thrown.
+ * @returns
+ *
+ * @example
+ * ```typescript
+ * import { reduce } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = [1, 2, 3, 4, 5];
+ * console.log(reduce(iterable, (accumulator, currentValue) => accumulator + currentValue));
+ * // Output: 15
+ * ```
+ *
+ * @remarks
+ *
+ * If `initialValue` is not provided, the first element of the iterator is used as the initial value of `accumulator`,
+ * consuming the first element.
+ */
+declare function reduce<const ElementType, const MappedType>(iterable: IterableResolvable<ElementType>, callbackFn: (accumulator: MappedType, currentValue: ElementType, currentIndex: number) => MappedType, initialValue?: MappedType): MappedType;
+
+export { reduce };