@sapphire/iterator-utilities 1.0.0

package/dist/cjs/lib/chunk.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+var _assertPositive_cjs = require('./shared/_assertPositive.cjs');
+var _toIntegerOrThrow_cjs = require('./shared/_toIntegerOrThrow.cjs');
+var toIterableIterator_cjs = require('./toIterableIterator.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function* chunk(iterable, size) {
+  size = _assertPositive_cjs.assertPositive(_toIntegerOrThrow_cjs.toIntegerOrThrow(size), size);
+  let buffer = [];
+  for (const element of toIterableIterator_cjs.toIterableIterator(iterable)) {
+    buffer.push(element);
+    if (buffer.length === size) {
+      yield buffer;
+      buffer = [];
+    }
+  }
+  if (buffer.length) {
+    yield buffer;
+  }
+}
+__name(chunk, "chunk");
+
+exports.chunk = chunk;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=chunk.cjs.map

package/dist/cjs/lib/chunk.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/chunk.ts"],"names":[],"mappings":";;;;AACA,SAAS,sBAAsB;AAC/B,SAAS,wBAAwB;AACjC,SAAS,0BAA0B;AAiB5B,UAAU,MAAyB,UAA2C,MAA+C;AACnI,SAAO,eAAe,iBAAiB,IAAI,GAAG,IAAI;AAElD,MAAI,SAAwB,CAAC;AAC7B,aAAW,WAAW,mBAAmB,QAAQ,GAAG;AACnD,WAAO,KAAK,OAAO;AAEnB,QAAI,OAAO,WAAW,MAAM;AAC3B,YAAM;AACN,eAAS,CAAC;AAAA,IACX;AAAA,EACD;AAEA,MAAI,OAAO,QAAQ;AAClB,UAAM;AAAA,EACP;AACD;AAhBiB","sourcesContent":["import type { IterableResolvable } from './from';\nimport { assertPositive } from './shared/_assertPositive';\nimport { toIntegerOrThrow } from './shared/_toIntegerOrThrow';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Chunks the iterable into arrays of at most `size` elements.\n *\n * @param iterable The iterator whose elements to chunk.\n * @param size The maximum size of each chunk.\n *\n * @example\n * ```typescript\n * import { chunk } from '@sapphire/iterator-utilities';\n *\n * const iterable = [1, 2, 3, 4, 5];\n * console.log([...chunk(iterable, 2)]);\n * // Output: [[1, 2], [3, 4], [5]]\n * ```\n */\nexport function* chunk<const ElementType>(iterable: IterableResolvable<ElementType>, size: number): IterableIterator<ElementType[]> {\n\tsize = assertPositive(toIntegerOrThrow(size), size);\n\n\tlet buffer: ElementType[] = [];\n\tfor (const element of toIterableIterator(iterable)) {\n\t\tbuffer.push(element);\n\n\t\tif (buffer.length === size) {\n\t\t\tyield buffer;\n\t\t\tbuffer = [];\n\t\t}\n\t}\n\n\tif (buffer.length) {\n\t\tyield buffer;\n\t}\n}\n"]}

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

@@ -0,0 +1,20 @@
+import { IterableResolvable } from './from.cjs';
+
+/**
+ * Chunks the iterable into arrays of at most `size` elements.
+ *
+ * @param iterable The iterator whose elements to chunk.
+ * @param size The maximum size of each chunk.
+ *
+ * @example
+ * ```typescript
+ * import { chunk } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = [1, 2, 3, 4, 5];
+ * console.log([...chunk(iterable, 2)]);
+ * // Output: [[1, 2], [3, 4], [5]]
+ * ```
+ */
+declare function chunk<const ElementType>(iterable: IterableResolvable<ElementType>, size: number): IterableIterator<ElementType[]>;
+
+export { chunk };

package/dist/cjs/lib/compact.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var filter_cjs = require('./filter.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function compact(iterable) {
+  return filter_cjs.filter(iterable, (value) => value !== null && value !== void 0);
+}
+__name(compact, "compact");
+
+exports.compact = compact;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=compact.cjs.map

package/dist/cjs/lib/compact.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/compact.ts"],"names":[],"mappings":";;;;AAAA,SAAS,cAAc;AAiBhB,SAAS,QAA2B,UAA6F;AACvI,SAAO,OAAO,UAAU,CAAC,UAAgC,UAAU,QAAQ,UAAU,MAAS;AAC/F;AAFgB","sourcesContent":["import { filter } from './filter';\nimport type { IterableResolvable } from './from';\n\n/**\n * Creates a new iterable that yields all the non-nullish values (`null` and `undefined`) from the iterable.\n *\n * @param iterable An iterator that contains elements to be compacted.\n *\n * @example\n * ```typescript\n * import { compact } from '@sapphire/iterator-utilities';\n *\n * const iterable = [1, null, 2, undefined, 3];\n * console.log([...compact(iterable)]);\n * // Output: [1, 2, 3]\n * ```\n */\nexport function compact<const ElementType>(iterable: IterableResolvable<ElementType | null | undefined>): IterableIterator<ElementType> {\n\treturn filter(iterable, (value): value is ElementType => value !== null && value !== undefined);\n}\n"]}

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

