es-toolkit 1.50.0 → 1.51.0-dev.2069

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

@@ -0,0 +1,19 @@
+//#region src/fp/iterator/chunk.d.ts
+/**
+ * Creates a function that lazily groups the elements of an iterator into arrays
+ * of length `size`, for use with {@link pipe}. The final chunk may be shorter.
+ *
+ * @template T - The type of elements produced by the source iterator.
+ * @param size - The length of each chunk; must be an integer greater than zero.
+ * @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<T[]>`.
+ * @throws {Error} Throws an error if `size` is not an integer greater than zero.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { chunk, toArray } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2, 3, 4, 5].values(), chunk(2), toArray()); // => [[1, 2], [3, 4], [5]]
+ */
+declare function chunk<T>(size: number): (source: Iterator<T>) => IteratorObject<T[], undefined>;
+//#endregion
+export { chunk };

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

@@ -0,0 +1,19 @@
+//#region src/fp/iterator/chunk.d.ts
+/**
+ * Creates a function that lazily groups the elements of an iterator into arrays
+ * of length `size`, for use with {@link pipe}. The final chunk may be shorter.
+ *
+ * @template T - The type of elements produced by the source iterator.
+ * @param size - The length of each chunk; must be an integer greater than zero.
+ * @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<T[]>`.
+ * @throws {Error} Throws an error if `size` is not an integer greater than zero.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { chunk, toArray } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2, 3, 4, 5].values(), chunk(2), toArray()); // => [[1, 2], [3, 4], [5]]
+ */
+declare function chunk<T>(size: number): (source: Iterator<T>) => IteratorObject<T[], undefined>;
+//#endregion
+export { chunk };

package/dist/fp/iterator/chunk.js

@@ -0,0 +1,24 @@
+const require_chunk = require("../../iterator/chunk.js");
+//#region src/fp/iterator/chunk.ts
+/**
+* Creates a function that lazily groups the elements of an iterator into arrays
+* of length `size`, for use with {@link pipe}. The final chunk may be shorter.
+*
+* @template T - The type of elements produced by the source iterator.
+* @param size - The length of each chunk; must be an integer greater than zero.
+* @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<T[]>`.
+* @throws {Error} Throws an error if `size` is not an integer greater than zero.
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { chunk, toArray } from 'es-toolkit/fp/iterator';
+*
+* pipe([1, 2, 3, 4, 5].values(), chunk(2), toArray()); // => [[1, 2], [3, 4], [5]]
+*/
+function chunk(size) {
+	return function chunkInIterator(source) {
+		return require_chunk.chunk(source, size);
+	};
+}
+//#endregion
+exports.chunk = chunk;

package/dist/fp/iterator/chunk.mjs

@@ -0,0 +1,24 @@
+import { chunk as chunk$1 } from "../../iterator/chunk.mjs";
+//#region src/fp/iterator/chunk.ts
+/**
+* Creates a function that lazily groups the elements of an iterator into arrays
+* of length `size`, for use with {@link pipe}. The final chunk may be shorter.
+*
+* @template T - The type of elements produced by the source iterator.
+* @param size - The length of each chunk; must be an integer greater than zero.
+* @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<T[]>`.
+* @throws {Error} Throws an error if `size` is not an integer greater than zero.
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { chunk, toArray } from 'es-toolkit/fp/iterator';
+*
+* pipe([1, 2, 3, 4, 5].values(), chunk(2), toArray()); // => [[1, 2], [3, 4], [5]]
+*/
+function chunk(size) {
+	return function chunkInIterator(source) {
+		return chunk$1(source, size);
+	};
+}
+//#endregion
+export { chunk };

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

@@ -0,0 +1,20 @@
+//#region src/fp/iterator/count.d.ts
+/**
+ * Creates a function that consumes an iterator and returns the number of
+ * elements it produces, for use as the terminal step of a {@link pipe}.
+ *
+ * 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 its element count.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { filter, count } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2, 3, 4].values(), filter(x => x % 2 === 0), count()); // => 2
+ */
+declare function count<T>(): (source: Iterator<T>) => number;
+//#endregion
+export { count };

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

@@ -0,0 +1,20 @@
+//#region src/fp/iterator/count.d.ts
+/**
+ * Creates a function that consumes an iterator and returns the number of
+ * elements it produces, for use as the terminal step of a {@link pipe}.
+ *
+ * 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 its element count.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { filter, count } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2, 3, 4].values(), filter(x => x % 2 === 0), count()); // => 2
+ */
+declare function count<T>(): (source: Iterator<T>) => number;
+//#endregion
+export { count };

package/dist/fp/iterator/count.js

