@sapphire/iterator-utilities 1.0.3-next.fc35dd86 → 2.0.0-next.1e7d2dec

package/dist/esm/index.mjs

@@ -1,9 +1,15 @@
+export * from './lib/all.mjs';
+export * from './lib/any.mjs';
 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/collect.mjs';
+export * from './lib/collectInto.mjs';
 export * from './lib/compact.mjs';
+export * from './lib/compare.mjs';
+export * from './lib/compareBy.mjs';
 export * from './lib/compress.mjs';
 export * from './lib/contains.mjs';
 export * from './lib/count.mjs';
@@ -14,6 +20,8 @@ export * from './lib/dropLast.mjs';
 export * from './lib/dropWhile.mjs';
 export * from './lib/empty.mjs';
 export * from './lib/enumerate.mjs';
+export * from './lib/equal.mjs';
+export * from './lib/equalBy.mjs';
 export * from './lib/every.mjs';
 export * from './lib/filter.mjs';
 export * from './lib/find.mjs';
@@ -23,28 +31,51 @@ export * from './lib/flat.mjs';
 export * from './lib/flatMap.mjs';
 export * from './lib/forEach.mjs';
 export * from './lib/from.mjs';
+export * from './lib/fuse.mjs';
+export * from './lib/greaterOrEqualThan.mjs';
+export * from './lib/greaterThan.mjs';
 export * from './lib/indexOf.mjs';
+export * from './lib/inspect.mjs';
 export * from './lib/intersect.mjs';
+export * from './lib/intersperse.mjs';
 export * from './lib/isEmpty.mjs';
+export * from './lib/isSorted.mjs';
+export * from './lib/isSortedBy.mjs';
+export * from './lib/isSortedByKey.mjs';
 export * from './lib/last.mjs';
+export * from './lib/lessOrEqualThan.mjs';
+export * from './lib/lessThan.mjs';
 export * from './lib/map.mjs';
 export * from './lib/max.mjs';
+export * from './lib/maxBy.mjs';
+export * from './lib/maxByKey.mjs';
 export * from './lib/min.mjs';
+export * from './lib/minBy.mjs';
+export * from './lib/minByKey.mjs';
+export * from './lib/notEqual.mjs';
+export * from './lib/nth.mjs';
 export * from './lib/partition.mjs';
 export * from './lib/peekable.mjs';
+export * from './lib/position.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/shared/comparators.mjs';
+export * from './lib/skip.mjs';
+export * from './lib/skipLast.mjs';
+export * from './lib/skipWhile.mjs';
 export * from './lib/slice.mjs';
 export * from './lib/some.mjs';
 export * from './lib/sorted.mjs';
 export * from './lib/starMap.mjs';
+export * from './lib/stepBy.mjs';
 export * from './lib/sum.mjs';
 export * from './lib/take.mjs';
 export * from './lib/takeLast.mjs';
+export * from './lib/takeWhile.mjs';
 export * from './lib/tee.mjs';
 export * from './lib/toArray.mjs';
 export * from './lib/toIterableIterator.mjs';

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

@@ -0,0 +1,2 @@
+export { every as all } from './every.mjs';
+import './from.mjs';

package/dist/esm/lib/all.mjs

@@ -0,0 +1,4 @@
+import '../chunk-PAWJFY3S.mjs';
+export { every as all } from './every.mjs';
+//# sourceMappingURL=all.mjs.map
+//# sourceMappingURL=all.mjs.map

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

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

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

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

package/dist/esm/lib/any.mjs

@@ -0,0 +1,4 @@
+import '../chunk-PAWJFY3S.mjs';
+export { some as any } from './some.mjs';
+//# sourceMappingURL=any.mjs.map
+//# sourceMappingURL=any.mjs.map

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

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

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

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

package/dist/esm/lib/collect.mjs

@@ -0,0 +1,4 @@
+import '../chunk-PAWJFY3S.mjs';
+export { toArray as collect } from './toArray.mjs';
+//# sourceMappingURL=collect.mjs.map
+//# sourceMappingURL=collect.mjs.map

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

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

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

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

