es-toolkit 1.48.1-dev.1890 → 1.48.1-dev.1894

package/dist/fp/array/differenceWith.d.ts

@@ -0,0 +1,22 @@
+//#region src/fp/array/differenceWith.d.ts
+/**
+ * Creates a function that returns values that are not equal to any configured value.
+ *
+ * Equality is decided by the provided comparator. The returned function is
+ * lazy-capable inside {@link pipe}.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template U - The type of elements in the configured array.
+ * @param secondArray - Values to compare against the piped array.
+ * @param areItemsEqual - Returns true when a piped value equals a configured value.
+ * @returns A function that maps the piped array to its custom difference.
+ *
+ * @example
+ * import { differenceWith, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }, { id: 2 }], differenceWith([2], (item, id) => item.id === id));
+ * // => [{ id: 1 }]
+ */
+declare function differenceWith<T, U>(secondArray: readonly U[], areItemsEqual: (item: T, other: U) => boolean): (array: readonly T[]) => T[];
+//#endregion
+export { differenceWith };

package/dist/fp/array/differenceWith.js

@@ -0,0 +1,32 @@
+const require_differenceWith = require("../../array/differenceWith.js");
+const require_lazy = require("../_internal/lazy.js");
+//#region src/fp/array/differenceWith.ts
+/**
+* Creates a function that returns values that are not equal to any configured value.
+*
+* Equality is decided by the provided comparator. The returned function is
+* lazy-capable inside {@link pipe}.
+*
+* @template T - The type of elements in the piped array.
+* @template U - The type of elements in the configured array.
+* @param secondArray - Values to compare against the piped array.
+* @param areItemsEqual - Returns true when a piped value equals a configured value.
+* @returns A function that maps the piped array to its custom difference.
+*
+* @example
+* import { differenceWith, pipe } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }, { id: 2 }], differenceWith([2], (item, id) => item.id === id));
+* // => [{ id: 1 }]
+*/
+function differenceWith(secondArray, areItemsEqual) {
+	function differenceWithEager(array) {
+		return require_differenceWith.differenceWith(array, secondArray, areItemsEqual);
+	}
+	const differenceWithLazy = require_lazy.createLazyFunction((value, _index, emit) => {
+		if (secondArray.every((other) => !areItemsEqual(value, other))) emit(value);
+	});
+	return require_lazy.combineEagerAndLazyFunctions(differenceWithEager, differenceWithLazy);
+}
+//#endregion
+exports.differenceWith = differenceWith;

package/dist/fp/array/differenceWith.mjs

@@ -0,0 +1,31 @@
+import { differenceWith as differenceWith$1 } from "../../array/differenceWith.mjs";
+import { combineEagerAndLazyFunctions, createLazyFunction } from "../_internal/lazy.mjs";
+//#region src/fp/array/differenceWith.ts
+/**
+* Creates a function that returns values that are not equal to any configured value.
+*
+* Equality is decided by the provided comparator. The returned function is
+* lazy-capable inside {@link pipe}.
+*
+* @template T - The type of elements in the piped array.
+* @template U - The type of elements in the configured array.
+* @param secondArray - Values to compare against the piped array.
+* @param areItemsEqual - Returns true when a piped value equals a configured value.
+* @returns A function that maps the piped array to its custom difference.
+*
+* @example
+* import { differenceWith, pipe } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }, { id: 2 }], differenceWith([2], (item, id) => item.id === id));
+* // => [{ id: 1 }]
+*/
+function differenceWith(secondArray, areItemsEqual) {
+	function differenceWithEager(array) {
+		return differenceWith$1(array, secondArray, areItemsEqual);
+	}
+	return combineEagerAndLazyFunctions(differenceWithEager, createLazyFunction((value, _index, emit) => {
+		if (secondArray.every((other) => !areItemsEqual(value, other))) emit(value);
+	}));
+}
+//#endregion
+export { differenceWith };

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

