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

package/dist/fp/array/takeWhile.js

@@ -0,0 +1,32 @@
+const require_takeWhile = require("../../array/takeWhile.js");
+const require_lazy = require("../_internal/lazy.js");
+//#region src/fp/array/takeWhile.ts
+/**
+* Creates a function that takes leading values while a predicate returns true.
+*
+* The returned function is lazy-capable and short-circuiting inside
+* {@link pipe}; once the predicate returns false, upstream lazy operators stop
+* processing further input.
+*
+* @template T - The type of elements in the array.
+* @param predicate - Called with each value and index until it returns false.
+* @returns A function that maps the piped array to the matching prefix.
+*
+* @example
+* import { pipe, takeWhile } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3, 1], takeWhile(value => value < 3));
+* // => [1, 2]
+*/
+function takeWhile(predicate) {
+	function takeWhileEager(array) {
+		return require_takeWhile.takeWhile(array, (element, index) => predicate(element, index));
+	}
+	const takeWhileLazy = require_lazy.createLazyFunction((value, index, emit) => {
+		if (!predicate(value, index)) return false;
+		emit(value);
+	});
+	return require_lazy.combineEagerAndLazyFunctions(takeWhileEager, takeWhileLazy, { shortCircuit: true });
+}
+//#endregion
+exports.takeWhile = takeWhile;

package/dist/fp/array/takeWhile.mjs

@@ -0,0 +1,31 @@
+import { takeWhile as takeWhile$1 } from "../../array/takeWhile.mjs";
+import { combineEagerAndLazyFunctions, createLazyFunction } from "../_internal/lazy.mjs";
+//#region src/fp/array/takeWhile.ts
+/**
+* Creates a function that takes leading values while a predicate returns true.
+*
+* The returned function is lazy-capable and short-circuiting inside
+* {@link pipe}; once the predicate returns false, upstream lazy operators stop
+* processing further input.
+*
+* @template T - The type of elements in the array.
+* @param predicate - Called with each value and index until it returns false.
+* @returns A function that maps the piped array to the matching prefix.
+*
+* @example
+* import { pipe, takeWhile } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3, 1], takeWhile(value => value < 3));
+* // => [1, 2]
+*/
+function takeWhile(predicate) {
+	function takeWhileEager(array) {
+		return takeWhile$1(array, (element, index) => predicate(element, index));
+	}
+	return combineEagerAndLazyFunctions(takeWhileEager, createLazyFunction((value, index, emit) => {
+		if (!predicate(value, index)) return false;
+		emit(value);
+	}), { shortCircuit: true });
+}
+//#endregion
+export { takeWhile };

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

@@ -0,0 +1,23 @@
+//#region src/fp/array/toFilled.d.ts
+/**
+ * Creates a function that returns a filled copy of an array.
+ *
+ * The returned function follows Array.prototype.fill indexing semantics through the main
+ * {@link toFilled} implementation and does not mutate the input array.
+ *
+ * @template T - The type of elements in the input array.
+ * @template U - The type of the fill value.
+ * @param value - The value to write into the returned array.
+ * @param start - The start index. Defaults to 0.
+ * @param end - The end index. Defaults to the array length.
+ * @returns A function that maps a readonly array to a filled copy.
+ *
+ * @example
+ * import { pipe, toFilled } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3], toFilled(0, 1));
+ * // => [1, 0, 0]
+ */
+declare function toFilled<T, U>(value: U, start?: number, end?: number): (array: readonly T[]) => Array<T | U>;
+//#endregion
+export { toFilled };

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