@@ -0,0 +1,14 @@
+import { __name } from '../chunk-PAWJFY3S.mjs';
+import { toIterableIterator } from './toIterableIterator.mjs';
+
+function collectInto(iterable, output) {
+  for (const value of toIterableIterator(iterable)) {
+    output.push(value);
+  }
+  return output;
+}
+__name(collectInto, "collectInto");
+
+export { collectInto };
+//# sourceMappingURL=collectInto.mjs.map
+//# sourceMappingURL=collectInto.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/collectInto.ts"],"names":[],"mappings":";;;AA2BO,SAAS,WAAA,CAA+B,UAA2C,MAAsC,EAAA;AAC/H,EAAW,KAAA,MAAA,KAAA,IAAS,kBAAmB,CAAA,QAAQ,CAAG,EAAA;AACjD,IAAA,MAAA,CAAO,KAAK,KAAK,CAAA,CAAA;AAAA,GAClB;AAEA,EAAO,OAAA,MAAA,CAAA;AACR,CAAA;AANgB,MAAA,CAAA,WAAA,EAAA,aAAA,CAAA","file":"collectInto.mjs","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/esm/lib/compare.d.mts

@@ -0,0 +1,32 @@
+import { IterableResolvable } from './from.mjs';
+import { LexicographicComparison } from './shared/_compare.mjs';
+
+/**
+ * {@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/esm/lib/compare.mjs

@@ -0,0 +1,12 @@
+import { __name } from '../chunk-PAWJFY3S.mjs';
+import { compareBy } from './compareBy.mjs';
+import { defaultCompare } from './shared/comparators.mjs';
+
+function compare(iterable, other) {
+  return compareBy(iterable, other, defaultCompare);
+}
+__name(compare, "compare");
+
+export { compare };
+//# sourceMappingURL=compare.mjs.map
+//# sourceMappingURL=compare.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/compare.ts"],"names":[],"mappings":";;;;AA+BO,SAAS,OAAA,CACf,UACA,KAC0B,EAAA;AAC1B,EAAO,OAAA,SAAA,CAAU,QAAU,EAAA,KAAA,EAAO,cAAc,CAAA,CAAA;AACjD,CAAA;AALgB,MAAA,CAAA,OAAA,EAAA,SAAA,CAAA","file":"compare.mjs","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/esm/lib/compareBy.d.mts

@@ -0,0 +1,31 @@
+import { IterableResolvable } from './from.mjs';
+import { CompareByComparator, LexicographicComparison } from './shared/_compare.mjs';
+
+/**
+ * {@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/esm/lib/compareBy.mjs

@@ -0,0 +1,23 @@
+import { __name } from '../chunk-PAWJFY3S.mjs';
+import { from } from './from.mjs';
+import { compareIteratorElements, orderingIsEqual, orderingIsLess } from './shared/_compare.mjs';
+import { toIterableIterator } from './toIterableIterator.mjs';
+
+function compareBy(iterable, other, comparator) {
+  const iterator1 = from(other);
+  for (const x of toIterableIterator(iterable)) {
+    const result1 = iterator1.next();
+    if (result1.done) return 1;
+    const y = result1.value;
+    const comparison = compareIteratorElements(x, y, comparator);
+    if (!orderingIsEqual(comparison)) {
+      return orderingIsLess(comparison) ? -1 : 1;
+    }
+  }
+  return iterator1.next().done ? 0 : -1;
+}
+__name(compareBy, "compareBy");
+
+export { compareBy };
+//# sourceMappingURL=compareBy.mjs.map
+//# sourceMappingURL=compareBy.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/compareBy.ts"],"names":[],"mappings":";;;;;AA6BO,SAAS,SAAA,CACf,QACA,EAAA,KAAA,EACA,UAC0B,EAAA;AAC1B,EAAM,MAAA,SAAA,GAAY,KAAK,KAAK,CAAA,CAAA;AAE5B,EAAW,KAAA,MAAA,CAAA,IAAK,kBAAmB,CAAA,QAAQ,CAAG,EAAA;AAC7C,IAAM,MAAA,OAAA,GAAU,UAAU,IAAK,EAAA,CAAA;AAC/B,IAAI,IAAA,OAAA,CAAQ,MAAa,OAAA,CAAA,CAAA;AAEzB,IAAA,MAAM,IAAI,OAAQ,CAAA,KAAA,CAAA;AAClB,IAAA,MAAM,UAAa,GAAA,uBAAA,CAAqC,CAAG,EAAA,CAAA,EAAG,UAAU,CAAA,CAAA;AACxE,IAAI,IAAA,CAAC,eAAgB,CAAA,UAAU,CAAG,EAAA;AACjC,MAAO,OAAA,cAAA,CAAe,UAAU,CAAA,GAAI,CAAK,CAAA,GAAA,CAAA,CAAA;AAAA,KAC1C;AAAA,GACD;AAEA,EAAA,OAAO,SAAU,CAAA,IAAA,EAAO,CAAA,IAAA,GAAO,CAAI,GAAA,CAAA,CAAA,CAAA;AACpC,CAAA;AAnBgB,MAAA,CAAA,SAAA,EAAA,WAAA,CAAA","file":"compareBy.mjs","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/esm/lib/drop.d.mts

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

package/dist/esm/lib/drop.mjs

@@ -16,6 +16,6 @@ function drop(iterable, count) {
 }
 __name(drop, "drop");
 
-export { drop, drop as skip };
+export { drop };
 //# sourceMappingURL=drop.mjs.map
 //# sourceMappingURL=drop.mjs.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/drop.ts"],"names":[],"mappings":";;;;;;AAsBO,SAAS,IAAA,CAAwB,UAA2C,KAA8C,EAAA;AAChI,EAAA,KAAA,GAAQ,iBAAkB,CAAA,0BAAA,CAA2B,KAAK,CAAA,EAAG,KAAK,CAAA,CAAA;AAClE,EAAM,MAAA,gBAAA,GAAmB,mBAAmB,QAAQ,CAAA,CAAA;AAGpD,EAAI,IAAA,KAAA,KAAU,GAAU,OAAA,gBAAA,CAAA;AAExB,EAAA,IAAI,KAAU,KAAA,MAAA,CAAO,iBAAmB,EAAA,OAAO,KAAM,EAAA,CAAA;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,MAAA;AAAA,GACnC;AAEA,EAAO,OAAA,gBAAA,CAAA;AACR,CAAA;AAdgB,MAAA,CAAA,IAAA,EAAA,MAAA,CAAA","file":"drop.mjs","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":[],"mappings":";;;;;;AAsBO,SAAS,IAAA,CAAwB,UAA2C,KAA8C,EAAA;AAChI,EAAA,KAAA,GAAQ,iBAAkB,CAAA,0BAAA,CAA2B,KAAK,CAAA,EAAG,KAAK,CAAA,CAAA;AAClE,EAAM,MAAA,gBAAA,GAAmB,mBAAmB,QAAQ,CAAA,CAAA;AAGpD,EAAI,IAAA,KAAA,KAAU,GAAU,OAAA,gBAAA,CAAA;AAExB,EAAA,IAAI,KAAU,KAAA,MAAA,CAAO,iBAAmB,EAAA,OAAO,KAAM,EAAA,CAAA;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,MAAA;AAAA,GACnC;AAEA,EAAO,OAAA,gBAAA,CAAA;AACR,CAAA;AAdgB,MAAA,CAAA,IAAA,EAAA,MAAA,CAAA","file":"drop.mjs","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/esm/lib/dropLast.d.mts

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

package/dist/esm/lib/dropLast.mjs

@@ -13,6 +13,6 @@ function dropLast(iterable, count) {
 }
 __name(dropLast, "dropLast");
 
-export { dropLast, dropLast as skipLast };
+export { dropLast };
 //# sourceMappingURL=dropLast.mjs.map
 //# sourceMappingURL=dropLast.mjs.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/dropLast.ts"],"names":[],"mappings":";;;;;;;AA2BO,SAAS,QAAA,CAA4B,UAA2C,KAA8C,EAAA;AACpI,EAAA,KAAA,GAAQ,iBAAkB,CAAA,0BAAA,CAA2B,KAAK,CAAA,EAAG,KAAK,CAAA,CAAA;AAClE,EAAM,MAAA,KAAA,GAAQ,QAAQ,QAAQ,CAAA,CAAA;AAC9B,EAAA,IAAI,KAAM,CAAA,MAAA,IAAU,KAAO,EAAA,OAAO,KAAM,EAAA,CAAA;AACxC,EAAA,OAAO,KAAK,KAAM,CAAA,MAAA,EAAU,EAAA,KAAA,CAAM,SAAS,KAAK,CAAA,CAAA;AACjD,CAAA;AALgB,MAAA,CAAA,QAAA,EAAA,UAAA,CAAA","file":"dropLast.mjs","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":[],"mappings":";;;;;;;AA2BO,SAAS,QAAA,CAA4B,UAA2C,KAA8C,EAAA;AACpI,EAAA,KAAA,GAAQ,iBAAkB,CAAA,0BAAA,CAA2B,KAAK,CAAA,EAAG,KAAK,CAAA,CAAA;AAClE,EAAM,MAAA,KAAA,GAAQ,QAAQ,QAAQ,CAAA,CAAA;AAC9B,EAAA,IAAI,KAAM,CAAA,MAAA,IAAU,KAAO,EAAA,OAAO,KAAM,EAAA,CAAA;AACxC,EAAA,OAAO,KAAK,KAAM,CAAA,MAAA,EAAU,EAAA,KAAA,CAAM,SAAS,KAAK,CAAA,CAAA;AACjD,CAAA;AALgB,MAAA,CAAA,QAAA,EAAA,UAAA,CAAA","file":"dropLast.mjs","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/esm/lib/dropWhile.d.mts

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

@@ -13,6 +13,6 @@ function* dropWhile(iterable, callbackFn) {
 }
 __name(dropWhile, "dropWhile");
 
-export { dropWhile, dropWhile as skipWhile };
+export { dropWhile };
 //# sourceMappingURL=dropWhile.mjs.map
 //# sourceMappingURL=dropWhile.mjs.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/dropWhile.ts"],"names":[],"mappings":";;;;AA8BO,UAAU,SAAA,CAChB,UACA,UACgC,EAAA;AAChC,EAAA,UAAA,GAAa,eAAe,UAAU,CAAA,CAAA;AAEtC,EAAA,IAAI,KAAQ,GAAA,CAAA,CAAA;AACZ,EAAW,KAAA,MAAA,KAAA,IAAS,kBAAmB,CAAA,QAAQ,CAAG,EAAA;AACjD,IAAA,IAAI,CAAC,UAAA,CAAW,KAAO,EAAA,KAAA,EAAO,CAAG,EAAA;AAChC,MAAM,MAAA,KAAA,CAAA;AAAA,KACP;AAAA,GACD;AACD,CAAA;AAZiB,MAAA,CAAA,SAAA,EAAA,WAAA,CAAA","file":"dropWhile.mjs","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":[],"mappings":";;;;AA8BO,UAAU,SAAA,CAChB,UACA,UACgC,EAAA;AAChC,EAAA,UAAA,GAAa,eAAe,UAAU,CAAA,CAAA;AAEtC,EAAA,IAAI,KAAQ,GAAA,CAAA,CAAA;AACZ,EAAW,KAAA,MAAA,KAAA,IAAS,kBAAmB,CAAA,QAAQ,CAAG,EAAA;AACjD,IAAA,IAAI,CAAC,UAAA,CAAW,KAAO,EAAA,KAAA,EAAO,CAAG,EAAA;AAChC,MAAM,MAAA,KAAA,CAAA;AAAA,KACP;AAAA,GACD;AACD,CAAA;AAZiB,MAAA,CAAA,SAAA,EAAA,WAAA,CAAA","file":"dropWhile.mjs","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/esm/lib/equal.d.mts

@@ -0,0 +1,26 @@
+import { IterableResolvable } from './from.mjs';
+
+/**
+ * Determines if the elements of both iterators are equal.
+ *
+ * @param iterable The iterator to compare.
+ * @param other The iterator to compare against.
+ * @returns Whether the two iterators are equal.
+ *
+ * @example
+ * ```typescript
+ * import { equal } from '@sapphire/iterator-utilities';
+ *
+ * console.log(equal([1], [1]));
+ * // Output: true
+ * console.log(equal([1], [1, 2]));
+ * // Output: false
+ * ```
+ *
+ * @remarks
+ *
+ * This function consumes the entire iterator.
+ */
+declare function equal<const ElementType>(iterable: IterableResolvable<ElementType>, other: IterableResolvable<ElementType>): boolean;
+
+export { equal as eq, equal };

