es-toolkit 1.48.1 → 1.49.0

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

@@ -0,0 +1,39 @@
+//#region src/fp/array/findLast.d.ts
+/**
+ * Creates a function that returns the last value accepted by a type guard.
+ *
+ * The predicate receives the value, index, and full input array while scanning
+ * from right to left. 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 from right to left.
+ * @returns A function that maps a readonly array to the last matching value, or undefined.
+ *
+ * @example
+ * import { findLast, pipe } from 'es-toolkit/fp';
+ *
+ * const isString = (value: string | number): value is string => typeof value === 'string';
+ * pipe([1, 'a', 2, 'b'], findLast(isString));
+ * // => 'b'
+ */
+declare function findLast<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 last value matching a predicate.
+ *
+ * The predicate receives the value, index, and full input array while scanning
+ * from right to left. 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 from right to left.
+ * @returns A function that maps a readonly array to the last matching value, or undefined.
+ *
+ * @example
+ * import { findLast, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }, { id: 2 }, { id: 1 }], findLast(item => item.id === 1));
+ * // => { id: 1 }
+ */
+declare function findLast<T>(predicate: (value: T, index: number, array: readonly T[]) => boolean): (array: readonly T[]) => T | undefined;
+//#endregion
+export { findLast };

package/dist/fp/array/findLast.js

@@ -0,0 +1,11 @@
+//#region src/fp/array/findLast.ts
+function findLast(predicate) {
+	return function(array) {
+		for (let index = array.length - 1; index >= 0; index--) {
+			const value = array[index];
+			if (predicate(value, index, array)) return value;
+		}
+	};
+}
+//#endregion
+exports.findLast = findLast;

package/dist/fp/array/findLast.mjs

@@ -0,0 +1,11 @@
+//#region src/fp/array/findLast.ts
+function findLast(predicate) {
+	return function(array) {
+		for (let index = array.length - 1; index >= 0; index--) {
+			const value = array[index];
+			if (predicate(value, index, array)) return value;
+		}
+	};
+}
+//#endregion
+export { findLast };

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

@@ -0,0 +1,20 @@
+//#region src/fp/array/findLastIndex.d.ts
+/**
+ * Creates a function that returns the index of the last value matching a predicate.
+ *
+ * The predicate receives the value, index, and full input array while scanning from right
+ * to left. The returned function returns -1 when no value matches.
+ *
+ * @template T - The type of elements in the array.
+ * @param predicate - Called with each value, index, and array from right to left until it returns true.
+ * @returns A function that maps a readonly array to the last matching index, or -1.
+ *
+ * @example
+ * import { findLastIndex, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3, 2], findLastIndex(value => value === 2));
+ * // => 3
+ */
+declare function findLastIndex<T>(predicate: (value: T, index: number, array: readonly T[]) => boolean): (array: readonly T[]) => number;
+//#endregion
+export { findLastIndex };

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

@@ -0,0 +1,20 @@
+//#region src/fp/array/findLastIndex.d.ts
+/**
+ * Creates a function that returns the index of the last value matching a predicate.
+ *
+ * The predicate receives the value, index, and full input array while scanning from right
+ * to left. The returned function returns -1 when no value matches.
+ *
+ * @template T - The type of elements in the array.
+ * @param predicate - Called with each value, index, and array from right to left until it returns true.
+ * @returns A function that maps a readonly array to the last matching index, or -1.
+ *
+ * @example
+ * import { findLastIndex, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3, 2], findLastIndex(value => value === 2));
+ * // => 3
+ */
+declare function findLastIndex<T>(predicate: (value: T, index: number, array: readonly T[]) => boolean): (array: readonly T[]) => number;
+//#endregion
+export { findLastIndex };

package/dist/fp/array/findLastIndex.js

@@ -0,0 +1,25 @@
+//#region src/fp/array/findLastIndex.ts
+/**
+* Creates a function that returns the index of the last value matching a predicate.
+*
+* The predicate receives the value, index, and full input array while scanning from right
+* to left. The returned function returns -1 when no value matches.
+*
+* @template T - The type of elements in the array.
+* @param predicate - Called with each value, index, and array from right to left until it returns true.
+* @returns A function that maps a readonly array to the last matching index, or -1.
+*
+* @example
+* import { findLastIndex, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3, 2], findLastIndex(value => value === 2));
+* // => 3
+*/
+function findLastIndex(predicate) {
+	return function(array) {
+		for (let index = array.length - 1; index >= 0; index--) if (predicate(array[index], index, array)) return index;
+		return -1;
+	};
+}
+//#endregion
+exports.findLastIndex = findLastIndex;