@@ -0,0 +1,19 @@
+import { IterableResolvable } from './from.cjs';
+
+/**
+ * Creates a new iterable that yields all the non-nullish values (`null` and `undefined`) from the iterable.
+ *
+ * @param iterable An iterator that contains elements to be compacted.
+ *
+ * @example
+ * ```typescript
+ * import { compact } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = [1, null, 2, undefined, 3];
+ * console.log([...compact(iterable)]);
+ * // Output: [1, 2, 3]
+ * ```
+ */
+declare function compact<const ElementType>(iterable: IterableResolvable<ElementType | null | undefined>): IterableIterator<ElementType>;
+
+export { compact };

package/dist/cjs/lib/compress.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+var from_cjs = require('./from.cjs');
+var toIterableIterator_cjs = require('./toIterableIterator.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function* compress(iterable, selectors) {
+  const resolvedSelectors = from_cjs.from(selectors);
+  for (const resolvedIterableResult of toIterableIterator_cjs.toIterableIterator(iterable)) {
+    const selectorResult = resolvedSelectors.next();
+    if (selectorResult.done) {
+      return;
+    }
+    if (selectorResult.value) {
+      yield resolvedIterableResult;
+    }
+  }
+}
+__name(compress, "compress");
+
+exports.compress = compress;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=compress.cjs.map

package/dist/cjs/lib/compress.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/compress.ts"],"names":[],"mappings":";;;;AAAA,SAAS,YAAqC;AAC9C,SAAS,0BAA0B;AAuB5B,UAAU,SAChB,UACA,WACgC;AAChC,QAAM,oBAAoB,KAAK,SAAS;AACxC,aAAW,0BAA0B,mBAAmB,QAAQ,GAAG;AAClE,UAAM,iBAAiB,kBAAkB,KAAK;AAC9C,QAAI,eAAe,MAAM;AACxB;AAAA,IACD;AAEA,QAAI,eAAe,OAAO;AACzB,YAAM;AAAA,IACP;AAAA,EACD;AACD;AAfiB","sourcesContent":["import { from, type IterableResolvable } from './from';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Creates a new iterable of the first iterable based on the truthiness of the corresponding element in the second iterable.\n *\n * @param iterable An iterator that contains elements to be compressed.\n * @param selectors The selectors that determine which elements to include in the result.\n * @returns An iterator that contains only the elements from the input iterator that correspond to `true` values in the\n * selectors iterator.\n *\n * @example\n * ```typescript\n * import { compress } from '@sapphire/iterator-utilities';\n *\n * const iterable = compress([1, 2, 3, 4, 5], [true, false, true, false, true]);\n * console.log([...iterable]);\n * // Output: [1, 3, 5]\n * ```\n *\n * @remarks\n *\n * This function consumes both input iterators until either is exhausted.\n */\nexport function* compress<const ElementType>(\n\titerable: IterableResolvable<ElementType>,\n\tselectors: IterableResolvable<boolean>\n): IterableIterator<ElementType> {\n\tconst resolvedSelectors = from(selectors);\n\tfor (const resolvedIterableResult of toIterableIterator(iterable)) {\n\t\tconst selectorResult = resolvedSelectors.next();\n\t\tif (selectorResult.done) {\n\t\t\treturn;\n\t\t}\n\n\t\tif (selectorResult.value) {\n\t\t\tyield resolvedIterableResult;\n\t\t}\n\t}\n}\n"]}

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

@@ -0,0 +1,26 @@
+import { IterableResolvable } from './from.cjs';
+
+/**
+ * Creates a new iterable of the first iterable based on the truthiness of the corresponding element in the second iterable.
+ *
+ * @param iterable An iterator that contains elements to be compressed.
+ * @param selectors The selectors that determine which elements to include in the result.
+ * @returns An iterator that contains only the elements from the input iterator that correspond to `true` values in the
+ * selectors iterator.
+ *
+ * @example
+ * ```typescript
+ * import { compress } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = compress([1, 2, 3, 4, 5], [true, false, true, false, true]);
+ * console.log([...iterable]);
+ * // Output: [1, 3, 5]
+ * ```
+ *
+ * @remarks
+ *
+ * This function consumes both input iterators until either is exhausted.
+ */
+declare function compress<const ElementType>(iterable: IterableResolvable<ElementType>, selectors: IterableResolvable<boolean>): IterableIterator<ElementType>;
+
+export { compress };

