es-toolkit 1.51.0-dev.2065 → 1.51.0-dev.2069

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

@@ -0,0 +1,21 @@
+import { chunk } from "./chunk.mjs";
+import { count } from "./count.mjs";
+import { drop } from "./drop.mjs";
+import { dropWhile } from "./dropWhile.mjs";
+import { every } from "./every.mjs";
+import { filter } from "./filter.mjs";
+import { find } from "./find.mjs";
+import { flatMap } from "./flatMap.mjs";
+import { forEach } from "./forEach.mjs";
+import { head } from "./head.mjs";
+import { map } from "./map.mjs";
+import { partition } from "./partition.mjs";
+import { reduce } from "./reduce.mjs";
+import { scan } from "./scan.mjs";
+import { some } from "./some.mjs";
+import { take } from "./take.mjs";
+import { takeWhile } from "./takeWhile.mjs";
+import { toArray } from "./toArray.mjs";
+import { uniqBy } from "./uniqBy.mjs";
+import { zip } from "./zip.mjs";
+export { chunk, count, drop, dropWhile, every, filter, find, flatMap, forEach, head, map, partition, reduce, scan, some, take, takeWhile, toArray, uniqBy, zip };

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

@@ -0,0 +1,21 @@
+import { chunk } from "./chunk.js";
+import { count } from "./count.js";
+import { drop } from "./drop.js";
+import { dropWhile } from "./dropWhile.js";
+import { every } from "./every.js";
+import { filter } from "./filter.js";
+import { find } from "./find.js";
+import { flatMap } from "./flatMap.js";
+import { forEach } from "./forEach.js";
+import { head } from "./head.js";
+import { map } from "./map.js";
+import { partition } from "./partition.js";
+import { reduce } from "./reduce.js";
+import { scan } from "./scan.js";
+import { some } from "./some.js";
+import { take } from "./take.js";
+import { takeWhile } from "./takeWhile.js";
+import { toArray } from "./toArray.js";
+import { uniqBy } from "./uniqBy.js";
+import { zip } from "./zip.js";
+export { chunk, count, drop, dropWhile, every, filter, find, flatMap, forEach, head, map, partition, reduce, scan, some, take, takeWhile, toArray, uniqBy, zip };

package/dist/fp/iterator/index.js

@@ -0,0 +1,41 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_chunk = require("./chunk.js");
+const require_count = require("./count.js");
+const require_drop = require("./drop.js");
+const require_dropWhile = require("./dropWhile.js");
+const require_every = require("./every.js");
+const require_filter = require("./filter.js");
+const require_find = require("./find.js");
+const require_flatMap = require("./flatMap.js");
+const require_forEach = require("./forEach.js");
+const require_head = require("./head.js");
+const require_map = require("./map.js");
+const require_partition = require("./partition.js");
+const require_reduce = require("./reduce.js");
+const require_scan = require("./scan.js");
+const require_some = require("./some.js");
+const require_take = require("./take.js");
+const require_takeWhile = require("./takeWhile.js");
+const require_toArray = require("./toArray.js");
+const require_uniqBy = require("./uniqBy.js");
+const require_zip = require("./zip.js");
+exports.chunk = require_chunk.chunk;
+exports.count = require_count.count;
+exports.drop = require_drop.drop;
+exports.dropWhile = require_dropWhile.dropWhile;
+exports.every = require_every.every;
+exports.filter = require_filter.filter;
+exports.find = require_find.find;
+exports.flatMap = require_flatMap.flatMap;
+exports.forEach = require_forEach.forEach;
+exports.head = require_head.head;
+exports.map = require_map.map;
+exports.partition = require_partition.partition;
+exports.reduce = require_reduce.reduce;
+exports.scan = require_scan.scan;
+exports.some = require_some.some;
+exports.take = require_take.take;
+exports.takeWhile = require_takeWhile.takeWhile;
+exports.toArray = require_toArray.toArray;
+exports.uniqBy = require_uniqBy.uniqBy;
+exports.zip = require_zip.zip;

package/dist/fp/iterator/index.mjs