@@ -0,0 +1,20 @@
+//#region src/fp/array/drop.d.ts
+/**
+ * Creates a function that removes a number of values from the start of an array.
+ *
+ * Negative counts are treated as 0, matching the main {@link drop}
+ * implementation. The returned function is lazy-capable inside {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @param count - The number of values to skip from the start.
+ * @returns A function that maps the piped array to the remaining suffix.
+ *
+ * @example
+ * import { drop, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3, 4], drop(2));
+ * // => [3, 4]
+ */
+declare function drop<T>(count: number): (array: readonly T[]) => T[];
+//#endregion
+export { drop };

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

@@ -0,0 +1,20 @@
+//#region src/fp/array/drop.d.ts
+/**
+ * Creates a function that removes a number of values from the start of an array.
+ *
+ * Negative counts are treated as 0, matching the main {@link drop}
+ * implementation. The returned function is lazy-capable inside {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @param count - The number of values to skip from the start.
+ * @returns A function that maps the piped array to the remaining suffix.
+ *
+ * @example
+ * import { drop, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3, 4], drop(2));
+ * // => [3, 4]
+ */
+declare function drop<T>(count: number): (array: readonly T[]) => T[];
+//#endregion
+export { drop };

package/dist/fp/array/drop.js

@@ -0,0 +1,31 @@
+const require_drop = require("../../array/drop.js");
+const require_lazy = require("../_internal/lazy.js");
+//#region src/fp/array/drop.ts
+/**
+* Creates a function that removes a number of values from the start of an array.
+*
+* Negative counts are treated as 0, matching the main {@link drop}
+* implementation. The returned function is lazy-capable inside {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @param count - The number of values to skip from the start.
+* @returns A function that maps the piped array to the remaining suffix.
+*
+* @example
+* import { drop, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3, 4], drop(2));
+* // => [3, 4]
+*/
+function drop(count) {
+	const normalizedCount = Number.isNaN(count) ? 0 : Math.trunc(Math.max(count, 0));
+	function dropEager(array) {
+		return require_drop.drop(array, count);
+	}
+	const dropLazy = require_lazy.createLazyFunction((value, index, emit) => {
+		if (index >= normalizedCount) emit(value);
+	});
+	return require_lazy.combineEagerAndLazyFunctions(dropEager, dropLazy);
+}
+//#endregion
+exports.drop = drop;

package/dist/fp/array/drop.mjs

@@ -0,0 +1,30 @@
+import { drop as drop$1 } from "../../array/drop.mjs";
+import { combineEagerAndLazyFunctions, createLazyFunction } from "../_internal/lazy.mjs";
+//#region src/fp/array/drop.ts
+/**
+* Creates a function that removes a number of values from the start of an array.
+*
+* Negative counts are treated as 0, matching the main {@link drop}
+* implementation. The returned function is lazy-capable inside {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @param count - The number of values to skip from the start.
+* @returns A function that maps the piped array to the remaining suffix.
+*
+* @example
+* import { drop, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3, 4], drop(2));
+* // => [3, 4]
+*/
+function drop(count) {
+	const normalizedCount = Number.isNaN(count) ? 0 : Math.trunc(Math.max(count, 0));
+	function dropEager(array) {
+		return drop$1(array, count);
+	}
+	return combineEagerAndLazyFunctions(dropEager, createLazyFunction((value, index, emit) => {
+		if (index >= normalizedCount) emit(value);
+	}));
+}
+//#endregion
+export { drop };

package/dist/fp/array/dropRight.d.mts

@@ -0,0 +1,20 @@
+//#region src/fp/array/dropRight.d.ts
+/**
+ * Creates a function that removes a number of values from the end of an array.
+ *
+ * The returned function follows the main {@link dropRight} behavior and returns a new array.
+ * Use it with {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @param count - The number of values to drop from the end.
+ * @returns A function that maps a readonly array to the remaining prefix.
+ *
+ * @example
+ * import { dropRight, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3, 4], dropRight(2));
+ * // => [1, 2]
+ */
+declare function dropRight<T>(count: number): (array: readonly T[]) => T[];
+//#endregion
+export { dropRight };

package/dist/fp/array/dropRight.d.ts

