es-toolkit 1.48.1 → 1.49.0

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

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

package/dist/fp/array/compact.js

@@ -0,0 +1,31 @@
+const require_compact = require("../../array/compact.js");
+const require_lazy = require("../_internal/lazy.js");
+//#region src/fp/array/compact.ts
+/**
+* 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]
+*/
+function compact() {
+	function compactEager(array) {
+		return require_compact.compact(array);
+	}
+	const compactLazy = require_lazy.createLazyFunction((value, _index, emit) => {
+		if (value) emit(value);
+	});
+	return require_lazy.combineEagerAndLazyFunctions(compactEager, compactLazy);
+}
+//#endregion
+exports.compact = compact;

package/dist/fp/array/compact.mjs

@@ -0,0 +1,30 @@
+import { compact as compact$1 } from "../../array/compact.mjs";
+import { combineEagerAndLazyFunctions, createLazyFunction } from "../_internal/lazy.mjs";
+//#region src/fp/array/compact.ts
+/**
+* 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]
+*/
+function compact() {
+	function compactEager(array) {
+		return compact$1(array);
+	}
+	return combineEagerAndLazyFunctions(compactEager, createLazyFunction((value, _index, emit) => {
+		if (value) emit(value);
+	}));
+}
+//#endregion
+export { compact };

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

@@ -0,0 +1,21 @@
+//#region src/fp/array/countBy.d.ts
+/**
+ * Creates a function that counts values by a derived key.
+ *
+ * The mapper receives each value, its index, and the full input array. The returned object
+ * uses mapper results as keys and occurrence counts as values.
+ *
+ * @template T - The type of elements in the array.
+ * @template K - The property-key type produced by the mapper.
+ * @param mapper - Called with each value, index, and array to produce a key.
+ * @returns A function that maps a readonly array to counts by key.
+ *
+ * @example
+ * import { countBy, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3, 4, 5], countBy(value => (value % 2 === 0 ? 'even' : 'odd')));
+ * // => { odd: 3, even: 2 }
+ */
+declare function countBy<T, K extends PropertyKey>(mapper: (item: T, index: number, array: readonly T[]) => K): (array: readonly T[]) => Record<K, number>;
+//#endregion
+export { countBy };

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

@@ -0,0 +1,21 @@
+//#region src/fp/array/countBy.d.ts
+/**
+ * Creates a function that counts values by a derived key.
+ *
+ * The mapper receives each value, its index, and the full input array. The returned object
+ * uses mapper results as keys and occurrence counts as values.
+ *
+ * @template T - The type of elements in the array.
+ * @template K - The property-key type produced by the mapper.
+ * @param mapper - Called with each value, index, and array to produce a key.
+ * @returns A function that maps a readonly array to counts by key.
+ *
+ * @example
+ * import { countBy, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3, 4, 5], countBy(value => (value % 2 === 0 ? 'even' : 'odd')));
+ * // => { odd: 3, even: 2 }
+ */
+declare function countBy<T, K extends PropertyKey>(mapper: (item: T, index: number, array: readonly T[]) => K): (array: readonly T[]) => Record<K, number>;
+//#endregion
+export { countBy };

package/dist/fp/array/countBy.js

@@ -0,0 +1,26 @@
+const require_countBy = require("../../array/countBy.js");
+//#region src/fp/array/countBy.ts
+/**
+* Creates a function that counts values by a derived key.
+*
+* The mapper receives each value, its index, and the full input array. The returned object
+* uses mapper results as keys and occurrence counts as values.
+*
+* @template T - The type of elements in the array.
+* @template K - The property-key type produced by the mapper.
+* @param mapper - Called with each value, index, and array to produce a key.
+* @returns A function that maps a readonly array to counts by key.
+*
+* @example
+* import { countBy, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3, 4, 5], countBy(value => (value % 2 === 0 ? 'even' : 'odd')));
+* // => { odd: 3, even: 2 }
+*/
+function countBy(mapper) {
+	return function(array) {
+		return require_countBy.countBy(array, mapper);
+	};
+}
+//#endregion
+exports.countBy = countBy;

package/dist/fp/array/countBy.mjs

