@sapphire/iterator-utilities 1.0.0

package/dist/esm/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/index.ts"],"names":[],"mappings":";AAAA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc","sourcesContent":["export * from './lib/append';\nexport * from './lib/at';\nexport * from './lib/average';\nexport * from './lib/chain';\nexport * from './lib/chunk';\nexport * from './lib/compact';\nexport * from './lib/compress';\nexport * from './lib/contains';\nexport * from './lib/count';\nexport * from './lib/cycle';\nexport * from './lib/difference';\nexport * from './lib/drop';\nexport * from './lib/dropLast';\nexport * from './lib/dropWhile';\nexport * from './lib/empty';\nexport * from './lib/enumerate';\nexport * from './lib/every';\nexport * from './lib/filter';\nexport * from './lib/find';\nexport * from './lib/findIndex';\nexport * from './lib/first';\nexport * from './lib/flat';\nexport * from './lib/flatMap';\nexport * from './lib/forEach';\nexport * from './lib/from';\nexport * from './lib/indexOf';\nexport * from './lib/intersect';\nexport * from './lib/isEmpty';\nexport * from './lib/last';\nexport * from './lib/map';\nexport * from './lib/max';\nexport * from './lib/min';\nexport * from './lib/partition';\nexport * from './lib/peekable';\nexport * from './lib/prepend';\nexport * from './lib/product';\nexport * from './lib/range';\nexport * from './lib/reduce';\nexport * from './lib/repeat';\nexport * from './lib/reverse';\nexport * from './lib/slice';\nexport * from './lib/some';\nexport * from './lib/sorted';\nexport * from './lib/starMap';\nexport * from './lib/sum';\nexport * from './lib/take';\nexport * from './lib/takeLast';\nexport * from './lib/tee';\nexport * from './lib/toArray';\nexport * from './lib/toIterableIterator';\nexport * from './lib/union';\nexport * from './lib/unique';\nexport * from './lib/unzip';\nexport * from './lib/zip';\n"]}

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

@@ -0,0 +1,21 @@
+import { IterableResolvable } from './from.mjs';
+
+/**
+ * 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]`.
+ *
+ * @param iterable The iterator to append values to.
+ * @param iterables The iterables to append to the iterator.
+ * @returns An iterator that yields the values of the provided iterator followed by the values of the provided iterables.
+ *
+ * @example
+ * ```typescript
+ * import { append } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = append([1, 2, 3], [4, 5, 6], [7, 8, 9]);
+ * console.log([...iterable]);
+ * // Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]
+ * ```
+ */
+declare function append<const ElementType>(iterable: IterableResolvable<ElementType>, ...iterables: IterableResolvable<ElementType>[]): IterableIterator<ElementType>;
+
+export { append, append as concat };

package/dist/esm/lib/append.mjs

@@ -0,0 +1,11 @@
+import { __name } from '../chunk-G5GHKT7C.mjs';
+import { chain } from './chain.mjs';
+
+function append(iterable, ...iterables) {
+  return chain(iterable, ...iterables);
+}
+__name(append, "append");
+
+export { append, append as concat };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=append.mjs.map

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

@@ -0,0 +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"]}

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

@@ -0,0 +1,25 @@
+import { IterableResolvable } from './from.mjs';
+
+/**
+ * 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`.
+ *
+ * @param iterable An iterator to return an element from.
+ * @param index The index of the element to retrieve.
+ * @returns The element at the specified index, or `undefined` if the index is out of range.
+ *
+ * @example
+ * ```typescript
+ * import { at } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = [1, 2, 3, 4, 5];
+ * console.log(at(iterable, 2));
+ * // Output: 3
+ * ```
+ *
+ * @remarks
+ *
+ * This function consumes the input iterator up to the specified index.
+ */
+declare function at<const ElementType>(iterable: IterableResolvable<ElementType>, index: number): ElementType | undefined;
+
+export { at };

package/dist/esm/lib/at.mjs