package/dist/cjs/lib/contains.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var toIterableIterator_cjs = require('./toIterableIterator.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function contains(iterable, value) {
+  for (const element of toIterableIterator_cjs.toIterableIterator(iterable)) {
+    if (element === value)
+      return true;
+  }
+  return false;
+}
+__name(contains, "contains");
+
+exports.contains = contains;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=contains.cjs.map

package/dist/cjs/lib/contains.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/contains.ts"],"names":[],"mappings":";;;;AACA,SAAS,0BAA0B;AAsB5B,SAAS,SAA4B,UAA2C,OAA6B;AACnH,aAAW,WAAW,mBAAmB,QAAQ,GAAG;AACnD,QAAI,YAAY;AAAO,aAAO;AAAA,EAC/B;AAEA,SAAO;AACR;AANgB","sourcesContent":["import type { IterableResolvable } from './from';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Advances the iterable until it finds the element, returning `true` if it's found and `false` otherwise.\n *\n * @param iterable The iterator in which to locate a value.\n * @param value The value to locate in the iterator.\n * @returns `true` if the value is found in the iterator; otherwise, `false`.\n *\n * @example\n * ```typescript\n * import { contains } from '@sapphire/iterator-utilities';\n *\n * const iterable = [1, 2, 3, 4, 5];\n * console.log(contains(iterable, 3));\n * // Output: true\n * ```\n *\n * @remarks\n *\n * This function consumes the iterator until the value is found or the iterator is exhausted.\n */\nexport function contains<const ElementType>(iterable: IterableResolvable<ElementType>, value: ElementType): boolean {\n\tfor (const element of toIterableIterator(iterable)) {\n\t\tif (element === value) return true;\n\t}\n\n\treturn false;\n}\n"]}

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

@@ -0,0 +1,25 @@
+import { IterableResolvable } from './from.cjs';
+
+/**
+ * Advances the iterable until it finds the element, returning `true` if it's found and `false` otherwise.
+ *
+ * @param iterable The iterator in which to locate a value.
+ * @param value The value to locate in the iterator.
+ * @returns `true` if the value is found in the iterator; otherwise, `false`.
+ *
+ * @example
+ * ```typescript
+ * import { contains } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = [1, 2, 3, 4, 5];
+ * console.log(contains(iterable, 3));
+ * // Output: true
+ * ```
+ *
+ * @remarks
+ *
+ * This function consumes the iterator until the value is found or the iterator is exhausted.
+ */
+declare function contains<const ElementType>(iterable: IterableResolvable<ElementType>, value: ElementType): boolean;
+
+export { contains };

package/dist/cjs/lib/count.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var from_cjs = require('./from.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function count(iterable) {
+  let count2 = 0;
+  const resolvedIterable = from_cjs.from(iterable);
+  while (!resolvedIterable.next().done) {
+    count2++;
+  }
+  return count2;
+}
+__name(count, "count");
+
+exports.count = count;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=count.cjs.map

package/dist/cjs/lib/count.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/count.ts"],"names":["count"],"mappings":";;;;AAAA,SAAS,YAAqC;AAqBvC,SAAS,MAAyB,UAAmD;AAC3F,MAAIA,SAAQ;AACZ,QAAM,mBAAmB,KAAK,QAAQ;AACtC,SAAO,CAAC,iBAAiB,KAAK,EAAE,MAAM;AACrC,IAAAA;AAAA,EACD;AAEA,SAAOA;AACR;AARgB","sourcesContent":["import { from, type IterableResolvable } from './from';\n\n/**\n * Consumes the iterable and returns the number of elements.\n *\n * @param iterable An iterator that contains elements to be counted.\n * @returns The number of elements in the input iterator.\n *\n * @example\n * ```typescript\n * import { count } from '@sapphire/iterator-utilities';\n *\n * const iterable = [1, 2, 3, 4, 5];\n * console.log(count(iterable));\n * // Output: 5\n * ```\n *\n * @remarks\n *\n * This function consumes the entire iterator.\n */\nexport function count<const ElementType>(iterable: IterableResolvable<ElementType>): number {\n\tlet count = 0;\n\tconst resolvedIterable = from(iterable);\n\twhile (!resolvedIterable.next().done) {\n\t\tcount++;\n\t}\n\n\treturn count;\n}\n"]}

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

