es-toolkit 1.50.0 → 1.51.0-dev.2069

package/dist/fp/iterator/reduce.js

@@ -0,0 +1,28 @@
+//#region src/fp/iterator/reduce.ts
+/**
+* Creates a function that consumes an iterator and folds its elements into a
+* single value, starting from `initial`, for use as the terminal step of a
+* {@link pipe}. It delegates to the native `Iterator.prototype.reduce`.
+*
+* This is a terminal operation: it pulls every element, so it must not be used
+* on an infinite iterator.
+*
+* @template T - The type of elements produced by the source iterator.
+* @template U - The type of the accumulated value.
+* @param callback - Called with `(accumulator, value, index)`; returns the next accumulator.
+* @param initial - The initial accumulator value.
+* @returns A function mapping an `Iterator<T>` to the final accumulated value.
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { reduce } from 'es-toolkit/fp/iterator';
+*
+* pipe([1, 2, 3].values(), reduce((acc, x) => acc + x, 0)); // => 6
+*/
+function reduce(callback, initial) {
+	return function reduceInIterator(source) {
+		return Iterator.from(source).reduce(callback, initial);
+	};
+}
+//#endregion
+exports.reduce = reduce;

package/dist/fp/iterator/reduce.mjs

@@ -0,0 +1,28 @@
+//#region src/fp/iterator/reduce.ts
+/**
+* Creates a function that consumes an iterator and folds its elements into a
+* single value, starting from `initial`, for use as the terminal step of a
+* {@link pipe}. It delegates to the native `Iterator.prototype.reduce`.
+*
+* This is a terminal operation: it pulls every element, so it must not be used
+* on an infinite iterator.
+*
+* @template T - The type of elements produced by the source iterator.
+* @template U - The type of the accumulated value.
+* @param callback - Called with `(accumulator, value, index)`; returns the next accumulator.
+* @param initial - The initial accumulator value.
+* @returns A function mapping an `Iterator<T>` to the final accumulated value.
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { reduce } from 'es-toolkit/fp/iterator';
+*
+* pipe([1, 2, 3].values(), reduce((acc, x) => acc + x, 0)); // => 6
+*/
+function reduce(callback, initial) {
+	return function reduceInIterator(source) {
+		return Iterator.from(source).reduce(callback, initial);
+	};
+}
+//#endregion
+export { reduce };

package/dist/fp/iterator/scan.d.mts

@@ -0,0 +1,21 @@
+//#region src/fp/iterator/scan.d.ts
+/**
+ * Creates a function that lazily yields the running accumulation of an iterator,
+ * emitting `initial` first and then the accumulator after each element, for use
+ * with {@link pipe}.
+ *
+ * @template T - The type of elements produced by the source iterator.
+ * @template U - The type of the accumulated value.
+ * @param callback - Called with `(accumulator, value, index)`; returns the next accumulator.
+ * @param initial - The initial accumulator, emitted as the first value.
+ * @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<U>`.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { scan, toArray } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2, 3].values(), scan((acc, x) => acc + x, 0), toArray()); // => [0, 1, 3, 6]
+ */
+declare function scan<T, U>(callback: (accumulator: U, value: T, index: number) => U, initial: U): (source: Iterator<T>) => IteratorObject<U, undefined>;
+//#endregion
+export { scan };

package/dist/fp/iterator/scan.d.ts

@@ -0,0 +1,21 @@
+//#region src/fp/iterator/scan.d.ts
+/**
+ * Creates a function that lazily yields the running accumulation of an iterator,
+ * emitting `initial` first and then the accumulator after each element, for use
+ * with {@link pipe}.
+ *
+ * @template T - The type of elements produced by the source iterator.
+ * @template U - The type of the accumulated value.
+ * @param callback - Called with `(accumulator, value, index)`; returns the next accumulator.
+ * @param initial - The initial accumulator, emitted as the first value.
+ * @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<U>`.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { scan, toArray } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2, 3].values(), scan((acc, x) => acc + x, 0), toArray()); // => [0, 1, 3, 6]
+ */
+declare function scan<T, U>(callback: (accumulator: U, value: T, index: number) => U, initial: U): (source: Iterator<T>) => IteratorObject<U, undefined>;
+//#endregion
+export { scan };