@@ -0,0 +1,25 @@
+const require_count = require("../../iterator/count.js");
+//#region src/fp/iterator/count.ts
+/**
+* Creates a function that consumes an iterator and returns the number of
+* elements it produces, for use as the terminal step of a {@link pipe}.
+*
+* 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 its element count.
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { filter, count } from 'es-toolkit/fp/iterator';
+*
+* pipe([1, 2, 3, 4].values(), filter(x => x % 2 === 0), count()); // => 2
+*/
+function count() {
+	return function countInIterator(source) {
+		return require_count.count(source);
+	};
+}
+//#endregion
+exports.count = count;

package/dist/fp/iterator/count.mjs

@@ -0,0 +1,25 @@
+import { count as count$1 } from "../../iterator/count.mjs";
+//#region src/fp/iterator/count.ts
+/**
+* Creates a function that consumes an iterator and returns the number of
+* elements it produces, for use as the terminal step of a {@link pipe}.
+*
+* 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 its element count.
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { filter, count } from 'es-toolkit/fp/iterator';
+*
+* pipe([1, 2, 3, 4].values(), filter(x => x % 2 === 0), count()); // => 2
+*/
+function count() {
+	return function countInIterator(source) {
+		return count$1(source);
+	};
+}
+//#endregion
+export { count };

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

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

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

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

package/dist/fp/iterator/drop.js

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

package/dist/fp/iterator/drop.mjs

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

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

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

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

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

package/dist/fp/iterator/dropWhile.js

@@ -0,0 +1,23 @@
+const require_dropWhile = require("../../iterator/dropWhile.js");
+//#region src/fp/iterator/dropWhile.ts
+/**
+* Creates a function that lazily skips elements of an iterator while `shouldDrop`
+* returns truthy, then yields the rest, for use with {@link pipe}.
+*
+* @template T - The type of elements produced by the source iterator.
+* @param shouldDrop - Called with `(value, index)`; elements are skipped while it returns truthy.
+* @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<T>`.
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { dropWhile, toArray } from 'es-toolkit/fp/iterator';
+*
+* pipe([1, 2, 3, 1].values(), dropWhile(x => x < 3), toArray()); // => [3, 1]
+*/
+function dropWhile(shouldDrop) {
+	return function dropWhileInIterator(source) {
+		return require_dropWhile.dropWhile(source, shouldDrop);
+	};
+}
+//#endregion
+exports.dropWhile = dropWhile;

package/dist/fp/iterator/dropWhile.mjs

@@ -0,0 +1,23 @@
+import { dropWhile as dropWhile$1 } from "../../iterator/dropWhile.mjs";
+//#region src/fp/iterator/dropWhile.ts
+/**
+* Creates a function that lazily skips elements of an iterator while `shouldDrop`
+* returns truthy, then yields the rest, for use with {@link pipe}.
+*
+* @template T - The type of elements produced by the source iterator.
+* @param shouldDrop - Called with `(value, index)`; elements are skipped while it returns truthy.
+* @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<T>`.
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { dropWhile, toArray } from 'es-toolkit/fp/iterator';
+*
+* pipe([1, 2, 3, 1].values(), dropWhile(x => x < 3), toArray()); // => [3, 1]
+*/
+function dropWhile(shouldDrop) {
+	return function dropWhileInIterator(source) {
+		return dropWhile$1(source, shouldDrop);
+	};
+}
+//#endregion
+export { dropWhile };

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

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

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

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

package/dist/fp/iterator/every.js

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

package/dist/fp/iterator/every.mjs

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

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

@@ -0,0 +1,37 @@
+//#region src/fp/iterator/filter.d.ts
+/**
+ * Creates a function that lazily keeps the elements of an iterator for which
+ * `predicate` returns truthy, narrowing the element type when `predicate` is a
+ * type guard. For use with {@link pipe}. It delegates to the native
+ * `Iterator.prototype.filter`.
+ *
+ * @template T - The type of elements produced by the source iterator.
+ * @template S - The narrowed element type when `predicate` is a type guard.
+ * @param predicate - Called with `(value, index)`; truthy keeps the element.
+ * @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<S>`.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { filter } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2, 3, 4].values(), filter(x => x % 2 === 0)).toArray(); // => [2, 4]
+ */
+declare function filter<T, S extends T>(predicate: (value: T, index: number) => value is S): (source: Iterator<T>) => IteratorObject<S, undefined>;
+/**
+ * Creates a function that lazily keeps the elements of an iterator for which
+ * `predicate` returns truthy, for use with {@link pipe}. It delegates to the
+ * native `Iterator.prototype.filter`.
+ *
+ * @template T - The type of elements produced by the source iterator.
+ * @param predicate - Called with `(value, index)`; truthy keeps the element.
+ * @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<T>`.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { filter } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2, 3, 4].values(), filter(x => x % 2 === 0)).toArray(); // => [2, 4]
+ */
+declare function filter<T>(predicate: (value: T, index: number) => unknown): (source: Iterator<T>) => IteratorObject<T, undefined>;
+//#endregion
+export { filter };

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