package/dist/fp/array/findLastIndex.mjs

@@ -0,0 +1,25 @@
+//#region src/fp/array/findLastIndex.ts
+/**
+* Creates a function that returns the index of the last value matching a predicate.
+*
+* The predicate receives the value, index, and full input array while scanning from right
+* to left. The returned function returns -1 when no value matches.
+*
+* @template T - The type of elements in the array.
+* @param predicate - Called with each value, index, and array from right to left until it returns true.
+* @returns A function that maps a readonly array to the last matching index, or -1.
+*
+* @example
+* import { findLastIndex, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3, 2], findLastIndex(value => value === 2));
+* // => 3
+*/
+function findLastIndex(predicate) {
+	return function(array) {
+		for (let index = array.length - 1; index >= 0; index--) if (predicate(array[index], index, array)) return index;
+		return -1;
+	};
+}
+//#endregion
+export { findLastIndex };

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

@@ -0,0 +1,28 @@
+//#region src/fp/array/flatMap.d.ts
+/**
+ * Creates a function that maps every element to an array with `callback` and
+ * concatenates the results, equivalent to `Array.prototype.flatMap`. 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, so a trailing
+ * `take` can terminate the walk early without expanding the rest of the input.
+ *
+ * @template T - The type of elements in the input array.
+ * @template U - The type of elements in the output array.
+ * @param callback - Called with `(value, index)` for each element; returns an
+ *   array whose elements are flattened into the output.
+ * @returns A function that maps a `readonly T[]` to a new `U[]`.
+ *
+ * @example
+ * import { pipe, flatMap } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3], flatMap(x => [x, x * 10])); // => [1, 10, 2, 20, 3, 30]
+ *
+ * @example
+ * // Returning an empty array drops the element.
+ * pipe([1, 2, 3, 4], flatMap(x => (x % 2 === 0 ? [x] : []))); // => [2, 4]
+ */
+declare function flatMap<T, U>(callback: (value: T, index: number) => U[]): (array: readonly T[]) => U[];
+//#endregion
+export { flatMap };

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

@@ -0,0 +1,28 @@
+//#region src/fp/array/flatMap.d.ts
+/**
+ * Creates a function that maps every element to an array with `callback` and
+ * concatenates the results, equivalent to `Array.prototype.flatMap`. 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, so a trailing
+ * `take` can terminate the walk early without expanding the rest of the input.
+ *
+ * @template T - The type of elements in the input array.
+ * @template U - The type of elements in the output array.
+ * @param callback - Called with `(value, index)` for each element; returns an
+ *   array whose elements are flattened into the output.
+ * @returns A function that maps a `readonly T[]` to a new `U[]`.
+ *
+ * @example
+ * import { pipe, flatMap } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3], flatMap(x => [x, x * 10])); // => [1, 10, 2, 20, 3, 30]
+ *
+ * @example
+ * // Returning an empty array drops the element.
+ * pipe([1, 2, 3, 4], flatMap(x => (x % 2 === 0 ? [x] : []))); // => [2, 4]
+ */
+declare function flatMap<T, U>(callback: (value: T, index: number) => U[]): (array: readonly T[]) => U[];
+//#endregion
+export { flatMap };

package/dist/fp/array/flatMap.js