@@ -0,0 +1,20 @@
+//#region src/fp/array/dropRight.d.ts
+/**
+ * Creates a function that removes a number of values from the end of an array.
+ *
+ * The returned function follows the main {@link dropRight} behavior and returns a new array.
+ * Use it with {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @param count - The number of values to drop from the end.
+ * @returns A function that maps a readonly array to the remaining prefix.
+ *
+ * @example
+ * import { dropRight, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3, 4], dropRight(2));
+ * // => [1, 2]
+ */
+declare function dropRight<T>(count: number): (array: readonly T[]) => T[];
+//#endregion
+export { dropRight };

package/dist/fp/array/dropRight.js

@@ -0,0 +1,25 @@
+const require_dropRight = require("../../array/dropRight.js");
+//#region src/fp/array/dropRight.ts
+/**
+* Creates a function that removes a number of values from the end of an array.
+*
+* The returned function follows the main {@link dropRight} behavior and returns a new array.
+* Use it with {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @param count - The number of values to drop from the end.
+* @returns A function that maps a readonly array to the remaining prefix.
+*
+* @example
+* import { dropRight, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3, 4], dropRight(2));
+* // => [1, 2]
+*/
+function dropRight(count) {
+	return function(array) {
+		return require_dropRight.dropRight(array, count);
+	};
+}
+//#endregion
+exports.dropRight = dropRight;

package/dist/fp/array/dropRight.mjs

@@ -0,0 +1,25 @@
+import { dropRight as dropRight$1 } from "../../array/dropRight.mjs";
+//#region src/fp/array/dropRight.ts
+/**
+* Creates a function that removes a number of values from the end of an array.
+*
+* The returned function follows the main {@link dropRight} behavior and returns a new array.
+* Use it with {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @param count - The number of values to drop from the end.
+* @returns A function that maps a readonly array to the remaining prefix.
+*
+* @example
+* import { dropRight, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3, 4], dropRight(2));
+* // => [1, 2]
+*/
+function dropRight(count) {
+	return function(array) {
+		return dropRight$1(array, count);
+	};
+}
+//#endregion
+export { dropRight };

package/dist/fp/array/dropRightWhile.d.mts

@@ -0,0 +1,20 @@
+//#region src/fp/array/dropRightWhile.d.ts
+/**
+ * Creates a function that drops trailing values while a predicate returns true.
+ *
+ * The predicate is evaluated from right to left and receives the value, index, and full
+ * input array. Use the returned function with {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @param predicate - Called with each value, index, and array while dropping from the end.
+ * @returns A function that maps a readonly array to the remaining prefix.
+ *
+ * @example
+ * import { dropRightWhile, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3, 4], dropRightWhile(value => value > 2));
+ * // => [1, 2]
+ */
+declare function dropRightWhile<T>(predicate: (item: T, index: number, array: readonly T[]) => boolean): (array: readonly T[]) => T[];
+//#endregion
+export { dropRightWhile };

package/dist/fp/array/dropRightWhile.d.ts

@@ -0,0 +1,20 @@
+//#region src/fp/array/dropRightWhile.d.ts
+/**
+ * Creates a function that drops trailing values while a predicate returns true.
+ *
+ * The predicate is evaluated from right to left and receives the value, index, and full
+ * input array. Use the returned function with {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @param predicate - Called with each value, index, and array while dropping from the end.
+ * @returns A function that maps a readonly array to the remaining prefix.
+ *
+ * @example
+ * import { dropRightWhile, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3, 4], dropRightWhile(value => value > 2));
+ * // => [1, 2]
+ */
+declare function dropRightWhile<T>(predicate: (item: T, index: number, array: readonly T[]) => boolean): (array: readonly T[]) => T[];
+//#endregion
+export { dropRightWhile };

package/dist/fp/array/dropRightWhile.js