package/dist/esm/lib/equal.mjs

@@ -0,0 +1,11 @@
+import { __name } from '../chunk-PAWJFY3S.mjs';
+import { equalBy } from './equalBy.mjs';
+
+function equal(iterable, other) {
+  return equalBy(iterable, other, (a, b) => a === b);
+}
+__name(equal, "equal");
+
+export { equal as eq, equal };
+//# sourceMappingURL=equal.mjs.map
+//# sourceMappingURL=equal.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/equal.ts"],"names":[],"mappings":";;;AAwBO,SAAS,KAAA,CAAyB,UAA2C,KAAiD,EAAA;AACpI,EAAA,OAAO,QAAQ,QAAU,EAAA,KAAA,EAAO,CAAC,CAAG,EAAA,CAAA,KAAM,MAAM,CAAC,CAAA,CAAA;AAClD,CAAA;AAFgB,MAAA,CAAA,KAAA,EAAA,OAAA,CAAA","file":"equal.mjs","sourcesContent":["import { equalBy } from './equalBy';\nimport type { IterableResolvable } from './from';\n\n/**\n * Determines if the elements of both iterators are equal.\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 { equal } from '@sapphire/iterator-utilities';\n *\n * console.log(equal([1], [1]));\n * // Output: true\n * console.log(equal([1], [1, 2]));\n * // Output: false\n * ```\n *\n * @remarks\n *\n * This function consumes the entire iterator.\n */\nexport function equal<const ElementType>(iterable: IterableResolvable<ElementType>, other: IterableResolvable<ElementType>): boolean {\n\treturn equalBy(iterable, other, (a, b) => a === b);\n}\n\nexport { equal as eq };\n"]}

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

