@sapphire/iterator-utilities 1.0.0

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

@@ -0,0 +1,21 @@
+import { IterableResolvable } from './from.cjs';
+
+/**
+ * Creates an iterable with the first `count` elements.
+ *
+ * @param iterable The iterator to take values from.
+ * @param count The maximum number of values to take from the iterator.
+ * @returns An iterator that yields at most `count` values from the provided iterator.
+ *
+ * @example
+ * ```typescript
+ * import { take } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = [1, 2, 3, 4, 5];
+ * console.log([...take(iterable, 2)]);
+ * // Output: [1, 2]
+ * ```
+ */
+declare function take<const ElementType>(iterable: IterableResolvable<ElementType>, count: number): IterableIterator<ElementType>;
+
+export { take };

package/dist/cjs/lib/takeLast.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+var empty_cjs = require('./empty.cjs');
+var _assertNotNegative_cjs = require('./shared/_assertNotNegative.cjs');
+var _makeIterableIterator_cjs = require('./shared/_makeIterableIterator.cjs');
+var _toIntegerOrInfinityOrThrow_cjs = require('./shared/_toIntegerOrInfinityOrThrow.cjs');
+var toArray_cjs = require('./toArray.cjs');
+var toIterableIterator_cjs = require('./toIterableIterator.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function takeLast(iterable, count) {
+  count = _assertNotNegative_cjs.assertNotNegative(_toIntegerOrInfinityOrThrow_cjs.toIntegerOrInfinityOrThrow(count), count);
+  if (count === 0)
+    return empty_cjs.empty();
+  if (count === Number.POSITIVE_INFINITY)
+    return toIterableIterator_cjs.toIterableIterator(iterable);
+  const array = toArray_cjs.toArray(iterable);
+  let i = Math.max(0, array.length - count);
+  return _makeIterableIterator_cjs.makeIterableIterator(() => {
+    if (i >= array.length) {
+      return { done: true, value: void 0 };
+    }
+    return { done: false, value: array[i++] };
+  });
+}
+__name(takeLast, "takeLast");
+
+exports.takeLast = takeLast;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=takeLast.cjs.map

package/dist/cjs/lib/takeLast.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/takeLast.ts"],"names":[],"mappings":";;;;AAAA,SAAS,aAAa;AAEtB,SAAS,yBAAyB;AAClC,SAAS,4BAA4B;AACrC,SAAS,kCAAkC;AAC3C,SAAS,eAAe;AACxB,SAAS,0BAA0B;AAsB5B,SAAS,SAA4B,UAA2C,OAA8C;AACpI,UAAQ,kBAAkB,2BAA2B,KAAK,GAAG,KAAK;AAClE,MAAI,UAAU;AAAG,WAAO,MAAM;AAC9B,MAAI,UAAU,OAAO;AAAmB,WAAO,mBAAmB,QAAQ;AAE1E,QAAM,QAAQ,QAAQ,QAAQ;AAC9B,MAAI,IAAI,KAAK,IAAI,GAAG,MAAM,SAAS,KAAK;AACxC,SAAO,qBAAkC,MAAM;AAC9C,QAAI,KAAK,MAAM,QAAQ;AACtB,aAAO,EAAE,MAAM,MAAM,OAAO,OAAU;AAAA,IACvC;AAEA,WAAO,EAAE,MAAM,OAAO,OAAO,MAAM,GAAG,EAAE;AAAA,EACzC,CAAC;AACF;AAdgB","sourcesContent":["import { empty } from './empty';\nimport type { IterableResolvable } from './from';\nimport { assertNotNegative } from './shared/_assertNotNegative';\nimport { makeIterableIterator } from './shared/_makeIterableIterator';\nimport { toIntegerOrInfinityOrThrow } from './shared/_toIntegerOrInfinityOrThrow';\nimport { toArray } from './toArray';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Consumes the iterable and returns a new iterable with the last `count` elements.\n *\n * @param iterable An iterator to take values from.\n * @param count The number of values to take from the end of the iterator.\n * @returns An iterator that contains the last `count` elements of the provided iterator.\n *\n * @example\n * ```typescript\n * import { takeLast } from '@sapphire/iterator-utilities';\n *\n * const iterable = [1, 2, 3, 4, 5];\n * console.log([...takeLast(iterable, 2)]);\n * // Output: [4, 5]\n * ```\n *\n * @remarks\n *\n * This function consumes the entire iterator.\n */\nexport function takeLast<const ElementType>(iterable: IterableResolvable<ElementType>, count: number): IterableIterator<ElementType> {\n\tcount = assertNotNegative(toIntegerOrInfinityOrThrow(count), count);\n\tif (count === 0) return empty();\n\tif (count === Number.POSITIVE_INFINITY) return toIterableIterator(iterable);\n\n\tconst array = toArray(iterable);\n\tlet i = Math.max(0, array.length - count);\n\treturn makeIterableIterator<ElementType>(() => {\n\t\tif (i >= array.length) {\n\t\t\treturn { done: true, value: undefined };\n\t\t}\n\n\t\treturn { done: false, value: array[i++] };\n\t});\n}\n"]}

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

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