@@ -0,0 +1,25 @@
+const require_dropRightWhile = require("../../array/dropRightWhile.js");
+//#region src/fp/array/dropRightWhile.ts
+/**
+* Creates a function that drops trailing values while a predicate returns true.
+*
+* The predicate is evaluated from right to left and receives the value, index, and full
+* input array. Use the returned function with {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @param predicate - Called with each value, index, and array while dropping from the end.
+* @returns A function that maps a readonly array to the remaining prefix.
+*
+* @example
+* import { dropRightWhile, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3, 4], dropRightWhile(value => value > 2));
+* // => [1, 2]
+*/
+function dropRightWhile(predicate) {
+	return function(array) {
+		return require_dropRightWhile.dropRightWhile(array, predicate);
+	};
+}
+//#endregion
+exports.dropRightWhile = dropRightWhile;

package/dist/fp/array/dropRightWhile.mjs

@@ -0,0 +1,25 @@
+import { dropRightWhile as dropRightWhile$1 } from "../../array/dropRightWhile.mjs";
+//#region src/fp/array/dropRightWhile.ts
+/**
+* Creates a function that drops trailing values while a predicate returns true.
+*
+* The predicate is evaluated from right to left and receives the value, index, and full
+* input array. Use the returned function with {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @param predicate - Called with each value, index, and array while dropping from the end.
+* @returns A function that maps a readonly array to the remaining prefix.
+*
+* @example
+* import { dropRightWhile, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3, 4], dropRightWhile(value => value > 2));
+* // => [1, 2]
+*/
+function dropRightWhile(predicate) {
+	return function(array) {
+		return dropRightWhile$1(array, predicate);
+	};
+}
+//#endregion
+export { dropRightWhile };

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

@@ -0,0 +1,20 @@
+//#region src/fp/array/dropWhile.d.ts
+/**
+ * Creates a function that removes leading values while a predicate returns true.
+ *
+ * Once the predicate returns false, that value and all following values are
+ * emitted. The returned function is lazy-capable inside {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @param predicate - Called with each leading value and index while values are being dropped.
+ * @returns A function that maps the piped array to the remaining suffix.
+ *
+ * @example
+ * import { dropWhile, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3, 1], dropWhile(value => value < 3));
+ * // => [3, 1]
+ */
+declare function dropWhile<T>(predicate: (item: T, index: number) => boolean): (array: readonly T[]) => T[];
+//#endregion
+export { dropWhile };

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

@@ -0,0 +1,20 @@
+//#region src/fp/array/dropWhile.d.ts
+/**
+ * Creates a function that removes leading values while a predicate returns true.
+ *
+ * Once the predicate returns false, that value and all following values are
+ * emitted. The returned function is lazy-capable inside {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @param predicate - Called with each leading value and index while values are being dropped.
+ * @returns A function that maps the piped array to the remaining suffix.
+ *
+ * @example
+ * import { dropWhile, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3, 1], dropWhile(value => value < 3));
+ * // => [3, 1]
+ */
+declare function dropWhile<T>(predicate: (item: T, index: number) => boolean): (array: readonly T[]) => T[];
+//#endregion
+export { dropWhile };

package/dist/fp/array/dropWhile.js

@@ -0,0 +1,36 @@
+const require_dropWhile = require("../../array/dropWhile.js");
+const require_lazy = require("../_internal/lazy.js");
+//#region src/fp/array/dropWhile.ts
+/**
+* Creates a function that removes leading values while a predicate returns true.
+*
+* Once the predicate returns false, that value and all following values are
+* emitted. The returned function is lazy-capable inside {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @param predicate - Called with each leading value and index while values are being dropped.
+* @returns A function that maps the piped array to the remaining suffix.
+*
+* @example
+* import { dropWhile, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3, 1], dropWhile(value => value < 3));
+* // => [3, 1]
+*/
+function dropWhile(predicate) {
+	function dropWhileEager(array) {
+		return require_dropWhile.dropWhile(array, (item, index) => predicate(item, index));
+	}
+	const dropWhileLazy = (emit) => {
+		let dropping = true;
+		let index = 0;
+		return (value) => {
+			if (dropping && predicate(value, index++)) return true;
+			dropping = false;
+			return emit(value);
+		};
+	};
+	return require_lazy.combineEagerAndLazyFunctions(dropWhileEager, dropWhileLazy);
+}
+//#endregion
+exports.dropWhile = dropWhile;