@@ -0,0 +1,24 @@
+import { IterableResolvable } from './from.cjs';
+
+/**
+ * Consumes the iterable and returns the number of elements.
+ *
+ * @param iterable An iterator that contains elements to be counted.
+ * @returns The number of elements in the input iterator.
+ *
+ * @example
+ * ```typescript
+ * import { count } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = [1, 2, 3, 4, 5];
+ * console.log(count(iterable));
+ * // Output: 5
+ * ```
+ *
+ * @remarks
+ *
+ * This function consumes the entire iterator.
+ */
+declare function count<const ElementType>(iterable: IterableResolvable<ElementType>): number;
+
+export { count };

package/dist/cjs/lib/cycle.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var toIterableIterator_cjs = require('./toIterableIterator.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function* cycle(iterable) {
+  const results = [];
+  for (const element of toIterableIterator_cjs.toIterableIterator(iterable)) {
+    yield element;
+    results.push(element);
+  }
+  while (results.length > 0) {
+    for (const element of results) {
+      yield element;
+    }
+  }
+}
+__name(cycle, "cycle");
+
+exports.cycle = cycle;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=cycle.cjs.map

package/dist/cjs/lib/cycle.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/cycle.ts"],"names":[],"mappings":";;;;AACA,SAAS,0BAA0B;AAkB5B,UAAU,MAAyB,UAA0E;AACnH,QAAM,UAAU,CAAC;AACjB,aAAW,WAAW,mBAAmB,QAAQ,GAAG;AACnD,UAAM;AACN,YAAQ,KAAK,OAAO;AAAA,EACrB;AAEA,SAAO,QAAQ,SAAS,GAAG;AAC1B,eAAW,WAAW,SAAS;AAC9B,YAAM;AAAA,IACP;AAAA,EACD;AACD;AAZiB","sourcesContent":["import type { IterableResolvable } from './from';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Creates an infinite iterable by cycling through the elements of the input iterable.\n *\n * @param iterable An iterator to cycle over.\n *\n * @example\n * ```typescript\n * import { cycle } from '@sapphire/iterator-utilities';\n *\n * const iterable = cycle([1, 2, 3]);\n * for (const element of iterable) {\n * \tconsole.log(element);\n * \t// Output: 1, 2, 3, 1, 2, 3, 1, 2, 3, ...\n * }\n * ```\n */\nexport function* cycle<const ElementType>(iterable: IterableResolvable<ElementType>): IterableIterator<ElementType> {\n\tconst results = [] as ElementType[];\n\tfor (const element of toIterableIterator(iterable)) {\n\t\tyield element;\n\t\tresults.push(element);\n\t}\n\n\twhile (results.length > 0) {\n\t\tfor (const element of results) {\n\t\t\tyield element;\n\t\t}\n\t}\n}\n"]}

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

@@ -0,0 +1,21 @@
+import { IterableResolvable } from './from.cjs';
+
+/**
+ * Creates an infinite iterable by cycling through the elements of the input iterable.
+ *
+ * @param iterable An iterator to cycle over.
+ *
+ * @example
+ * ```typescript
+ * import { cycle } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = cycle([1, 2, 3]);
+ * for (const element of iterable) {
+ * 	console.log(element);
+ * 	// Output: 1, 2, 3, 1, 2, 3, 1, 2, 3, ...
+ * }
+ * ```
+ */
+declare function cycle<const ElementType>(iterable: IterableResolvable<ElementType>): IterableIterator<ElementType>;
+
+export { cycle };

package/dist/cjs/lib/difference.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var filter_cjs = require('./filter.cjs');
+var toIterableIterator_cjs = require('./toIterableIterator.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function difference(first, second) {
+  const set = new Set(toIterableIterator_cjs.toIterableIterator(second));
+  return filter_cjs.filter(first, (value) => !set.has(value));
+}
+__name(difference, "difference");
+
+exports.difference = difference;
+exports.except = difference;
+exports.omit = difference;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=difference.cjs.map

package/dist/cjs/lib/difference.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/difference.ts"],"names":[],"mappings":";;;;AAAA,SAAS,cAAc;AAEvB,SAAS,0BAA0B;AAsB5B,SAAS,WACf,OACA,QACgC;AAChC,QAAM,MAAM,IAAI,IAAI,mBAAmB,MAAM,CAAC;AAC9C,SAAO,OAAO,OAAO,CAAC,UAAU,CAAC,IAAI,IAAI,KAAK,CAAC;AAChD;AANgB","sourcesContent":["import { filter } from './filter';\nimport type { IterableResolvable } from './from';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Creates an iterable with the elements of the first iterable that are not in the second iterable.\n *\n * @param first An iterator to return elements from.\n * @param second An iterator that contains elements to exclude from the result.\n *\n * @example\n * ```typescript\n * import { difference } from '@sapphire/iterator-utilities';\n *\n * const first = [1, 2, 3, 4, 5];\n * const second = [3, 4, 5, 6, 7];\n * console.log([...difference(first, second)]);\n * // Output: [1, 2]\n * ```\n *\n * @remarks\n *\n * This function consumes the entire `second` iterator to build the set of elements to exclude from `first`.\n */\nexport function difference<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\nexport { difference as except, difference as omit };\n"]}

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

