@sapphire/iterator-utilities 1.0.0

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

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

@@ -0,0 +1,19 @@
+'use strict';
+
+var _assertFunction_cjs = require('./shared/_assertFunction.cjs');
+var toIterableIterator_cjs = require('./toIterableIterator.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function* map(iterable, callbackFn) {
+  callbackFn = _assertFunction_cjs.assertFunction(callbackFn);
+  let index = 0;
+  for (const element of toIterableIterator_cjs.toIterableIterator(iterable)) {
+    yield callbackFn(element, index++);
+  }
+}
+__name(map, "map");
+
+exports.map = map;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=map.cjs.map

package/dist/cjs/lib/map.cjs.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/cjs/lib/map.d.cts

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

@@ -0,0 +1,20 @@
+'use strict';
+
+var map_cjs = require('./map.cjs');
+var _toNumberOrThrow_cjs = require('./shared/_toNumberOrThrow.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function max(iterable) {
+  let max2 = null;
+  for (const value of map_cjs.map(iterable, _toNumberOrThrow_cjs.toNumberOrThrow)) {
+    if (max2 === null || value > max2)
+      max2 = value;
+  }
+  return max2;
+}
+__name(max, "max");
+
+exports.max = max;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=max.cjs.map

package/dist/cjs/lib/max.cjs.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/cjs/lib/max.d.cts