package/dist/fp/iterator/scan.js

@@ -0,0 +1,26 @@
+const require_scan = require("../../iterator/scan.js");
+//#region src/fp/iterator/scan.ts
+/**
+* Creates a function that lazily yields the running accumulation of an iterator,
+* emitting `initial` first and then the accumulator after each element, for use
+* with {@link pipe}.
+*
+* @template T - The type of elements produced by the source iterator.
+* @template U - The type of the accumulated value.
+* @param callback - Called with `(accumulator, value, index)`; returns the next accumulator.
+* @param initial - The initial accumulator, emitted as the first value.
+* @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<U>`.
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { scan, toArray } from 'es-toolkit/fp/iterator';
+*
+* pipe([1, 2, 3].values(), scan((acc, x) => acc + x, 0), toArray()); // => [0, 1, 3, 6]
+*/
+function scan(callback, initial) {
+	return function scanInIterator(source) {
+		return require_scan.scan(source, callback, initial);
+	};
+}
+//#endregion
+exports.scan = scan;

package/dist/fp/iterator/scan.mjs

@@ -0,0 +1,26 @@
+import { scan as scan$1 } from "../../iterator/scan.mjs";
+//#region src/fp/iterator/scan.ts
+/**
+* Creates a function that lazily yields the running accumulation of an iterator,
+* emitting `initial` first and then the accumulator after each element, for use
+* with {@link pipe}.
+*
+* @template T - The type of elements produced by the source iterator.
+* @template U - The type of the accumulated value.
+* @param callback - Called with `(accumulator, value, index)`; returns the next accumulator.
+* @param initial - The initial accumulator, emitted as the first value.
+* @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<U>`.
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { scan, toArray } from 'es-toolkit/fp/iterator';
+*
+* pipe([1, 2, 3].values(), scan((acc, x) => acc + x, 0), toArray()); // => [0, 1, 3, 6]
+*/
+function scan(callback, initial) {
+	return function scanInIterator(source) {
+		return scan$1(source, callback, initial);
+	};
+}
+//#endregion
+export { scan };

package/dist/fp/iterator/some.d.mts

@@ -0,0 +1,20 @@
+//#region src/fp/iterator/some.d.ts
+/**
+ * Creates a function that consumes an iterator until `predicate` returns truthy
+ * and reports whether any element matched, for use as the terminal step of a
+ * {@link pipe}. It delegates to the native `Iterator.prototype.some` and stops
+ * pulling at the first match.
+ *
+ * @template T - The type of elements produced by the source iterator.
+ * @param predicate - Called with `(value, index)`; truthy short-circuits to `true`.
+ * @returns A function mapping an `Iterator<T>` to a boolean.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { some } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2, 3].values(), some(x => x > 2)); // => true
+ */
+declare function some<T>(predicate: (value: T, index: number) => unknown): (source: Iterator<T>) => boolean;
+//#endregion
+export { some };

package/dist/fp/iterator/some.d.ts

@@ -0,0 +1,20 @@
+//#region src/fp/iterator/some.d.ts
+/**
+ * Creates a function that consumes an iterator until `predicate` returns truthy
+ * and reports whether any element matched, for use as the terminal step of a
+ * {@link pipe}. It delegates to the native `Iterator.prototype.some` and stops
+ * pulling at the first match.
+ *
+ * @template T - The type of elements produced by the source iterator.
+ * @param predicate - Called with `(value, index)`; truthy short-circuits to `true`.
+ * @returns A function mapping an `Iterator<T>` to a boolean.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { some } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2, 3].values(), some(x => x > 2)); // => true
+ */
+declare function some<T>(predicate: (value: T, index: number) => unknown): (source: Iterator<T>) => boolean;
+//#endregion
+export { some };

package/dist/fp/iterator/some.js

@@ -0,0 +1,24 @@
+//#region src/fp/iterator/some.ts
+/**
+* Creates a function that consumes an iterator until `predicate` returns truthy
+* and reports whether any element matched, for use as the terminal step of a
+* {@link pipe}. It delegates to the native `Iterator.prototype.some` and stops
+* pulling at the first match.
+*
+* @template T - The type of elements produced by the source iterator.
+* @param predicate - Called with `(value, index)`; truthy short-circuits to `true`.
+* @returns A function mapping an `Iterator<T>` to a boolean.
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { some } from 'es-toolkit/fp/iterator';
+*
+* pipe([1, 2, 3].values(), some(x => x > 2)); // => true
+*/
+function some(predicate) {
+	return function someInIterator(source) {
+		return Iterator.from(source).some(predicate);
+	};
+}
+//#endregion
+exports.some = some;