@@ -0,0 +1,21 @@
+import { chunk } from "./chunk.mjs";
+import { count } from "./count.mjs";
+import { drop } from "./drop.mjs";
+import { dropWhile } from "./dropWhile.mjs";
+import { every } from "./every.mjs";
+import { filter } from "./filter.mjs";
+import { find } from "./find.mjs";
+import { flatMap } from "./flatMap.mjs";
+import { forEach } from "./forEach.mjs";
+import { head } from "./head.mjs";
+import { map } from "./map.mjs";
+import { partition } from "./partition.mjs";
+import { reduce } from "./reduce.mjs";
+import { scan } from "./scan.mjs";
+import { some } from "./some.mjs";
+import { take } from "./take.mjs";
+import { takeWhile } from "./takeWhile.mjs";
+import { toArray } from "./toArray.mjs";
+import { uniqBy } from "./uniqBy.mjs";
+import { zip } from "./zip.mjs";
+export { chunk, count, drop, dropWhile, every, filter, find, flatMap, forEach, head, map, partition, reduce, scan, some, take, takeWhile, toArray, uniqBy, zip };

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

@@ -0,0 +1,20 @@
+//#region src/fp/iterator/map.d.ts
+/**
+ * Creates a function that lazily transforms each element of an iterator with
+ * `callback`, for use with {@link pipe}. It delegates to the native
+ * `Iterator.prototype.map`, so the result is a lazy, single-shot iterator.
+ *
+ * @template T - The type of elements produced by the source iterator.
+ * @template U - The type of elements produced by the result.
+ * @param callback - Called with `(value, index)`; its return value is yielded.
+ * @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<U>`.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { map } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2, 3].values(), map(x => x * 2)).toArray(); // => [2, 4, 6]
+ */
+declare function map<T, U>(callback: (value: T, index: number) => U): (source: Iterator<T>) => IteratorObject<U, undefined>;
+//#endregion
+export { map };

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

@@ -0,0 +1,20 @@
+//#region src/fp/iterator/map.d.ts
+/**
+ * Creates a function that lazily transforms each element of an iterator with
+ * `callback`, for use with {@link pipe}. It delegates to the native
+ * `Iterator.prototype.map`, so the result is a lazy, single-shot iterator.
+ *
+ * @template T - The type of elements produced by the source iterator.
+ * @template U - The type of elements produced by the result.
+ * @param callback - Called with `(value, index)`; its return value is yielded.
+ * @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<U>`.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { map } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2, 3].values(), map(x => x * 2)).toArray(); // => [2, 4, 6]
+ */
+declare function map<T, U>(callback: (value: T, index: number) => U): (source: Iterator<T>) => IteratorObject<U, undefined>;
+//#endregion
+export { map };

package/dist/fp/iterator/map.js

@@ -0,0 +1,24 @@
+//#region src/fp/iterator/map.ts
+/**
+* Creates a function that lazily transforms each element of an iterator with
+* `callback`, for use with {@link pipe}. It delegates to the native
+* `Iterator.prototype.map`, so the result is a lazy, single-shot iterator.
+*
+* @template T - The type of elements produced by the source iterator.
+* @template U - The type of elements produced by the result.
+* @param callback - Called with `(value, index)`; its return value is yielded.
+* @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<U>`.
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { map } from 'es-toolkit/fp/iterator';
+*
+* pipe([1, 2, 3].values(), map(x => x * 2)).toArray(); // => [2, 4, 6]
+*/
+function map(callback) {
+	return function mapInIterator(source) {
+		return Iterator.from(source).map(callback);
+	};
+}
+//#endregion
+exports.map = map;

package/dist/fp/iterator/map.mjs

@@ -0,0 +1,24 @@
+//#region src/fp/iterator/map.ts
+/**
+* Creates a function that lazily transforms each element of an iterator with
+* `callback`, for use with {@link pipe}. It delegates to the native
+* `Iterator.prototype.map`, so the result is a lazy, single-shot iterator.
+*
+* @template T - The type of elements produced by the source iterator.
+* @template U - The type of elements produced by the result.
+* @param callback - Called with `(value, index)`; its return value is yielded.
+* @returns A function mapping an `Iterator<T>` to a lazy `IteratorObject<U>`.
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { map } from 'es-toolkit/fp/iterator';
+*
+* pipe([1, 2, 3].values(), map(x => x * 2)).toArray(); // => [2, 4, 6]
+*/
+function map(callback) {
+	return function mapInIterator(source) {
+		return Iterator.from(source).map(callback);
+	};
+}
+//#endregion
+export { map };

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