package/dist/cjs/lib/tee.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+var from_cjs = require('./from.cjs');
+var repeat_cjs = require('./repeat.cjs');
+var _assertNotNegative_cjs = require('./shared/_assertNotNegative.cjs');
+var _makeIterableIterator_cjs = require('./shared/_makeIterableIterator.cjs');
+var _toIntegerOrThrow_cjs = require('./shared/_toIntegerOrThrow.cjs');
+var toArray_cjs = require('./toArray.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function tee(iterable, count) {
+  count = _assertNotNegative_cjs.assertNotNegative(_toIntegerOrThrow_cjs.toIntegerOrThrow(count), count);
+  if (count === 0)
+    return [];
+  const entries = [];
+  const indexes = toArray_cjs.toArray(repeat_cjs.repeat(0, count));
+  const resolvedIterable = from_cjs.from(iterable);
+  const iterables = [];
+  for (let i = 0; i < count; i++) {
+    const iterable2 = _makeIterableIterator_cjs.makeIterableIterator(() => {
+      if (indexes[i] >= entries.length) {
+        const result = resolvedIterable.next();
+        if (result.done) {
+          return { done: true, value: void 0 };
+        }
+        entries.push(result.value);
+      }
+      return { done: false, value: entries[indexes[i]++] };
+    });
+    iterables.push(iterable2);
+  }
+  return iterables;
+}
+__name(tee, "tee");
+
+exports.tee = tee;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=tee.cjs.map

package/dist/cjs/lib/tee.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/tee.ts"],"names":["iterable"],"mappings":";;;;AAAA,SAAS,YAAqC;AAC9C,SAAS,cAAc;AACvB,SAAS,yBAAyB;AAClC,SAAS,4BAA4B;AACrC,SAAS,wBAAwB;AACjC,SAAS,eAAe;AAsBjB,SAAS,IAAuB,UAA2C,OAAgD;AACjI,UAAQ,kBAAkB,iBAAiB,KAAK,GAAG,KAAK;AACxD,MAAI,UAAU;AAAG,WAAO,CAAC;AAEzB,QAAM,UAAU,CAAC;AACjB,QAAM,UAAU,QAAQ,OAAO,GAAG,KAAK,CAAC;AACxC,QAAM,mBAAmB,KAAK,QAAQ;AAEtC,QAAM,YAAY,CAAC;AACnB,WAAS,IAAI,GAAG,IAAI,OAAO,KAAK;AAC/B,UAAMA,YAAW,qBAAkC,MAAM;AACxD,UAAI,QAAQ,CAAC,KAAK,QAAQ,QAAQ;AACjC,cAAM,SAAS,iBAAiB,KAAK;AACrC,YAAI,OAAO,MAAM;AAChB,iBAAO,EAAE,MAAM,MAAM,OAAO,OAAU;AAAA,QACvC;AAEA,gBAAQ,KAAK,OAAO,KAAK;AAAA,MAC1B;AAEA,aAAO,EAAE,MAAM,OAAO,OAAO,QAAQ,QAAQ,CAAC,GAAG,EAAE;AAAA,IACpD,CAAC;AAED,cAAU,KAAKA,SAAQ;AAAA,EACxB;AAEA,SAAO;AACR;AA3BgB","sourcesContent":["import { from, type IterableResolvable } from './from';\nimport { repeat } from './repeat';\nimport { assertNotNegative } from './shared/_assertNotNegative';\nimport { makeIterableIterator } from './shared/_makeIterableIterator';\nimport { toIntegerOrThrow } from './shared/_toIntegerOrThrow';\nimport { toArray } from './toArray';\n\n/**\n * Creates `count` independent iterators from the input iterable.\n *\n * @param iterable An iterator to tee.\n * @param count The number of iterators to create.\n * @returns An array of `count` iterators that each yield the same values as the input iterator.\n *\n * @example\n * ```typescript\n * import { tee } from '@sapphire/iterator-utilities';\n *\n * const iterable = [1, 2, 3, 4, 5];\n * const [iter1, iter2] = tee(iterable, 2);\n * console.log([...iter1]);\n * // Output: [1, 2, 3, 4, 5]\n *\n * console.log([...iter2]);\n * // Output: [1, 2, 3, 4, 5]\n * ```\n */\nexport function tee<const ElementType>(iterable: IterableResolvable<ElementType>, count: number): IterableIterator<ElementType>[] {\n\tcount = assertNotNegative(toIntegerOrThrow(count), count);\n\tif (count === 0) return [];\n\n\tconst entries = [] as ElementType[];\n\tconst indexes = toArray(repeat(0, count));\n\tconst resolvedIterable = from(iterable);\n\n\tconst iterables = [] as IterableIterator<ElementType>[];\n\tfor (let i = 0; i < count; i++) {\n\t\tconst iterable = makeIterableIterator<ElementType>(() => {\n\t\t\tif (indexes[i] >= entries.length) {\n\t\t\t\tconst result = resolvedIterable.next();\n\t\t\t\tif (result.done) {\n\t\t\t\t\treturn { done: true, value: undefined };\n\t\t\t\t}\n\n\t\t\t\tentries.push(result.value);\n\t\t\t}\n\n\t\t\treturn { done: false, value: entries[indexes[i]++] };\n\t\t});\n\n\t\titerables.push(iterable);\n\t}\n\n\treturn iterables;\n}\n"]}

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