@@ -0,0 +1,23 @@
+//#region src/fp/array/toFilled.d.ts
+/**
+ * Creates a function that returns a filled copy of an array.
+ *
+ * The returned function follows Array.prototype.fill indexing semantics through the main
+ * {@link toFilled} implementation and does not mutate the input array.
+ *
+ * @template T - The type of elements in the input array.
+ * @template U - The type of the fill value.
+ * @param value - The value to write into the returned array.
+ * @param start - The start index. Defaults to 0.
+ * @param end - The end index. Defaults to the array length.
+ * @returns A function that maps a readonly array to a filled copy.
+ *
+ * @example
+ * import { pipe, toFilled } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3], toFilled(0, 1));
+ * // => [1, 0, 0]
+ */
+declare function toFilled<T, U>(value: U, start?: number, end?: number): (array: readonly T[]) => Array<T | U>;
+//#endregion
+export { toFilled };

package/dist/fp/array/toFilled.js

@@ -0,0 +1,30 @@
+const require_toFilled = require("../../array/toFilled.js");
+//#region src/fp/array/toFilled.ts
+/**
+* Creates a function that returns a filled copy of an array.
+*
+* The returned function follows Array.prototype.fill indexing semantics through the main
+* {@link toFilled} implementation and does not mutate the input array.
+*
+* @template T - The type of elements in the input array.
+* @template U - The type of the fill value.
+* @param value - The value to write into the returned array.
+* @param start - The start index. Defaults to 0.
+* @param end - The end index. Defaults to the array length.
+* @returns A function that maps a readonly array to a filled copy.
+*
+* @example
+* import { pipe, toFilled } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3], toFilled(0, 1));
+* // => [1, 0, 0]
+*/
+function toFilled(value, start, end) {
+	return function(array) {
+		if (start == null) return require_toFilled.toFilled(array, value);
+		if (end == null) return require_toFilled.toFilled(array, value, start);
+		return require_toFilled.toFilled(array, value, start, end);
+	};
+}
+//#endregion
+exports.toFilled = toFilled;

package/dist/fp/array/toFilled.mjs

@@ -0,0 +1,30 @@
+import { toFilled as toFilled$1 } from "../../array/toFilled.mjs";
+//#region src/fp/array/toFilled.ts
+/**
+* Creates a function that returns a filled copy of an array.
+*
+* The returned function follows Array.prototype.fill indexing semantics through the main
+* {@link toFilled} implementation and does not mutate the input array.
+*
+* @template T - The type of elements in the input array.
+* @template U - The type of the fill value.
+* @param value - The value to write into the returned array.
+* @param start - The start index. Defaults to 0.
+* @param end - The end index. Defaults to the array length.
+* @returns A function that maps a readonly array to a filled copy.
+*
+* @example
+* import { pipe, toFilled } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3], toFilled(0, 1));
+* // => [1, 0, 0]
+*/
+function toFilled(value, start, end) {
+	return function(array) {
+		if (start == null) return toFilled$1(array, value);
+		if (end == null) return toFilled$1(array, value, start);
+		return toFilled$1(array, value, start, end);
+	};
+}
+//#endregion
+export { toFilled };

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

@@ -0,0 +1,20 @@
+//#region src/fp/array/union.d.ts
+/**
+ * Creates a function that returns unique values from the piped array and secondArray.
+ *
+ * Values keep their first occurrence order, matching the main {@link union} behavior.
+ * Use the returned function with {@link pipe}.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param secondArray - Values to include after the piped array.
+ * @returns A function that maps a readonly array to its union with secondArray.
+ *
+ * @example
+ * import { pipe, union } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2], union([2, 3]));
+ * // => [1, 2, 3]
+ */
+declare function union<T>(secondArray: readonly T[]): (array: readonly T[]) => T[];
+//#endregion
+export { union };

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

@@ -0,0 +1,20 @@
+//#region src/fp/array/union.d.ts
+/**
+ * Creates a function that returns unique values from the piped array and secondArray.
+ *
+ * Values keep their first occurrence order, matching the main {@link union} behavior.
+ * Use the returned function with {@link pipe}.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param secondArray - Values to include after the piped array.
+ * @returns A function that maps a readonly array to its union with secondArray.
+ *
+ * @example
+ * import { pipe, union } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2], union([2, 3]));
+ * // => [1, 2, 3]
+ */
+declare function union<T>(secondArray: readonly T[]): (array: readonly T[]) => T[];
+//#endregion
+export { union };