@@ -0,0 +1,22 @@
+//#region src/fp/iterator/partition.d.ts
+/**
+ * Creates a function that consumes an iterator and splits its elements into
+ * `[matched, unmatched]` arrays by `predicate`, 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.
+ * @param predicate - Called with `(value, index)`; truthy sends the element to the first array.
+ * @returns A function mapping an `Iterator<T>` to a `[T[], T[]]` tuple.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { partition } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2, 3, 4].values(), partition(x => x % 2 === 0)); // => [[2, 4], [1, 3]]
+ */
+declare function partition<T>(predicate: (value: T, index: number) => boolean): (source: Iterator<T>) => [T[], T[]];
+//#endregion
+export { partition };

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

@@ -0,0 +1,22 @@
+//#region src/fp/iterator/partition.d.ts
+/**
+ * Creates a function that consumes an iterator and splits its elements into
+ * `[matched, unmatched]` arrays by `predicate`, 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.
+ * @param predicate - Called with `(value, index)`; truthy sends the element to the first array.
+ * @returns A function mapping an `Iterator<T>` to a `[T[], T[]]` tuple.
+ *
+ * @example
+ * import { pipe } from 'es-toolkit/fp';
+ * import { partition } from 'es-toolkit/fp/iterator';
+ *
+ * pipe([1, 2, 3, 4].values(), partition(x => x % 2 === 0)); // => [[2, 4], [1, 3]]
+ */
+declare function partition<T>(predicate: (value: T, index: number) => boolean): (source: Iterator<T>) => [T[], T[]];
+//#endregion
+export { partition };

package/dist/fp/iterator/partition.js

@@ -0,0 +1,27 @@
+const require_partition = require("../../iterator/partition.js");
+//#region src/fp/iterator/partition.ts
+/**
+* Creates a function that consumes an iterator and splits its elements into
+* `[matched, unmatched]` arrays by `predicate`, 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.
+* @param predicate - Called with `(value, index)`; truthy sends the element to the first array.
+* @returns A function mapping an `Iterator<T>` to a `[T[], T[]]` tuple.
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { partition } from 'es-toolkit/fp/iterator';
+*
+* pipe([1, 2, 3, 4].values(), partition(x => x % 2 === 0)); // => [[2, 4], [1, 3]]
+*/
+function partition(predicate) {
+	return function partitionInIterator(source) {
+		return require_partition.partition(source, predicate);
+	};
+}
+//#endregion
+exports.partition = partition;

package/dist/fp/iterator/partition.mjs

@@ -0,0 +1,27 @@
+import { partition as partition$1 } from "../../iterator/partition.mjs";
+//#region src/fp/iterator/partition.ts
+/**
+* Creates a function that consumes an iterator and splits its elements into
+* `[matched, unmatched]` arrays by `predicate`, 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.
+* @param predicate - Called with `(value, index)`; truthy sends the element to the first array.
+* @returns A function mapping an `Iterator<T>` to a `[T[], T[]]` tuple.
+*
+* @example
+* import { pipe } from 'es-toolkit/fp';
+* import { partition } from 'es-toolkit/fp/iterator';
+*
+* pipe([1, 2, 3, 4].values(), partition(x => x % 2 === 0)); // => [[2, 4], [1, 3]]
+*/
+function partition(predicate) {
+	return function partitionInIterator(source) {
+		return partition$1(source, predicate);
+	};
+}
+//#endregion
+export { partition };

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

@@ -0,0 +1,24 @@
+//#region src/fp/iterator/reduce.d.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
+ */
+declare function reduce<T, U>(callback: (accumulator: U, value: T, index: number) => U, initial: U): (source: Iterator<T>) => U;
+//#endregion
+export { reduce };

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

@@ -0,0 +1,24 @@
+//#region src/fp/iterator/reduce.d.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
+ */
+declare function reduce<T, U>(callback: (accumulator: U, value: T, index: number) => U, initial: U): (source: Iterator<T>) => U;
+//#endregion
+export { reduce };

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 };