package/dist/fp/array/dropWhile.mjs

@@ -0,0 +1,36 @@
+import { dropWhile as dropWhile$1 } from "../../array/dropWhile.mjs";
+import { combineEagerAndLazyFunctions } from "../_internal/lazy.mjs";
+//#region src/fp/array/dropWhile.ts
+/**
+* Creates a function that removes leading values while a predicate returns true.
+*
+* Once the predicate returns false, that value and all following values are
+* emitted. The returned function is lazy-capable inside {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @param predicate - Called with each leading value and index while values are being dropped.
+* @returns A function that maps the piped array to the remaining suffix.
+*
+* @example
+* import { dropWhile, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3, 1], dropWhile(value => value < 3));
+* // => [3, 1]
+*/
+function dropWhile(predicate) {
+	function dropWhileEager(array) {
+		return dropWhile$1(array, (item, index) => predicate(item, index));
+	}
+	const dropWhileLazy = (emit) => {
+		let dropping = true;
+		let index = 0;
+		return (value) => {
+			if (dropping && predicate(value, index++)) return true;
+			dropping = false;
+			return emit(value);
+		};
+	};
+	return combineEagerAndLazyFunctions(dropWhileEager, dropWhileLazy);
+}
+//#endregion
+export { dropWhile };

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

@@ -0,0 +1,45 @@
+//#region src/fp/array/filter.d.ts
+/**
+ * Creates a function that keeps only the elements for which `predicate` returns
+ * a truthy value, equivalent to `Array.prototype.filter`. A type predicate
+ * narrows the element type of the result. Use it with {@link pipe}.
+ *
+ * The returned function is **lazy-capable**: inside a {@link pipe} it is fused
+ * with adjacent lazy functions and runs element-by-element.
+ *
+ * @template T - The type of elements in the input array.
+ * @template S - The narrowed element type when `predicate` is a type guard.
+ * @param predicate - Called with `(value, index)` for each element; return
+ *   `true` to keep the element.
+ * @returns A function that maps a `readonly T[]` to a filtered array.
+ *
+ * @example
+ * import { pipe, filter } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3, 4], filter(x => x % 2 === 0)); // => [2, 4]
+ *
+ * @example
+ * // A type guard narrows the result type to `string[]`.
+ * pipe([1, 'a', 2, 'b'], filter((x): x is string => typeof x === 'string')); // => ['a', 'b']
+ */
+declare function filter<T, S extends T>(predicate: (value: T, index: number) => value is S): (array: readonly T[]) => S[];
+/**
+ * Creates a function that keeps only the elements for which `predicate` returns
+ * a truthy value, equivalent to `Array.prototype.filter`. Use it with {@link pipe}.
+ *
+ * The returned function is **lazy-capable**: inside a {@link pipe} it is fused
+ * with adjacent lazy functions and runs element-by-element.
+ *
+ * @template T - The type of elements in the input array.
+ * @param predicate - Called with `(value, index)` for each element; return
+ *   `true` to keep the element.
+ * @returns A function that maps a `readonly T[]` to a filtered array.
+ *
+ * @example
+ * import { pipe, filter } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3, 4], filter(x => x % 2 === 0)); // => [2, 4]
+ */
+declare function filter<T>(predicate: (value: T, index: number) => boolean): (array: readonly T[]) => T[];
+//#endregion
+export { filter };

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