@@ -0,0 +1,27 @@
+import { IterableResolvable } from './from.mjs';
+
+/**
+ * Determines if the elements of both iterators are equal with respect to the specified equality function.
+ *
+ * @param iterable The iterator to compare.
+ * @param other The iterator to compare against.
+ * @returns Whether the two iterators are equal with respect to the specified equality function.
+ *
+ * @example
+ * ```typescript
+ * import { equalBy } from '@sapphire/iterator-utilities';
+ *
+ * const x = [1, 2, 3, 4];
+ * const y = [1, 4, 9, 16];
+ *
+ * console.log(equalBy(x, y, (a, b) => a * a === b));
+ * // Output: true
+ * ```
+ *
+ * @remarks
+ *
+ * This function consumes the entire iterator.
+ */
+declare function equalBy<const ElementType>(iterable: IterableResolvable<ElementType>, other: IterableResolvable<ElementType>, callbackFn: (x: ElementType, y: ElementType) => boolean): boolean;
+
+export { equalBy as eqBy, equalBy };

package/dist/esm/lib/equalBy.mjs

@@ -0,0 +1,19 @@
+import { __name } from '../chunk-PAWJFY3S.mjs';
+import { from } from './from.mjs';
+import { assertFunction } from './shared/_assertFunction.mjs';
+import { toIterableIterator } from './toIterableIterator.mjs';
+
+function equalBy(iterable, other, callbackFn) {
+  callbackFn = assertFunction(callbackFn);
+  const iterator1 = from(other);
+  for (const value0 of toIterableIterator(iterable)) {
+    const result1 = iterator1.next();
+    if (result1.done || !callbackFn(value0, result1.value)) return false;
+  }
+  return iterator1.next().done === true;
+}
+__name(equalBy, "equalBy");
+
+export { equalBy as eqBy, equalBy };
+//# sourceMappingURL=equalBy.mjs.map
+//# sourceMappingURL=equalBy.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/equalBy.ts"],"names":[],"mappings":";;;;;AA0BO,SAAS,OAAA,CACf,QACA,EAAA,KAAA,EACA,UACU,EAAA;AACV,EAAA,UAAA,GAAa,eAAe,UAAU,CAAA,CAAA;AAEtC,EAAM,MAAA,SAAA,GAAY,KAAK,KAAK,CAAA,CAAA;AAE5B,EAAW,KAAA,MAAA,MAAA,IAAU,kBAAmB,CAAA,QAAQ,CAAG,EAAA;AAClD,IAAM,MAAA,OAAA,GAAU,UAAU,IAAK,EAAA,CAAA;AAC/B,IAAI,IAAA,OAAA,CAAQ,QAAQ,CAAC,UAAA,CAAW,QAAQ,OAAQ,CAAA,KAAK,GAAU,OAAA,KAAA,CAAA;AAAA,GAChE;AAEA,EAAO,OAAA,SAAA,CAAU,IAAK,EAAA,CAAE,IAAS,KAAA,IAAA,CAAA;AAClC,CAAA;AAfgB,MAAA,CAAA,OAAA,EAAA,SAAA,CAAA","file":"equalBy.mjs","sourcesContent":["import { from, type IterableResolvable } from './from';\nimport { assertFunction } from './shared/_assertFunction';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Determines if the elements of both iterators are equal with respect to the specified equality function.\n *\n * @param iterable The iterator to compare.\n * @param other The iterator to compare against.\n * @returns Whether the two iterators are equal with respect to the specified equality function.\n *\n * @example\n * ```typescript\n * import { equalBy } from '@sapphire/iterator-utilities';\n *\n * const x = [1, 2, 3, 4];\n * const y = [1, 4, 9, 16];\n *\n * console.log(equalBy(x, y, (a, b) => a * a === b));\n * // Output: true\n * ```\n *\n * @remarks\n *\n * This function consumes the entire iterator.\n */\nexport function equalBy<const ElementType>(\n\titerable: IterableResolvable<ElementType>,\n\tother: IterableResolvable<ElementType>,\n\tcallbackFn: (x: ElementType, y: ElementType) => boolean\n): boolean {\n\tcallbackFn = assertFunction(callbackFn);\n\n\tconst iterator1 = from(other);\n\n\tfor (const value0 of toIterableIterator(iterable)) {\n\t\tconst result1 = iterator1.next();\n\t\tif (result1.done || !callbackFn(value0, result1.value)) return false;\n\t}\n\n\treturn iterator1.next().done === true;\n}\n\nexport { equalBy as eqBy };\n"]}

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

