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

package/dist/fp/array/uniqBy.js

@@ -0,0 +1,38 @@
+const require_uniqBy = require("../../array/uniqBy.js");
+const require_lazy = require("../_internal/lazy.js");
+//#region src/fp/array/uniqBy.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 }]
+*/
+function uniqBy(mapper) {
+	function uniqByEager(array) {
+		return require_uniqBy.uniqBy(array, (item, index) => mapper(item, index));
+	}
+	const uniqByLazy = (emit) => {
+		const seen = /* @__PURE__ */ new Set();
+		let index = 0;
+		return (value) => {
+			const key = mapper(value, index++);
+			if (seen.has(key)) return true;
+			seen.add(key);
+			return emit(value);
+		};
+	};
+	return require_lazy.combineEagerAndLazyFunctions(uniqByEager, uniqByLazy);
+}
+//#endregion
+exports.uniqBy = uniqBy;

package/dist/fp/array/uniqBy.mjs

@@ -0,0 +1,38 @@
+import { uniqBy as uniqBy$1 } from "../../array/uniqBy.mjs";
+import { combineEagerAndLazyFunctions } from "../_internal/lazy.mjs";
+//#region src/fp/array/uniqBy.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 }]
+*/
+function uniqBy(mapper) {
+	function uniqByEager(array) {
+		return uniqBy$1(array, (item, index) => mapper(item, index));
+	}
+	const uniqByLazy = (emit) => {
+		const seen = /* @__PURE__ */ new Set();
+		let index = 0;
+		return (value) => {
+			const key = mapper(value, index++);
+			if (seen.has(key)) return true;
+			seen.add(key);
+			return emit(value);
+		};
+	};
+	return combineEagerAndLazyFunctions(uniqByEager, uniqByLazy);
+}
+//#endregion
+export { uniqBy };

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

@@ -0,0 +1,20 @@
+//#region src/fp/array/uniqWith.d.ts
+/**
+ * Creates a function that removes duplicate values using a custom equality function.
+ *
+ * The first value in each equality group is preserved. The returned function is
+ * lazy-capable inside {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @param areItemsEqual - Returns true when two values should be treated as equal.
+ * @returns A function that maps the piped array to unique values.
+ *
+ * @example
+ * import { pipe, uniqWith } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }, { id: 1 }, { id: 2 }], uniqWith((a, b) => a.id === b.id));
+ * // => [{ id: 1 }, { id: 2 }]
+ */
+declare function uniqWith<T>(areItemsEqual: (item: T, other: T) => boolean): (array: readonly T[]) => T[];
+//#endregion
+export { uniqWith };

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

@@ -0,0 +1,20 @@
+//#region src/fp/array/uniqWith.d.ts
+/**
+ * Creates a function that removes duplicate values using a custom equality function.
+ *
+ * The first value in each equality group is preserved. The returned function is
+ * lazy-capable inside {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @param areItemsEqual - Returns true when two values should be treated as equal.
+ * @returns A function that maps the piped array to unique values.
+ *
+ * @example
+ * import { pipe, uniqWith } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }, { id: 1 }, { id: 2 }], uniqWith((a, b) => a.id === b.id));
+ * // => [{ id: 1 }, { id: 2 }]
+ */
+declare function uniqWith<T>(areItemsEqual: (item: T, other: T) => boolean): (array: readonly T[]) => T[];
+//#endregion
+export { uniqWith };

package/dist/fp/array/uniqWith.js

@@ -0,0 +1,35 @@
+const require_uniqWith = require("../../array/uniqWith.js");
+const require_lazy = require("../_internal/lazy.js");
+//#region src/fp/array/uniqWith.ts
+/**
+* Creates a function that removes duplicate values using a custom equality function.
+*
+* The first value in each equality group is preserved. The returned function is
+* lazy-capable inside {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @param areItemsEqual - Returns true when two values should be treated as equal.
+* @returns A function that maps the piped array to unique values.
+*
+* @example
+* import { pipe, uniqWith } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }, { id: 1 }, { id: 2 }], uniqWith((a, b) => a.id === b.id));
+* // => [{ id: 1 }, { id: 2 }]
+*/
+function uniqWith(areItemsEqual) {
+	function uniqWithEager(array) {
+		return require_uniqWith.uniqWith(array, areItemsEqual);
+	}
+	const uniqWithLazy = (emit) => {
+		const seen = [];
+		return (value) => {
+			if (seen.some((item) => areItemsEqual(item, value))) return true;
+			seen.push(value);
+			return emit(value);
+		};
+	};
+	return require_lazy.combineEagerAndLazyFunctions(uniqWithEager, uniqWithLazy);
+}
+//#endregion
+exports.uniqWith = uniqWith;