@@ -0,0 +1,37 @@
+//#region src/fp/iterator/filter.d.ts
+/**
+ * Creates a function that lazily keeps the elements of an iterator for which
+ * `predicate` returns truthy, narrowing the element type when `predicate` is a
+ * type guard. For use with {@link pipe}. It delegates to the native
+ * `Iterator.prototype.filter`.
+ *
+ * @template T - The type of elements produced by the source iterator.
+ * @template S - The narrowed element type when `predicate` is a type guard.
+ * @param predicate - Called with `(value, index)`; truthy keeps the element.
+ * @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<S>`.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { filter } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2, 3, 4].values(), filter(x => x % 2 === 0)).toArray(); // => [2, 4]
+ */
+declare function filter<T, S extends T>(predicate: (value: T, index: number) => value is S): (source: Iterator<T>) => IteratorObject<S, undefined>;
+/**
+ * Creates a function that lazily keeps the elements of an iterator for which
+ * `predicate` returns truthy, for use with {@link pipe}. It delegates to the
+ * native `Iterator.prototype.filter`.
+ *
+ * @template T - The type of elements produced by the source iterator.
+ * @param predicate - Called with `(value, index)`; truthy keeps the element.
+ * @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<T>`.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { filter } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2, 3, 4].values(), filter(x => x % 2 === 0)).toArray(); // => [2, 4]
+ */
+declare function filter<T>(predicate: (value: T, index: number) => unknown): (source: Iterator<T>) => IteratorObject<T, undefined>;
+//#endregion
+export { filter };

package/dist/fp/iterator/filter.js

@@ -0,0 +1,8 @@
+//#region src/fp/iterator/filter.ts
+function filter(predicate) {
+	return function filterInIterator(source) {
+		return Iterator.from(source).filter(predicate);
+	};
+}
+//#endregion
+exports.filter = filter;

package/dist/fp/iterator/filter.mjs

@@ -0,0 +1,8 @@
+//#region src/fp/iterator/filter.ts
+function filter(predicate) {
+	return function filterInIterator(source) {
+		return Iterator.from(source).filter(predicate);
+	};
+}
+//#endregion
+export { filter };

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

@@ -0,0 +1,20 @@
+//#region src/fp/iterator/find.d.ts
+/**
+ * Creates a function that consumes an iterator until `predicate` returns truthy
+ * and returns that element (or `undefined` if none match), for use as the
+ * terminal step of a {@link pipe}. It delegates to the native
+ * `Iterator.prototype.find` 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 selects the element.
+ * @returns A function mapping an `Iterator<T>` to the matching element or `undefined`.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { find } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2, 3, 4].values(), find(x => x > 2)); // => 3
+ */
+declare function find<T>(predicate: (value: T, index: number) => unknown): (source: Iterator<T>) => T | undefined;
+//#endregion
+export { find };

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

@@ -0,0 +1,20 @@
+//#region src/fp/iterator/find.d.ts
+/**
+ * Creates a function that consumes an iterator until `predicate` returns truthy
+ * and returns that element (or `undefined` if none match), for use as the
+ * terminal step of a {@link pipe}. It delegates to the native
+ * `Iterator.prototype.find` 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 selects the element.
+ * @returns A function mapping an `Iterator<T>` to the matching element or `undefined`.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { find } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2, 3, 4].values(), find(x => x > 2)); // => 3
+ */
+declare function find<T>(predicate: (value: T, index: number) => unknown): (source: Iterator<T>) => T | undefined;
+//#endregion
+export { find };

package/dist/fp/iterator/find.js

@@ -0,0 +1,24 @@
+//#region src/fp/iterator/find.ts
+/**
+* Creates a function that consumes an iterator until `predicate` returns truthy
+* and returns that element (or `undefined` if none match), for use as the
+* terminal step of a {@link pipe}. It delegates to the native
+* `Iterator.prototype.find` 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 selects the element.
+* @returns A function mapping an `Iterator<T>` to the matching element or `undefined`.
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { find } from 'es-toolkit/fp/iterator';
+*
+* pipe([1, 2, 3, 4].values(), find(x => x > 2)); // => 3
+*/
+function find(predicate) {
+	return function findInIterator(source) {
+		return Iterator.from(source).find(predicate);
+	};
+}
+//#endregion
+exports.find = find;

package/dist/fp/iterator/find.mjs

@@ -0,0 +1,24 @@
+//#region src/fp/iterator/find.ts
+/**
+* Creates a function that consumes an iterator until `predicate` returns truthy
+* and returns that element (or `undefined` if none match), for use as the
+* terminal step of a {@link pipe}. It delegates to the native
+* `Iterator.prototype.find` 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 selects the element.
+* @returns A function mapping an `Iterator<T>` to the matching element or `undefined`.
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { find } from 'es-toolkit/fp/iterator';
+*
+* pipe([1, 2, 3, 4].values(), find(x => x > 2)); // => 3
+*/
+function find(predicate) {
+	return function findInIterator(source) {
+		return Iterator.from(source).find(predicate);
+	};
+}
+//#endregion
+export { find };