@@ -19,4 +19,4 @@ import { IterableResolvable } from './from.mjs';
 declare function filter<const ElementType, const FilteredType extends ElementType>(iterable: IterableResolvable<ElementType>, callbackFn: (element: ElementType, index: number) => element is FilteredType): IterableIterator<FilteredType>;
 declare function filter<const ElementType>(iterable: IterableResolvable<ElementType>, callbackFn: (element: ElementType, index: number) => boolean): IterableIterator<ElementType>;
 
-export { filter, filter as takeWhile };
+export { filter };

package/dist/esm/lib/filter.mjs

@@ -11,6 +11,6 @@ function* filter(iterable, callbackFn) {
 }
 __name(filter, "filter");
 
-export { filter, filter as takeWhile };
+export { filter };
 //# sourceMappingURL=filter.mjs.map
 //# sourceMappingURL=filter.mjs.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/filter.ts"],"names":[],"mappings":";;;;AA4BO,UAAU,MAAA,CAChB,UACA,UACgC,EAAA;AAChC,EAAA,UAAA,GAAa,eAAe,UAAU,CAAA,CAAA;AAEtC,EAAA,IAAI,KAAQ,GAAA,CAAA,CAAA;AACZ,EAAW,KAAA,MAAA,KAAA,IAAS,kBAAmB,CAAA,QAAQ,CAAG,EAAA;AACjD,IAAA,IAAI,UAAW,CAAA,KAAA,EAAO,KAAO,EAAA,CAAA,EAAS,MAAA,KAAA,CAAA;AAAA,GACvC;AACD,CAAA;AAViB,MAAA,CAAA,MAAA,EAAA,QAAA,CAAA","file":"filter.mjs","sourcesContent":["import type { IterableResolvable } from './from';\nimport { assertFunction } from './shared/_assertFunction';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Creates an iterable with the elements that pass the test implemented by the provided function.\n *\n * @param iterable The iterator to filter.\n * @param callbackFn A function to execute for each element produced by the iterator. It should return a truthy value to make the element yielded by the iterator helper, and a falsy value otherwise.\n * @returns An iterator that produces elements from the given iterator that satisfy the specified test.\n *\n * @example\n * ```typescript\n * import { filter } from '@sapphire/iterator-utilities';\n *\n * const iterable = [1, 2, 3, 4, 5];\n * console.log([...filter(iterable, (value) => value % 2 === 0)]);\n * // Output: [2, 4]\n * ```\n */\nexport function filter<const ElementType, const FilteredType extends ElementType>(\n\titerable: IterableResolvable<ElementType>,\n\tcallbackFn: (element: ElementType, index: number) => element is FilteredType\n): IterableIterator<FilteredType>;\nexport function filter<const ElementType>(\n\titerable: IterableResolvable<ElementType>,\n\tcallbackFn: (element: ElementType, index: number) => boolean\n): IterableIterator<ElementType>;\nexport function* filter<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++)) yield value;\n\t}\n}\n\nexport { filter as takeWhile };\n"]}