@@ -0,0 +1,15 @@
+import { __name } from '../chunk-G5GHKT7C.mjs';
+import { drop } from './drop.mjs';
+import { first } from './first.mjs';
+import { assertNotNegative } from './shared/_assertNotNegative.mjs';
+import { toIntegerOrInfinityOrThrow } from './shared/_toIntegerOrInfinityOrThrow.mjs';
+
+function at(iterable, index) {
+  index = assertNotNegative(toIntegerOrInfinityOrThrow(index), index);
+  return first(index === 0 ? iterable : drop(iterable, index));
+}
+__name(at, "at");
+
+export { at };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=at.mjs.map

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

@@ -0,0 +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"]}

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

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

package/dist/esm/lib/average.mjs

@@ -0,0 +1,18 @@
+import { __name } from '../chunk-G5GHKT7C.mjs';
+import { map } from './map.mjs';
+import { toNumberOrThrow } from './shared/_toNumberOrThrow.mjs';
+
+function average(iterable) {
+  let sum = 0;
+  let total = 0;
+  for (const value of map(iterable, toNumberOrThrow)) {
+    sum += value;
+    total++;
+  }
+  return total === 0 ? null : sum / total;
+}
+__name(average, "average");
+
+export { average };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=average.mjs.map

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

@@ -0,0 +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"]}

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

@@ -0,0 +1,20 @@
+import { IterableResolvable } from './from.mjs';
+
+/**
+ * Similar to `append`, but takes an iterable of iterables and chains them together.
+ *
+ * @param iterables The iterators to chain together.
+ * @returns An iterator that yields the values of the provided iterators in order.
+ *
+ * @example
+ * ```typescript
+ * import { chain } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = chain([1, 2, 3], [4, 5, 6], [7, 8, 9]);
+ * console.log([...iterable]);
+ * // Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]
+ * ```
+ */
+declare function chain<const ElementType>(...iterables: IterableResolvable<ElementType>[]): IterableIterator<ElementType>;
+
+export { chain };

package/dist/esm/lib/chain.mjs

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

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

@@ -0,0 +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"]}

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

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

@@ -0,0 +1,24 @@
+import { __name } from '../chunk-G5GHKT7C.mjs';
+import { assertPositive } from './shared/_assertPositive.mjs';
+import { toIntegerOrThrow } from './shared/_toIntegerOrThrow.mjs';
+import { toIterableIterator } from './toIterableIterator.mjs';
+
+function* chunk(iterable, size) {
+  size = assertPositive(toIntegerOrThrow(size), size);
+  let buffer = [];
+  for (const element of toIterableIterator(iterable)) {
+    buffer.push(element);
+    if (buffer.length === size) {
+      yield buffer;
+      buffer = [];
+    }
+  }
+  if (buffer.length) {
+    yield buffer;
+  }
+}
+__name(chunk, "chunk");
+
+export { chunk };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=chunk.mjs.map

package/dist/esm/lib/chunk.mjs.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/esm/lib/compact.d.mts