package/dist/fp/array/uniqWith.mjs

@@ -0,0 +1,35 @@
+import { uniqWith as uniqWith$1 } from "../../array/uniqWith.mjs";
+import { combineEagerAndLazyFunctions } from "../_internal/lazy.mjs";
+//#region src/fp/array/uniqWith.ts
+/**
+* Creates a function that removes duplicate values using a custom equality function.
+*
+* The first value in each equality group is preserved. The returned function is
+* lazy-capable inside {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @param areItemsEqual - Returns true when two values should be treated as equal.
+* @returns A function that maps the piped array to unique values.
+*
+* @example
+* import { pipe, uniqWith } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }, { id: 1 }, { id: 2 }], uniqWith((a, b) => a.id === b.id));
+* // => [{ id: 1 }, { id: 2 }]
+*/
+function uniqWith(areItemsEqual) {
+	function uniqWithEager(array) {
+		return uniqWith$1(array, areItemsEqual);
+	}
+	const uniqWithLazy = (emit) => {
+		const seen = [];
+		return (value) => {
+			if (seen.some((item) => areItemsEqual(item, value))) return true;
+			seen.push(value);
+			return emit(value);
+		};
+	};
+	return combineEagerAndLazyFunctions(uniqWithEager, uniqWithLazy);
+}
+//#endregion
+export { uniqWith };

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

@@ -0,0 +1,20 @@
+//#region src/fp/array/unzip.d.ts
+type Unzip<K extends unknown[]> = { [I in keyof K]: Array<K[I]> };
+/**
+ * Creates a function that unzips grouped tuples into arrays by position.
+ *
+ * The returned function is the data-last form of the main {@link unzip} utility.
+ * Use it with {@link pipe}.
+ *
+ * @template T - The tuple type inside the zipped array.
+ * @returns A function that maps zipped tuples to arrays grouped by tuple position.
+ *
+ * @example
+ * import { pipe, unzip } from 'es-toolkit/fp';
+ *
+ * pipe([[1, 'a'], [2, 'b']] as Array<[number, string]>, unzip());
+ * // => [[1, 2], ['a', 'b']]
+ */
+declare function unzip<T extends unknown[]>(): (zipped: ReadonlyArray<[...T]>) => Unzip<T>;
+//#endregion
+export { unzip };

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

@@ -0,0 +1,20 @@
+//#region src/fp/array/unzip.d.ts
+type Unzip<K extends unknown[]> = { [I in keyof K]: Array<K[I]> };
+/**
+ * Creates a function that unzips grouped tuples into arrays by position.
+ *
+ * The returned function is the data-last form of the main {@link unzip} utility.
+ * Use it with {@link pipe}.
+ *
+ * @template T - The tuple type inside the zipped array.
+ * @returns A function that maps zipped tuples to arrays grouped by tuple position.
+ *
+ * @example
+ * import { pipe, unzip } from 'es-toolkit/fp';
+ *
+ * pipe([[1, 'a'], [2, 'b']] as Array<[number, string]>, unzip());
+ * // => [[1, 2], ['a', 'b']]
+ */
+declare function unzip<T extends unknown[]>(): (zipped: ReadonlyArray<[...T]>) => Unzip<T>;
+//#endregion
+export { unzip };

package/dist/fp/array/unzip.js

@@ -0,0 +1,24 @@
+const require_unzip = require("../../array/unzip.js");
+//#region src/fp/array/unzip.ts
+/**
+* Creates a function that unzips grouped tuples into arrays by position.
+*
+* The returned function is the data-last form of the main {@link unzip} utility.
+* Use it with {@link pipe}.
+*
+* @template T - The tuple type inside the zipped array.
+* @returns A function that maps zipped tuples to arrays grouped by tuple position.
+*
+* @example
+* import { pipe, unzip } from 'es-toolkit/fp';
+*
+* pipe([[1, 'a'], [2, 'b']] as Array<[number, string]>, unzip());
+* // => [[1, 2], ['a', 'b']]
+*/
+function unzip() {
+	return function(zipped) {
+		return require_unzip.unzip(zipped);
+	};
+}
+//#endregion
+exports.unzip = unzip;

package/dist/fp/array/unzip.mjs

