es-toolkit 1.48.1 → 1.49.0

package/dist/fp/_internal/lazy.js

@@ -0,0 +1,58 @@
+//#region src/fp/_internal/lazy.ts
+/**
+* Pairs an eager data-last function with a lazy transform (see
+* {@link createLazyFunction}).
+*
+* The returned function behaves exactly like `eager` when called directly. When
+* placed inside a {@link pipe}, the attached transform lets `pipe` fuse it with
+* adjacent lazy functions into a single, short-circuiting pass.
+*
+* @template Eager - The eager data-last function type.
+* @param eager - The eager `(array) => result` implementation.
+* @param lazy - The lazy transform built by {@link createLazyFunction}.
+* @param options - Set `shortCircuit: true` for functions that can end a run early.
+* @returns `eager`, augmented in place with the lazy metadata.
+*/
+function combineEagerAndLazyFunctions(eager, lazy, { shortCircuit } = {}) {
+	return Object.assign(eager, {
+		lazy,
+		shortCircuit
+	});
+}
+/**
+* Builds a {@link LazyTransform} from a per-element `step`.
+*
+* `step` receives each input `value`, its zero-based `index` within this stage,
+* and an `emit` callback that forwards a result to the next stage. Call `emit`
+* zero times (drop), once (`map`), or many times (`flatMap`). Return
+* `false` to end the run after this element (used by short-circuiting functions
+* like `take`); returning nothing continues.
+*
+* @template T - The type of values entering this stage.
+* @template U - The type of values it emits.
+* @param step - The per-element push function.
+* @returns A lazy transform that `pipe` can fuse and drive.
+*
+* @example
+* // map
+* createLazyFunction<T, U>((value, index, emit) => {
+*   emit(callback(value, index));
+* });
+*/
+function createLazyFunction(step) {
+	return (emit) => {
+		let index = 0;
+		let active = true;
+		const _emit = (value) => {
+			if (!active) return;
+			if (emit(value) === false) active = false;
+		};
+		return (value) => {
+			if (step(value, index++, _emit) === false) active = false;
+			return active;
+		};
+	};
+}
+//#endregion
+exports.combineEagerAndLazyFunctions = combineEagerAndLazyFunctions;
+exports.createLazyFunction = createLazyFunction;

package/dist/fp/_internal/lazy.mjs

@@ -0,0 +1,57 @@
+//#region src/fp/_internal/lazy.ts
+/**
+* Pairs an eager data-last function with a lazy transform (see
+* {@link createLazyFunction}).
+*
+* The returned function behaves exactly like `eager` when called directly. When
+* placed inside a {@link pipe}, the attached transform lets `pipe` fuse it with
+* adjacent lazy functions into a single, short-circuiting pass.
+*
+* @template Eager - The eager data-last function type.
+* @param eager - The eager `(array) => result` implementation.
+* @param lazy - The lazy transform built by {@link createLazyFunction}.
+* @param options - Set `shortCircuit: true` for functions that can end a run early.
+* @returns `eager`, augmented in place with the lazy metadata.
+*/
+function combineEagerAndLazyFunctions(eager, lazy, { shortCircuit } = {}) {
+	return Object.assign(eager, {
+		lazy,
+		shortCircuit
+	});
+}
+/**
+* Builds a {@link LazyTransform} from a per-element `step`.
+*
+* `step` receives each input `value`, its zero-based `index` within this stage,
+* and an `emit` callback that forwards a result to the next stage. Call `emit`
+* zero times (drop), once (`map`), or many times (`flatMap`). Return
+* `false` to end the run after this element (used by short-circuiting functions
+* like `take`); returning nothing continues.
+*
+* @template T - The type of values entering this stage.
+* @template U - The type of values it emits.
+* @param step - The per-element push function.
+* @returns A lazy transform that `pipe` can fuse and drive.
+*
+* @example
+* // map
+* createLazyFunction<T, U>((value, index, emit) => {
+*   emit(callback(value, index));
+* });
+*/
+function createLazyFunction(step) {
+	return (emit) => {
+		let index = 0;
+		let active = true;
+		const _emit = (value) => {
+			if (!active) return;
+			if (emit(value) === false) active = false;
+		};
+		return (value) => {
+			if (step(value, index++, _emit) === false) active = false;
+			return active;
+		};
+	};
+}
+//#endregion
+export { combineEagerAndLazyFunctions, createLazyFunction };

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