@@ -0,0 +1,39 @@
+const require_flatMap = require("../../array/flatMap.js");
+const require_lazy = require("../_internal/lazy.js");
+//#region src/fp/array/flatMap.ts
+/**
+* Creates a function that maps every element to an array with `callback` and
+* concatenates the results, equivalent to `Array.prototype.flatMap`. 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, so a trailing
+* `take` can terminate the walk early without expanding the rest of the input.
+*
+* @template T - The type of elements in the input array.
+* @template U - The type of elements in the output array.
+* @param callback - Called with `(value, index)` for each element; returns an
+*   array whose elements are flattened into the output.
+* @returns A function that maps a `readonly T[]` to a new `U[]`.
+*
+* @example
+* import { pipe, flatMap } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3], flatMap(x => [x, x * 10])); // => [1, 10, 2, 20, 3, 30]
+*
+* @example
+* // Returning an empty array drops the element.
+* pipe([1, 2, 3, 4], flatMap(x => (x % 2 === 0 ? [x] : []))); // => [2, 4]
+*/
+function flatMap(callback) {
+	function flatMapEager(array) {
+		return require_flatMap.flatMap(array, callback);
+	}
+	const flatMapLazy = require_lazy.createLazyFunction((value, index, emit) => {
+		const items = callback(value, index);
+		for (let i = 0; i < items.length; i++) emit(items[i]);
+	});
+	return require_lazy.combineEagerAndLazyFunctions(flatMapEager, flatMapLazy);
+}
+//#endregion
+exports.flatMap = flatMap;

package/dist/fp/array/flatMap.mjs

@@ -0,0 +1,38 @@
+import { flatMap as flatMap$1 } from "../../array/flatMap.mjs";
+import { combineEagerAndLazyFunctions, createLazyFunction } from "../_internal/lazy.mjs";
+//#region src/fp/array/flatMap.ts
+/**
+* Creates a function that maps every element to an array with `callback` and
+* concatenates the results, equivalent to `Array.prototype.flatMap`. 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, so a trailing
+* `take` can terminate the walk early without expanding the rest of the input.
+*
+* @template T - The type of elements in the input array.
+* @template U - The type of elements in the output array.
+* @param callback - Called with `(value, index)` for each element; returns an
+*   array whose elements are flattened into the output.
+* @returns A function that maps a `readonly T[]` to a new `U[]`.
+*
+* @example
+* import { pipe, flatMap } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3], flatMap(x => [x, x * 10])); // => [1, 10, 2, 20, 3, 30]
+*
+* @example
+* // Returning an empty array drops the element.
+* pipe([1, 2, 3, 4], flatMap(x => (x % 2 === 0 ? [x] : []))); // => [2, 4]
+*/
+function flatMap(callback) {
+	function flatMapEager(array) {
+		return flatMap$1(array, callback);
+	}
+	return combineEagerAndLazyFunctions(flatMapEager, createLazyFunction((value, index, emit) => {
+		const items = callback(value, index);
+		for (let i = 0; i < items.length; i++) emit(items[i]);
+	}));
+}
+//#endregion
+export { flatMap };

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

@@ -0,0 +1,23 @@
+import { ExtractNestedArrayType } from "../../array/flattenDeep.mjs";
+
+//#region src/fp/array/flatMapDeep.d.ts
+/**
+ * Creates a function that maps each element and recursively flattens the mapped values.
+ *
+ * The iteratee receives each value and index. The returned function is lazy-capable inside
+ * {@link pipe}; a trailing short-circuiting operator can stop before later input values are mapped.
+ *
+ * @template T - The type of elements in the input array.
+ * @template U - The type returned by the iteratee before recursive flattening.
+ * @param iteratee - Called with each value and index to produce values to flatten.
+ * @returns A function that maps a readonly array to a deeply flattened array.
+ *
+ * @example
+ * import { flatMapDeep, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2], flatMapDeep(value => [[value, value * 10]]));
+ * // => [1, 10, 2, 20]
+ */
+declare function flatMapDeep<T, U>(iteratee: (item: T, index: number) => U): (array: readonly T[]) => Array<ExtractNestedArrayType<U>>;
+//#endregion
+export { flatMapDeep };

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

@@ -0,0 +1,23 @@
+import { ExtractNestedArrayType } from "../../array/flattenDeep.js";
+
+//#region src/fp/array/flatMapDeep.d.ts
+/**
+ * Creates a function that maps each element and recursively flattens the mapped values.
+ *
+ * The iteratee receives each value and index. The returned function is lazy-capable inside
+ * {@link pipe}; a trailing short-circuiting operator can stop before later input values are mapped.
+ *
+ * @template T - The type of elements in the input array.
+ * @template U - The type returned by the iteratee before recursive flattening.
+ * @param iteratee - Called with each value and index to produce values to flatten.
+ * @returns A function that maps a readonly array to a deeply flattened array.
+ *
+ * @example
+ * import { flatMapDeep, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2], flatMapDeep(value => [[value, value * 10]]));
+ * // => [1, 10, 2, 20]
+ */
+declare function flatMapDeep<T, U>(iteratee: (item: T, index: number) => U): (array: readonly T[]) => Array<ExtractNestedArrayType<U>>;
+//#endregion
+export { flatMapDeep };

