es-toolkit 1.48.1 → 1.49.0

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

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

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

package/dist/fp/array/xor.js

@@ -0,0 +1,25 @@
+const require_xor = require("../../array/xor.js");
+//#region src/fp/array/xor.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]
+*/
+function xor(secondArray) {
+	return function(array) {
+		return require_xor.xor(array, secondArray);
+	};
+}
+//#endregion
+exports.xor = xor;

package/dist/fp/array/xor.mjs

@@ -0,0 +1,25 @@
+import { xor as xor$1 } from "../../array/xor.mjs";
+//#region src/fp/array/xor.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]
+*/
+function xor(secondArray) {
+	return function(array) {
+		return xor$1(array, secondArray);
+	};
+}
+//#endregion
+export { xor };

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

@@ -0,0 +1,22 @@
+//#region src/fp/array/xorBy.d.ts
+/**
+ * Creates a function that returns the symmetric difference by mapped identity.
+ *
+ * The mapper is used to decide which values appear in exactly one array, matching the main
+ * {@link xorBy} 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 compare with 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 symmetric difference.
+ *
+ * @example
+ * import { pipe, xorBy } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }, { id: 2 }], xorBy([{ id: 2 }, { id: 3 }], item => item.id));
+ * // => [{ id: 1 }, { id: 3 }]
+ */
+declare function xorBy<T, U>(secondArray: readonly T[], mapper: (item: T) => U): (array: readonly T[]) => T[];
+//#endregion
+export { xorBy };

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

@@ -0,0 +1,22 @@
+//#region src/fp/array/xorBy.d.ts
+/**
+ * Creates a function that returns the symmetric difference by mapped identity.
+ *
+ * The mapper is used to decide which values appear in exactly one array, matching the main
+ * {@link xorBy} 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 compare with 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 symmetric difference.
+ *
+ * @example
+ * import { pipe, xorBy } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }, { id: 2 }], xorBy([{ id: 2 }, { id: 3 }], item => item.id));
+ * // => [{ id: 1 }, { id: 3 }]
+ */
+declare function xorBy<T, U>(secondArray: readonly T[], mapper: (item: T) => U): (array: readonly T[]) => T[];
+//#endregion
+export { xorBy };

package/dist/fp/array/xorBy.js

@@ -0,0 +1,27 @@
+const require_xorBy = require("../../array/xorBy.js");
+//#region src/fp/array/xorBy.ts
+/**
+* Creates a function that returns the symmetric difference by mapped identity.
+*
+* The mapper is used to decide which values appear in exactly one array, matching the main
+* {@link xorBy} 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 compare with 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 symmetric difference.
+*
+* @example
+* import { pipe, xorBy } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }, { id: 2 }], xorBy([{ id: 2 }, { id: 3 }], item => item.id));
+* // => [{ id: 1 }, { id: 3 }]
+*/
+function xorBy(secondArray, mapper) {
+	return function(array) {
+		return require_xorBy.xorBy(array, secondArray, mapper);
+	};
+}
+//#endregion
+exports.xorBy = xorBy;

package/dist/fp/array/xorBy.mjs

@@ -0,0 +1,27 @@
+import { xorBy as xorBy$1 } from "../../array/xorBy.mjs";
+//#region src/fp/array/xorBy.ts
+/**
+* Creates a function that returns the symmetric difference by mapped identity.
+*
+* The mapper is used to decide which values appear in exactly one array, matching the main
+* {@link xorBy} 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 compare with 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 symmetric difference.
+*
+* @example
+* import { pipe, xorBy } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }, { id: 2 }], xorBy([{ id: 2 }, { id: 3 }], item => item.id));
+* // => [{ id: 1 }, { id: 3 }]
+*/
+function xorBy(secondArray, mapper) {
+	return function(array) {
+		return xorBy$1(array, secondArray, mapper);
+	};
+}
+//#endregion
+export { xorBy };

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

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

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

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