+{"version":3,"sources":["../../../src/lib/filter.ts"],"names":[],"mappings":";;;;AA4BO,UAAU,MAAA,CAChB,UACA,UACgC,EAAA;AAChC,EAAA,UAAA,GAAa,eAAe,UAAU,CAAA,CAAA;AAEtC,EAAA,IAAI,KAAQ,GAAA,CAAA,CAAA;AACZ,EAAW,KAAA,MAAA,KAAA,IAAS,kBAAmB,CAAA,QAAQ,CAAG,EAAA;AACjD,IAAA,IAAI,UAAW,CAAA,KAAA,EAAO,KAAO,EAAA,CAAA,EAAS,MAAA,KAAA,CAAA;AAAA,GACvC;AACD,CAAA;AAViB,MAAA,CAAA,MAAA,EAAA,QAAA,CAAA","file":"filter.mjs","sourcesContent":["import type { IterableResolvable } from './from';\nimport { assertFunction } from './shared/_assertFunction';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Creates an iterable with the elements that pass the test implemented by the provided function.\n *\n * @param iterable The iterator to filter.\n * @param callbackFn A function to execute for each element produced by the iterator. It should return a truthy value to make the element yielded by the iterator helper, and a falsy value otherwise.\n * @returns An iterator that produces elements from the given iterator that satisfy the specified test.\n *\n * @example\n * ```typescript\n * import { filter } from '@sapphire/iterator-utilities';\n *\n * const iterable = [1, 2, 3, 4, 5];\n * console.log([...filter(iterable, (value) => value % 2 === 0)]);\n * // Output: [2, 4]\n * ```\n */\nexport function filter<const ElementType, const FilteredType extends ElementType>(\n\titerable: IterableResolvable<ElementType>,\n\tcallbackFn: (element: ElementType, index: number) => element is FilteredType\n): IterableIterator<FilteredType>;\nexport function filter<const ElementType>(\n\titerable: IterableResolvable<ElementType>,\n\tcallbackFn: (element: ElementType, index: number) => boolean\n): IterableIterator<ElementType>;\nexport function* filter<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++)) yield value;\n\t}\n}\n"]}

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