package/dist/fp/array/flatMapDeep.js

@@ -0,0 +1,38 @@
+const require_flatMapDeep = require("../../array/flatMapDeep.js");
+const require_lazy = require("../_internal/lazy.js");
+//#region src/fp/array/flatMapDeep.ts
+/**
+* Creates a function that maps each element and recursively flattens the mapped values.
+*
+* The iteratee receives each value and index. The returned function is lazy-capable inside
+* {@link pipe}; a trailing short-circuiting operator can stop before later input values are mapped.
+*
+* @template T - The type of elements in the input array.
+* @template U - The type returned by the iteratee before recursive flattening.
+* @param iteratee - Called with each value and index to produce values to flatten.
+* @returns A function that maps a readonly array to a deeply flattened array.
+*
+* @example
+* import { flatMapDeep, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, 2], flatMapDeep(value => [[value, value * 10]]));
+* // => [1, 10, 2, 20]
+*/
+function flatMapDeep(iteratee) {
+	function flatMapDeepEager(array) {
+		return require_flatMapDeep.flatMapDeep(array, (item, index) => iteratee(item, index));
+	}
+	const flatMapDeepLazy = require_lazy.createLazyFunction((value, index, emit) => {
+		emitDeep(iteratee(value, index), emit);
+	});
+	return require_lazy.combineEagerAndLazyFunctions(flatMapDeepEager, flatMapDeepLazy);
+}
+function emitDeep(value, emit) {
+	if (Array.isArray(value)) {
+		for (let index = 0; index < value.length; index++) emitDeep(value[index], emit);
+		return;
+	}
+	emit(value);
+}
+//#endregion
+exports.flatMapDeep = flatMapDeep;

package/dist/fp/array/flatMapDeep.mjs

@@ -0,0 +1,37 @@
+import { flatMapDeep as flatMapDeep$1 } from "../../array/flatMapDeep.mjs";
+import { combineEagerAndLazyFunctions, createLazyFunction } from "../_internal/lazy.mjs";
+//#region src/fp/array/flatMapDeep.ts
+/**
+* Creates a function that maps each element and recursively flattens the mapped values.
+*
+* The iteratee receives each value and index. The returned function is lazy-capable inside
+* {@link pipe}; a trailing short-circuiting operator can stop before later input values are mapped.
+*
+* @template T - The type of elements in the input array.
+* @template U - The type returned by the iteratee before recursive flattening.
+* @param iteratee - Called with each value and index to produce values to flatten.
+* @returns A function that maps a readonly array to a deeply flattened array.
+*
+* @example
+* import { flatMapDeep, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, 2], flatMapDeep(value => [[value, value * 10]]));
+* // => [1, 10, 2, 20]
+*/
+function flatMapDeep(iteratee) {
+	function flatMapDeepEager(array) {
+		return flatMapDeep$1(array, (item, index) => iteratee(item, index));
+	}
+	return combineEagerAndLazyFunctions(flatMapDeepEager, createLazyFunction((value, index, emit) => {
+		emitDeep(iteratee(value, index), emit);
+	}));
+}
+function emitDeep(value, emit) {
+	if (Array.isArray(value)) {
+		for (let index = 0; index < value.length; index++) emitDeep(value[index], emit);
+		return;
+	}
+	emit(value);
+}
+//#endregion
+export { flatMapDeep };

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

@@ -0,0 +1,21 @@
+//#region src/fp/array/flatten.d.ts
+/**
+ * Creates a function that flattens an array up to the specified depth.
+ *
+ * The returned function is lazy-capable inside {@link pipe}. A trailing
+ * short-circuiting operator can stop before later nested values are visited.
+ *
+ * @template T - The type of elements in the array.
+ * @template D - The depth to which nested arrays should be flattened.
+ * @param depth - The flattening depth. Defaults to 1.
+ * @returns A function that maps the piped array to a flattened array.
+ *
+ * @example
+ * import { flatten, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, [2, [3]]], flatten(2));
+ * // => [1, 2, 3]
+ */
+declare function flatten<T, D extends number = 1>(depth?: D): (array: readonly T[]) => Array<FlatArray<T[], D>>;
+//#endregion
+export { flatten };

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