@@ -0,0 +1,24 @@
+import { unzip as unzip$1 } from "../../array/unzip.mjs";
+//#region src/fp/array/unzip.ts
+/**
+* Creates a function that unzips grouped tuples into arrays by position.
+*
+* The returned function is the data-last form of the main {@link unzip} utility.
+* Use it with {@link pipe}.
+*
+* @template T - The tuple type inside the zipped array.
+* @returns A function that maps zipped tuples to arrays grouped by tuple position.
+*
+* @example
+* import { pipe, unzip } from 'es-toolkit/fp';
+*
+* pipe([[1, 'a'], [2, 'b']] as Array<[number, string]>, unzip());
+* // => [[1, 2], ['a', 'b']]
+*/
+function unzip() {
+	return function(zipped) {
+		return unzip$1(zipped);
+	};
+}
+//#endregion
+export { unzip };

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

@@ -0,0 +1,21 @@
+//#region src/fp/array/unzipWith.d.ts
+/**
+ * Creates a function that unzips grouped arrays and combines values by position.
+ *
+ * Values at the same position are passed to iteratee, and its return values form the
+ * resulting array.
+ *
+ * @template T - The element type inside each grouped array.
+ * @template R - The value returned by the iteratee.
+ * @param iteratee - Called with the values at each position.
+ * @returns A function that maps grouped arrays to combined values.
+ *
+ * @example
+ * import { pipe, unzipWith } from 'es-toolkit/fp';
+ *
+ * pipe([[1, 10], [2, 20]], unzipWith((a, b) => a + b));
+ * // => [3, 30]
+ */
+declare function unzipWith<T, R>(iteratee: (...args: T[]) => R): (target: readonly T[][]) => R[];
+//#endregion
+export { unzipWith };

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

@@ -0,0 +1,21 @@
+//#region src/fp/array/unzipWith.d.ts
+/**
+ * Creates a function that unzips grouped arrays and combines values by position.
+ *
+ * Values at the same position are passed to iteratee, and its return values form the
+ * resulting array.
+ *
+ * @template T - The element type inside each grouped array.
+ * @template R - The value returned by the iteratee.
+ * @param iteratee - Called with the values at each position.
+ * @returns A function that maps grouped arrays to combined values.
+ *
+ * @example
+ * import { pipe, unzipWith } from 'es-toolkit/fp';
+ *
+ * pipe([[1, 10], [2, 20]], unzipWith((a, b) => a + b));
+ * // => [3, 30]
+ */
+declare function unzipWith<T, R>(iteratee: (...args: T[]) => R): (target: readonly T[][]) => R[];
+//#endregion
+export { unzipWith };

package/dist/fp/array/unzipWith.js

@@ -0,0 +1,26 @@
+const require_unzipWith = require("../../array/unzipWith.js");
+//#region src/fp/array/unzipWith.ts
+/**
+* Creates a function that unzips grouped arrays and combines values by position.
+*
+* Values at the same position are passed to iteratee, and its return values form the
+* resulting array.
+*
+* @template T - The element type inside each grouped array.
+* @template R - The value returned by the iteratee.
+* @param iteratee - Called with the values at each position.
+* @returns A function that maps grouped arrays to combined values.
+*
+* @example
+* import { pipe, unzipWith } from 'es-toolkit/fp';
+*
+* pipe([[1, 10], [2, 20]], unzipWith((a, b) => a + b));
+* // => [3, 30]
+*/
+function unzipWith(iteratee) {
+	return function(target) {
+		return require_unzipWith.unzipWith(target, iteratee);
+	};
+}
+//#endregion
+exports.unzipWith = unzipWith;

package/dist/fp/array/unzipWith.mjs

@@ -0,0 +1,26 @@
+import { unzipWith as unzipWith$1 } from "../../array/unzipWith.mjs";
+//#region src/fp/array/unzipWith.ts
+/**
+* Creates a function that unzips grouped arrays and combines values by position.
+*
+* Values at the same position are passed to iteratee, and its return values form the
+* resulting array.
+*
+* @template T - The element type inside each grouped array.
+* @template R - The value returned by the iteratee.
+* @param iteratee - Called with the values at each position.
+* @returns A function that maps grouped arrays to combined values.
+*
+* @example
+* import { pipe, unzipWith } from 'es-toolkit/fp';
+*
+* pipe([[1, 10], [2, 20]], unzipWith((a, b) => a + b));
+* // => [3, 30]
+*/
+function unzipWith(iteratee) {
+	return function(target) {
+		return unzipWith$1(target, iteratee);
+	};
+}
+//#endregion
+export { unzipWith };

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