package/dist/fp/array/union.js

@@ -0,0 +1,25 @@
+const require_union = require("../../array/union.js");
+//#region src/fp/array/union.ts
+/**
+* Creates a function that returns unique values from the piped array and secondArray.
+*
+* Values keep their first occurrence order, matching the main {@link union} behavior.
+* Use the returned function with {@link pipe}.
+*
+* @template T - The type of elements in the arrays.
+* @param secondArray - Values to include after the piped array.
+* @returns A function that maps a readonly array to its union with secondArray.
+*
+* @example
+* import { pipe, union } from 'es-toolkit/fp';
+*
+* pipe([1, 2], union([2, 3]));
+* // => [1, 2, 3]
+*/
+function union(secondArray) {
+	return function(array) {
+		return require_union.union(array, secondArray);
+	};
+}
+//#endregion
+exports.union = union;

package/dist/fp/array/union.mjs

@@ -0,0 +1,25 @@
+import { union as union$1 } from "../../array/union.mjs";
+//#region src/fp/array/union.ts
+/**
+* Creates a function that returns unique values from the piped array and secondArray.
+*
+* Values keep their first occurrence order, matching the main {@link union} behavior.
+* Use the returned function with {@link pipe}.
+*
+* @template T - The type of elements in the arrays.
+* @param secondArray - Values to include after the piped array.
+* @returns A function that maps a readonly array to its union with secondArray.
+*
+* @example
+* import { pipe, union } from 'es-toolkit/fp';
+*
+* pipe([1, 2], union([2, 3]));
+* // => [1, 2, 3]
+*/
+function union(secondArray) {
+	return function(array) {
+		return union$1(array, secondArray);
+	};
+}
+//#endregion
+export { union };

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

@@ -0,0 +1,22 @@
+//#region src/fp/array/unionBy.d.ts
+/**
+ * Creates a function that returns unique values by mapped identity.
+ *
+ * Values from the piped array are considered before values from secondArray. The mapper
+ * is used to compare identities, matching the main {@link unionBy} behavior.
+ *
+ * @template T - The type of elements in the arrays.
+ * @template U - The type of comparison keys returned by the mapper.
+ * @param secondArray - Values to include after the piped array.
+ * @param mapper - Called for values from both arrays to produce comparison keys.
+ * @returns A function that maps a readonly array to its union with secondArray.
+ *
+ * @example
+ * import { pipe, unionBy } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }], unionBy([{ id: 1 }, { id: 2 }], item => item.id));
+ * // => [{ id: 1 }, { id: 2 }]
+ */
+declare function unionBy<T, U>(secondArray: readonly T[], mapper: (item: T) => U): (array: readonly T[]) => T[];
+//#endregion
+export { unionBy };

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

@@ -0,0 +1,22 @@
+//#region src/fp/array/unionBy.d.ts
+/**
+ * Creates a function that returns unique values by mapped identity.
+ *
+ * Values from the piped array are considered before values from secondArray. The mapper
+ * is used to compare identities, matching the main {@link unionBy} behavior.
+ *
+ * @template T - The type of elements in the arrays.
+ * @template U - The type of comparison keys returned by the mapper.
+ * @param secondArray - Values to include after the piped array.
+ * @param mapper - Called for values from both arrays to produce comparison keys.
+ * @returns A function that maps a readonly array to its union with secondArray.
+ *
+ * @example
+ * import { pipe, unionBy } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }], unionBy([{ id: 1 }, { id: 2 }], item => item.id));
+ * // => [{ id: 1 }, { id: 2 }]
+ */
+declare function unionBy<T, U>(secondArray: readonly T[], mapper: (item: T) => U): (array: readonly T[]) => T[];
+//#endregion
+export { unionBy };

package/dist/fp/array/unionBy.js