@@ -0,0 +1,20 @@
+//#region src/fp/array/at.d.ts
+/**
+ * Creates a function that retrieves elements from the piped array at the specified indices.
+ *
+ * Negative indices count back from the end of the array, matching the main {@link at}
+ * implementation. Use the returned function with {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @param indices - The indices of the elements to retrieve from the piped array.
+ * @returns A function that maps a readonly array to a new array of selected values.
+ *
+ * @example
+ * import { at, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([10, 20, 30, 40], at([1, -1]));
+ * // => [20, 40]
+ */
+declare function at<T>(indices: number[]): (array: readonly T[]) => T[];
+//#endregion
+export { at };

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

@@ -0,0 +1,20 @@
+//#region src/fp/array/at.d.ts
+/**
+ * Creates a function that retrieves elements from the piped array at the specified indices.
+ *
+ * Negative indices count back from the end of the array, matching the main {@link at}
+ * implementation. Use the returned function with {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @param indices - The indices of the elements to retrieve from the piped array.
+ * @returns A function that maps a readonly array to a new array of selected values.
+ *
+ * @example
+ * import { at, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([10, 20, 30, 40], at([1, -1]));
+ * // => [20, 40]
+ */
+declare function at<T>(indices: number[]): (array: readonly T[]) => T[];
+//#endregion
+export { at };

package/dist/fp/array/at.js

@@ -0,0 +1,25 @@
+const require_at = require("../../array/at.js");
+//#region src/fp/array/at.ts
+/**
+* Creates a function that retrieves elements from the piped array at the specified indices.
+*
+* Negative indices count back from the end of the array, matching the main {@link at}
+* implementation. Use the returned function with {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @param indices - The indices of the elements to retrieve from the piped array.
+* @returns A function that maps a readonly array to a new array of selected values.
+*
+* @example
+* import { at, pipe } from 'es-toolkit/fp';
+*
+* pipe([10, 20, 30, 40], at([1, -1]));
+* // => [20, 40]
+*/
+function at(indices) {
+	return function(array) {
+		return require_at.at(array, indices);
+	};
+}
+//#endregion
+exports.at = at;

package/dist/fp/array/at.mjs

@@ -0,0 +1,25 @@
+import { at as at$1 } from "../../array/at.mjs";
+//#region src/fp/array/at.ts
+/**
+* Creates a function that retrieves elements from the piped array at the specified indices.
+*
+* Negative indices count back from the end of the array, matching the main {@link at}
+* implementation. Use the returned function with {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @param indices - The indices of the elements to retrieve from the piped array.
+* @returns A function that maps a readonly array to a new array of selected values.
+*
+* @example
+* import { at, pipe } from 'es-toolkit/fp';
+*
+* pipe([10, 20, 30, 40], at([1, -1]));
+* // => [20, 40]
+*/
+function at(indices) {
+	return function(array) {
+		return at$1(array, indices);
+	};
+}
+//#endregion
+export { at };

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