@@ -0,0 +1,25 @@
+import { IterableResolvable } from './from.cjs';
+
+/**
+ * Creates an iterable with the elements of the first iterable that are not in the second iterable.
+ *
+ * @param first An iterator to return elements from.
+ * @param second An iterator that contains elements to exclude from the result.
+ *
+ * @example
+ * ```typescript
+ * import { difference } from '@sapphire/iterator-utilities';
+ *
+ * const first = [1, 2, 3, 4, 5];
+ * const second = [3, 4, 5, 6, 7];
+ * console.log([...difference(first, second)]);
+ * // Output: [1, 2]
+ * ```
+ *
+ * @remarks
+ *
+ * This function consumes the entire `second` iterator to build the set of elements to exclude from `first`.
+ */
+declare function difference<const ElementType>(first: IterableResolvable<ElementType>, second: IterableResolvable<ElementType>): IterableIterator<ElementType>;
+
+export { difference, difference as except, difference as omit };

package/dist/cjs/lib/drop.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+var empty_cjs = require('./empty.cjs');
+var _assertNotNegative_cjs = require('./shared/_assertNotNegative.cjs');
+var _toIntegerOrInfinityOrThrow_cjs = require('./shared/_toIntegerOrInfinityOrThrow.cjs');
+var toIterableIterator_cjs = require('./toIterableIterator.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function drop(iterable, count) {
+  count = _assertNotNegative_cjs.assertNotNegative(_toIntegerOrInfinityOrThrow_cjs.toIntegerOrInfinityOrThrow(count), count);
+  const resolvedIterable = toIterableIterator_cjs.toIterableIterator(iterable);
+  if (count === 0)
+    return resolvedIterable;
+  if (count === Number.POSITIVE_INFINITY)
+    return empty_cjs.empty();
+  for (let i = 0; i < count; i++) {
+    if (resolvedIterable.next().done)
+      break;
+  }
+  return resolvedIterable;
+}
+__name(drop, "drop");
+
+exports.drop = drop;
+exports.skip = drop;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=drop.cjs.map