@@ -0,0 +1,27 @@
+const require_unionBy = require("../../array/unionBy.js");
+//#region src/fp/array/unionBy.ts
+/**
+* Creates a function that returns unique values by mapped identity.
+*
+* Values from the piped array are considered before values from secondArray. The mapper
+* is used to compare identities, matching the main {@link unionBy} behavior.
+*
+* @template T - The type of elements in the arrays.
+* @template U - The type of comparison keys returned by the mapper.
+* @param secondArray - Values to include after the piped array.
+* @param mapper - Called for values from both arrays to produce comparison keys.
+* @returns A function that maps a readonly array to its union with secondArray.
+*
+* @example
+* import { pipe, unionBy } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }], unionBy([{ id: 1 }, { id: 2 }], item => item.id));
+* // => [{ id: 1 }, { id: 2 }]
+*/
+function unionBy(secondArray, mapper) {
+	return function(array) {
+		return require_unionBy.unionBy(array, secondArray, mapper);
+	};
+}
+//#endregion
+exports.unionBy = unionBy;

package/dist/fp/array/unionBy.mjs

@@ -0,0 +1,27 @@
+import { unionBy as unionBy$1 } from "../../array/unionBy.mjs";
+//#region src/fp/array/unionBy.ts
+/**
+* Creates a function that returns unique values by mapped identity.
+*
+* Values from the piped array are considered before values from secondArray. The mapper
+* is used to compare identities, matching the main {@link unionBy} behavior.
+*
+* @template T - The type of elements in the arrays.
+* @template U - The type of comparison keys returned by the mapper.
+* @param secondArray - Values to include after the piped array.
+* @param mapper - Called for values from both arrays to produce comparison keys.
+* @returns A function that maps a readonly array to its union with secondArray.
+*
+* @example
+* import { pipe, unionBy } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }], unionBy([{ id: 1 }, { id: 2 }], item => item.id));
+* // => [{ id: 1 }, { id: 2 }]
+*/
+function unionBy(secondArray, mapper) {
+	return function(array) {
+		return unionBy$1(array, secondArray, mapper);
+	};
+}
+//#endregion
+export { unionBy };

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

@@ -0,0 +1,21 @@
+//#region src/fp/array/unionWith.d.ts
+/**
+ * Creates a function that returns unique values using a custom equality function.
+ *
+ * Values from the piped array are considered before values from secondArray. The equality
+ * function decides whether two values represent the same item.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param secondArray - Values to include after the piped array.
+ * @param areItemsEqual - Returns true when two values are equal.
+ * @returns A function that maps a readonly array to its union with secondArray.
+ *
+ * @example
+ * import { pipe, unionWith } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }], unionWith([{ id: 1 }, { id: 2 }], (a, b) => a.id === b.id));
+ * // => [{ id: 1 }, { id: 2 }]
+ */
+declare function unionWith<T>(secondArray: readonly T[], areItemsEqual: (item: T, other: T) => boolean): (array: readonly T[]) => T[];
+//#endregion
+export { unionWith };

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

@@ -0,0 +1,21 @@
+//#region src/fp/array/unionWith.d.ts
+/**
+ * Creates a function that returns unique values using a custom equality function.
+ *
+ * Values from the piped array are considered before values from secondArray. The equality
+ * function decides whether two values represent the same item.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param secondArray - Values to include after the piped array.
+ * @param areItemsEqual - Returns true when two values are equal.
+ * @returns A function that maps a readonly array to its union with secondArray.
+ *
+ * @example
+ * import { pipe, unionWith } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }], unionWith([{ id: 1 }, { id: 2 }], (a, b) => a.id === b.id));
+ * // => [{ id: 1 }, { id: 2 }]
+ */
+declare function unionWith<T>(secondArray: readonly T[], areItemsEqual: (item: T, other: T) => boolean): (array: readonly T[]) => T[];
+//#endregion
+export { unionWith };

package/dist/fp/array/unionWith.js

