@sapphire/iterator-utilities 1.1.0-next.63f6019b.0 → 2.0.0-next.09afdaab

package/dist/cjs/lib/any.cjs

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

package/dist/cjs/lib/any.cjs.map

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

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

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

package/dist/cjs/lib/append.cjs

@@ -11,5 +11,5 @@ __name(append, "append");
 
 exports.append = append;
 exports.concat = append;
-//# sourceMappingURL=out.js.map
+//# sourceMappingURL=append.cjs.map
 //# sourceMappingURL=append.cjs.map

package/dist/cjs/lib/append.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/append.ts"],"names":[],"mappings":";;;;AAAA,SAAS,aAAa;AAmBf,SAAS,OACf,aACG,WAC6B;AAChC,SAAO,MAAM,UAAU,GAAG,SAAS;AACpC;AALgB","sourcesContent":["import { chain } from './chain';\nimport type { IterableResolvable } from './from';\n\n/**\n * Appends iterables to the end of the first iterable, returning a new iterable combining all of them. It's similar to concatenating arrays or doing `[...a, ...b, ...c]`.\n *\n * @param iterable The iterator to append values to.\n * @param iterables The iterables to append 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 { append } from '@sapphire/iterator-utilities';\n *\n * const iterable = append([1, 2, 3], [4, 5, 6], [7, 8, 9]);\n * console.log([...iterable]);\n * // Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]\n * ```\n */\nexport function append<const ElementType>(\n\titerable: IterableResolvable<ElementType>,\n\t...iterables: IterableResolvable<ElementType>[]\n): IterableIterator<ElementType> {\n\treturn chain(iterable, ...iterables);\n}\n\nexport { append as concat };\n"]}
+{"version":3,"sources":["../../../src/lib/append.ts"],"names":["chain"],"mappings":";;;;;;AAmBO,SAAS,MAAA,CACf,aACG,SAC6B,EAAA;AAChC,EAAO,OAAAA,eAAA,CAAM,QAAU,EAAA,GAAG,SAAS,CAAA;AACpC;AALgB,MAAA,CAAA,MAAA,EAAA,QAAA,CAAA","file":"append.cjs","sourcesContent":["import { chain } from './chain';\nimport type { IterableResolvable } from './from';\n\n/**\n * Appends iterables to the end of the first iterable, returning a new iterable combining all of them. It's similar to concatenating arrays or doing `[...a, ...b, ...c]`.\n *\n * @param iterable The iterator to append values to.\n * @param iterables The iterables to append 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 { append } from '@sapphire/iterator-utilities';\n *\n * const iterable = append([1, 2, 3], [4, 5, 6], [7, 8, 9]);\n * console.log([...iterable]);\n * // Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]\n * ```\n */\nexport function append<const ElementType>(\n\titerable: IterableResolvable<ElementType>,\n\t...iterables: IterableResolvable<ElementType>[]\n): IterableIterator<ElementType> {\n\treturn chain(iterable, ...iterables);\n}\n\nexport { append as concat };\n"]}

package/dist/cjs/lib/at.cjs