@@ -0,0 +1,25 @@
+import { WindowedOptions } from "../../array/windowed.mjs";
+
+//#region src/fp/array/windowed.d.ts
+/**
+ * Creates a function that returns sliding windows from an array.
+ *
+ * By default only full windows are returned. Pass partialWindows: true to include shorter
+ * trailing windows. The full-window form is lazy-capable inside {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @param size - The size of each window. Must be a positive integer.
+ * @param step - The step between window starts. Defaults to 1.
+ * @param options - Window options.
+ * @returns A function that maps a readonly array to sliding windows.
+ * @throws {Error} When size or step is not a positive integer.
+ *
+ * @example
+ * import { pipe, windowed } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3, 4], windowed(2));
+ * // => [[1, 2], [2, 3], [3, 4]]
+ */
+declare function windowed<T>(size: number, step?: number, options?: WindowedOptions): (array: readonly T[]) => T[][];
+//#endregion
+export { windowed };

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

@@ -0,0 +1,25 @@
+import { WindowedOptions } from "../../array/windowed.js";
+
+//#region src/fp/array/windowed.d.ts
+/**
+ * Creates a function that returns sliding windows from an array.
+ *
+ * By default only full windows are returned. Pass partialWindows: true to include shorter
+ * trailing windows. The full-window form is lazy-capable inside {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @param size - The size of each window. Must be a positive integer.
+ * @param step - The step between window starts. Defaults to 1.
+ * @param options - Window options.
+ * @returns A function that maps a readonly array to sliding windows.
+ * @throws {Error} When size or step is not a positive integer.
+ *
+ * @example
+ * import { pipe, windowed } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3, 4], windowed(2));
+ * // => [[1, 2], [2, 3], [3, 4]]
+ */
+declare function windowed<T>(size: number, step?: number, options?: WindowedOptions): (array: readonly T[]) => T[][];
+//#endregion
+export { windowed };

package/dist/fp/array/windowed.js

@@ -0,0 +1,50 @@
+const require_windowed = require("../../array/windowed.js");
+const require_lazy = require("../_internal/lazy.js");
+//#region src/fp/array/windowed.ts
+/**
+* Creates a function that returns sliding windows from an array.
+*
+* By default only full windows are returned. Pass partialWindows: true to include shorter
+* trailing windows. The full-window form is lazy-capable inside {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @param size - The size of each window. Must be a positive integer.
+* @param step - The step between window starts. Defaults to 1.
+* @param options - Window options.
+* @returns A function that maps a readonly array to sliding windows.
+* @throws {Error} When size or step is not a positive integer.
+*
+* @example
+* import { pipe, windowed } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3, 4], windowed(2));
+* // => [[1, 2], [2, 3], [3, 4]]
+*/
+function windowed(size, step, options) {
+	const resolvedStep = step ?? 1;
+	const partialWindows = options?.partialWindows ?? false;
+	function windowedEager(array) {
+		return require_windowed.windowed(array, size, step, options);
+	}
+	if (partialWindows || !Number.isInteger(size) || size <= 0 || !Number.isInteger(resolvedStep) || resolvedStep <= 0) return windowedEager;
+	const windowedLazy = (emit) => {
+		const buffer = [];
+		let index = 0;
+		return (value) => {
+			buffer.push(value);
+			if (buffer.length > size) buffer.shift();
+			if (buffer.length === size) {
+				if ((index - size + 1) % resolvedStep === 0) {
+					const shouldContinue = emit(buffer.slice());
+					index++;
+					return shouldContinue;
+				}
+			}
+			index++;
+			return true;
+		};
+	};
+	return require_lazy.combineEagerAndLazyFunctions(windowedEager, windowedLazy);
+}
+//#endregion
+exports.windowed = windowed;

package/dist/fp/array/windowed.mjs