@@ -0,0 +1,26 @@
+const require_unionWith = require("../../array/unionWith.js");
+//#region src/fp/array/unionWith.ts
+/**
+* Creates a function that returns unique values using a custom equality function.
+*
+* Values from the piped array are considered before values from secondArray. The equality
+* function decides whether two values represent the same item.
+*
+* @template T - The type of elements in the arrays.
+* @param secondArray - Values to include after the piped array.
+* @param areItemsEqual - Returns true when two values are equal.
+* @returns A function that maps a readonly array to its union with secondArray.
+*
+* @example
+* import { pipe, unionWith } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }], unionWith([{ id: 1 }, { id: 2 }], (a, b) => a.id === b.id));
+* // => [{ id: 1 }, { id: 2 }]
+*/
+function unionWith(secondArray, areItemsEqual) {
+	return function(array) {
+		return require_unionWith.unionWith(array, secondArray, areItemsEqual);
+	};
+}
+//#endregion
+exports.unionWith = unionWith;

package/dist/fp/array/unionWith.mjs

@@ -0,0 +1,26 @@
+import { unionWith as unionWith$1 } from "../../array/unionWith.mjs";
+//#region src/fp/array/unionWith.ts
+/**
+* Creates a function that returns unique values using a custom equality function.
+*
+* Values from the piped array are considered before values from secondArray. The equality
+* function decides whether two values represent the same item.
+*
+* @template T - The type of elements in the arrays.
+* @param secondArray - Values to include after the piped array.
+* @param areItemsEqual - Returns true when two values are equal.
+* @returns A function that maps a readonly array to its union with secondArray.
+*
+* @example
+* import { pipe, unionWith } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }], unionWith([{ id: 1 }, { id: 2 }], (a, b) => a.id === b.id));
+* // => [{ id: 1 }, { id: 2 }]
+*/
+function unionWith(secondArray, areItemsEqual) {
+	return function(array) {
+		return unionWith$1(array, secondArray, areItemsEqual);
+	};
+}
+//#endregion
+export { unionWith };

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

@@ -0,0 +1,21 @@
+//#region src/fp/array/uniq.d.ts
+/**
+ * Creates a function that removes duplicate values from an array, preserving
+ * the order of first occurrence. Equality follows SameValueZero, matching
+ * Set semantics. Use it with {@link pipe}.
+ *
+ * The returned function is lazy-capable inside {@link pipe}. It keeps a Set of
+ * values already emitted during each pipeline run.
+ *
+ * @template T - The type of elements in the array.
+ * @returns A function that maps a readonly array to a duplicate-free array.
+ *
+ * @example
+ * import { pipe, uniq } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 2, 3, 3, 3], uniq());
+ * // => [1, 2, 3]
+ */
+declare function uniq<T>(): (array: readonly T[]) => T[];
+//#endregion
+export { uniq };

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

@@ -0,0 +1,21 @@
+//#region src/fp/array/uniq.d.ts
+/**
+ * Creates a function that removes duplicate values from an array, preserving
+ * the order of first occurrence. Equality follows SameValueZero, matching
+ * Set semantics. Use it with {@link pipe}.
+ *
+ * The returned function is lazy-capable inside {@link pipe}. It keeps a Set of
+ * values already emitted during each pipeline run.
+ *
+ * @template T - The type of elements in the array.
+ * @returns A function that maps a readonly array to a duplicate-free array.
+ *
+ * @example
+ * import { pipe, uniq } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 2, 3, 3, 3], uniq());
+ * // => [1, 2, 3]
+ */
+declare function uniq<T>(): (array: readonly T[]) => T[];
+//#endregion
+export { uniq };

package/dist/fp/array/uniq.js