@@ -14,5 +14,5 @@ function at(iterable, index) {
 __name(at, "at");
 
 exports.at = at;
-//# sourceMappingURL=out.js.map
+//# sourceMappingURL=at.cjs.map
 //# sourceMappingURL=at.cjs.map

package/dist/cjs/lib/at.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/at.ts"],"names":[],"mappings":";;;;AAAA,SAAS,YAAY;AACrB,SAAS,aAAa;AAEtB,SAAS,yBAAyB;AAClC,SAAS,kCAAkC;AAsBpC,SAAS,GAAsB,UAA2C,OAAwC;AACxH,UAAQ,kBAAkB,2BAA2B,KAAK,GAAG,KAAK;AAClE,SAAO,MAAM,UAAU,IAAI,WAAW,KAAK,UAAU,KAAK,CAAC;AAC5D;AAHgB","sourcesContent":["import { drop } from './drop';\nimport { first } from './first';\nimport type { IterableResolvable } from './from';\nimport { assertNotNegative } from './shared/_assertNotNegative';\nimport { toIntegerOrInfinityOrThrow } from './shared/_toIntegerOrInfinityOrThrow';\n\n/**\n * Advances the iterable to the `n`th element and returns it. If the iterable is exhausted before reaching the `n`th element, it returns `undefined`.\n *\n * @param iterable An iterator to return an element from.\n * @param index The index of the element to retrieve.\n * @returns The element at the specified index, or `undefined` if the index is out of range.\n *\n * @example\n * ```typescript\n * import { at } from '@sapphire/iterator-utilities';\n *\n * const iterable = [1, 2, 3, 4, 5];\n * console.log(at(iterable, 2));\n * // Output: 3\n * ```\n *\n * @remarks\n *\n * This function consumes the input iterator up to the specified index.\n */\nexport function at<const ElementType>(iterable: IterableResolvable<ElementType>, index: number): ElementType | undefined {\n\tindex = assertNotNegative(toIntegerOrInfinityOrThrow(index), index);\n\treturn first(index === 0 ? iterable : drop(iterable, index));\n}\n"]}
+{"version":3,"sources":["../../../src/lib/at.ts"],"names":["assertNotNegative","toIntegerOrInfinityOrThrow","first","drop"],"mappings":";;;;;;;;;AA0BO,SAAS,EAAA,CAAsB,UAA2C,KAAwC,EAAA;AACxH,EAAA,KAAA,GAAQA,wCAAkB,CAAAC,0DAAA,CAA2B,KAAK,CAAA,EAAG,KAAK,CAAA;AAClE,EAAA,OAAOC,gBAAM,KAAU,KAAA,CAAA,GAAI,WAAWC,aAAK,CAAA,QAAA,EAAU,KAAK,CAAC,CAAA;AAC5D;AAHgB,MAAA,CAAA,EAAA,EAAA,IAAA,CAAA","file":"at.cjs","sourcesContent":["import { drop } from './drop';\nimport { first } from './first';\nimport type { IterableResolvable } from './from';\nimport { assertNotNegative } from './shared/_assertNotNegative';\nimport { toIntegerOrInfinityOrThrow } from './shared/_toIntegerOrInfinityOrThrow';\n\n/**\n * Advances the iterable to the `n`th element and returns it. If the iterable is exhausted before reaching the `n`th element, it returns `undefined`.\n *\n * @param iterable An iterator to return an element from.\n * @param index The index of the element to retrieve.\n * @returns The element at the specified index, or `undefined` if the index is out of range.\n *\n * @example\n * ```typescript\n * import { at } from '@sapphire/iterator-utilities';\n *\n * const iterable = [1, 2, 3, 4, 5];\n * console.log(at(iterable, 2));\n * // Output: 3\n * ```\n *\n * @remarks\n *\n * This function consumes the input iterator up to the specified index.\n */\nexport function at<const ElementType>(iterable: IterableResolvable<ElementType>, index: number): ElementType | undefined {\n\tindex = assertNotNegative(toIntegerOrInfinityOrThrow(index), index);\n\treturn first(index === 0 ? iterable : drop(iterable, index));\n}\n"]}

package/dist/cjs/lib/average.cjs

@@ -17,5 +17,5 @@ function average(iterable) {
 __name(average, "average");
 
 exports.average = average;
-//# sourceMappingURL=out.js.map
+//# sourceMappingURL=average.cjs.map
 //# sourceMappingURL=average.cjs.map

package/dist/cjs/lib/average.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/average.ts"],"names":[],"mappings":";;;;AACA,SAAS,WAAW;AACpB,SAAS,uBAA8C;AAqBhD,SAAS,QAAQ,UAA+D;AACtF,MAAI,MAAM;AACV,MAAI,QAAQ;AACZ,aAAW,SAAS,IAAI,UAAU,eAAe,GAAG;AACnD,WAAO;AACP;AAAA,EACD;AAEA,SAAO,UAAU,IAAI,OAAO,MAAM;AACnC;AATgB","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 average value of all the elements. If the iterable is empty, it returns `null`.\n *\n * @param iterable The iterator to calculate the average of.\n * @returns The average of the sequence of numbers, or `null` if the sequence is empty or contains only non-number values.\n *\n * @example\n * ```typescript\n * import { average } from '@sapphire/iterator-utilities';\n *\n * const iterable = [1, 2, 3, 4, 5];\n * console.log(average(iterable));\n * // Output: 3\n * ```\n *\n * @remarks\n *\n * This function consumes the entire iterator.\n */\nexport function average(iterable: IterableResolvable<NumberResolvable>): number | null {\n\tlet sum = 0;\n\tlet total = 0;\n\tfor (const value of map(iterable, toNumberOrThrow)) {\n\t\tsum += value;\n\t\ttotal++;\n\t}\n\n\treturn total === 0 ? null : sum / total;\n}\n"]}
+{"version":3,"sources":["../../../src/lib/average.ts"],"names":["map","toNumberOrThrow"],"mappings":";;;;;;;AAuBO,SAAS,QAAQ,QAA+D,EAAA;AACtF,EAAA,IAAI,GAAM,GAAA,CAAA;AACV,EAAA,IAAI,KAAQ,GAAA,CAAA;AACZ,EAAA,KAAA,MAAW,KAAS,IAAAA,WAAA,CAAI,QAAU,EAAAC,oCAAe,CAAG,EAAA;AACnD,IAAO,GAAA,IAAA,KAAA;AACP,IAAA,KAAA,EAAA;AAAA;AAGD,EAAO,OAAA,KAAA,KAAU,CAAI,GAAA,IAAA,GAAO,GAAM,GAAA,KAAA;AACnC;AATgB,MAAA,CAAA,OAAA,EAAA,SAAA,CAAA","file":"average.cjs","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 average value of all the elements. If the iterable is empty, it returns `null`.\n *\n * @param iterable The iterator to calculate the average of.\n * @returns The average of the sequence of numbers, or `null` if the sequence is empty or contains only non-number values.\n *\n * @example\n * ```typescript\n * import { average } from '@sapphire/iterator-utilities';\n *\n * const iterable = [1, 2, 3, 4, 5];\n * console.log(average(iterable));\n * // Output: 3\n * ```\n *\n * @remarks\n *\n * This function consumes the entire iterator.\n */\nexport function average(iterable: IterableResolvable<NumberResolvable>): number | null {\n\tlet sum = 0;\n\tlet total = 0;\n\tfor (const value of map(iterable, toNumberOrThrow)) {\n\t\tsum += value;\n\t\ttotal++;\n\t}\n\n\treturn total === 0 ? null : sum / total;\n}\n"]}

package/dist/cjs/lib/chain.cjs

@@ -12,5 +12,5 @@ function* chain(...iterables) {
 __name(chain, "chain");
 
 exports.chain = chain;
-//# sourceMappingURL=out.js.map
+//# sourceMappingURL=chain.cjs.map
 //# sourceMappingURL=chain.cjs.map

package/dist/cjs/lib/chain.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/chain.ts"],"names":[],"mappings":";;;;AACA,SAAS,0BAA0B;AAiB5B,UAAU,SAA4B,WAA6E;AACzH,aAAW,YAAY,WAAW;AACjC,WAAO,mBAAmB,QAAQ;AAAA,EACnC;AACD;AAJiB","sourcesContent":["import type { IterableResolvable } from './from';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Similar to `append`, but takes an iterable of iterables and chains them together.\n *\n * @param iterables The iterators to chain together.\n * @returns An iterator that yields the values of the provided iterators in order.\n *\n * @example\n * ```typescript\n * import { chain } from '@sapphire/iterator-utilities';\n *\n * const iterable = chain([1, 2, 3], [4, 5, 6], [7, 8, 9]);\n * console.log([...iterable]);\n * // Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]\n * ```\n */\nexport function* chain<const ElementType>(...iterables: IterableResolvable<ElementType>[]): IterableIterator<ElementType> {\n\tfor (const iterable of iterables) {\n\t\tyield* toIterableIterator(iterable);\n\t}\n}\n"]}
+{"version":3,"sources":["../../../src/lib/chain.ts"],"names":["toIterableIterator"],"mappings":";;;;;;AAkBO,UAAU,SAA4B,SAA6E,EAAA;AACzH,EAAA,KAAA,MAAW,YAAY,SAAW,EAAA;AACjC,IAAA,OAAOA,0CAAmB,QAAQ,CAAA;AAAA;AAEpC;AAJiB,MAAA,CAAA,KAAA,EAAA,OAAA,CAAA","file":"chain.cjs","sourcesContent":["import type { IterableResolvable } from './from';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Similar to `append`, but takes an iterable of iterables and chains them together.\n *\n * @param iterables The iterators to chain together.\n * @returns An iterator that yields the values of the provided iterators in order.\n *\n * @example\n * ```typescript\n * import { chain } from '@sapphire/iterator-utilities';\n *\n * const iterable = chain([1, 2, 3], [4, 5, 6], [7, 8, 9]);\n * console.log([...iterable]);\n * // Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]\n * ```\n */\nexport function* chain<const ElementType>(...iterables: IterableResolvable<ElementType>[]): IterableIterator<ElementType> {\n\tfor (const iterable of iterables) {\n\t\tyield* toIterableIterator(iterable);\n\t}\n}\n"]}

package/dist/cjs/lib/chunk.cjs

@@ -23,5 +23,5 @@ function* chunk(iterable, size) {
 __name(chunk, "chunk");
 
 exports.chunk = chunk;
-//# sourceMappingURL=out.js.map
+//# sourceMappingURL=chunk.cjs.map
 //# sourceMappingURL=chunk.cjs.map

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

@@ -1 +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"]}
+{"version":3,"sources":["../../../src/lib/chunk.ts"],"names":["assertPositive","toIntegerOrThrow","toIterableIterator"],"mappings":";;;;;;;;AAoBO,UAAU,KAAA,CAAyB,UAA2C,IAA+C,EAAA;AACnI,EAAA,IAAA,GAAOA,kCAAe,CAAAC,sCAAA,CAAiB,IAAI,CAAA,EAAG,IAAI,CAAA;AAElD,EAAA,IAAI,SAAwB,EAAC;AAC7B,EAAW,KAAA,MAAA,OAAA,IAAWC,yCAAmB,CAAA,QAAQ,CAAG,EAAA;AACnD,IAAA,MAAA,CAAO,KAAK,OAAO,CAAA;AAEnB,IAAI,IAAA,MAAA,CAAO,WAAW,IAAM,EAAA;AAC3B,MAAM,MAAA,MAAA;AACN,MAAA,MAAA,GAAS,EAAC;AAAA;AACX;AAGD,EAAA,IAAI,OAAO,MAAQ,EAAA;AAClB,IAAM,MAAA,MAAA;AAAA;AAER;AAhBiB,MAAA,CAAA,KAAA,EAAA,OAAA,CAAA","file":"chunk.cjs","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/collect.cjs

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

package/dist/cjs/lib/collect.cjs.map

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

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

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

package/dist/cjs/lib/collectInto.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 collectInto(iterable, output) {
+  for (const value of toIterableIterator_cjs.toIterableIterator(iterable)) {
+    output.push(value);
+  }
+  return output;
+}
+__name(collectInto, "collectInto");
+
+exports.collectInto = collectInto;
+//# sourceMappingURL=collectInto.cjs.map
+//# sourceMappingURL=collectInto.cjs.map

package/dist/cjs/lib/collectInto.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/collectInto.ts"],"names":["toIterableIterator"],"mappings":";;;;;;AA2BO,SAAS,WAAA,CAA+B,UAA2C,MAAsC,EAAA;AAC/H,EAAW,KAAA,MAAA,KAAA,IAASA,yCAAmB,CAAA,QAAQ,CAAG,EAAA;AACjD,IAAA,MAAA,CAAO,KAAK,KAAK,CAAA;AAAA;AAGlB,EAAO,OAAA,MAAA;AACR;AANgB,MAAA,CAAA,WAAA,EAAA,aAAA,CAAA","file":"collectInto.cjs","sourcesContent":["import type { IterableResolvable } from './from';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Collects all the items from an iterator into an array.\n *\n * This method consumes the iterator and adds all its items to the passed array. The array is then returned, so the call\n * chain can be continued.\n *\n * This is useful when you already have a collection and want to add the iterator items to it.\n *\n * @param iterable An iterator to fuse.\n *\n * @example\n * ```typescript\n * import { collectInto, map } from '@sapphire/iterator-utilities';\n *\n * const iterable = [1, 2, 3];\n * const output = [0, 1];\n *\n * collectInto(map(iterable, (value) => value * 2), output);\n * collectInto(map(iterable, (value) => value * 10), output);\n *\n * console.log(output);\n * // Output: [0, 1, 2, 4, 6, 10, 20, 30]\n * ```\n */\nexport function collectInto<const ElementType>(iterable: IterableResolvable<ElementType>, output: ElementType[]): ElementType[] {\n\tfor (const value of toIterableIterator(iterable)) {\n\t\toutput.push(value);\n\t}\n\n\treturn output;\n}\n"]}

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

@@ -0,0 +1,29 @@
+import { IterableResolvable } from './from.cjs';
+
+/**
+ * Collects all the items from an iterator into an array.
+ *
+ * This method consumes the iterator and adds all its items to the passed array. The array is then returned, so the call
+ * chain can be continued.
+ *
+ * This is useful when you already have a collection and want to add the iterator items to it.
+ *
+ * @param iterable An iterator to fuse.
+ *
+ * @example
+ * ```typescript
+ * import { collectInto, map } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = [1, 2, 3];
+ * const output = [0, 1];
+ *
+ * collectInto(map(iterable, (value) => value * 2), output);
+ * collectInto(map(iterable, (value) => value * 10), output);
+ *
+ * console.log(output);
+ * // Output: [0, 1, 2, 4, 6, 10, 20, 30]
+ * ```
+ */
+declare function collectInto<const ElementType>(iterable: IterableResolvable<ElementType>, output: ElementType[]): ElementType[];
+
+export { collectInto };

package/dist/cjs/lib/compact.cjs

@@ -10,5 +10,5 @@ function compact(iterable) {
 __name(compact, "compact");
 
 exports.compact = compact;
-//# sourceMappingURL=out.js.map
+//# sourceMappingURL=compact.cjs.map
 //# sourceMappingURL=compact.cjs.map

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

@@ -1 +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"]}
+{"version":3,"sources":["../../../src/lib/compact.ts"],"names":["filter"],"mappings":";;;;;;AAiBO,SAAS,QAA2B,QAA6F,EAAA;AACvI,EAAA,OAAOA,kBAAO,QAAU,EAAA,CAAC,UAAgC,KAAU,KAAA,IAAA,IAAQ,UAAU,KAAS,CAAA,CAAA;AAC/F;AAFgB,MAAA,CAAA,OAAA,EAAA,SAAA,CAAA","file":"compact.cjs","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/compare.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var compareBy_cjs = require('./compareBy.cjs');
+var comparators_cjs = require('./shared/comparators.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function compare(iterable, other) {
+  return compareBy_cjs.compareBy(iterable, other, comparators_cjs.defaultCompare);
+}
+__name(compare, "compare");
+
+exports.compare = compare;
+//# sourceMappingURL=compare.cjs.map
+//# sourceMappingURL=compare.cjs.map

package/dist/cjs/lib/compare.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/compare.ts"],"names":["compareBy","defaultCompare"],"mappings":";;;;;;;AA+BO,SAAS,OAAA,CACf,UACA,KAC0B,EAAA;AAC1B,EAAO,OAAAA,uBAAA,CAAU,QAAU,EAAA,KAAA,EAAOC,8BAAc,CAAA;AACjD;AALgB,MAAA,CAAA,OAAA,EAAA,SAAA,CAAA","file":"compare.cjs","sourcesContent":["import { compareBy } from './compareBy';\nimport type { IterableResolvable } from './from';\nimport type { LexicographicComparison } from './shared/_compare';\nimport { defaultCompare } from './shared/comparators';\n\n/**\n * {@link LexicographicComparison Lexicographically} compares the elements of both iterators are equal.\n *\n * This function uses the default comparator (lexicographically), which means it will compare the elements as strings.\n * If this is undesirable, use {@link compareBy} instead.\n *\n * @param iterable The iterator to compare.\n * @param other The iterator to compare against.\n * @returns Whether the two iterators are equal.\n *\n * @example\n * ```typescript\n * import { compare } from '@sapphire/iterator-utilities';\n *\n * console.log(compare([1], [1]));\n * // Output: 0\n * console.log(compare([1], [1, 2]));\n * // Output: -1\n * console.log(compare([1, 2], [1]));\n * // Output: 1\n * ```\n *\n * @remarks\n *\n * This function consumes the entire iterator.\n */\nexport function compare<const ElementType>(\n\titerable: IterableResolvable<ElementType>,\n\tother: IterableResolvable<ElementType>\n): LexicographicComparison {\n\treturn compareBy(iterable, other, defaultCompare);\n}\n"]}

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

@@ -0,0 +1,32 @@
+import { IterableResolvable } from './from.cjs';
+import { LexicographicComparison } from './shared/_compare.js';
+
+/**
+ * {@link LexicographicComparison Lexicographically} compares the elements of both iterators are equal.
+ *
+ * This function uses the default comparator (lexicographically), which means it will compare the elements as strings.
+ * If this is undesirable, use {@link compareBy} instead.
+ *
+ * @param iterable The iterator to compare.
+ * @param other The iterator to compare against.
+ * @returns Whether the two iterators are equal.
+ *
+ * @example
+ * ```typescript
+ * import { compare } from '@sapphire/iterator-utilities';
+ *
+ * console.log(compare([1], [1]));
+ * // Output: 0
+ * console.log(compare([1], [1, 2]));
+ * // Output: -1
+ * console.log(compare([1, 2], [1]));
+ * // Output: 1
+ * ```
+ *
+ * @remarks
+ *
+ * This function consumes the entire iterator.
+ */
+declare function compare<const ElementType>(iterable: IterableResolvable<ElementType>, other: IterableResolvable<ElementType>): LexicographicComparison;
+
+export { compare };

package/dist/cjs/lib/compareBy.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+var from_cjs = require('./from.cjs');
+var _compare_cjs = require('./shared/_compare.cjs');
+var toIterableIterator_cjs = require('./toIterableIterator.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function compareBy(iterable, other, comparator) {
+  const iterator1 = from_cjs.from(other);
+  for (const x of toIterableIterator_cjs.toIterableIterator(iterable)) {
+    const result1 = iterator1.next();
+    if (result1.done) return 1;
+    const y = result1.value;
+    const comparison = _compare_cjs.compareIteratorElements(x, y, comparator);
+    if (!_compare_cjs.orderingIsEqual(comparison)) {
+      return _compare_cjs.orderingIsLess(comparison) ? -1 : 1;
+    }
+  }
+  return iterator1.next().done ? 0 : -1;
+}
+__name(compareBy, "compareBy");
+
+exports.compareBy = compareBy;
+//# sourceMappingURL=compareBy.cjs.map
+//# sourceMappingURL=compareBy.cjs.map

package/dist/cjs/lib/compareBy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/compareBy.ts"],"names":["from","toIterableIterator","compareIteratorElements","orderingIsEqual","orderingIsLess"],"mappings":";;;;;;;;AA6BO,SAAS,SAAA,CACf,QACA,EAAA,KAAA,EACA,UAC0B,EAAA;AAC1B,EAAM,MAAA,SAAA,GAAYA,cAAK,KAAK,CAAA;AAE5B,EAAW,KAAA,MAAA,CAAA,IAAKC,yCAAmB,CAAA,QAAQ,CAAG,EAAA;AAC7C,IAAM,MAAA,OAAA,GAAU,UAAU,IAAK,EAAA;AAC/B,IAAI,IAAA,OAAA,CAAQ,MAAa,OAAA,CAAA;AAEzB,IAAA,MAAM,IAAI,OAAQ,CAAA,KAAA;AAClB,IAAA,MAAM,UAAa,GAAAC,oCAAA,CAAqC,CAAG,EAAA,CAAA,EAAG,UAAU,CAAA;AACxE,IAAI,IAAA,CAACC,4BAAgB,CAAA,UAAU,CAAG,EAAA;AACjC,MAAO,OAAAC,2BAAA,CAAe,UAAU,CAAA,GAAI,CAAK,CAAA,GAAA,CAAA;AAAA;AAC1C;AAGD,EAAA,OAAO,SAAU,CAAA,IAAA,EAAO,CAAA,IAAA,GAAO,CAAI,GAAA,CAAA,CAAA;AACpC;AAnBgB,MAAA,CAAA,SAAA,EAAA,WAAA,CAAA","file":"compareBy.cjs","sourcesContent":["import { from, type IterableResolvable } from './from';\nimport { compareIteratorElements, orderingIsEqual, orderingIsLess, type CompareByComparator, type LexicographicComparison } from './shared/_compare';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * {@link LexicographicComparison Lexicographically} compares the elements of both iterators are equal. That is:\n *\n * @param iterable The iterator to compare.\n * @param other The iterator to compare against.\n * @returns Whether the two iterators are equal.\n *\n * @example\n * ```typescript\n * import { ascNumber, compareBy } from '@sapphire/iterator-utilities';\n *\n * const x = [1, 2, 3, 4];\n * const y = [1, 4, 9, 16];\n * console.log(compareBy(x, y, (x, y) => ascNumber(x, y)));\n * // Output: -1\n * console.log(compareBy(x, y, (x, y) => ascNumber(x * x, y)));\n * // Output: 0\n * console.log(compareBy(x, y, (x, y) => ascNumber(x * 2, y)));\n * // Output: 1\n * ```\n *\n * @remarks\n *\n * This function consumes the entire iterator.\n */\nexport function compareBy<const ElementType>(\n\titerable: IterableResolvable<ElementType | undefined>,\n\tother: IterableResolvable<ElementType | undefined>,\n\tcomparator: CompareByComparator<ElementType>\n): LexicographicComparison {\n\tconst iterator1 = from(other);\n\n\tfor (const x of toIterableIterator(iterable)) {\n\t\tconst result1 = iterator1.next();\n\t\tif (result1.done) return 1;\n\n\t\tconst y = result1.value;\n\t\tconst comparison = compareIteratorElements<ElementType>(x, y, comparator);\n\t\tif (!orderingIsEqual(comparison)) {\n\t\t\treturn orderingIsLess(comparison) ? -1 : 1;\n\t\t}\n\t}\n\n\treturn iterator1.next().done ? 0 : -1;\n}\n"]}

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

@@ -0,0 +1,31 @@
+import { IterableResolvable } from './from.cjs';
+import { CompareByComparator, LexicographicComparison } from './shared/_compare.js';
+
+/**
+ * {@link LexicographicComparison Lexicographically} compares the elements of both iterators are equal. That is:
+ *
+ * @param iterable The iterator to compare.
+ * @param other The iterator to compare against.
+ * @returns Whether the two iterators are equal.
+ *
+ * @example
+ * ```typescript
+ * import { ascNumber, compareBy } from '@sapphire/iterator-utilities';
+ *
+ * const x = [1, 2, 3, 4];
+ * const y = [1, 4, 9, 16];
+ * console.log(compareBy(x, y, (x, y) => ascNumber(x, y)));
+ * // Output: -1
+ * console.log(compareBy(x, y, (x, y) => ascNumber(x * x, y)));
+ * // Output: 0
+ * console.log(compareBy(x, y, (x, y) => ascNumber(x * 2, y)));
+ * // Output: 1
+ * ```
+ *
+ * @remarks
+ *
+ * This function consumes the entire iterator.
+ */
+declare function compareBy<const ElementType>(iterable: IterableResolvable<ElementType | undefined>, other: IterableResolvable<ElementType | undefined>, comparator: CompareByComparator<ElementType>): LexicographicComparison;
+
+export { compareBy };

package/dist/cjs/lib/compress.cjs

@@ -20,5 +20,5 @@ function* compress(iterable, selectors) {
 __name(compress, "compress");
 
 exports.compress = compress;
-//# sourceMappingURL=out.js.map
+//# sourceMappingURL=compress.cjs.map
 //# sourceMappingURL=compress.cjs.map

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

@@ -1 +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"]}
+{"version":3,"sources":["../../../src/lib/compress.ts"],"names":["from","toIterableIterator"],"mappings":";;;;;;;AAwBO,UAAU,QAAA,CAChB,UACA,SACgC,EAAA;AAChC,EAAM,MAAA,iBAAA,GAAoBA,cAAK,SAAS,CAAA;AACxC,EAAW,KAAA,MAAA,sBAAA,IAA0BC,yCAAmB,CAAA,QAAQ,CAAG,EAAA;AAClE,IAAM,MAAA,cAAA,GAAiB,kBAAkB,IAAK,EAAA;AAC9C,IAAA,IAAI,eAAe,IAAM,EAAA;AACxB,MAAA;AAAA;AAGD,IAAA,IAAI,eAAe,KAAO,EAAA;AACzB,MAAM,MAAA,sBAAA;AAAA;AACP;AAEF;AAfiB,MAAA,CAAA,QAAA,EAAA,UAAA,CAAA","file":"compress.cjs","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/contains.cjs

@@ -6,13 +6,12 @@ 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;
+    if (element === value) return true;
   }
   return false;
 }
 __name(contains, "contains");
 
 exports.contains = contains;
-//# sourceMappingURL=out.js.map
+//# sourceMappingURL=contains.cjs.map
 //# sourceMappingURL=contains.cjs.map

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

@@ -1 +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"]}
+{"version":3,"sources":["../../../src/lib/contains.ts"],"names":["toIterableIterator"],"mappings":";;;;;;AAuBO,SAAS,QAAA,CAA4B,UAA2C,KAA6B,EAAA;AACnH,EAAW,KAAA,MAAA,OAAA,IAAWA,yCAAmB,CAAA,QAAQ,CAAG,EAAA;AACnD,IAAI,IAAA,OAAA,KAAY,OAAc,OAAA,IAAA;AAAA;AAG/B,EAAO,OAAA,KAAA;AACR;AANgB,MAAA,CAAA,QAAA,EAAA,UAAA,CAAA","file":"contains.cjs","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/count.cjs

@@ -15,5 +15,5 @@ function count(iterable) {
 __name(count, "count");
 
 exports.count = count;
-//# sourceMappingURL=out.js.map
+//# sourceMappingURL=count.cjs.map
 //# sourceMappingURL=count.cjs.map

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

@@ -1 +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"]}
+{"version":3,"sources":["../../../src/lib/count.ts"],"names":["count","from"],"mappings":";;;;;;AAqBO,SAAS,MAAyB,QAAmD,EAAA;AAC3F,EAAA,IAAIA,MAAQ,GAAA,CAAA;AACZ,EAAM,MAAA,gBAAA,GAAmBC,cAAK,QAAQ,CAAA;AACtC,EAAA,OAAO,CAAC,gBAAA,CAAiB,IAAK,EAAA,CAAE,IAAM,EAAA;AACrC,IAAAD,MAAAA,EAAAA;AAAA;AAGD,EAAOA,OAAAA,MAAAA;AACR;AARgB,MAAA,CAAA,KAAA,EAAA,OAAA,CAAA","file":"count.cjs","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/cycle.cjs

@@ -19,5 +19,5 @@ function* cycle(iterable) {
 __name(cycle, "cycle");
 
 exports.cycle = cycle;
-//# sourceMappingURL=out.js.map
+//# sourceMappingURL=cycle.cjs.map
 //# sourceMappingURL=cycle.cjs.map

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

@@ -1 +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"]}
+{"version":3,"sources":["../../../src/lib/cycle.ts"],"names":["toIterableIterator"],"mappings":";;;;;;AAmBO,UAAU,MAAyB,QAA0E,EAAA;AACnH,EAAA,MAAM,UAAU,EAAC;AACjB,EAAW,KAAA,MAAA,OAAA,IAAWA,yCAAmB,CAAA,QAAQ,CAAG,EAAA;AACnD,IAAM,MAAA,OAAA;AACN,IAAA,OAAA,CAAQ,KAAK,OAAO,CAAA;AAAA;AAGrB,EAAO,OAAA,OAAA,CAAQ,SAAS,CAAG,EAAA;AAC1B,IAAA,KAAA,MAAW,WAAW,OAAS,EAAA;AAC9B,MAAM,MAAA,OAAA;AAAA;AACP;AAEF;AAZiB,MAAA,CAAA,KAAA,EAAA,OAAA,CAAA","file":"cycle.cjs","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/difference.cjs

@@ -14,5 +14,5 @@ __name(difference, "difference");
 exports.difference = difference;
 exports.except = difference;
 exports.omit = difference;
-//# sourceMappingURL=out.js.map
+//# sourceMappingURL=difference.cjs.map
 //# sourceMappingURL=difference.cjs.map

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

@@ -1 +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"]}
+{"version":3,"sources":["../../../src/lib/difference.ts"],"names":["toIterableIterator","filter"],"mappings":";;;;;;;AAwBO,SAAS,UAAA,CACf,OACA,MACgC,EAAA;AAChC,EAAA,MAAM,GAAM,GAAA,IAAI,GAAI,CAAAA,yCAAA,CAAmB,MAAM,CAAC,CAAA;AAC9C,EAAO,OAAAC,iBAAA,CAAO,OAAO,CAAC,KAAA,KAAU,CAAC,GAAI,CAAA,GAAA,CAAI,KAAK,CAAC,CAAA;AAChD;AANgB,MAAA,CAAA,UAAA,EAAA,YAAA,CAAA","file":"difference.cjs","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/drop.cjs

@@ -10,19 +10,15 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 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();
+  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;
+    if (resolvedIterable.next().done) break;
   }
   return resolvedIterable;
 }
 __name(drop, "drop");
 
 exports.drop = drop;
-exports.skip = drop;
-//# sourceMappingURL=out.js.map
+//# sourceMappingURL=drop.cjs.map
 //# sourceMappingURL=drop.cjs.map

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

@@ -1 +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"]}
+{"version":3,"sources":["../../../src/lib/drop.ts"],"names":["assertNotNegative","toIntegerOrInfinityOrThrow","toIterableIterator","empty"],"mappings":";;;;;;;;;AAsBO,SAAS,IAAA,CAAwB,UAA2C,KAA8C,EAAA;AAChI,EAAA,KAAA,GAAQA,wCAAkB,CAAAC,0DAAA,CAA2B,KAAK,CAAA,EAAG,KAAK,CAAA;AAClE,EAAM,MAAA,gBAAA,GAAmBC,0CAAmB,QAAQ,CAAA;AAGpD,EAAI,IAAA,KAAA,KAAU,GAAU,OAAA,gBAAA;AAExB,EAAA,IAAI,KAAU,KAAA,MAAA,CAAO,iBAAmB,EAAA,OAAOC,eAAM,EAAA;AAErD,EAAA,KAAA,IAAS,CAAI,GAAA,CAAA,EAAG,CAAI,GAAA,KAAA,EAAO,CAAK,EAAA,EAAA;AAC/B,IAAI,IAAA,gBAAA,CAAiB,IAAK,EAAA,CAAE,IAAM,EAAA;AAAA;AAGnC,EAAO,OAAA,gBAAA;AACR;AAdgB,MAAA,CAAA,IAAA,EAAA,MAAA,CAAA","file":"drop.cjs","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"]}

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

@@ -18,4 +18,4 @@ import { IterableResolvable } from './from.cjs';
  */
 declare function drop<const ElementType>(iterable: IterableResolvable<ElementType>, count: number): IterableIterator<ElementType>;
 
-export { drop, drop as skip };
+export { drop };

package/dist/cjs/lib/dropLast.cjs

@@ -11,13 +11,11 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 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();
+  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
 //# sourceMappingURL=dropLast.cjs.map

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

@@ -1 +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"]}
+{"version":3,"sources":["../../../src/lib/dropLast.ts"],"names":["assertNotNegative","toIntegerOrInfinityOrThrow","toArray","empty","take"],"mappings":";;;;;;;;;;AA2BO,SAAS,QAAA,CAA4B,UAA2C,KAA8C,EAAA;AACpI,EAAA,KAAA,GAAQA,wCAAkB,CAAAC,0DAAA,CAA2B,KAAK,CAAA,EAAG,KAAK,CAAA;AAClE,EAAM,MAAA,KAAA,GAAQC,oBAAQ,QAAQ,CAAA;AAC9B,EAAA,IAAI,KAAM,CAAA,MAAA,IAAU,KAAO,EAAA,OAAOC,eAAM,EAAA;AACxC,EAAA,OAAOC,cAAK,KAAM,CAAA,MAAA,EAAU,EAAA,KAAA,CAAM,SAAS,KAAK,CAAA;AACjD;AALgB,MAAA,CAAA,QAAA,EAAA,UAAA,CAAA","file":"dropLast.cjs","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"]}

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

@@ -22,4 +22,4 @@ import { IterableResolvable } from './from.cjs';
  */
 declare function dropLast<const ElementType>(iterable: IterableResolvable<ElementType>, count: number): IterableIterator<ElementType>;
 
-export { dropLast, dropLast as skipLast };
+export { dropLast };

package/dist/cjs/lib/dropWhile.cjs

@@ -17,6 +17,5 @@ function* dropWhile(iterable, callbackFn) {
 __name(dropWhile, "dropWhile");
 
 exports.dropWhile = dropWhile;
-exports.skipWhile = dropWhile;
-//# sourceMappingURL=out.js.map
+//# sourceMappingURL=dropWhile.cjs.map
 //# sourceMappingURL=dropWhile.cjs.map

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

@@ -1 +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"]}
+{"version":3,"sources":["../../../src/lib/dropWhile.ts"],"names":["assertFunction","toIterableIterator"],"mappings":";;;;;;;AA8BO,UAAU,SAAA,CAChB,UACA,UACgC,EAAA;AAChC,EAAA,UAAA,GAAaA,mCAAe,UAAU,CAAA;AAEtC,EAAA,IAAI,KAAQ,GAAA,CAAA;AACZ,EAAW,KAAA,MAAA,KAAA,IAASC,yCAAmB,CAAA,QAAQ,CAAG,EAAA;AACjD,IAAA,IAAI,CAAC,UAAA,CAAW,KAAO,EAAA,KAAA,EAAO,CAAG,EAAA;AAChC,MAAM,MAAA,KAAA;AAAA;AACP;AAEF;AAZiB,MAAA,CAAA,SAAA,EAAA,WAAA,CAAA","file":"dropWhile.cjs","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"]}

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

@@ -21,4 +21,4 @@ import { IterableResolvable } from './from.cjs';
 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 };
+export { dropWhile };

package/dist/cjs/lib/empty.cjs

@@ -10,5 +10,5 @@ function empty() {
 __name(empty, "empty");
 
 exports.empty = empty;
-//# sourceMappingURL=out.js.map
+//# sourceMappingURL=empty.cjs.map
 //# sourceMappingURL=empty.cjs.map

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

@@ -1 +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"]}
+{"version":3,"sources":["../../../src/lib/empty.ts"],"names":["makeIterableIterator"],"mappings":";;;;;;AAgBO,SAAS,KAAkE,GAAA;AACjF,EAAA,OAAOA,+CAAkC,OAAO,EAAE,MAAM,IAAM,EAAA,KAAA,EAAO,QAAY,CAAA,CAAA;AAClF;AAFgB,MAAA,CAAA,KAAA,EAAA,OAAA,CAAA","file":"empty.cjs","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/enumerate.cjs

@@ -13,5 +13,5 @@ function* enumerate(iterable) {
 __name(enumerate, "enumerate");
 
 exports.enumerate = enumerate;
-//# sourceMappingURL=out.js.map
+//# sourceMappingURL=enumerate.cjs.map
 //# sourceMappingURL=enumerate.cjs.map

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

@@ -1 +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"]}
+{"version":3,"sources":["../../../src/lib/enumerate.ts"],"names":["toIterableIterator"],"mappings":";;;;;;AAsBO,UAAU,UAA6B,QAAoF,EAAA;AACjI,EAAA,IAAI,KAAQ,GAAA,CAAA;AACZ,EAAW,KAAA,MAAA,KAAA,IAASA,yCAAmB,CAAA,QAAQ,CAAG,EAAA;AACjD,IAAM,MAAA,CAAC,SAAS,KAAK,CAAA;AAAA;AAEvB;AALiB,MAAA,CAAA,SAAA,EAAA,WAAA,CAAA","file":"enumerate.cjs","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"]}