@@ -0,0 +1,25 @@
+import { IterableResolvable } from './from.cjs';
+import { NumberResolvable } from './shared/_toNumberOrThrow.js';
+
+/**
+ * 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/cjs/lib/min.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var map_cjs = require('./map.cjs');
+var _toNumberOrThrow_cjs = require('./shared/_toNumberOrThrow.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function min(iterable) {
+  let min2 = null;
+  for (const value of map_cjs.map(iterable, _toNumberOrThrow_cjs.toNumberOrThrow)) {
+    if (min2 === null || value < min2)
+      min2 = value;
+  }
+  return min2;
+}
+__name(min, "min");
+
+exports.min = min;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=min.cjs.map

package/dist/cjs/lib/min.cjs.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/cjs/lib/min.d.cts

@@ -0,0 +1,25 @@
+import { IterableResolvable } from './from.cjs';
+import { NumberResolvable } from './shared/_toNumberOrThrow.js';
+
+/**
+ * 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/cjs/lib/partition.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+var _assertFunction_cjs = require('./shared/_assertFunction.cjs');
+var toIterableIterator_cjs = require('./toIterableIterator.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function partition(iterable, predicate) {
+  predicate = _assertFunction_cjs.assertFunction(predicate);
+  const bufferLeft = [];
+  const bufferRight = [];
+  let index = 0;
+  for (const value of toIterableIterator_cjs.toIterableIterator(iterable)) {
+    if (predicate(value, index++)) {
+      bufferLeft.push(value);
+    } else {
+      bufferRight.push(value);
+    }
+  }
+  return [bufferLeft, bufferRight];
+}
+__name(partition, "partition");
+
+exports.partition = partition;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=partition.cjs.map

package/dist/cjs/lib/partition.cjs.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/cjs/lib/partition.d.cts

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

@@ -0,0 +1,32 @@
+'use strict';
+
+var from_cjs = require('./from.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function peekable(iterable) {
+  const resolvedIterable = from_cjs.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");
+
+exports.peekable = peekable;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=peekable.cjs.map

package/dist/cjs/lib/peekable.cjs.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/cjs/lib/peekable.d.cts

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

@@ -0,0 +1,17 @@
+'use strict';
+
+var toIterableIterator_cjs = require('./toIterableIterator.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function* prepend(iterable, ...iterables) {
+  for (const iterable2 of iterables) {
+    yield* toIterableIterator_cjs.toIterableIterator(iterable2);
+  }
+  yield* toIterableIterator_cjs.toIterableIterator(iterable);
+}
+__name(prepend, "prepend");
+
+exports.prepend = prepend;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=prepend.cjs.map

package/dist/cjs/lib/prepend.cjs.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/cjs/lib/prepend.d.cts

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

@@ -0,0 +1,19 @@
+'use strict';
+
+var map_cjs = require('./map.cjs');
+var _toNumberOrThrow_cjs = require('./shared/_toNumberOrThrow.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function product(iterable) {
+  let result = 1;
+  for (const value of map_cjs.map(iterable, _toNumberOrThrow_cjs.toNumberOrThrow)) {
+    result *= value;
+  }
+  return result;
+}
+__name(product, "product");
+
+exports.product = product;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=product.cjs.map

package/dist/cjs/lib/product.cjs.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/cjs/lib/product.d.cts

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

@@ -0,0 +1,37 @@
+'use strict';
+
+var _toNumberOrThrow_cjs = require('./shared/_toNumberOrThrow.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function* range(start, end, step) {
+  start = _toNumberOrThrow_cjs.toNumberOrThrow(start);
+  end = _toNumberOrThrow_cjs.toNumberOrThrow(end);
+  if (step === void 0) {
+    step = start < end ? 1 : -1;
+  } else {
+    step = _toNumberOrThrow_cjs.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");
+
+exports.range = range;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=range.cjs.map

package/dist/cjs/lib/range.cjs.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/cjs/lib/range.d.cts

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

@@ -0,0 +1,32 @@
+'use strict';
+
+var _assertFunction_cjs = require('./shared/_assertFunction.cjs');
+var toIterableIterator_cjs = require('./toIterableIterator.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function reduce(iterable, callbackFn, initialValue) {
+  callbackFn = _assertFunction_cjs.assertFunction(callbackFn);
+  let index;
+  let accumulator;
+  const resolvedIterable = toIterableIterator_cjs.toIterableIterator(iterable);
+  if (arguments.length < 3) {
+    const firstValue = resolvedIterable.next();
+    if (firstValue.done)
+      throw new TypeError("Reduce of empty iterator with no initial value");
+    index = 1;
+    accumulator = firstValue.value;
+  } else {
+    index = 0;
+    accumulator = initialValue;
+  }
+  for (const value of resolvedIterable) {
+    accumulator = callbackFn(accumulator, value, index++);
+  }
+  return accumulator;
+}
+__name(reduce, "reduce");
+
+exports.reduce = reduce;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=reduce.cjs.map

package/dist/cjs/lib/reduce.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/reduce.ts"],"names":[],"mappings":";;;;AACA,SAAS,sBAAsB;AAC/B,SAAS,0BAA0B;AA8B5B,SAAS,OACf,UACA,YACA,cACa;AACb,eAAa,eAAe,UAAU;AAEtC,MAAI;AACJ,MAAI;AACJ,QAAM,mBAAmB,mBAAmB,QAAQ;AACpD,MAAI,UAAU,SAAS,GAAG;AACzB,UAAM,aAAa,iBAAiB,KAAK;AACzC,QAAI,WAAW;AAAM,YAAM,IAAI,UAAU,gDAAgD;AAEzF,YAAQ;AACR,kBAAc,WAAW;AAAA,EAC1B,OAAO;AACN,YAAQ;AACR,kBAAc;AAAA,EACf;AAEA,aAAW,SAAS,kBAAkB;AACrC,kBAAc,WAAW,aAAa,OAAO,OAAO;AAAA,EACrD;AAEA,SAAO;AACR;AA1BgB","sourcesContent":["import type { IterableResolvable } from './from';\nimport { assertFunction } from './shared/_assertFunction';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Consumes the iterable and reduces it to the reducer function's result.\n *\n * @param iterable An iterator to reduce.\n * @param callbackFn A function to execute for each element produced by the iterator. Its return value becomes the value\n * of the `accumulator` parameter on the next invocation of `callbackFn`. For the last invocation, the return value\n * becomes the return value of `reduce()`.\n * @param initialValue A value to which `accumulator` is initialized the first time the callback is called. If\n * `initialValue` is specified, `callbackFn` starts executing with the first element as `currentValue`. If\n * `initialValue` is not specified, `accumulator` is initialized to the first element, and `callbackFn` starts executing\n * with the second element as `currentValue`. In this case, if the iterator is empty (so that there's no first value to\n * return as `accumulator`), an error is thrown.\n * @returns\n *\n * @example\n * ```typescript\n * import { reduce } from '@sapphire/iterator-utilities';\n *\n * const iterable = [1, 2, 3, 4, 5];\n * console.log(reduce(iterable, (accumulator, currentValue) => accumulator + currentValue));\n * // Output: 15\n * ```\n *\n * @remarks\n *\n * If `initialValue` is not provided, the first element of the iterator is used as the initial value of `accumulator`,\n * consuming the first element.\n */\nexport function reduce<const ElementType, const MappedType>(\n\titerable: IterableResolvable<ElementType>,\n\tcallbackFn: (accumulator: MappedType, currentValue: ElementType, currentIndex: number) => MappedType,\n\tinitialValue?: MappedType\n): MappedType {\n\tcallbackFn = assertFunction(callbackFn);\n\n\tlet index: number;\n\tlet accumulator: MappedType;\n\tconst resolvedIterable = toIterableIterator(iterable);\n\tif (arguments.length < 3) {\n\t\tconst firstValue = resolvedIterable.next();\n\t\tif (firstValue.done) throw new TypeError('Reduce of empty iterator with no initial value');\n\n\t\tindex = 1;\n\t\taccumulator = firstValue.value! as MappedType;\n\t} else {\n\t\tindex = 0;\n\t\taccumulator = initialValue!;\n\t}\n\n\tfor (const value of resolvedIterable) {\n\t\taccumulator = callbackFn(accumulator, value, index++);\n\t}\n\n\treturn accumulator;\n}\n"]}

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

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