@@ -0,0 +1,36 @@
+const require_uniq = require("../../array/uniq.js");
+const require_lazy = require("../_internal/lazy.js");
+//#region src/fp/array/uniq.ts
+/**
+* Creates a function that removes duplicate values from an array, preserving
+* the order of first occurrence. Equality follows SameValueZero, matching
+* Set semantics. Use it with {@link pipe}.
+*
+* The returned function is lazy-capable inside {@link pipe}. It keeps a Set of
+* values already emitted during each pipeline run.
+*
+* @template T - The type of elements in the array.
+* @returns A function that maps a readonly array to a duplicate-free array.
+*
+* @example
+* import { pipe, uniq } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 2, 3, 3, 3], uniq());
+* // => [1, 2, 3]
+*/
+function uniq() {
+	function uniqEager(array) {
+		return require_uniq.uniq(array);
+	}
+	const uniqLazy = (emit) => {
+		const seen = /* @__PURE__ */ new Set();
+		return (value) => {
+			if (seen.has(value)) return true;
+			seen.add(value);
+			return emit(value);
+		};
+	};
+	return require_lazy.combineEagerAndLazyFunctions(uniqEager, uniqLazy);
+}
+//#endregion
+exports.uniq = uniq;

package/dist/fp/array/uniq.mjs

@@ -0,0 +1,36 @@
+import { uniq as uniq$1 } from "../../array/uniq.mjs";
+import { combineEagerAndLazyFunctions } from "../_internal/lazy.mjs";
+//#region src/fp/array/uniq.ts
+/**
+* Creates a function that removes duplicate values from an array, preserving
+* the order of first occurrence. Equality follows SameValueZero, matching
+* Set semantics. Use it with {@link pipe}.
+*
+* The returned function is lazy-capable inside {@link pipe}. It keeps a Set of
+* values already emitted during each pipeline run.
+*
+* @template T - The type of elements in the array.
+* @returns A function that maps a readonly array to a duplicate-free array.
+*
+* @example
+* import { pipe, uniq } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 2, 3, 3, 3], uniq());
+* // => [1, 2, 3]
+*/
+function uniq() {
+	function uniqEager(array) {
+		return uniq$1(array);
+	}
+	const uniqLazy = (emit) => {
+		const seen = /* @__PURE__ */ new Set();
+		return (value) => {
+			if (seen.has(value)) return true;
+			seen.add(value);
+			return emit(value);
+		};
+	};
+	return combineEagerAndLazyFunctions(uniqEager, uniqLazy);
+}
+//#endregion
+export { uniq };

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

@@ -0,0 +1,21 @@
+//#region src/fp/array/uniqBy.d.ts
+/**
+ * Creates a function that removes duplicate values by mapped identity.
+ *
+ * The first value for each mapped key is preserved. The returned function is
+ * lazy-capable inside {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @template U - The type of comparison keys returned by the mapper.
+ * @param mapper - Called with each value and index to produce a comparison key.
+ * @returns A function that maps the piped array to unique values.
+ *
+ * @example
+ * import { pipe, uniqBy } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }, { id: 1 }, { id: 2 }], uniqBy(item => item.id));
+ * // => [{ id: 1 }, { id: 2 }]
+ */
+declare function uniqBy<T, U>(mapper: (item: T, index: number) => U): (array: readonly T[]) => T[];
+//#endregion
+export { uniqBy };

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

@@ -0,0 +1,21 @@
+//#region src/fp/array/uniqBy.d.ts
+/**
+ * Creates a function that removes duplicate values by mapped identity.
+ *
+ * The first value for each mapped key is preserved. The returned function is
+ * lazy-capable inside {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @template U - The type of comparison keys returned by the mapper.
+ * @param mapper - Called with each value and index to produce a comparison key.
+ * @returns A function that maps the piped array to unique values.
+ *
+ * @example
+ * import { pipe, uniqBy } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }, { id: 1 }, { id: 2 }], uniqBy(item => item.id));
+ * // => [{ id: 1 }, { id: 2 }]
+ */
+declare function uniqBy<T, U>(mapper: (item: T, index: number) => U): (array: readonly T[]) => T[];
+//#endregion
+export { uniqBy };