@@ -0,0 +1,25 @@
+import { IterableResolvable } from './from.cjs';
+
+/**
+ * Creates `count` independent iterators from the input iterable.
+ *
+ * @param iterable An iterator to tee.
+ * @param count The number of iterators to create.
+ * @returns An array of `count` iterators that each yield the same values as the input iterator.
+ *
+ * @example
+ * ```typescript
+ * import { tee } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = [1, 2, 3, 4, 5];
+ * const [iter1, iter2] = tee(iterable, 2);
+ * console.log([...iter1]);
+ * // Output: [1, 2, 3, 4, 5]
+ *
+ * console.log([...iter2]);
+ * // Output: [1, 2, 3, 4, 5]
+ * ```
+ */
+declare function tee<const ElementType>(iterable: IterableResolvable<ElementType>, count: number): IterableIterator<ElementType>[];
+
+export { tee };

package/dist/cjs/lib/toArray.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var toIterableIterator_cjs = require('./toIterableIterator.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function toArray(iterable) {
+  return [...toIterableIterator_cjs.toIterableIterator(iterable)];
+}
+__name(toArray, "toArray");
+
+exports.toArray = toArray;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=toArray.cjs.map

package/dist/cjs/lib/toArray.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/toArray.ts"],"names":[],"mappings":";;;;AACA,SAAS,0BAA0B;AAiC5B,SAAS,QAA2B,UAA0D;AACpG,SAAO,CAAC,GAAG,mBAAmB,QAAQ,CAAC;AACxC;AAFgB","sourcesContent":["import type { IterableResolvable } from './from';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Consumes the iterable and returns an array with all the elements.\n *\n * @param iterable The iterator to convert to an array.\n * @returns An array containing the values of the provided iterator.\n *\n * @example\n * ```typescript\n * import { toArray } from '@sapphire/iterator-utilities';\n *\n * const array = [1, 2, 3, 4, 5];\n * console.log(toArray(array));\n * // Output: [1, 2, 3, 4, 5]\n *\n * const set = new Set([1, 2, 3, 4, 5]);\n * console.log(toArray(set));\n * // Output: [1, 2, 3, 4, 5]\n *\n * const map = new Map([['a', 1], ['b', 2], ['c', 3]]);\n * console.log(toArray(map));\n * // Output: [['a', 1], ['b', 2], ['c', 3]]\n *\n * const string = 'hello';\n * console.log(toArray(string));\n * // Output: ['h', 'e', 'l', 'l', 'o']\n * ```\n *\n * @remarks\n *\n * This function consumes the entire iterator.\n */\nexport function toArray<const ElementType>(iterable: IterableResolvable<ElementType>): ElementType[] {\n\treturn [...toIterableIterator(iterable)];\n}\n"]}

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

@@ -0,0 +1,36 @@
+import { IterableResolvable } from './from.cjs';
+
+/**
+ * Consumes the iterable and returns an array with all the elements.
+ *
+ * @param iterable The iterator to convert to an array.
+ * @returns An array containing the values of the provided iterator.
+ *
+ * @example
+ * ```typescript
+ * import { toArray } from '@sapphire/iterator-utilities';
+ *
+ * const array = [1, 2, 3, 4, 5];
+ * console.log(toArray(array));
+ * // Output: [1, 2, 3, 4, 5]
+ *
+ * const set = new Set([1, 2, 3, 4, 5]);
+ * console.log(toArray(set));
+ * // Output: [1, 2, 3, 4, 5]
+ *
+ * const map = new Map([['a', 1], ['b', 2], ['c', 3]]);
+ * console.log(toArray(map));
+ * // Output: [['a', 1], ['b', 2], ['c', 3]]
+ *
+ * const string = 'hello';
+ * console.log(toArray(string));
+ * // Output: ['h', 'e', 'l', 'l', 'o']
+ * ```
+ *
+ * @remarks
+ *
+ * This function consumes the entire iterator.
+ */
+declare function toArray<const ElementType>(iterable: IterableResolvable<ElementType>): ElementType[];
+
+export { toArray };