package/dist/cjs/lib/drop.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/drop.ts"],"names":[],"mappings":";;;;AAAA,SAAS,aAAa;AAEtB,SAAS,yBAAyB;AAClC,SAAS,kCAAkC;AAC3C,SAAS,0BAA0B;AAkB5B,SAAS,KAAwB,UAA2C,OAA8C;AAChI,UAAQ,kBAAkB,2BAA2B,KAAK,GAAG,KAAK;AAClE,QAAM,mBAAmB,mBAAmB,QAAQ;AAGpD,MAAI,UAAU;AAAG,WAAO;AAExB,MAAI,UAAU,OAAO;AAAmB,WAAO,MAAM;AAErD,WAAS,IAAI,GAAG,IAAI,OAAO,KAAK;AAC/B,QAAI,iBAAiB,KAAK,EAAE;AAAM;AAAA,EACnC;AAEA,SAAO;AACR;AAdgB","sourcesContent":["import { empty } from './empty';\nimport type { IterableResolvable } from './from';\nimport { assertNotNegative } from './shared/_assertNotNegative';\nimport { toIntegerOrInfinityOrThrow } from './shared/_toIntegerOrInfinityOrThrow';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Advances the iterable by `count` elements from the iterable.\n *\n * @param iterable An iterator to drop values from.\n * @param count The number of elements to drop from the start of the iteration.\n * @returns An iterator that contains the elements of the provided iterator, except for the first `count` elements.\n *\n * @example\n * ```typescript\n * import { drop } from '@sapphire/iterator-utilities';\n *\n * const iterable = drop(iterator, 2);\n * console.log([...iterable]);\n * // Output: [3, 4, 5]\n * ```\n */\nexport function drop<const ElementType>(iterable: IterableResolvable<ElementType>, count: number): IterableIterator<ElementType> {\n\tcount = assertNotNegative(toIntegerOrInfinityOrThrow(count), count);\n\tconst resolvedIterable = toIterableIterator(iterable);\n\n\t// If the count is 0, return the original iterable:\n\tif (count === 0) return resolvedIterable;\n\t// If the count is infinite, return an empty iterable:\n\tif (count === Number.POSITIVE_INFINITY) return empty();\n\n\tfor (let i = 0; i < count; i++) {\n\t\tif (resolvedIterable.next().done) break;\n\t}\n\n\treturn resolvedIterable;\n}\n\nexport { drop as skip };\n"]}

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

@@ -0,0 +1,21 @@
+import { IterableResolvable } from './from.cjs';
+
+/**
+ * Advances the iterable by `count` elements from the iterable.
+ *
+ * @param iterable An iterator to drop values from.
+ * @param count The number of elements to drop from the start of the iteration.
+ * @returns An iterator that contains the elements of the provided iterator, except for the first `count` elements.
+ *
+ * @example
+ * ```typescript
+ * import { drop } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = drop(iterator, 2);
+ * console.log([...iterable]);
+ * // Output: [3, 4, 5]
+ * ```
+ */
+declare function drop<const ElementType>(iterable: IterableResolvable<ElementType>, count: number): IterableIterator<ElementType>;
+
+export { drop, drop as skip };

package/dist/cjs/lib/dropLast.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var empty_cjs = require('./empty.cjs');
+var _assertNotNegative_cjs = require('./shared/_assertNotNegative.cjs');
+var _toIntegerOrInfinityOrThrow_cjs = require('./shared/_toIntegerOrInfinityOrThrow.cjs');
+var take_cjs = require('./take.cjs');
+var toArray_cjs = require('./toArray.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function dropLast(iterable, count) {
+  count = _assertNotNegative_cjs.assertNotNegative(_toIntegerOrInfinityOrThrow_cjs.toIntegerOrInfinityOrThrow(count), count);
+  const array = toArray_cjs.toArray(iterable);
+  if (array.length <= count)
+    return empty_cjs.empty();
+  return take_cjs.take(array.values(), array.length - count);
+}
+__name(dropLast, "dropLast");
+
+exports.dropLast = dropLast;
+exports.skipLast = dropLast;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=dropLast.cjs.map

package/dist/cjs/lib/dropLast.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/dropLast.ts"],"names":[],"mappings":";;;;AAAA,SAAS,aAAa;AAEtB,SAAS,yBAAyB;AAClC,SAAS,kCAAkC;AAC3C,SAAS,YAAY;AACrB,SAAS,eAAe;AAsBjB,SAAS,SAA4B,UAA2C,OAA8C;AACpI,UAAQ,kBAAkB,2BAA2B,KAAK,GAAG,KAAK;AAClE,QAAM,QAAQ,QAAQ,QAAQ;AAC9B,MAAI,MAAM,UAAU;AAAO,WAAO,MAAM;AACxC,SAAO,KAAK,MAAM,OAAO,GAAG,MAAM,SAAS,KAAK;AACjD;AALgB","sourcesContent":["import { empty } from './empty';\nimport type { IterableResolvable } from './from';\nimport { assertNotNegative } from './shared/_assertNotNegative';\nimport { toIntegerOrInfinityOrThrow } from './shared/_toIntegerOrInfinityOrThrow';\nimport { take } from './take';\nimport { toArray } from './toArray';\n\n/**\n * Consumes the iterable, creating a new iterator without the last `count` elements from the iterable.\n *\n * @param iterable An iterator to drop values from.\n * @param count The number of values to drop from the end of the iterator.\n * @returns An iterator that contains the elements of the provided iterator, except for the last `count` elements.\n *\n * @example\n * ```typescript\n * import { dropLast } from '@sapphire/iterator-utilities';\n *\n * const iterable = dropLast([1, 2, 3, 4, 5], 2);\n * console.log([...iterable]);\n * // Output: [1, 2, 3]\n * ```\n *\n * @remarks\n *\n * This function consumes the entire iterator.\n */\nexport function dropLast<const ElementType>(iterable: IterableResolvable<ElementType>, count: number): IterableIterator<ElementType> {\n\tcount = assertNotNegative(toIntegerOrInfinityOrThrow(count), count);\n\tconst array = toArray(iterable);\n\tif (array.length <= count) return empty();\n\treturn take(array.values(), array.length - count);\n}\n\nexport { dropLast as skipLast };\n"]}

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

@@ -0,0 +1,25 @@
+import { IterableResolvable } from './from.cjs';
+
+/**
+ * Consumes the iterable, creating a new iterator without the last `count` elements from the iterable.
+ *
+ * @param iterable An iterator to drop values from.
+ * @param count The number of values to drop from the end of the iterator.
+ * @returns An iterator that contains the elements of the provided iterator, except for the last `count` elements.
+ *
+ * @example
+ * ```typescript
+ * import { dropLast } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = dropLast([1, 2, 3, 4, 5], 2);
+ * console.log([...iterable]);
+ * // Output: [1, 2, 3]
+ * ```
+ *
+ * @remarks
+ *
+ * This function consumes the entire iterator.
+ */
+declare function dropLast<const ElementType>(iterable: IterableResolvable<ElementType>, count: number): IterableIterator<ElementType>;
+
+export { dropLast, dropLast as skipLast };

package/dist/cjs/lib/dropWhile.cjs

@@ -0,0 +1,22 @@
+'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* dropWhile(iterable, callbackFn) {
+  callbackFn = _assertFunction_cjs.assertFunction(callbackFn);
+  let index = 0;
+  for (const value of toIterableIterator_cjs.toIterableIterator(iterable)) {
+    if (!callbackFn(value, index++)) {
+      yield value;
+    }
+  }
+}
+__name(dropWhile, "dropWhile");
+
+exports.dropWhile = dropWhile;
+exports.skipWhile = dropWhile;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=dropWhile.cjs.map