package/dist/fp/iterator/some.mjs

@@ -0,0 +1,24 @@
+//#region src/fp/iterator/some.ts
+/**
+* Creates a function that consumes an iterator until `predicate` returns truthy
+* and reports whether any element matched, for use as the terminal step of a
+* {@link pipe}. It delegates to the native `Iterator.prototype.some` and stops
+* pulling at the first match.
+*
+* @template T - The type of elements produced by the source iterator.
+* @param predicate - Called with `(value, index)`; truthy short-circuits to `true`.
+* @returns A function mapping an `Iterator<T>` to a boolean.
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { some } from 'es-toolkit/fp/iterator';
+*
+* pipe([1, 2, 3].values(), some(x => x > 2)); // => true
+*/
+function some(predicate) {
+	return function someInIterator(source) {
+		return Iterator.from(source).some(predicate);
+	};
+}
+//#endregion
+export { some };

package/dist/fp/iterator/take.d.mts

@@ -0,0 +1,21 @@
+//#region src/fp/iterator/take.d.ts
+/**
+ * Creates a function that lazily yields the first `limit` elements of an
+ * iterator, for use with {@link pipe}. It delegates to the native
+ * `Iterator.prototype.take`, which stops pulling from the source once `limit`
+ * elements have been produced.
+ *
+ * @template T - The type of elements produced by the source iterator.
+ * @param limit - The number of elements to take; must be a non-negative integer.
+ * @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<T>`.
+ * @throws {RangeError} Throws if `limit` is negative or `NaN` (native behavior).
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { take } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2, 3, 4, 5].values(), take(3)).toArray(); // => [1, 2, 3]
+ */
+declare function take<T>(limit: number): (source: Iterator<T>) => IteratorObject<T, undefined>;
+//#endregion
+export { take };

package/dist/fp/iterator/take.d.ts

@@ -0,0 +1,21 @@
+//#region src/fp/iterator/take.d.ts
+/**
+ * Creates a function that lazily yields the first `limit` elements of an
+ * iterator, for use with {@link pipe}. It delegates to the native
+ * `Iterator.prototype.take`, which stops pulling from the source once `limit`
+ * elements have been produced.
+ *
+ * @template T - The type of elements produced by the source iterator.
+ * @param limit - The number of elements to take; must be a non-negative integer.
+ * @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<T>`.
+ * @throws {RangeError} Throws if `limit` is negative or `NaN` (native behavior).
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { take } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2, 3, 4, 5].values(), take(3)).toArray(); // => [1, 2, 3]
+ */
+declare function take<T>(limit: number): (source: Iterator<T>) => IteratorObject<T, undefined>;
+//#endregion
+export { take };

package/dist/fp/iterator/take.js

@@ -0,0 +1,25 @@
+//#region src/fp/iterator/take.ts
+/**
+* Creates a function that lazily yields the first `limit` elements of an
+* iterator, for use with {@link pipe}. It delegates to the native
+* `Iterator.prototype.take`, which stops pulling from the source once `limit`
+* elements have been produced.
+*
+* @template T - The type of elements produced by the source iterator.
+* @param limit - The number of elements to take; must be a non-negative integer.
+* @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<T>`.
+* @throws {RangeError} Throws if `limit` is negative or `NaN` (native behavior).
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { take } from 'es-toolkit/fp/iterator';
+*
+* pipe([1, 2, 3, 4, 5].values(), take(3)).toArray(); // => [1, 2, 3]
+*/
+function take(limit) {
+	return function takeInIterator(source) {
+		return Iterator.from(source).take(limit);
+	};
+}
+//#endregion
+exports.take = take;

package/dist/fp/iterator/take.mjs