@@ -0,0 +1,26 @@
+import { countBy as countBy$1 } from "../../array/countBy.mjs";
+//#region src/fp/array/countBy.ts
+/**
+* Creates a function that counts values by a derived key.
+*
+* The mapper receives each value, its index, and the full input array. The returned object
+* uses mapper results as keys and occurrence counts as values.
+*
+* @template T - The type of elements in the array.
+* @template K - The property-key type produced by the mapper.
+* @param mapper - Called with each value, index, and array to produce a key.
+* @returns A function that maps a readonly array to counts by key.
+*
+* @example
+* import { countBy, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3, 4, 5], countBy(value => (value % 2 === 0 ? 'even' : 'odd')));
+* // => { odd: 3, even: 2 }
+*/
+function countBy(mapper) {
+	return function(array) {
+		return countBy$1(array, mapper);
+	};
+}
+//#endregion
+export { countBy };

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

@@ -0,0 +1,21 @@
+//#region src/fp/array/difference.d.ts
+/**
+ * Creates a function that returns values from the piped array that are not present in another array.
+ *
+ * Equality follows SameValueZero through Set membership, matching the main
+ * {@link difference} implementation. The returned function is lazy-capable
+ * inside {@link pipe}.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param secondArray - Values to exclude from the piped array.
+ * @returns A function that maps the piped array to its difference.
+ *
+ * @example
+ * import { difference, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3], difference([2, 4]));
+ * // => [1, 3]
+ */
+declare function difference<T>(secondArray: readonly T[]): (array: readonly T[]) => T[];
+//#endregion
+export { difference };

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

@@ -0,0 +1,21 @@
+//#region src/fp/array/difference.d.ts
+/**
+ * Creates a function that returns values from the piped array that are not present in another array.
+ *
+ * Equality follows SameValueZero through Set membership, matching the main
+ * {@link difference} implementation. The returned function is lazy-capable
+ * inside {@link pipe}.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param secondArray - Values to exclude from the piped array.
+ * @returns A function that maps the piped array to its difference.
+ *
+ * @example
+ * import { difference, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3], difference([2, 4]));
+ * // => [1, 3]
+ */
+declare function difference<T>(secondArray: readonly T[]): (array: readonly T[]) => T[];
+//#endregion
+export { difference };

package/dist/fp/array/difference.js

@@ -0,0 +1,32 @@
+const require_difference = require("../../array/difference.js");
+const require_lazy = require("../_internal/lazy.js");
+//#region src/fp/array/difference.ts
+/**
+* Creates a function that returns values from the piped array that are not present in another array.
+*
+* Equality follows SameValueZero through Set membership, matching the main
+* {@link difference} implementation. The returned function is lazy-capable
+* inside {@link pipe}.
+*
+* @template T - The type of elements in the arrays.
+* @param secondArray - Values to exclude from the piped array.
+* @returns A function that maps the piped array to its difference.
+*
+* @example
+* import { difference, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3], difference([2, 4]));
+* // => [1, 3]
+*/
+function difference(secondArray) {
+	const secondSet = new Set(secondArray);
+	function differenceEager(array) {
+		return require_difference.difference(array, secondArray);
+	}
+	const differenceLazy = require_lazy.createLazyFunction((value, _index, emit) => {
+		if (!secondSet.has(value)) emit(value);
+	});
+	return require_lazy.combineEagerAndLazyFunctions(differenceEager, differenceLazy);
+}
+//#endregion
+exports.difference = difference;

package/dist/fp/array/difference.mjs

@@ -0,0 +1,31 @@
+import { difference as difference$1 } from "../../array/difference.mjs";
+import { combineEagerAndLazyFunctions, createLazyFunction } from "../_internal/lazy.mjs";
+//#region src/fp/array/difference.ts
+/**
+* Creates a function that returns values from the piped array that are not present in another array.
+*
+* Equality follows SameValueZero through Set membership, matching the main
+* {@link difference} implementation. The returned function is lazy-capable
+* inside {@link pipe}.
+*
+* @template T - The type of elements in the arrays.
+* @param secondArray - Values to exclude from the piped array.
+* @returns A function that maps the piped array to its difference.
+*
+* @example
+* import { difference, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3], difference([2, 4]));
+* // => [1, 3]
+*/
+function difference(secondArray) {
+	const secondSet = new Set(secondArray);
+	function differenceEager(array) {
+		return difference$1(array, secondArray);
+	}
+	return combineEagerAndLazyFunctions(differenceEager, createLazyFunction((value, _index, emit) => {
+		if (!secondSet.has(value)) emit(value);
+	}));
+}
+//#endregion
+export { difference };

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