package/dist/cjs/lib/dropWhile.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/dropWhile.ts"],"names":[],"mappings":";;;;AACA,SAAS,sBAAsB;AAC/B,SAAS,0BAA0B;AA4B5B,UAAU,UAChB,UACA,YACgC;AAChC,eAAa,eAAe,UAAU;AAEtC,MAAI,QAAQ;AACZ,aAAW,SAAS,mBAAmB,QAAQ,GAAG;AACjD,QAAI,CAAC,WAAW,OAAO,OAAO,GAAG;AAChC,YAAM;AAAA,IACP;AAAA,EACD;AACD;AAZiB","sourcesContent":["import type { IterableResolvable } from './from';\nimport { assertFunction } from './shared/_assertFunction';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Creates a new iterator without the elements that satisfy the specified test.\n *\n * @param iterable An iterator to drop values from.\n * @param callbackFn A function to execute for each element produced by the iterator. It should return a falsy value to make the element yielded by the iterator helper, and a truthy value otherwise.\n * @returns An iterator that produces elements from the given iterator that don't satisfy the specified test.\n *\n * @example\n * ```typescript\n * import { dropWhile } from '@sapphire/iterator-utilities';\n *\n * const iterable = dropWhile([1, 2, 3, 4, 5], (value) => value < 3);\n * console.log([...iterable]);\n * // Output: [3, 4, 5]\n * ```\n *\n * @seealso {@link filter} or {@link takeWhile} for the opposite behavior.\n */\nexport function dropWhile<const ElementType, const FilteredType extends ElementType>(\n\titerable: IterableResolvable<ElementType>,\n\tcallbackFn: (element: ElementType, index: number) => element is FilteredType\n): IterableIterator<Exclude<ElementType, FilteredType>>;\nexport function dropWhile<const ElementType>(\n\titerable: IterableResolvable<ElementType>,\n\tcallbackFn: (element: ElementType, index: number) => boolean\n): IterableIterator<ElementType>;\nexport function* dropWhile<const ElementType>(\n\titerable: IterableResolvable<ElementType>,\n\tcallbackFn: (element: ElementType, index: number) => boolean\n): IterableIterator<ElementType> {\n\tcallbackFn = assertFunction(callbackFn);\n\n\tlet index = 0;\n\tfor (const value of toIterableIterator(iterable)) {\n\t\tif (!callbackFn(value, index++)) {\n\t\t\tyield value;\n\t\t}\n\t}\n}\n\nexport { dropWhile as skipWhile };\n"]}

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

@@ -0,0 +1,24 @@
+import { IterableResolvable } from './from.cjs';
+
+/**
+ * Creates a new iterator without the elements that satisfy the specified test.
+ *
+ * @param iterable An iterator to drop values from.
+ * @param callbackFn A function to execute for each element produced by the iterator. It should return a falsy value to make the element yielded by the iterator helper, and a truthy value otherwise.
+ * @returns An iterator that produces elements from the given iterator that don't satisfy the specified test.
+ *
+ * @example
+ * ```typescript
+ * import { dropWhile } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = dropWhile([1, 2, 3, 4, 5], (value) => value < 3);
+ * console.log([...iterable]);
+ * // Output: [3, 4, 5]
+ * ```
+ *
+ * @seealso {@link filter} or {@link takeWhile} for the opposite behavior.
+ */
+declare function dropWhile<const ElementType, const FilteredType extends ElementType>(iterable: IterableResolvable<ElementType>, callbackFn: (element: ElementType, index: number) => element is FilteredType): IterableIterator<Exclude<ElementType, FilteredType>>;
+declare function dropWhile<const ElementType>(iterable: IterableResolvable<ElementType>, callbackFn: (element: ElementType, index: number) => boolean): IterableIterator<ElementType>;
+
+export { dropWhile, dropWhile as skipWhile };