@@ -0,0 +1,25 @@
+//#region src/fp/iterator/take.ts
+/**
+* Creates a function that lazily yields the first `limit` elements of an
+* iterator, for use with {@link pipe}. It delegates to the native
+* `Iterator.prototype.take`, which stops pulling from the source once `limit`
+* elements have been produced.
+*
+* @template T - The type of elements produced by the source iterator.
+* @param limit - The number of elements to take; must be a non-negative integer.
+* @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<T>`.
+* @throws {RangeError} Throws if `limit` is negative or `NaN` (native behavior).
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { take } from 'es-toolkit/fp/iterator';
+*
+* pipe([1, 2, 3, 4, 5].values(), take(3)).toArray(); // => [1, 2, 3]
+*/
+function take(limit) {
+	return function takeInIterator(source) {
+		return Iterator.from(source).take(limit);
+	};
+}
+//#endregion
+export { take };

package/dist/fp/iterator/takeWhile.d.mts

@@ -0,0 +1,19 @@
+//#region src/fp/iterator/takeWhile.d.ts
+/**
+ * Creates a function that lazily yields elements of an iterator while
+ * `shouldContinue` returns truthy, stopping at the first failure, for use with
+ * {@link pipe}.
+ *
+ * @template T - The type of elements produced by the source iterator.
+ * @param shouldContinue - Called with `(value, index)`; iteration stops once it returns falsy.
+ * @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<T>`.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { takeWhile, toArray } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2, 3, 1].values(), takeWhile(x => x < 3), toArray()); // => [1, 2]
+ */
+declare function takeWhile<T>(shouldContinue: (value: T, index: number) => boolean): (source: Iterator<T>) => IteratorObject<T, undefined>;
+//#endregion
+export { takeWhile };

package/dist/fp/iterator/takeWhile.d.ts

@@ -0,0 +1,19 @@
+//#region src/fp/iterator/takeWhile.d.ts
+/**
+ * Creates a function that lazily yields elements of an iterator while
+ * `shouldContinue` returns truthy, stopping at the first failure, for use with
+ * {@link pipe}.
+ *
+ * @template T - The type of elements produced by the source iterator.
+ * @param shouldContinue - Called with `(value, index)`; iteration stops once it returns falsy.
+ * @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<T>`.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { takeWhile, toArray } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2, 3, 1].values(), takeWhile(x => x < 3), toArray()); // => [1, 2]
+ */
+declare function takeWhile<T>(shouldContinue: (value: T, index: number) => boolean): (source: Iterator<T>) => IteratorObject<T, undefined>;
+//#endregion
+export { takeWhile };

package/dist/fp/iterator/takeWhile.js

@@ -0,0 +1,24 @@
+const require_takeWhile = require("../../iterator/takeWhile.js");
+//#region src/fp/iterator/takeWhile.ts
+/**
+* Creates a function that lazily yields elements of an iterator while
+* `shouldContinue` returns truthy, stopping at the first failure, for use with
+* {@link pipe}.
+*
+* @template T - The type of elements produced by the source iterator.
+* @param shouldContinue - Called with `(value, index)`; iteration stops once it returns falsy.
+* @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<T>`.
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { takeWhile, toArray } from 'es-toolkit/fp/iterator';
+*
+* pipe([1, 2, 3, 1].values(), takeWhile(x => x < 3), toArray()); // => [1, 2]
+*/
+function takeWhile(shouldContinue) {
+	return function takeWhileInIterator(source) {
+		return require_takeWhile.takeWhile(source, shouldContinue);
+	};
+}
+//#endregion
+exports.takeWhile = takeWhile;

package/dist/fp/iterator/takeWhile.mjs

@@ -0,0 +1,24 @@
+import { takeWhile as takeWhile$1 } from "../../iterator/takeWhile.mjs";
+//#region src/fp/iterator/takeWhile.ts
+/**
+* Creates a function that lazily yields elements of an iterator while
+* `shouldContinue` returns truthy, stopping at the first failure, for use with
+* {@link pipe}.
+*
+* @template T - The type of elements produced by the source iterator.
+* @param shouldContinue - Called with `(value, index)`; iteration stops once it returns falsy.
+* @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<T>`.
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { takeWhile, toArray } from 'es-toolkit/fp/iterator';
+*
+* pipe([1, 2, 3, 1].values(), takeWhile(x => x < 3), toArray()); // => [1, 2]
+*/
+function takeWhile(shouldContinue) {
+	return function takeWhileInIterator(source) {
+		return takeWhile$1(source, shouldContinue);
+	};
+}
+//#endregion
+export { takeWhile };