@@ -0,0 +1,61 @@
+//#region src/fp/array/cartesianProduct.d.ts
+/**
+ * Creates a function that wraps each element of the piped array in a one-item tuple.
+ *
+ * @template T - The type of elements in the piped array.
+ * @returns A function that maps the piped array to one-item cartesian product tuples.
+ *
+ * @example
+ * import { cartesianProduct, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2], cartesianProduct());
+ * // => [[1], [2]]
+ */
+declare function cartesianProduct<T>(): (array: readonly T[]) => Array<[T]>;
+/**
+ * Creates a function that computes the cartesian product of the piped array and one configured array.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template U - The type of elements in the configured array.
+ * @param arr2 - The second array in the cartesian product.
+ * @returns A function that maps the piped array to two-item cartesian product tuples.
+ *
+ * @example
+ * pipe([1, 2], cartesianProduct(['a', 'b']));
+ * // => [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
+ */
+declare function cartesianProduct<T, U>(arr2: readonly U[]): (array: readonly T[]) => Array<[T, U]>;
+/**
+ * Creates a function that computes the cartesian product of the piped array and two configured arrays.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template U - The type of elements in the second array.
+ * @template V - The type of elements in the third array.
+ * @param arr2 - The second array in the cartesian product.
+ * @param arr3 - The third array in the cartesian product.
+ * @returns A function that maps the piped array to three-item cartesian product tuples.
+ */
+declare function cartesianProduct<T, U, V>(arr2: readonly U[], arr3: readonly V[]): (array: readonly T[]) => Array<[T, U, V]>;
+/**
+ * Creates a function that computes the cartesian product of the piped array and three configured arrays.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template U - The type of elements in the second array.
+ * @template V - The type of elements in the third array.
+ * @template W - The type of elements in the fourth array.
+ * @param arr2 - The second array in the cartesian product.
+ * @param arr3 - The third array in the cartesian product.
+ * @param arr4 - The fourth array in the cartesian product.
+ * @returns A function that maps the piped array to four-item cartesian product tuples.
+ */
+declare function cartesianProduct<T, U, V, W>(arr2: readonly U[], arr3: readonly V[], arr4: readonly W[]): (array: readonly T[]) => Array<[T, U, V, W]>;
+/**
+ * Creates a function that computes the cartesian product of the piped array and any number of configured arrays.
+ *
+ * @template T - The shared element type of the arrays.
+ * @param arrs - Additional arrays included in the cartesian product.
+ * @returns A function that maps the piped array to cartesian product rows.
+ */
+declare function cartesianProduct<T>(...arrs: Array<readonly T[]>): (array: readonly T[]) => T[][];
+//#endregion
+export { cartesianProduct };

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

@@ -0,0 +1,61 @@
+//#region src/fp/array/cartesianProduct.d.ts
+/**
+ * Creates a function that wraps each element of the piped array in a one-item tuple.
+ *
+ * @template T - The type of elements in the piped array.
+ * @returns A function that maps the piped array to one-item cartesian product tuples.
+ *
+ * @example
+ * import { cartesianProduct, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2], cartesianProduct());
+ * // => [[1], [2]]
+ */
+declare function cartesianProduct<T>(): (array: readonly T[]) => Array<[T]>;
+/**
+ * Creates a function that computes the cartesian product of the piped array and one configured array.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template U - The type of elements in the configured array.
+ * @param arr2 - The second array in the cartesian product.
+ * @returns A function that maps the piped array to two-item cartesian product tuples.
+ *
+ * @example
+ * pipe([1, 2], cartesianProduct(['a', 'b']));
+ * // => [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
+ */
+declare function cartesianProduct<T, U>(arr2: readonly U[]): (array: readonly T[]) => Array<[T, U]>;
+/**
+ * Creates a function that computes the cartesian product of the piped array and two configured arrays.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template U - The type of elements in the second array.
+ * @template V - The type of elements in the third array.
+ * @param arr2 - The second array in the cartesian product.
+ * @param arr3 - The third array in the cartesian product.
+ * @returns A function that maps the piped array to three-item cartesian product tuples.
+ */
+declare function cartesianProduct<T, U, V>(arr2: readonly U[], arr3: readonly V[]): (array: readonly T[]) => Array<[T, U, V]>;
+/**
+ * Creates a function that computes the cartesian product of the piped array and three configured arrays.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template U - The type of elements in the second array.
+ * @template V - The type of elements in the third array.
+ * @template W - The type of elements in the fourth array.
+ * @param arr2 - The second array in the cartesian product.
+ * @param arr3 - The third array in the cartesian product.
+ * @param arr4 - The fourth array in the cartesian product.
+ * @returns A function that maps the piped array to four-item cartesian product tuples.
+ */
+declare function cartesianProduct<T, U, V, W>(arr2: readonly U[], arr3: readonly V[], arr4: readonly W[]): (array: readonly T[]) => Array<[T, U, V, W]>;
+/**
+ * Creates a function that computes the cartesian product of the piped array and any number of configured arrays.
+ *
+ * @template T - The shared element type of the arrays.
+ * @param arrs - Additional arrays included in the cartesian product.
+ * @returns A function that maps the piped array to cartesian product rows.
+ */
+declare function cartesianProduct<T>(...arrs: Array<readonly T[]>): (array: readonly T[]) => T[][];
+//#endregion
+export { cartesianProduct };