@@ -0,0 +1,45 @@
+//#region src/fp/array/filter.d.ts
+/**
+ * Creates a function that keeps only the elements for which `predicate` returns
+ * a truthy value, equivalent to `Array.prototype.filter`. A type predicate
+ * narrows the element type of the result. Use it with {@link pipe}.
+ *
+ * The returned function is **lazy-capable**: inside a {@link pipe} it is fused
+ * with adjacent lazy functions and runs element-by-element.
+ *
+ * @template T - The type of elements in the input array.
+ * @template S - The narrowed element type when `predicate` is a type guard.
+ * @param predicate - Called with `(value, index)` for each element; return
+ *   `true` to keep the element.
+ * @returns A function that maps a `readonly T[]` to a filtered array.
+ *
+ * @example
+ * import { pipe, filter } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3, 4], filter(x => x % 2 === 0)); // => [2, 4]
+ *
+ * @example
+ * // A type guard narrows the result type to `string[]`.
+ * pipe([1, 'a', 2, 'b'], filter((x): x is string => typeof x === 'string')); // => ['a', 'b']
+ */
+declare function filter<T, S extends T>(predicate: (value: T, index: number) => value is S): (array: readonly T[]) => S[];
+/**
+ * Creates a function that keeps only the elements for which `predicate` returns
+ * a truthy value, equivalent to `Array.prototype.filter`. Use it with {@link pipe}.
+ *
+ * The returned function is **lazy-capable**: inside a {@link pipe} it is fused
+ * with adjacent lazy functions and runs element-by-element.
+ *
+ * @template T - The type of elements in the input array.
+ * @param predicate - Called with `(value, index)` for each element; return
+ *   `true` to keep the element.
+ * @returns A function that maps a `readonly T[]` to a filtered array.
+ *
+ * @example
+ * import { pipe, filter } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3, 4], filter(x => x % 2 === 0)); // => [2, 4]
+ */
+declare function filter<T>(predicate: (value: T, index: number) => boolean): (array: readonly T[]) => T[];
+//#endregion
+export { filter };

package/dist/fp/array/filter.js

@@ -0,0 +1,13 @@
+const require_lazy = require("../_internal/lazy.js");
+//#region src/fp/array/filter.ts
+function filter(predicate) {
+	function filterEager(array) {
+		return array.filter(predicate);
+	}
+	const filterLazy = require_lazy.createLazyFunction((value, index, emit) => {
+		if (predicate(value, index)) emit(value);
+	});
+	return require_lazy.combineEagerAndLazyFunctions(filterEager, filterLazy);
+}
+//#endregion
+exports.filter = filter;

package/dist/fp/array/filter.mjs

@@ -0,0 +1,12 @@
+import { combineEagerAndLazyFunctions, createLazyFunction } from "../_internal/lazy.mjs";
+//#region src/fp/array/filter.ts
+function filter(predicate) {
+	function filterEager(array) {
+		return array.filter(predicate);
+	}
+	return combineEagerAndLazyFunctions(filterEager, createLazyFunction((value, index, emit) => {
+		if (predicate(value, index)) emit(value);
+	}));
+}
+//#endregion
+export { filter };

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

@@ -0,0 +1,39 @@
+//#region src/fp/array/find.d.ts
+/**
+ * Creates a function that returns the first value accepted by a type guard.
+ *
+ * The predicate receives the value, index, and full input array. The returned
+ * function returns undefined when no value matches.
+ *
+ * @template T - The type of elements in the array.
+ * @template S - The narrowed element type accepted by the type guard.
+ * @param predicate - Type guard called with each value, index, and array until it returns true.
+ * @returns A function that maps a readonly array to the first matching value, or undefined.
+ *
+ * @example
+ * import { find, pipe } from 'es-toolkit/fp';
+ *
+ * const isString = (value: string | number): value is string => typeof value === 'string';
+ * pipe([1, 'a', 2], find(isString));
+ * // => 'a'
+ */
+declare function find<T, S extends T>(predicate: (value: T, index: number, array: readonly T[]) => value is S): (array: readonly T[]) => S | undefined;
+/**
+ * Creates a function that returns the first value matching a predicate.
+ *
+ * The predicate receives the value, index, and full input array. The returned
+ * function returns undefined when no value matches.
+ *
+ * @template T - The type of elements in the array.
+ * @param predicate - Predicate called with each value, index, and array until it returns true.
+ * @returns A function that maps a readonly array to the first matching value, or undefined.
+ *
+ * @example
+ * import { find, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }, { id: 2 }], find(item => item.id === 2));
+ * // => { id: 2 }
+ */
+declare function find<T>(predicate: (value: T, index: number, array: readonly T[]) => boolean): (array: readonly T[]) => T | undefined;
+//#endregion
+export { find };