package/dist/cjs/lib/toIterableIterator.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var from_cjs = require('./from.cjs');
+var _makeIterableIterator_cjs = require('./shared/_makeIterableIterator.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function toIterableIterator(iterable) {
+  const resolvedIterable = from_cjs.from(iterable);
+  if (Symbol.iterator in resolvedIterable) {
+    return resolvedIterable;
+  }
+  return _makeIterableIterator_cjs.makeIterableIterator(() => resolvedIterable.next());
+}
+__name(toIterableIterator, "toIterableIterator");
+
+exports.toIterableIterator = toIterableIterator;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=toIterableIterator.cjs.map

package/dist/cjs/lib/toIterableIterator.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/toIterableIterator.ts"],"names":[],"mappings":";;;;AAAA,SAAS,YAAqC;AAC9C,SAAS,4BAA4B;AA6B9B,SAAS,mBAAsC,UAA0E;AAC/H,QAAM,mBAAmB,KAAK,QAAQ;AACtC,MAAI,OAAO,YAAY,kBAAkB;AACxC,WAAO;AAAA,EACR;AAEA,SAAO,qBAAqB,MAAM,iBAAiB,KAAK,CAAC;AAC1D;AAPgB","sourcesContent":["import { from, type IterableResolvable } from './from';\nimport { makeIterableIterator } from './shared/_makeIterableIterator';\n\n/**\n * Creates an iterable iterator from an iterable or iterator-like object.\n *\n * @param iterable The iterable or iterable-like object to convert.\n * @returns An iterable iterator.\n *\n * @example\n * ```typescript\n * import { toIterableIterator } from '@sapphire/iterator-utilities';\n *\n * const array = [1, 2, 3, 4, 5];\n * console.log([...toIterableIterator(array)]);\n * // Output: [1, 2, 3, 4, 5]\n *\n * const set = new Set([1, 2, 3, 4, 5]);\n * console.log([...toIterableIterator(set)]);\n * // Output: [1, 2, 3, 4, 5]\n *\n * const map = new Map([['a', 1], ['b', 2], ['c', 3]]);\n * console.log([...toIterableIterator(map)]);\n * // Output: [['a', 1], ['b', 2], ['c', 3]]\n *\n * const string = 'hello';\n * console.log([...toIterableIterator(string)]);\n * // Output: ['h', 'e', 'l', 'l', 'o']\n * ```\n */\nexport function toIterableIterator<const ElementType>(iterable: IterableResolvable<ElementType>): IterableIterator<ElementType> {\n\tconst resolvedIterable = from(iterable);\n\tif (Symbol.iterator in resolvedIterable) {\n\t\treturn resolvedIterable;\n\t}\n\n\treturn makeIterableIterator(() => resolvedIterable.next());\n}\n"]}

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

@@ -0,0 +1,32 @@
+import { IterableResolvable } from './from.cjs';
+
+/**
+ * Creates an iterable iterator from an iterable or iterator-like object.
+ *
+ * @param iterable The iterable or iterable-like object to convert.
+ * @returns An iterable iterator.
+ *
+ * @example
+ * ```typescript
+ * import { toIterableIterator } from '@sapphire/iterator-utilities';
+ *
+ * const array = [1, 2, 3, 4, 5];
+ * console.log([...toIterableIterator(array)]);
+ * // Output: [1, 2, 3, 4, 5]
+ *
+ * const set = new Set([1, 2, 3, 4, 5]);
+ * console.log([...toIterableIterator(set)]);
+ * // Output: [1, 2, 3, 4, 5]
+ *
+ * const map = new Map([['a', 1], ['b', 2], ['c', 3]]);
+ * console.log([...toIterableIterator(map)]);
+ * // Output: [['a', 1], ['b', 2], ['c', 3]]
+ *
+ * const string = 'hello';
+ * console.log([...toIterableIterator(string)]);
+ * // Output: ['h', 'e', 'l', 'l', 'o']
+ * ```
+ */
+declare function toIterableIterator<const ElementType>(iterable: IterableResolvable<ElementType>): IterableIterator<ElementType>;
+
+export { toIterableIterator };

package/dist/cjs/lib/union.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var toIterableIterator_cjs = require('./toIterableIterator.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function* union(...iterables) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const iterator of iterables) {
+    for (const value of toIterableIterator_cjs.toIterableIterator(iterator)) {
+      if (!seen.has(value)) {
+        seen.add(value);
+        yield value;
+      }
+    }
+  }
+}
+__name(union, "union");
+
+exports.union = union;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=union.cjs.map