package/dist/fp/array/cartesianProduct.js

@@ -0,0 +1,9 @@
+const require_cartesianProduct = require("../../array/cartesianProduct.js");
+//#region src/fp/array/cartesianProduct.ts
+function cartesianProduct(...arrs) {
+	return function(array) {
+		return require_cartesianProduct.cartesianProduct(array, ...arrs);
+	};
+}
+//#endregion
+exports.cartesianProduct = cartesianProduct;

package/dist/fp/array/cartesianProduct.mjs

@@ -0,0 +1,9 @@
+import { cartesianProduct as cartesianProduct$1 } from "../../array/cartesianProduct.mjs";
+//#region src/fp/array/cartesianProduct.ts
+function cartesianProduct(...arrs) {
+	return function(array) {
+		return cartesianProduct$1(array, ...arrs);
+	};
+}
+//#endregion
+export { cartesianProduct };

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

@@ -0,0 +1,19 @@
+//#region src/fp/array/chunk.d.ts
+/**
+ * Creates a function that splits an array into sub-arrays of length `size`. The
+ * final chunk holds the remaining elements when the array cannot be divided
+ * evenly. Use it with {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @param size - The length of each chunk. Must be a positive integer.
+ * @returns A function that maps a `readonly T[]` to a `T[][]`.
+ * @throws {Error} When `size` is not a positive integer (propagated from the underlying implementation).
+ *
+ * @example
+ * import { pipe, chunk } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3, 4, 5], chunk(2)); // => [[1, 2], [3, 4], [5]]
+ */
+declare function chunk<T>(size: number): (array: readonly T[]) => T[][];
+//#endregion
+export { chunk };

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

@@ -0,0 +1,19 @@
+//#region src/fp/array/chunk.d.ts
+/**
+ * Creates a function that splits an array into sub-arrays of length `size`. The
+ * final chunk holds the remaining elements when the array cannot be divided
+ * evenly. Use it with {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @param size - The length of each chunk. Must be a positive integer.
+ * @returns A function that maps a `readonly T[]` to a `T[][]`.
+ * @throws {Error} When `size` is not a positive integer (propagated from the underlying implementation).
+ *
+ * @example
+ * import { pipe, chunk } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3, 4, 5], chunk(2)); // => [[1, 2], [3, 4], [5]]
+ */
+declare function chunk<T>(size: number): (array: readonly T[]) => T[][];
+//#endregion
+export { chunk };

package/dist/fp/array/chunk.js

@@ -0,0 +1,24 @@
+const require_chunk = require("../../array/chunk.js");
+//#region src/fp/array/chunk.ts
+/**
+* Creates a function that splits an array into sub-arrays of length `size`. The
+* final chunk holds the remaining elements when the array cannot be divided
+* evenly. Use it with {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @param size - The length of each chunk. Must be a positive integer.
+* @returns A function that maps a `readonly T[]` to a `T[][]`.
+* @throws {Error} When `size` is not a positive integer (propagated from the underlying implementation).
+*
+* @example
+* import { pipe, chunk } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3, 4, 5], chunk(2)); // => [[1, 2], [3, 4], [5]]
+*/
+function chunk(size) {
+	return function(array) {
+		return require_chunk.chunk(array, size);
+	};
+}
+//#endregion
+exports.chunk = chunk;

package/dist/fp/array/chunk.mjs

@@ -0,0 +1,24 @@
+import { chunk as chunk$1 } from "../../array/chunk.mjs";
+//#region src/fp/array/chunk.ts
+/**
+* Creates a function that splits an array into sub-arrays of length `size`. The
+* final chunk holds the remaining elements when the array cannot be divided
+* evenly. Use it with {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @param size - The length of each chunk. Must be a positive integer.
+* @returns A function that maps a `readonly T[]` to a `T[][]`.
+* @throws {Error} When `size` is not a positive integer (propagated from the underlying implementation).
+*
+* @example
+* import { pipe, chunk } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3, 4, 5], chunk(2)); // => [[1, 2], [3, 4], [5]]
+*/
+function chunk(size) {
+	return function(array) {
+		return chunk$1(array, size);
+	};
+}
+//#endregion
+export { chunk };

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