@@ -0,0 +1,50 @@
+import { windowed as windowed$1 } from "../../array/windowed.mjs";
+import { combineEagerAndLazyFunctions } from "../_internal/lazy.mjs";
+//#region src/fp/array/windowed.ts
+/**
+* Creates a function that returns sliding windows from an array.
+*
+* By default only full windows are returned. Pass partialWindows: true to include shorter
+* trailing windows. The full-window form is lazy-capable inside {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @param size - The size of each window. Must be a positive integer.
+* @param step - The step between window starts. Defaults to 1.
+* @param options - Window options.
+* @returns A function that maps a readonly array to sliding windows.
+* @throws {Error} When size or step is not a positive integer.
+*
+* @example
+* import { pipe, windowed } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3, 4], windowed(2));
+* // => [[1, 2], [2, 3], [3, 4]]
+*/
+function windowed(size, step, options) {
+	const resolvedStep = step ?? 1;
+	const partialWindows = options?.partialWindows ?? false;
+	function windowedEager(array) {
+		return windowed$1(array, size, step, options);
+	}
+	if (partialWindows || !Number.isInteger(size) || size <= 0 || !Number.isInteger(resolvedStep) || resolvedStep <= 0) return windowedEager;
+	const windowedLazy = (emit) => {
+		const buffer = [];
+		let index = 0;
+		return (value) => {
+			buffer.push(value);
+			if (buffer.length > size) buffer.shift();
+			if (buffer.length === size) {
+				if ((index - size + 1) % resolvedStep === 0) {
+					const shouldContinue = emit(buffer.slice());
+					index++;
+					return shouldContinue;
+				}
+			}
+			index++;
+			return true;
+		};
+	};
+	return combineEagerAndLazyFunctions(windowedEager, windowedLazy);
+}
+//#endregion
+export { windowed };

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

@@ -0,0 +1,19 @@
+//#region src/fp/array/without.d.ts
+/**
+ * Creates a function that removes the configured values from an array.
+ *
+ * The returned function is lazy-capable inside {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @param values - Values to remove from the piped array.
+ * @returns A function that maps the piped array to the remaining values.
+ *
+ * @example
+ * import { pipe, without } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3, 2], without(2));
+ * // => [1, 3]
+ */
+declare function without<T>(...values: T[]): (array: readonly T[]) => T[];
+//#endregion
+export { without };

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

@@ -0,0 +1,19 @@
+//#region src/fp/array/without.d.ts
+/**
+ * Creates a function that removes the configured values from an array.
+ *
+ * The returned function is lazy-capable inside {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @param values - Values to remove from the piped array.
+ * @returns A function that maps the piped array to the remaining values.
+ *
+ * @example
+ * import { pipe, without } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3, 2], without(2));
+ * // => [1, 3]
+ */
+declare function without<T>(...values: T[]): (array: readonly T[]) => T[];
+//#endregion
+export { without };

package/dist/fp/array/without.js

@@ -0,0 +1,30 @@
+const require_without = require("../../array/without.js");
+const require_lazy = require("../_internal/lazy.js");
+//#region src/fp/array/without.ts
+/**
+* Creates a function that removes the configured values from an array.
+*
+* The returned function is lazy-capable inside {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @param values - Values to remove from the piped array.
+* @returns A function that maps the piped array to the remaining values.
+*
+* @example
+* import { pipe, without } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3, 2], without(2));
+* // => [1, 3]
+*/
+function without(...values) {
+	const valueSet = new Set(values);
+	function withoutEager(array) {
+		return require_without.without(array, ...values);
+	}
+	const withoutLazy = require_lazy.createLazyFunction((value, _index, emit) => {
+		if (!valueSet.has(value)) emit(value);
+	});
+	return require_lazy.combineEagerAndLazyFunctions(withoutEager, withoutLazy);
+}
+//#endregion
+exports.without = without;

package/dist/fp/array/without.mjs

@@ -0,0 +1,29 @@
+import { without as without$1 } from "../../array/without.mjs";
+import { combineEagerAndLazyFunctions, createLazyFunction } from "../_internal/lazy.mjs";
+//#region src/fp/array/without.ts
+/**
+* Creates a function that removes the configured values from an array.
+*
+* The returned function is lazy-capable inside {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @param values - Values to remove from the piped array.
+* @returns A function that maps the piped array to the remaining values.
+*
+* @example
+* import { pipe, without } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3, 2], without(2));
+* // => [1, 3]
+*/
+function without(...values) {
+	const valueSet = new Set(values);
+	function withoutEager(array) {
+		return without$1(array, ...values);
+	}
+	return combineEagerAndLazyFunctions(withoutEager, createLazyFunction((value, _index, emit) => {
+		if (!valueSet.has(value)) emit(value);
+	}));
+}
+//#endregion
+export { without };

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

@@ -0,0 +1,20 @@
+//#region src/fp/array/xor.d.ts
+/**
+ * Creates a function that returns the symmetric difference with secondArray.
+ *
+ * The result contains values that appear in exactly one of the arrays, matching the main
+ * {@link xor} behavior.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param secondArray - Values to compare with the piped array.
+ * @returns A function that maps a readonly array to its symmetric difference.
+ *
+ * @example
+ * import { pipe, xor } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2], xor([2, 3]));
+ * // => [1, 3]
+ */
+declare function xor<T>(secondArray: readonly T[]): (array: readonly T[]) => T[];
+//#endregion
+export { xor };