@@ -0,0 +1,22 @@
+//#region src/fp/array/differenceBy.d.ts
+/**
+ * Creates a function that returns values whose mapped identity is absent from another array.
+ *
+ * The mapper is applied to values from both arrays. 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 exclude from the piped array after mapping.
+ * @param mapper - Maps values from both arrays to comparison keys.
+ * @returns A function that maps the piped array to its mapped difference.
+ *
+ * @example
+ * import { differenceBy, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }, { id: 2 }], differenceBy([2], value => typeof value === 'number' ? value : value.id));
+ * // => [{ id: 1 }]
+ */
+declare function differenceBy<T, U>(secondArray: readonly U[], mapper: (value: T | U) => unknown): (array: readonly T[]) => T[];
+//#endregion
+export { differenceBy };

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

@@ -0,0 +1,22 @@
+//#region src/fp/array/differenceBy.d.ts
+/**
+ * Creates a function that returns values whose mapped identity is absent from another array.
+ *
+ * The mapper is applied to values from both arrays. 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 exclude from the piped array after mapping.
+ * @param mapper - Maps values from both arrays to comparison keys.
+ * @returns A function that maps the piped array to its mapped difference.
+ *
+ * @example
+ * import { differenceBy, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }, { id: 2 }], differenceBy([2], value => typeof value === 'number' ? value : value.id));
+ * // => [{ id: 1 }]
+ */
+declare function differenceBy<T, U>(secondArray: readonly U[], mapper: (value: T | U) => unknown): (array: readonly T[]) => T[];
+//#endregion
+export { differenceBy };

package/dist/fp/array/differenceBy.js

@@ -0,0 +1,33 @@
+const require_differenceBy = require("../../array/differenceBy.js");
+const require_lazy = require("../_internal/lazy.js");
+//#region src/fp/array/differenceBy.ts
+/**
+* Creates a function that returns values whose mapped identity is absent from another array.
+*
+* The mapper is applied to values from both arrays. 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 exclude from the piped array after mapping.
+* @param mapper - Maps values from both arrays to comparison keys.
+* @returns A function that maps the piped array to its mapped difference.
+*
+* @example
+* import { differenceBy, pipe } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }, { id: 2 }], differenceBy([2], value => typeof value === 'number' ? value : value.id));
+* // => [{ id: 1 }]
+*/
+function differenceBy(secondArray, mapper) {
+	const mappedSecondSet = new Set(secondArray.map((item) => mapper(item)));
+	function differenceByEager(array) {
+		return require_differenceBy.differenceBy(array, secondArray, mapper);
+	}
+	const differenceByLazy = require_lazy.createLazyFunction((value, _index, emit) => {
+		if (!mappedSecondSet.has(mapper(value))) emit(value);
+	});
+	return require_lazy.combineEagerAndLazyFunctions(differenceByEager, differenceByLazy);
+}
+//#endregion
+exports.differenceBy = differenceBy;

package/dist/fp/array/differenceBy.mjs

@@ -0,0 +1,32 @@
+import { differenceBy as differenceBy$1 } from "../../array/differenceBy.mjs";
+import { combineEagerAndLazyFunctions, createLazyFunction } from "../_internal/lazy.mjs";
+//#region src/fp/array/differenceBy.ts
+/**
+* Creates a function that returns values whose mapped identity is absent from another array.
+*
+* The mapper is applied to values from both arrays. 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 exclude from the piped array after mapping.
+* @param mapper - Maps values from both arrays to comparison keys.
+* @returns A function that maps the piped array to its mapped difference.
+*
+* @example
+* import { differenceBy, pipe } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }, { id: 2 }], differenceBy([2], value => typeof value === 'number' ? value : value.id));
+* // => [{ id: 1 }]
+*/
+function differenceBy(secondArray, mapper) {
+	const mappedSecondSet = new Set(secondArray.map((item) => mapper(item)));
+	function differenceByEager(array) {
+		return differenceBy$1(array, secondArray, mapper);
+	}
+	return combineEagerAndLazyFunctions(differenceByEager, createLazyFunction((value, _index, emit) => {
+		if (!mappedSecondSet.has(mapper(value))) emit(value);
+	}));
+}
+//#endregion
+export { differenceBy };

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

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