@@ -0,0 +1,20 @@
+//#region src/fp/array/chunkBy.d.ts
+/**
+ * Creates a function that splits consecutive elements whenever the derived key changes.
+ *
+ * The iteratee is called from left to right. A new chunk starts when its key differs
+ * from the previous key by strict inequality. Use the returned function with {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @param iteratee - Called for each value to produce the comparison key.
+ * @returns A function that maps a readonly array to consecutive same-key chunks.
+ *
+ * @example
+ * import { chunkBy, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 1, 2, 3, 3], chunkBy(value => value));
+ * // => [[1, 1], [2], [3, 3]]
+ */
+declare function chunkBy<T>(iteratee: (value: T) => unknown): (array: readonly T[]) => T[][];
+//#endregion
+export { chunkBy };

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

@@ -0,0 +1,20 @@
+//#region src/fp/array/chunkBy.d.ts
+/**
+ * Creates a function that splits consecutive elements whenever the derived key changes.
+ *
+ * The iteratee is called from left to right. A new chunk starts when its key differs
+ * from the previous key by strict inequality. Use the returned function with {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @param iteratee - Called for each value to produce the comparison key.
+ * @returns A function that maps a readonly array to consecutive same-key chunks.
+ *
+ * @example
+ * import { chunkBy, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 1, 2, 3, 3], chunkBy(value => value));
+ * // => [[1, 1], [2], [3, 3]]
+ */
+declare function chunkBy<T>(iteratee: (value: T) => unknown): (array: readonly T[]) => T[][];
+//#endregion
+export { chunkBy };

package/dist/fp/array/chunkBy.js

@@ -0,0 +1,25 @@
+const require_chunkBy = require("../../array/chunkBy.js");
+//#region src/fp/array/chunkBy.ts
+/**
+* Creates a function that splits consecutive elements whenever the derived key changes.
+*
+* The iteratee is called from left to right. A new chunk starts when its key differs
+* from the previous key by strict inequality. Use the returned function with {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @param iteratee - Called for each value to produce the comparison key.
+* @returns A function that maps a readonly array to consecutive same-key chunks.
+*
+* @example
+* import { chunkBy, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, 1, 2, 3, 3], chunkBy(value => value));
+* // => [[1, 1], [2], [3, 3]]
+*/
+function chunkBy(iteratee) {
+	return function(array) {
+		return require_chunkBy.chunkBy(array, iteratee);
+	};
+}
+//#endregion
+exports.chunkBy = chunkBy;

package/dist/fp/array/chunkBy.mjs

@@ -0,0 +1,25 @@
+import { chunkBy as chunkBy$1 } from "../../array/chunkBy.mjs";
+//#region src/fp/array/chunkBy.ts
+/**
+* Creates a function that splits consecutive elements whenever the derived key changes.
+*
+* The iteratee is called from left to right. A new chunk starts when its key differs
+* from the previous key by strict inequality. Use the returned function with {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @param iteratee - Called for each value to produce the comparison key.
+* @returns A function that maps a readonly array to consecutive same-key chunks.
+*
+* @example
+* import { chunkBy, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, 1, 2, 3, 3], chunkBy(value => value));
+* // => [[1, 1], [2], [3, 3]]
+*/
+function chunkBy(iteratee) {
+	return function(array) {
+		return chunkBy$1(array, iteratee);
+	};
+}
+//#endregion
+export { chunkBy };

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

@@ -0,0 +1,21 @@
+//#region src/fp/array/combinations.d.ts
+/**
+ * Creates a function that returns every combination of the configured size.
+ *
+ * Elements are treated as unique by position, so duplicate values can produce identical-looking
+ * combinations. The returned function throws when size is not a non-negative integer.
+ *
+ * @template T - The type of elements in the array.
+ * @param size - The number of items in each combination.
+ * @returns A function that maps a readonly array to its size-length combinations.
+ * @throws {Error} When size is not a non-negative integer.
+ *
+ * @example
+ * import { combinations, pipe } from 'es-toolkit/fp';
+ *
+ * pipe(['A', 'B', 'C'], combinations(2));
+ * // => [['A', 'B'], ['A', 'C'], ['B', 'C']]
+ */
+declare function combinations<T>(size: number): (array: readonly T[]) => T[][];
+//#endregion
+export { combinations };

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