package/dist/cjs/lib/empty.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var _makeIterableIterator_cjs = require('./shared/_makeIterableIterator.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function empty() {
+  return _makeIterableIterator_cjs.makeIterableIterator(() => ({ done: true, value: void 0 }));
+}
+__name(empty, "empty");
+
+exports.empty = empty;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=empty.cjs.map

package/dist/cjs/lib/empty.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/empty.ts"],"names":[],"mappings":";;;;AAAA,SAAS,4BAA4B;AAgB9B,SAAS,QAAkE;AACjF,SAAO,qBAAkC,OAAO,EAAE,MAAM,MAAM,OAAO,OAAU,EAAE;AAClF;AAFgB","sourcesContent":["import { makeIterableIterator } from './shared/_makeIterableIterator';\n\n/**\n * Creates an empty iterator.\n *\n * @returns An empty iterator.\n *\n * @example\n * ```typescript\n * import { empty } from '@sapphire/iterator-utilities';\n *\n * const iterable = empty();\n * console.log([...iterable]);\n * // Output: []\n * ```\n */\nexport function empty<const ElementType = never>(): IterableIterator<ElementType> {\n\treturn makeIterableIterator<ElementType>(() => ({ done: true, value: undefined }));\n}\n"]}

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

@@ -0,0 +1,17 @@
+/**
+ * Creates an empty iterator.
+ *
+ * @returns An empty iterator.
+ *
+ * @example
+ * ```typescript
+ * import { empty } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = empty();
+ * console.log([...iterable]);
+ * // Output: []
+ * ```
+ */
+declare function empty<const ElementType = never>(): IterableIterator<ElementType>;
+
+export { empty };

package/dist/cjs/lib/enumerate.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* enumerate(iterable) {
+  let index = 0;
+  for (const value of toIterableIterator_cjs.toIterableIterator(iterable)) {
+    yield [index++, value];
+  }
+}
+__name(enumerate, "enumerate");
+
+exports.enumerate = enumerate;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=enumerate.cjs.map

package/dist/cjs/lib/enumerate.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/enumerate.ts"],"names":[],"mappings":";;;;AACA,SAAS,0BAA0B;AAqB5B,UAAU,UAA6B,UAAoF;AACjI,MAAI,QAAQ;AACZ,aAAW,SAAS,mBAAmB,QAAQ,GAAG;AACjD,UAAM,CAAC,SAAS,KAAK;AAAA,EACtB;AACD;AALiB","sourcesContent":["import type { IterableResolvable } from './from';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Creates a new iterable that yields the index and value of each element.\n *\n * @param iterable An iterator to enumerate.\n * @returns An iterator that yields the index and value of each element in the source iterator.\n *\n * @example\n * ```typescript\n * import { enumerate } from '@sapphire/iterator-utilities';\n *\n * const iterable = ['a', 'b', 'c'];\n * for (const [index, value] of enumerate(iterable)) {\n * \tconsole.log(`Index: ${index}, Value: ${value}`);\n * \t// Output: Index: 0, Value: a\n * \t// Output: Index: 1, Value: b\n * \t// Output: Index: 2, Value: c\n * }\n * ```\n */\nexport function* enumerate<const ElementType>(iterable: IterableResolvable<ElementType>): IterableIterator<[number, ElementType]> {\n\tlet index = 0;\n\tfor (const value of toIterableIterator(iterable)) {\n\t\tyield [index++, value];\n\t}\n}\n"]}

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

@@ -0,0 +1,24 @@
+import { IterableResolvable } from './from.cjs';
+
+/**
+ * Creates a new iterable that yields the index and value of each element.
+ *
+ * @param iterable An iterator to enumerate.
+ * @returns An iterator that yields the index and value of each element in the source iterator.
+ *
+ * @example
+ * ```typescript
+ * import { enumerate } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = ['a', 'b', 'c'];
+ * for (const [index, value] of enumerate(iterable)) {
+ * 	console.log(`Index: ${index}, Value: ${value}`);
+ * 	// Output: Index: 0, Value: a
+ * 	// Output: Index: 1, Value: b
+ * 	// Output: Index: 2, Value: c
+ * }
+ * ```
+ */
+declare function enumerate<const ElementType>(iterable: IterableResolvable<ElementType>): IterableIterator<[number, ElementType]>;
+
+export { enumerate };

package/dist/cjs/lib/every.cjs

@@ -0,0 +1,21 @@
+'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 every(iterable, callbackFn) {
+  callbackFn = _assertFunction_cjs.assertFunction(callbackFn);
+  let index = 0;
+  for (const value of toIterableIterator_cjs.toIterableIterator(iterable)) {
+    if (!callbackFn(value, index++))
+      return false;
+  }
+  return true;
+}
+__name(every, "every");
+
+exports.every = every;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=every.cjs.map