package/dist/cjs/lib/repeat.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var _assertNotNegative_cjs = require('./shared/_assertNotNegative.cjs');
+var _makeIterableIterator_cjs = require('./shared/_makeIterableIterator.cjs');
+var _toNumberOrThrow_cjs = require('./shared/_toNumberOrThrow.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function repeat(value, count) {
+  count = _assertNotNegative_cjs.assertNotNegative(_toNumberOrThrow_cjs.toNumberOrThrow(count), count);
+  let i = 0;
+  return _makeIterableIterator_cjs.makeIterableIterator(
+    () => i >= count ? { done: true, value: void 0 } : (i++, { done: false, value })
+  );
+}
+__name(repeat, "repeat");
+
+exports.repeat = repeat;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=repeat.cjs.map

package/dist/cjs/lib/repeat.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/repeat.ts"],"names":[],"mappings":";;;;AAAA,SAAS,yBAAyB;AAClC,SAAS,4BAA4B;AACrC,SAAS,uBAAuB;AAmBzB,SAAS,OAA0B,OAAoB,OAA8C;AAC3G,UAAQ,kBAAkB,gBAAgB,KAAK,GAAG,KAAK;AAEvD,MAAI,IAAI;AACR,SAAO;AAAA,IAAkC,MACxC,KAAK,QACF,EAAE,MAAM,MAAM,OAAO,OAAU,KAC9B,KAAK,EAAE,MAAM,OAAO,MAAM;AAAA,EAC/B;AACD;AATgB","sourcesContent":["import { assertNotNegative } from './shared/_assertNotNegative';\nimport { makeIterableIterator } from './shared/_makeIterableIterator';\nimport { toNumberOrThrow } from './shared/_toNumberOrThrow';\n\n/**\n * Creates an iterable that repeats the input iterable `count` times.\n *\n * @param value The value to be repeated.\n * @param count The number of times to repeat the value.\n *\n * @example\n * ```typescript\n * import { repeat } from '@sapphire/iterator-utilities';\n *\n * const iterator = repeat('Hello, world!', 3);\n * console.log([...iterator]);\n * // Output: ['Hello, world!', 'Hello, world!', 'Hello, world!']\n * ```\n *\n * @remarks This function does not clone `value`, it will be repeated as a reference.\n */\nexport function repeat<const ElementType>(value: ElementType, count: number): IterableIterator<ElementType> {\n\tcount = assertNotNegative(toNumberOrThrow(count), count);\n\n\tlet i = 0;\n\treturn makeIterableIterator<ElementType>(() =>\n\t\ti >= count //\n\t\t\t? { done: true, value: undefined }\n\t\t\t: (i++, { done: false, value })\n\t);\n}\n"]}

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

@@ -0,0 +1,20 @@
+/**
+ * Creates an iterable that repeats the input iterable `count` times.
+ *
+ * @param value The value to be repeated.
+ * @param count The number of times to repeat the value.
+ *
+ * @example
+ * ```typescript
+ * import { repeat } from '@sapphire/iterator-utilities';
+ *
+ * const iterator = repeat('Hello, world!', 3);
+ * console.log([...iterator]);
+ * // Output: ['Hello, world!', 'Hello, world!', 'Hello, world!']
+ * ```
+ *
+ * @remarks This function does not clone `value`, it will be repeated as a reference.
+ */
+declare function repeat<const ElementType>(value: ElementType, count: number): IterableIterator<ElementType>;
+
+export { repeat };

package/dist/cjs/lib/reverse.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var toIterableIterator_cjs = require('./toIterableIterator.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);
+  }
+  for (let i = items.length - 1; i >= 0; i--) {
+    yield items[i];
+  }
+}
+__name(reverse, "reverse");
+
+exports.reverse = reverse;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=reverse.cjs.map