@@ -0,0 +1,21 @@
+//#region src/fp/array/combinations.d.ts
+/**
+ * Creates a function that returns every combination of the configured size.
+ *
+ * Elements are treated as unique by position, so duplicate values can produce identical-looking
+ * combinations. The returned function throws when size is not a non-negative integer.
+ *
+ * @template T - The type of elements in the array.
+ * @param size - The number of items in each combination.
+ * @returns A function that maps a readonly array to its size-length combinations.
+ * @throws {Error} When size is not a non-negative integer.
+ *
+ * @example
+ * import { combinations, pipe } from 'es-toolkit/fp';
+ *
+ * pipe(['A', 'B', 'C'], combinations(2));
+ * // => [['A', 'B'], ['A', 'C'], ['B', 'C']]
+ */
+declare function combinations<T>(size: number): (array: readonly T[]) => T[][];
+//#endregion
+export { combinations };

package/dist/fp/array/combinations.js

@@ -0,0 +1,26 @@
+const require_combinations = require("../../array/combinations.js");
+//#region src/fp/array/combinations.ts
+/**
+* Creates a function that returns every combination of the configured size.
+*
+* Elements are treated as unique by position, so duplicate values can produce identical-looking
+* combinations. The returned function throws when size is not a non-negative integer.
+*
+* @template T - The type of elements in the array.
+* @param size - The number of items in each combination.
+* @returns A function that maps a readonly array to its size-length combinations.
+* @throws {Error} When size is not a non-negative integer.
+*
+* @example
+* import { combinations, pipe } from 'es-toolkit/fp';
+*
+* pipe(['A', 'B', 'C'], combinations(2));
+* // => [['A', 'B'], ['A', 'C'], ['B', 'C']]
+*/
+function combinations(size) {
+	return function(array) {
+		return require_combinations.combinations(array, size);
+	};
+}
+//#endregion
+exports.combinations = combinations;

package/dist/fp/array/combinations.mjs

@@ -0,0 +1,26 @@
+import { combinations as combinations$1 } from "../../array/combinations.mjs";
+//#region src/fp/array/combinations.ts
+/**
+* Creates a function that returns every combination of the configured size.
+*
+* Elements are treated as unique by position, so duplicate values can produce identical-looking
+* combinations. The returned function throws when size is not a non-negative integer.
+*
+* @template T - The type of elements in the array.
+* @param size - The number of items in each combination.
+* @returns A function that maps a readonly array to its size-length combinations.
+* @throws {Error} When size is not a non-negative integer.
+*
+* @example
+* import { combinations, pipe } from 'es-toolkit/fp';
+*
+* pipe(['A', 'B', 'C'], combinations(2));
+* // => [['A', 'B'], ['A', 'C'], ['B', 'C']]
+*/
+function combinations(size) {
+	return function(array) {
+		return combinations$1(array, size);
+	};
+}
+//#endregion
+export { combinations };

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

@@ -0,0 +1,22 @@
+//#region src/fp/array/compact.d.ts
+type NotFalsey<T> = Exclude<T, false | null | 0 | 0n | '' | undefined>;
+/**
+ * Creates a function that removes falsey values from an array. Use it with {@link pipe}.
+ *
+ * Falsey values include false, null, 0, -0, 0n, an empty string, undefined,
+ * and NaN. The returned function is lazy-capable inside {@link pipe}, so a
+ * trailing short-circuiting operator such as {@link take} can stop once enough
+ * truthy values have been emitted.
+ *
+ * @template T - The type of elements in the array.
+ * @returns A function that maps a readonly array to a new array with falsey values removed.
+ *
+ * @example
+ * import { compact, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([0, 1, false, 2, '', 3], compact());
+ * // => [1, 2, 3]
+ */
+declare function compact<T>(): (array: readonly T[]) => Array<NotFalsey<T>>;
+//#endregion
+export { compact };