package/dist/cjs/lib/union.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/union.ts"],"names":[],"mappings":";;;;AACA,SAAS,0BAA0B;AAiB5B,UAAU,SAA4B,WAA6E;AACzH,QAAM,OAAO,oBAAI,IAAiB;AAClC,aAAW,YAAY,WAAW;AACjC,eAAW,SAAS,mBAAmB,QAAQ,GAAG;AACjD,UAAI,CAAC,KAAK,IAAI,KAAK,GAAG;AACrB,aAAK,IAAI,KAAK;AACd,cAAM;AAAA,MACP;AAAA,IACD;AAAA,EACD;AACD;AAViB","sourcesContent":["import type { IterableResolvable } from './from';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Creates an iterable with the elements that are in either input iterable.\n *\n * @param iterables The iterators to combine.\n * @returns An iterator that yields the union of the provided iterators.\n *\n * @example\n * ```typescript\n * import { union } from '@sapphire/iterator-utilities';\n *\n * const iterable1 = [1, 2, 3];\n * const iterable2 = [3, 4, 5];\n * console.log([...union(iterable1, iterable2)]);\n * // Output: [1, 2, 3, 4, 5]\n */\nexport function* union<const ElementType>(...iterables: IterableResolvable<ElementType>[]): IterableIterator<ElementType> {\n\tconst seen = new Set<ElementType>();\n\tfor (const iterator of iterables) {\n\t\tfor (const value of toIterableIterator(iterator)) {\n\t\t\tif (!seen.has(value)) {\n\t\t\t\tseen.add(value);\n\t\t\t\tyield value;\n\t\t\t}\n\t\t}\n\t}\n}\n"]}

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

@@ -0,0 +1,20 @@
+import { IterableResolvable } from './from.cjs';
+
+/**
+ * Creates an iterable with the elements that are in either input iterable.
+ *
+ * @param iterables The iterators to combine.
+ * @returns An iterator that yields the union of the provided iterators.
+ *
+ * @example
+ * ```typescript
+ * import { union } from '@sapphire/iterator-utilities';
+ *
+ * const iterable1 = [1, 2, 3];
+ * const iterable2 = [3, 4, 5];
+ * console.log([...union(iterable1, iterable2)]);
+ * // Output: [1, 2, 3, 4, 5]
+ */
+declare function union<const ElementType>(...iterables: IterableResolvable<ElementType>[]): IterableIterator<ElementType>;
+
+export { union };

package/dist/cjs/lib/unique.cjs

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