@@ -0,0 +1,47 @@
+import { IterableResolvable } from './from.mjs';
+
+/**
+ * Creates an iterator which ends after the first `done` result from the original iterator.
+ *
+ * After an iterator returns a `done` result, future calls may or may not yield additional results again. This function
+ * adapts an iterator, ensuring that after a `done` result is given, it will always return a `done` result forever.
+ *
+ * @param iterable An iterator to fuse.
+ *
+ * @example
+ * ```typescript
+ * import { fuse } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = {
+ *   state: 0,
+ *   next() {
+ *     const value = this.state;
+ *     this.state += 1;
+ *
+ *     return value % 2 === 0 //
+ *       ? { done: false, value }
+ *       : { done: true, value: undefined };
+ *   }
+ * };
+ *
+ * // We can see our iterator going back and forth
+ * assert(iterable.next(), { done: false, value: 0 });
+ * assert(iterable.next(), { done: true, value: undefined });
+ * assert(iterable.next(), { done: false, value: 2 });
+ * assert(iterable.next(), { done: true, value: undefined });
+ *
+ * // However, once we fuse it...
+ * const fused = fuse(iterable);
+ *
+ * assert(fused.next(), { done: false, value: 4 });
+ * assert(fused.next(), { done: true, value: undefined });
+ *
+ * // It will always return a `done` result after the first time
+ * assert(fused.next(), { done: true, value: undefined });
+ * assert(fused.next(), { done: true, value: undefined });
+ * assert(fused.next(), { done: true, value: undefined });
+ * ```
+ */
+declare function fuse<const ElementType>(iterable: IterableResolvable<ElementType>): IterableIterator<ElementType>;
+
+export { fuse };

package/dist/esm/lib/fuse.mjs