@@ -0,0 +1,19 @@
+import { IterableResolvable } from './from.mjs';
+
+/**
+ * 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/esm/lib/compact.mjs

@@ -0,0 +1,11 @@
+import { __name } from '../chunk-G5GHKT7C.mjs';
+import { filter } from './filter.mjs';
+
+function compact(iterable) {
+  return filter(iterable, (value) => value !== null && value !== void 0);
+}
+__name(compact, "compact");
+
+export { compact };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=compact.mjs.map

package/dist/esm/lib/compact.mjs.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/esm/lib/compress.d.mts

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

@@ -0,0 +1,21 @@
+import { __name } from '../chunk-G5GHKT7C.mjs';
+import { from } from './from.mjs';
+import { toIterableIterator } from './toIterableIterator.mjs';
+
+function* compress(iterable, selectors) {
+  const resolvedSelectors = from(selectors);
+  for (const resolvedIterableResult of toIterableIterator(iterable)) {
+    const selectorResult = resolvedSelectors.next();
+    if (selectorResult.done) {
+      return;
+    }
+    if (selectorResult.value) {
+      yield resolvedIterableResult;
+    }
+  }
+}
+__name(compress, "compress");
+
+export { compress };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=compress.mjs.map

package/dist/esm/lib/compress.mjs.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/esm/lib/contains.d.mts

@@ -0,0 +1,25 @@
+import { IterableResolvable } from './from.mjs';
+
+/**
+ * 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/esm/lib/contains.mjs

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

package/dist/esm/lib/contains.mjs.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/esm/lib/count.d.mts

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

@@ -0,0 +1,16 @@
+import { __name } from '../chunk-G5GHKT7C.mjs';
+import { from } from './from.mjs';
+
+function count(iterable) {
+  let count2 = 0;
+  const resolvedIterable = from(iterable);
+  while (!resolvedIterable.next().done) {
+    count2++;
+  }
+  return count2;
+}
+__name(count, "count");
+
+export { count };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=count.mjs.map

package/dist/esm/lib/count.mjs.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/esm/lib/cycle.d.mts

@@ -0,0 +1,21 @@
+import { IterableResolvable } from './from.mjs';
+
+/**
+ * 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/esm/lib/cycle.mjs

@@ -0,0 +1,20 @@
+import { __name } from '../chunk-G5GHKT7C.mjs';
+import { toIterableIterator } from './toIterableIterator.mjs';
+
+function* cycle(iterable) {
+  const results = [];
+  for (const element of toIterableIterator(iterable)) {
+    yield element;
+    results.push(element);
+  }
+  while (results.length > 0) {
+    for (const element of results) {
+      yield element;
+    }
+  }
+}
+__name(cycle, "cycle");
+
+export { cycle };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=cycle.mjs.map

package/dist/esm/lib/cycle.mjs.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/esm/lib/difference.d.mts

@@ -0,0 +1,25 @@
+import { IterableResolvable } from './from.mjs';
+
+/**
+ * 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/esm/lib/difference.mjs

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

package/dist/esm/lib/difference.mjs.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/esm/lib/drop.d.mts

@@ -0,0 +1,21 @@
+import { IterableResolvable } from './from.mjs';
+
+/**
+ * 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/esm/lib/drop.mjs

@@ -0,0 +1,24 @@
+import { __name } from '../chunk-G5GHKT7C.mjs';
+import { empty } from './empty.mjs';
+import { assertNotNegative } from './shared/_assertNotNegative.mjs';
+import { toIntegerOrInfinityOrThrow } from './shared/_toIntegerOrInfinityOrThrow.mjs';
+import { toIterableIterator } from './toIterableIterator.mjs';
+
+function drop(iterable, count) {
+  count = assertNotNegative(toIntegerOrInfinityOrThrow(count), count);
+  const resolvedIterable = toIterableIterator(iterable);
+  if (count === 0)
+    return resolvedIterable;
+  if (count === Number.POSITIVE_INFINITY)
+    return empty();
+  for (let i = 0; i < count; i++) {
+    if (resolvedIterable.next().done)
+      break;
+  }
+  return resolvedIterable;
+}
+__name(drop, "drop");
+
+export { drop, drop as skip };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=drop.mjs.map

package/dist/esm/lib/drop.mjs.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/esm/lib/dropLast.d.mts

@@ -0,0 +1,25 @@
+import { IterableResolvable } from './from.mjs';
+
+/**
+ * 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/esm/lib/dropLast.mjs

@@ -0,0 +1,19 @@
+import { __name } from '../chunk-G5GHKT7C.mjs';
+import { empty } from './empty.mjs';
+import { assertNotNegative } from './shared/_assertNotNegative.mjs';
+import { toIntegerOrInfinityOrThrow } from './shared/_toIntegerOrInfinityOrThrow.mjs';
+import { take } from './take.mjs';
+import { toArray } from './toArray.mjs';
+
+function dropLast(iterable, count) {
+  count = assertNotNegative(toIntegerOrInfinityOrThrow(count), count);
+  const array = toArray(iterable);
+  if (array.length <= count)
+    return empty();
+  return take(array.values(), array.length - count);
+}
+__name(dropLast, "dropLast");
+
+export { dropLast, dropLast as skipLast };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=dropLast.mjs.map

package/dist/esm/lib/dropLast.mjs.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"]}