package/dist/cjs/lib/unique.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/unique.ts"],"names":[],"mappings":";;;;AACA,SAAS,aAAa;AAiBf,SAAS,OAA0B,UAA0E;AAEnH,SAAO,MAAM,QAAQ;AACtB;AAHgB","sourcesContent":["import type { IterableResolvable } from './from';\nimport { union } from './union';\n\n/**\n * Creates an iterable with the unique elements of the input iterable. Under the hood, it calls {@linkcode union} with the iterable itself.\n *\n * @param iterable An iterator to remove duplicates from.\n * @returns An iterator that yields the values of the provided iterator with duplicates removed.\n *\n * @example\n * ```typescript\n * import { unique } from '@sapphire/iterator-utilities';\n *\n * const iterable = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5];\n * console.log([...unique(iterable)]);\n * // Output: [1, 2, 3, 4, 5]\n * ```\n */\nexport function unique<const ElementType>(iterable: IterableResolvable<ElementType>): IterableIterator<ElementType> {\n\t// The union of a single iterator is the iterator itself, with duplicates removed.\n\treturn union(iterable);\n}\n"]}

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

@@ -0,0 +1,20 @@
+import { IterableResolvable } from './from.cjs';
+
+/**
+ * Creates an iterable with the unique elements of the input iterable. Under the hood, it calls {@linkcode union} with the iterable itself.
+ *
+ * @param iterable An iterator to remove duplicates from.
+ * @returns An iterator that yields the values of the provided iterator with duplicates removed.
+ *
+ * @example
+ * ```typescript
+ * import { unique } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5];
+ * console.log([...unique(iterable)]);
+ * // Output: [1, 2, 3, 4, 5]
+ * ```
+ */
+declare function unique<const ElementType>(iterable: IterableResolvable<ElementType>): IterableIterator<ElementType>;
+
+export { unique };

package/dist/cjs/lib/unzip.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+var toIterableIterator_cjs = require('./toIterableIterator.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function unzip(iterable) {
+  const resolvedIterable = toIterableIterator_cjs.toIterableIterator(iterable);
+  const firstResult = resolvedIterable.next();
+  if (firstResult.done) {
+    throw new Error("Cannot unzip an empty iterable");
+  }
+  if (!Array.isArray(firstResult.value)) {
+    throw new Error("Cannot unzip an iterable that does not yield an array");
+  }
+  const size = firstResult.value.length;
+  const results = [];
+  for (let i = 0; i < size; i++)
+    results.push([firstResult.value[i]]);
+  for (const entries of resolvedIterable) {
+    if (!Array.isArray(entries)) {
+      throw new Error("Cannot unzip an iterable that does not yield an array");
+    }
+    if (entries.length !== size) {
+      throw new Error("Cannot unzip an iterable that yields arrays of different sizes");
+    }
+    for (let i = 0; i < size; i++) {
+      results[i].push(entries[i]);
+    }
+  }
+  return results;
+}
+__name(unzip, "unzip");
+
+exports.unzip = unzip;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=unzip.cjs.map

package/dist/cjs/lib/unzip.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/unzip.ts"],"names":[],"mappings":";;;;AACA,SAAS,0BAA0B;AA0B5B,SAAS,MAAgD,UAAuE;AACtI,QAAM,mBAAmB,mBAAmB,QAAQ;AACpD,QAAM,cAAc,iBAAiB,KAAK;AAC1C,MAAI,YAAY,MAAM;AACrB,UAAM,IAAI,MAAM,gCAAgC;AAAA,EACjD;AAEA,MAAI,CAAC,MAAM,QAAQ,YAAY,KAAK,GAAG;AACtC,UAAM,IAAI,MAAM,uDAAuD;AAAA,EACxE;AAEA,QAAM,OAAO,YAAY,MAAM;AAC/B,QAAM,UAAU,CAAC;AACjB,WAAS,IAAI,GAAG,IAAI,MAAM;AAAK,YAAQ,KAAK,CAAC,YAAY,MAAM,CAAC,CAAC,CAAC;AAClE,aAAW,WAAW,kBAAkB;AACvC,QAAI,CAAC,MAAM,QAAQ,OAAO,GAAG;AAC5B,YAAM,IAAI,MAAM,uDAAuD;AAAA,IACxE;AAEA,QAAI,QAAQ,WAAW,MAAM;AAC5B,YAAM,IAAI,MAAM,gEAAgE;AAAA,IACjF;AAEA,aAAS,IAAI,GAAG,IAAI,MAAM,KAAK;AAC9B,cAAQ,CAAC,EAAE,KAAK,QAAQ,CAAC,CAAC;AAAA,IAC3B;AAAA,EACD;AAEA,SAAO;AACR;AA7BgB","sourcesContent":["import type { IterableResolvable } from './from';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Creates an array for each element of the input iterable, transposing the input iterable. The opposite of {@linkcode zip}.\n *\n * @param iterable An iterable to unzip.\n * @returns An array of iterables that yield the values of the original iterable.\n *\n * @example\n * ```typescript\n * import { unzip } from '@sapphire/iterator-utilities';\n *\n * const iterable = [[1, 'a'], [2, 'b'], [3, 'c']];\n * const [numbers, letters] = unzip(iterable);\n *\n * console.log(numbers);\n * // Output: [1, 2, 3]\n *\n * console.log(letters);\n * // Output: ['a', 'b', 'c']\n * ```\n *\n * @remarks\n *\n * This function consumes the entire iterable.\n */\nexport function unzip<const ElementType extends readonly any[]>(iterable: IterableResolvable<ElementType>): UnzipIterable<ElementType> {\n\tconst resolvedIterable = toIterableIterator(iterable);\n\tconst firstResult = resolvedIterable.next();\n\tif (firstResult.done) {\n\t\tthrow new Error('Cannot unzip an empty iterable');\n\t}\n\n\tif (!Array.isArray(firstResult.value)) {\n\t\tthrow new Error('Cannot unzip an iterable that does not yield an array');\n\t}\n\n\tconst size = firstResult.value.length;\n\tconst results = [] as ElementType[][];\n\tfor (let i = 0; i < size; i++) results.push([firstResult.value[i]]);\n\tfor (const entries of resolvedIterable) {\n\t\tif (!Array.isArray(entries)) {\n\t\t\tthrow new Error('Cannot unzip an iterable that does not yield an array');\n\t\t}\n\n\t\tif (entries.length !== size) {\n\t\t\tthrow new Error('Cannot unzip an iterable that yields arrays of different sizes');\n\t\t}\n\n\t\tfor (let i = 0; i < size; i++) {\n\t\t\tresults[i].push(entries[i]);\n\t\t}\n\t}\n\n\treturn results as UnzipIterable<ElementType>;\n}\n\nexport type UnzipIterable<ElementType extends readonly any[]> = {\n\t-readonly [P in keyof ElementType]: ElementType[P][];\n};\n"]}

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

@@ -0,0 +1,32 @@
+import { IterableResolvable } from './from.cjs';
+
+/**
+ * Creates an array for each element of the input iterable, transposing the input iterable. The opposite of {@linkcode zip}.
+ *
+ * @param iterable An iterable to unzip.
+ * @returns An array of iterables that yield the values of the original iterable.
+ *
+ * @example
+ * ```typescript
+ * import { unzip } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = [[1, 'a'], [2, 'b'], [3, 'c']];
+ * const [numbers, letters] = unzip(iterable);
+ *
+ * console.log(numbers);
+ * // Output: [1, 2, 3]
+ *
+ * console.log(letters);
+ * // Output: ['a', 'b', 'c']
+ * ```
+ *
+ * @remarks
+ *
+ * This function consumes the entire iterable.
+ */
+declare function unzip<const ElementType extends readonly any[]>(iterable: IterableResolvable<ElementType>): UnzipIterable<ElementType>;
+type UnzipIterable<ElementType extends readonly any[]> = {
+    -readonly [P in keyof ElementType]: ElementType[P][];
+};
+
+export { type UnzipIterable, unzip };

package/dist/cjs/lib/zip.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+var from_cjs = require('./from.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function* zip(...iterables) {
+  const resolvedIterables = iterables.map((iterable) => from_cjs.from(iterable));
+  while (true) {
+    const results = [];
+    for (const resolvedIterable of resolvedIterables) {
+      const result = resolvedIterable.next();
+      if (result.done)
+        return;
+      results.push(result.value);
+    }
+    yield results;
+  }
+}
+__name(zip, "zip");
+
+exports.zip = zip;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=zip.cjs.map

package/dist/cjs/lib/zip.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/zip.ts"],"names":[],"mappings":";;;;AAAA,SAAS,YAAqC;AAwBvC,UAAU,OAAmE,WAA+C;AAClI,QAAM,oBAAoB,UAAU,IAAI,CAAC,aAAa,KAAK,QAAQ,CAAC;AACpE,SAAO,MAAM;AACZ,UAAM,UAAU,CAAC;AACjB,eAAW,oBAAoB,mBAAmB;AACjD,YAAM,SAAS,iBAAiB,KAAK;AACrC,UAAI,OAAO;AAAM;AAEjB,cAAQ,KAAK,OAAO,KAAK;AAAA,IAC1B;AAEA,UAAM;AAAA,EACP;AACD;AAbiB","sourcesContent":["import { from, type IterableResolvable } from './from';\n\n/**\n * Creates an iterable with the elements of the input iterables zipped together. The opposite of {@linkcode unzip}.\n *\n * @param iterables The iterables to zip together.\n * @returns A new iterable that yields the next value of each iterable in the list.\n *\n * @example\n * ```typescript\n * import { zip } from '@sapphire/iterator-utilities';\n *\n * const iterable1 = [1, 2, 3];\n * const iterable2 = ['a', 'b', 'c'];\n * const iterable3 = [true, false, true];\n *\n * console.log(zip(iterable1, iterable2, iterable3));\n * // Output: [\n * // \t[1, 'a', true],\n * // \t[2, 'b', false],\n * // \t[3, 'c', true]\n * // ]\n * ```\n */\nexport function* zip<const Iterables extends readonly IterableResolvable<any>[]>(...iterables: Iterables): ZipIterators<Iterables> {\n\tconst resolvedIterables = iterables.map((iterable) => from(iterable));\n\twhile (true) {\n\t\tconst results = [] as any[];\n\t\tfor (const resolvedIterable of resolvedIterables) {\n\t\t\tconst result = resolvedIterable.next();\n\t\t\tif (result.done) return;\n\n\t\t\tresults.push(result.value);\n\t\t}\n\n\t\tyield results as any;\n\t}\n}\n\nexport type ZipIterators<Iterators extends readonly IterableResolvable<any>[]> = IterableIterator<{\n\t-readonly [P in keyof Iterators]: Iterators[P] extends IterableResolvable<infer T> ? T : never;\n}>;\n"]}

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

@@ -0,0 +1,30 @@
+import { IterableResolvable } from './from.cjs';
+
+/**
+ * Creates an iterable with the elements of the input iterables zipped together. The opposite of {@linkcode unzip}.
+ *
+ * @param iterables The iterables to zip together.
+ * @returns A new iterable that yields the next value of each iterable in the list.
+ *
+ * @example
+ * ```typescript
+ * import { zip } from '@sapphire/iterator-utilities';
+ *
+ * const iterable1 = [1, 2, 3];
+ * const iterable2 = ['a', 'b', 'c'];
+ * const iterable3 = [true, false, true];
+ *
+ * console.log(zip(iterable1, iterable2, iterable3));
+ * // Output: [
+ * // 	[1, 'a', true],
+ * // 	[2, 'b', false],
+ * // 	[3, 'c', true]
+ * // ]
+ * ```
+ */
+declare function zip<const Iterables extends readonly IterableResolvable<any>[]>(...iterables: Iterables): ZipIterators<Iterables>;
+type ZipIterators<Iterators extends readonly IterableResolvable<any>[]> = IterableIterator<{
+    -readonly [P in keyof Iterators]: Iterators[P] extends IterableResolvable<infer T> ? T : never;
+}>;
+
+export { type ZipIterators, zip };

package/dist/esm/chunk-G5GHKT7C.mjs

@@ -0,0 +1,6 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+export { __name };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=chunk-G5GHKT7C.mjs.map

package/dist/esm/chunk-G5GHKT7C.mjs.map

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

package/dist/esm/index.d.mts

@@ -0,0 +1,55 @@
+export { concat as append, concat } from './lib/append.mjs';
+export { at } from './lib/at.mjs';
+export { average } from './lib/average.mjs';
+export { chain } from './lib/chain.mjs';
+export { chunk } from './lib/chunk.mjs';
+export { compact } from './lib/compact.mjs';
+export { compress } from './lib/compress.mjs';
+export { contains } from './lib/contains.mjs';
+export { count } from './lib/count.mjs';
+export { cycle } from './lib/cycle.mjs';
+export { except as difference, except, except as omit } from './lib/difference.mjs';
+export { skip as drop, skip } from './lib/drop.mjs';
+export { skipLast as dropLast, skipLast } from './lib/dropLast.mjs';
+export { skipWhile as dropWhile, skipWhile } from './lib/dropWhile.mjs';
+export { empty } from './lib/empty.mjs';
+export { enumerate } from './lib/enumerate.mjs';
+export { every } from './lib/every.mjs';
+export { takeWhile as filter, takeWhile } from './lib/filter.mjs';
+export { find } from './lib/find.mjs';
+export { findIndex } from './lib/findIndex.mjs';
+export { first } from './lib/first.mjs';
+export { flat } from './lib/flat.mjs';
+export { flatMap } from './lib/flatMap.mjs';
+export { forEach } from './lib/forEach.mjs';
+export { IterableResolvable, IterableResolved, from } from './lib/from.mjs';
+export { position as indexOf, position } from './lib/indexOf.mjs';
+export { intersect } from './lib/intersect.mjs';
+export { isEmpty } from './lib/isEmpty.mjs';
+export { last } from './lib/last.mjs';
+export { map } from './lib/map.mjs';
+export { max } from './lib/max.mjs';
+export { min } from './lib/min.mjs';
+export { partition } from './lib/partition.mjs';
+export { Peekable, peekable } from './lib/peekable.mjs';
+export { prepend } from './lib/prepend.mjs';
+export { product } from './lib/product.mjs';
+export { range } from './lib/range.mjs';
+export { reduce } from './lib/reduce.mjs';
+export { repeat } from './lib/repeat.mjs';
+export { reverse } from './lib/reverse.mjs';
+export { slice } from './lib/slice.mjs';
+export { some } from './lib/some.mjs';
+export { sorted } from './lib/sorted.mjs';
+export { StarMapParameters, starMap } from './lib/starMap.mjs';
+export { sum } from './lib/sum.mjs';
+export { take } from './lib/take.mjs';
+export { takeLast } from './lib/takeLast.mjs';
+export { tee } from './lib/tee.mjs';
+export { toArray } from './lib/toArray.mjs';
+export { toIterableIterator } from './lib/toIterableIterator.mjs';
+export { union } from './lib/union.mjs';
+export { unique } from './lib/unique.mjs';
+export { UnzipIterable, unzip } from './lib/unzip.mjs';
+export { ZipIterators, zip } from './lib/zip.mjs';
+import './lib/shared/_toNumberOrThrow.mjs';

package/dist/esm/index.mjs

@@ -0,0 +1,56 @@
+export * from './lib/append.mjs';
+export * from './lib/at.mjs';
+export * from './lib/average.mjs';
+export * from './lib/chain.mjs';
+export * from './lib/chunk.mjs';
+export * from './lib/compact.mjs';
+export * from './lib/compress.mjs';
+export * from './lib/contains.mjs';
+export * from './lib/count.mjs';
+export * from './lib/cycle.mjs';
+export * from './lib/difference.mjs';
+export * from './lib/drop.mjs';
+export * from './lib/dropLast.mjs';
+export * from './lib/dropWhile.mjs';
+export * from './lib/empty.mjs';
+export * from './lib/enumerate.mjs';
+export * from './lib/every.mjs';
+export * from './lib/filter.mjs';
+export * from './lib/find.mjs';
+export * from './lib/findIndex.mjs';
+export * from './lib/first.mjs';
+export * from './lib/flat.mjs';
+export * from './lib/flatMap.mjs';
+export * from './lib/forEach.mjs';
+export * from './lib/from.mjs';
+export * from './lib/indexOf.mjs';
+export * from './lib/intersect.mjs';
+export * from './lib/isEmpty.mjs';
+export * from './lib/last.mjs';
+export * from './lib/map.mjs';
+export * from './lib/max.mjs';
+export * from './lib/min.mjs';
+export * from './lib/partition.mjs';
+export * from './lib/peekable.mjs';
+export * from './lib/prepend.mjs';
+export * from './lib/product.mjs';
+export * from './lib/range.mjs';
+export * from './lib/reduce.mjs';
+export * from './lib/repeat.mjs';
+export * from './lib/reverse.mjs';
+export * from './lib/slice.mjs';
+export * from './lib/some.mjs';
+export * from './lib/sorted.mjs';
+export * from './lib/starMap.mjs';
+export * from './lib/sum.mjs';
+export * from './lib/take.mjs';
+export * from './lib/takeLast.mjs';
+export * from './lib/tee.mjs';
+export * from './lib/toArray.mjs';
+export * from './lib/toIterableIterator.mjs';
+export * from './lib/union.mjs';
+export * from './lib/unique.mjs';
+export * from './lib/unzip.mjs';
+export * from './lib/zip.mjs';
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.mjs.map