package/dist/fp/iterator/toArray.d.mts

@@ -0,0 +1,21 @@
+//#region src/fp/iterator/toArray.d.ts
+/**
+ * Creates a function that consumes an iterator and collects its elements into an
+ * array, for use as the terminal step of a {@link pipe}. It delegates to the
+ * native `Iterator.prototype.toArray`.
+ *
+ * This is a terminal operation: it pulls every element, so it must not be used
+ * on an infinite iterator.
+ *
+ * @template T - The type of elements produced by the source iterator.
+ * @returns A function mapping an `Iterator<T>` to a `T[]`.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { map, toArray } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2, 3].values(), map(x => x * 2), toArray()); // => [2, 4, 6]
+ */
+declare function toArray<T>(): (source: Iterator<T>) => T[];
+//#endregion
+export { toArray };

package/dist/fp/iterator/toArray.d.ts

@@ -0,0 +1,21 @@
+//#region src/fp/iterator/toArray.d.ts
+/**
+ * Creates a function that consumes an iterator and collects its elements into an
+ * array, for use as the terminal step of a {@link pipe}. It delegates to the
+ * native `Iterator.prototype.toArray`.
+ *
+ * This is a terminal operation: it pulls every element, so it must not be used
+ * on an infinite iterator.
+ *
+ * @template T - The type of elements produced by the source iterator.
+ * @returns A function mapping an `Iterator<T>` to a `T[]`.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { map, toArray } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2, 3].values(), map(x => x * 2), toArray()); // => [2, 4, 6]
+ */
+declare function toArray<T>(): (source: Iterator<T>) => T[];
+//#endregion
+export { toArray };

package/dist/fp/iterator/toArray.js

@@ -0,0 +1,25 @@
+//#region src/fp/iterator/toArray.ts
+/**
+* Creates a function that consumes an iterator and collects its elements into an
+* array, for use as the terminal step of a {@link pipe}. It delegates to the
+* native `Iterator.prototype.toArray`.
+*
+* This is a terminal operation: it pulls every element, so it must not be used
+* on an infinite iterator.
+*
+* @template T - The type of elements produced by the source iterator.
+* @returns A function mapping an `Iterator<T>` to a `T[]`.
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { map, toArray } from 'es-toolkit/fp/iterator';
+*
+* pipe([1, 2, 3].values(), map(x => x * 2), toArray()); // => [2, 4, 6]
+*/
+function toArray() {
+	return function toArrayInIterator(source) {
+		return Iterator.from(source).toArray();
+	};
+}
+//#endregion
+exports.toArray = toArray;

package/dist/fp/iterator/toArray.mjs

@@ -0,0 +1,25 @@
+//#region src/fp/iterator/toArray.ts
+/**
+* Creates a function that consumes an iterator and collects its elements into an
+* array, for use as the terminal step of a {@link pipe}. It delegates to the
+* native `Iterator.prototype.toArray`.
+*
+* This is a terminal operation: it pulls every element, so it must not be used
+* on an infinite iterator.
+*
+* @template T - The type of elements produced by the source iterator.
+* @returns A function mapping an `Iterator<T>` to a `T[]`.
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { map, toArray } from 'es-toolkit/fp/iterator';
+*
+* pipe([1, 2, 3].values(), map(x => x * 2), toArray()); // => [2, 4, 6]
+*/
+function toArray() {
+	return function toArrayInIterator(source) {
+		return Iterator.from(source).toArray();
+	};
+}
+//#endregion
+export { toArray };

package/dist/fp/iterator/uniqBy.d.mts

@@ -0,0 +1,20 @@
+//#region src/fp/iterator/uniqBy.d.ts
+/**
+ * Creates a function that lazily yields the elements of an iterator whose mapped
+ * key has not been seen before, preserving first-occurrence order, for use with
+ * {@link pipe}. Keys are compared with SameValueZero semantics.
+ *
+ * @template T - The type of elements produced by the source iterator.
+ * @template K - The type of the key used for comparison.
+ * @param getKey - Maps an element to the key used to detect duplicates.
+ * @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<T>`.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { uniqBy, toArray } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1.1, 1.2, 2.3].values(), uniqBy(Math.floor), toArray()); // => [1.1, 2.3]
+ */
+declare function uniqBy<T, K>(getKey: (value: T) => K): (source: Iterator<T>) => IteratorObject<T, undefined>;
+//#endregion
+export { uniqBy };