@@ -0,0 +1,23 @@
+import { __name } from '../chunk-PAWJFY3S.mjs';
+import { makeIterableIterator } from './shared/_makeIterableIterator.mjs';
+import { toIterableIterator } from './toIterableIterator.mjs';
+
+function fuse(iterable) {
+  let ended = false;
+  const iterator = toIterableIterator(iterable);
+  return makeIterableIterator(() => {
+    if (ended) {
+      return { done: true, value: void 0 };
+    }
+    const result = iterator.next();
+    if (result.done) {
+      ended = true;
+    }
+    return result;
+  });
+}
+__name(fuse, "fuse");
+
+export { fuse };
+//# sourceMappingURL=fuse.mjs.map
+//# sourceMappingURL=fuse.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/fuse.ts"],"names":[],"mappings":";;;;AA8CO,SAAS,KAAwB,QAA0E,EAAA;AACjH,EAAA,IAAI,KAAQ,GAAA,KAAA,CAAA;AACZ,EAAM,MAAA,QAAA,GAAW,mBAAmB,QAAQ,CAAA,CAAA;AAC5C,EAAA,OAAO,qBAAqB,MAAM;AACjC,IAAA,IAAI,KAAO,EAAA;AACV,MAAA,OAAO,EAAE,IAAA,EAAM,IAAM,EAAA,KAAA,EAAO,KAAU,CAAA,EAAA,CAAA;AAAA,KACvC;AAEA,IAAM,MAAA,MAAA,GAAS,SAAS,IAAK,EAAA,CAAA;AAC7B,IAAA,IAAI,OAAO,IAAM,EAAA;AAChB,MAAQ,KAAA,GAAA,IAAA,CAAA;AAAA,KACT;AAEA,IAAO,OAAA,MAAA,CAAA;AAAA,GACP,CAAA,CAAA;AACF,CAAA;AAfgB,MAAA,CAAA,IAAA,EAAA,MAAA,CAAA","file":"fuse.mjs","sourcesContent":["import type { IterableResolvable } from './from';\nimport { makeIterableIterator } from './shared/_makeIterableIterator';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Creates an iterator which ends after the first `done` result from the original iterator.\n *\n * After an iterator returns a `done` result, future calls may or may not yield additional results again. This function\n * adapts an iterator, ensuring that after a `done` result is given, it will always return a `done` result forever.\n *\n * @param iterable An iterator to fuse.\n *\n * @example\n * ```typescript\n * import { fuse } from '@sapphire/iterator-utilities';\n *\n * const iterable = {\n *   state: 0,\n *   next() {\n *     const value = this.state;\n *     this.state += 1;\n *\n *     return value % 2 === 0 //\n *       ? { done: false, value }\n *       : { done: true, value: undefined };\n *   }\n * };\n *\n * // We can see our iterator going back and forth\n * assert(iterable.next(), { done: false, value: 0 });\n * assert(iterable.next(), { done: true, value: undefined });\n * assert(iterable.next(), { done: false, value: 2 });\n * assert(iterable.next(), { done: true, value: undefined });\n *\n * // However, once we fuse it...\n * const fused = fuse(iterable);\n *\n * assert(fused.next(), { done: false, value: 4 });\n * assert(fused.next(), { done: true, value: undefined });\n *\n * // It will always return a `done` result after the first time\n * assert(fused.next(), { done: true, value: undefined });\n * assert(fused.next(), { done: true, value: undefined });\n * assert(fused.next(), { done: true, value: undefined });\n * ```\n */\nexport function fuse<const ElementType>(iterable: IterableResolvable<ElementType>): IterableIterator<ElementType> {\n\tlet ended = false;\n\tconst iterator = toIterableIterator(iterable);\n\treturn makeIterableIterator(() => {\n\t\tif (ended) {\n\t\t\treturn { done: true, value: undefined };\n\t\t}\n\n\t\tconst result = iterator.next();\n\t\tif (result.done) {\n\t\t\tended = true;\n\t\t}\n\n\t\treturn result;\n\t});\n}\n"]}

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

@@ -0,0 +1,32 @@
+import { IterableResolvable } from './from.mjs';
+
+/**
+ * Determines if the elements of `iterable` are {@link LexicographicComparison lexicographically} greater or equal than
+ * those of another.
+ *
+ * @param iterable The iterator to compare.
+ * @param other The iterator to compare against.
+ *
+ * @example
+ * ```typescript
+ * import { greaterOrEqualThan } from '@sapphire/iterator-utilities';
+ *
+ * const x = [1, 2, 3, 4];
+ * const y = [1, 4, 9, 16];
+ * console.log(greaterOrEqualThan([1], [1]));
+ * // Output: true
+ * console.log(greaterOrEqualThan([1], [1, 2]));
+ * // Output: false
+ * console.log(greaterOrEqualThan([1, 2], [1]));
+ * // Output: true
+ * console.log(greaterOrEqualThan([1, 2], [1, 2]));
+ * // Output: true
+ * ```
+ *
+ * @remarks
+ *
+ * This function consumes the entire iterator.
+ */
+declare function greaterOrEqualThan<const ElementType>(iterable: IterableResolvable<ElementType>, other: IterableResolvable<ElementType>): boolean;
+
+export { greaterOrEqualThan as ge, greaterOrEqualThan };