@@ -0,0 +1,21 @@
+//#region src/fp/array/flatten.d.ts
+/**
+ * Creates a function that flattens an array up to the specified depth.
+ *
+ * The returned function is lazy-capable inside {@link pipe}. A trailing
+ * short-circuiting operator can stop before later nested values are visited.
+ *
+ * @template T - The type of elements in the array.
+ * @template D - The depth to which nested arrays should be flattened.
+ * @param depth - The flattening depth. Defaults to 1.
+ * @returns A function that maps the piped array to a flattened array.
+ *
+ * @example
+ * import { flatten, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, [2, [3]]], flatten(2));
+ * // => [1, 2, 3]
+ */
+declare function flatten<T, D extends number = 1>(depth?: D): (array: readonly T[]) => Array<FlatArray<T[], D>>;
+//#endregion
+export { flatten };

package/dist/fp/array/flatten.js

@@ -0,0 +1,39 @@
+const require_flatten = require("../../array/flatten.js");
+const require_lazy = require("../_internal/lazy.js");
+//#region src/fp/array/flatten.ts
+/**
+* Creates a function that flattens an array up to the specified depth.
+*
+* The returned function is lazy-capable inside {@link pipe}. A trailing
+* short-circuiting operator can stop before later nested values are visited.
+*
+* @template T - The type of elements in the array.
+* @template D - The depth to which nested arrays should be flattened.
+* @param depth - The flattening depth. Defaults to 1.
+* @returns A function that maps the piped array to a flattened array.
+*
+* @example
+* import { flatten, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, [2, [3]]], flatten(2));
+* // => [1, 2, 3]
+*/
+function flatten(depth = 1) {
+	const flooredDepth = Math.floor(depth);
+	function flattenEager(array) {
+		return require_flatten.flatten(array, depth);
+	}
+	const flattenLazy = require_lazy.createLazyFunction((value, _index, emit) => {
+		emitFlattened(value, 0, flooredDepth, emit);
+	});
+	return require_lazy.combineEagerAndLazyFunctions(flattenEager, flattenLazy);
+}
+function emitFlattened(value, currentDepth, maxDepth, emit) {
+	if (Array.isArray(value) && currentDepth < maxDepth) {
+		for (let index = 0; index < value.length; index++) emitFlattened(value[index], currentDepth + 1, maxDepth, emit);
+		return;
+	}
+	emit(value);
+}
+//#endregion
+exports.flatten = flatten;

package/dist/fp/array/flatten.mjs

@@ -0,0 +1,38 @@
+import { flatten as flatten$1 } from "../../array/flatten.mjs";
+import { combineEagerAndLazyFunctions, createLazyFunction } from "../_internal/lazy.mjs";
+//#region src/fp/array/flatten.ts
+/**
+* Creates a function that flattens an array up to the specified depth.
+*
+* The returned function is lazy-capable inside {@link pipe}. A trailing
+* short-circuiting operator can stop before later nested values are visited.
+*
+* @template T - The type of elements in the array.
+* @template D - The depth to which nested arrays should be flattened.
+* @param depth - The flattening depth. Defaults to 1.
+* @returns A function that maps the piped array to a flattened array.
+*
+* @example
+* import { flatten, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, [2, [3]]], flatten(2));
+* // => [1, 2, 3]
+*/
+function flatten(depth = 1) {
+	const flooredDepth = Math.floor(depth);
+	function flattenEager(array) {
+		return flatten$1(array, depth);
+	}
+	return combineEagerAndLazyFunctions(flattenEager, createLazyFunction((value, _index, emit) => {
+		emitFlattened(value, 0, flooredDepth, emit);
+	}));
+}
+function emitFlattened(value, currentDepth, maxDepth, emit) {
+	if (Array.isArray(value) && currentDepth < maxDepth) {
+		for (let index = 0; index < value.length; index++) emitFlattened(value[index], currentDepth + 1, maxDepth, emit);
+		return;
+	}
+	emit(value);
+}
+//#endregion
+export { flatten };

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