package/dist/fp/iterator/uniqBy.d.ts

@@ -0,0 +1,20 @@
+//#region src/fp/iterator/uniqBy.d.ts
+/**
+ * Creates a function that lazily yields the elements of an iterator whose mapped
+ * key has not been seen before, preserving first-occurrence order, for use with
+ * {@link pipe}. Keys are compared with SameValueZero semantics.
+ *
+ * @template T - The type of elements produced by the source iterator.
+ * @template K - The type of the key used for comparison.
+ * @param getKey - Maps an element to the key used to detect duplicates.
+ * @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<T>`.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { uniqBy, toArray } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1.1, 1.2, 2.3].values(), uniqBy(Math.floor), toArray()); // => [1.1, 2.3]
+ */
+declare function uniqBy<T, K>(getKey: (value: T) => K): (source: Iterator<T>) => IteratorObject<T, undefined>;
+//#endregion
+export { uniqBy };

package/dist/fp/iterator/uniqBy.js

@@ -0,0 +1,25 @@
+const require_uniqBy = require("../../iterator/uniqBy.js");
+//#region src/fp/iterator/uniqBy.ts
+/**
+* Creates a function that lazily yields the elements of an iterator whose mapped
+* key has not been seen before, preserving first-occurrence order, for use with
+* {@link pipe}. Keys are compared with SameValueZero semantics.
+*
+* @template T - The type of elements produced by the source iterator.
+* @template K - The type of the key used for comparison.
+* @param getKey - Maps an element to the key used to detect duplicates.
+* @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<T>`.
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { uniqBy, toArray } from 'es-toolkit/fp/iterator';
+*
+* pipe([1.1, 1.2, 2.3].values(), uniqBy(Math.floor), toArray()); // => [1.1, 2.3]
+*/
+function uniqBy(getKey) {
+	return function uniqByInIterator(source) {
+		return require_uniqBy.uniqBy(source, getKey);
+	};
+}
+//#endregion
+exports.uniqBy = uniqBy;

package/dist/fp/iterator/uniqBy.mjs

@@ -0,0 +1,25 @@
+import { uniqBy as uniqBy$1 } from "../../iterator/uniqBy.mjs";
+//#region src/fp/iterator/uniqBy.ts
+/**
+* Creates a function that lazily yields the elements of an iterator whose mapped
+* key has not been seen before, preserving first-occurrence order, for use with
+* {@link pipe}. Keys are compared with SameValueZero semantics.
+*
+* @template T - The type of elements produced by the source iterator.
+* @template K - The type of the key used for comparison.
+* @param getKey - Maps an element to the key used to detect duplicates.
+* @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<T>`.
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { uniqBy, toArray } from 'es-toolkit/fp/iterator';
+*
+* pipe([1.1, 1.2, 2.3].values(), uniqBy(Math.floor), toArray()); // => [1.1, 2.3]
+*/
+function uniqBy(getKey) {
+	return function uniqByInIterator(source) {
+		return uniqBy$1(source, getKey);
+	};
+}
+//#endregion
+export { uniqBy };

package/dist/fp/iterator/zip.d.mts

@@ -0,0 +1,20 @@
+//#region src/fp/iterator/zip.d.ts
+/**
+ * Creates a function that lazily pairs the elements of the piped iterator with
+ * those of `other`, for use with {@link pipe}. Iteration stops as soon as either
+ * iterator is exhausted.
+ *
+ * @template T - The type of elements produced by the piped iterator.
+ * @template U - The type of elements produced by `other`.
+ * @param other - The iterator to pair with the piped one.
+ * @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<[T, U]>`.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { zip, toArray } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2, 3].values(), zip(['a', 'b'].values()), toArray()); // => [[1, 'a'], [2, 'b']]
+ */
+declare function zip<T, U>(other: Iterator<U>): (source: Iterator<T>) => IteratorObject<[T, U], undefined>;
+//#endregion
+export { zip };