@@ -0,0 +1,21 @@
+import { ExtractNestedArrayType } from "../../array/flattenDeep.mjs";
+
+//#region src/fp/array/flattenDeep.d.ts
+/**
+ * Creates a function that recursively flattens an array.
+ *
+ * The returned function is lazy-capable inside {@link pipe}. A trailing
+ * short-circuiting operator can stop before later nested values are visited.
+ *
+ * @template T - The type of elements in the array.
+ * @returns A function that maps the piped array to a deeply flattened array.
+ *
+ * @example
+ * import { flattenDeep, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, [2, [3]]], flattenDeep());
+ * // => [1, 2, 3]
+ */
+declare function flattenDeep<T>(): (array: readonly T[]) => Array<ExtractNestedArrayType<T>>;
+//#endregion
+export { flattenDeep };

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

@@ -0,0 +1,21 @@
+import { ExtractNestedArrayType } from "../../array/flattenDeep.js";
+
+//#region src/fp/array/flattenDeep.d.ts
+/**
+ * Creates a function that recursively flattens an array.
+ *
+ * The returned function is lazy-capable inside {@link pipe}. A trailing
+ * short-circuiting operator can stop before later nested values are visited.
+ *
+ * @template T - The type of elements in the array.
+ * @returns A function that maps the piped array to a deeply flattened array.
+ *
+ * @example
+ * import { flattenDeep, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, [2, [3]]], flattenDeep());
+ * // => [1, 2, 3]
+ */
+declare function flattenDeep<T>(): (array: readonly T[]) => Array<ExtractNestedArrayType<T>>;
+//#endregion
+export { flattenDeep };

package/dist/fp/array/flattenDeep.js

@@ -0,0 +1,36 @@
+const require_flattenDeep = require("../../array/flattenDeep.js");
+const require_lazy = require("../_internal/lazy.js");
+//#region src/fp/array/flattenDeep.ts
+/**
+* Creates a function that recursively flattens an array.
+*
+* The returned function is lazy-capable inside {@link pipe}. A trailing
+* short-circuiting operator can stop before later nested values are visited.
+*
+* @template T - The type of elements in the array.
+* @returns A function that maps the piped array to a deeply flattened array.
+*
+* @example
+* import { flattenDeep, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, [2, [3]]], flattenDeep());
+* // => [1, 2, 3]
+*/
+function flattenDeep() {
+	function flattenDeepEager(array) {
+		return require_flattenDeep.flattenDeep(array);
+	}
+	const flattenDeepLazy = require_lazy.createLazyFunction((value, _index, emit) => {
+		emitDeep(value, emit);
+	});
+	return require_lazy.combineEagerAndLazyFunctions(flattenDeepEager, flattenDeepLazy);
+}
+function emitDeep(value, emit) {
+	if (Array.isArray(value)) {
+		for (let index = 0; index < value.length; index++) emitDeep(value[index], emit);
+		return;
+	}
+	emit(value);
+}
+//#endregion
+exports.flattenDeep = flattenDeep;

package/dist/fp/array/flattenDeep.mjs

@@ -0,0 +1,35 @@
+import { flattenDeep as flattenDeep$1 } from "../../array/flattenDeep.mjs";
+import { combineEagerAndLazyFunctions, createLazyFunction } from "../_internal/lazy.mjs";
+//#region src/fp/array/flattenDeep.ts
+/**
+* Creates a function that recursively flattens an array.
+*
+* The returned function is lazy-capable inside {@link pipe}. A trailing
+* short-circuiting operator can stop before later nested values are visited.
+*
+* @template T - The type of elements in the array.
+* @returns A function that maps the piped array to a deeply flattened array.
+*
+* @example
+* import { flattenDeep, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, [2, [3]]], flattenDeep());
+* // => [1, 2, 3]
+*/
+function flattenDeep() {
+	function flattenDeepEager(array) {
+		return flattenDeep$1(array);
+	}
+	return combineEagerAndLazyFunctions(flattenDeepEager, createLazyFunction((value, _index, emit) => {
+		emitDeep(value, emit);
+	}));
+}
+function emitDeep(value, emit) {
+	if (Array.isArray(value)) {
+		for (let index = 0; index < value.length; index++) emitDeep(value[index], emit);
+		return;
+	}
+	emit(value);
+}
+//#endregion
+export { flattenDeep };