es-toolkit 1.48.1 → 1.49.0

package/dist/fp/array/xorWith.js

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

package/dist/fp/array/xorWith.mjs

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

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

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

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

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

package/dist/fp/array/zip.js

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

package/dist/fp/array/zip.mjs

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

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

@@ -0,0 +1,21 @@
+//#region src/fp/array/zipObject.d.ts
+/**
+ * Creates a function that builds an object from the piped keys and configured values.
+ *
+ * Keys are read from the piped array and paired with values by index, matching the main
+ * {@link zipObject} behavior.
+ *
+ * @template P - The property-key type from the piped keys.
+ * @template V - The type of configured values.
+ * @param values - Values assigned to the piped keys by index.
+ * @returns A function that maps keys to an object.
+ *
+ * @example
+ * import { pipe, zipObject } from 'es-toolkit/fp';
+ *
+ * pipe(['a', 'b'] as const, zipObject([1, 2]));
+ * // => { a: 1, b: 2 }
+ */
+declare function zipObject<P extends PropertyKey, V>(values: readonly V[]): (keys: readonly P[]) => Record<P, V>;
+//#endregion
+export { zipObject };

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

@@ -0,0 +1,21 @@
+//#region src/fp/array/zipObject.d.ts
+/**
+ * Creates a function that builds an object from the piped keys and configured values.
+ *
+ * Keys are read from the piped array and paired with values by index, matching the main
+ * {@link zipObject} behavior.
+ *
+ * @template P - The property-key type from the piped keys.
+ * @template V - The type of configured values.
+ * @param values - Values assigned to the piped keys by index.
+ * @returns A function that maps keys to an object.
+ *
+ * @example
+ * import { pipe, zipObject } from 'es-toolkit/fp';
+ *
+ * pipe(['a', 'b'] as const, zipObject([1, 2]));
+ * // => { a: 1, b: 2 }
+ */
+declare function zipObject<P extends PropertyKey, V>(values: readonly V[]): (keys: readonly P[]) => Record<P, V>;
+//#endregion
+export { zipObject };

package/dist/fp/array/zipObject.js

@@ -0,0 +1,26 @@
+const require_zipObject = require("../../array/zipObject.js");
+//#region src/fp/array/zipObject.ts
+/**
+* Creates a function that builds an object from the piped keys and configured values.
+*
+* Keys are read from the piped array and paired with values by index, matching the main
+* {@link zipObject} behavior.
+*
+* @template P - The property-key type from the piped keys.
+* @template V - The type of configured values.
+* @param values - Values assigned to the piped keys by index.
+* @returns A function that maps keys to an object.
+*
+* @example
+* import { pipe, zipObject } from 'es-toolkit/fp';
+*
+* pipe(['a', 'b'] as const, zipObject([1, 2]));
+* // => { a: 1, b: 2 }
+*/
+function zipObject(values) {
+	return function(keys) {
+		return require_zipObject.zipObject(keys, values);
+	};
+}
+//#endregion
+exports.zipObject = zipObject;

package/dist/fp/array/zipObject.mjs

@@ -0,0 +1,26 @@
+import { zipObject as zipObject$1 } from "../../array/zipObject.mjs";
+//#region src/fp/array/zipObject.ts
+/**
+* Creates a function that builds an object from the piped keys and configured values.
+*
+* Keys are read from the piped array and paired with values by index, matching the main
+* {@link zipObject} behavior.
+*
+* @template P - The property-key type from the piped keys.
+* @template V - The type of configured values.
+* @param values - Values assigned to the piped keys by index.
+* @returns A function that maps keys to an object.
+*
+* @example
+* import { pipe, zipObject } from 'es-toolkit/fp';
+*
+* pipe(['a', 'b'] as const, zipObject([1, 2]));
+* // => { a: 1, b: 2 }
+*/
+function zipObject(values) {
+	return function(keys) {
+		return zipObject$1(keys, values);
+	};
+}
+//#endregion
+export { zipObject };

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

@@ -0,0 +1,57 @@
+//#region src/fp/array/zipWith.d.ts
+/**
+ * Creates a function that maps each value in the piped array with its index.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template R - The type returned by the combiner.
+ * @param combine - Called with each value and index.
+ * @returns A function that maps the piped array to combined values.
+ *
+ * @example
+ * import { pipe, zipWith } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2], zipWith((value, index) => value + index));
+ * // => [1, 3]
+ */
+declare function zipWith<T, R>(combine: (item: T, index: number) => R): (array: readonly T[]) => R[];
+/**
+ * Creates a function that zips the piped array with one configured array and combines each group.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template U - The type of elements in the configured array.
+ * @template R - The type returned by the combiner.
+ * @param arr2 - The second array to zip.
+ * @param combine - Called with a value from each array and the index.
+ * @returns A function that maps the piped array to combined values.
+ */
+declare function zipWith<T, U, R>(arr2: readonly U[], combine: (item1: T, item2: U, index: number) => R): (array: readonly T[]) => R[];
+/**
+ * Creates a function that zips the piped array with two configured arrays and combines each group.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template U - The type of elements in the second array.
+ * @template V - The type of elements in the third array.
+ * @template R - The type returned by the combiner.
+ * @param arr2 - The second array to zip.
+ * @param arr3 - The third array to zip.
+ * @param combine - Called with a value from each array and the index.
+ * @returns A function that maps the piped array to combined values.
+ */
+declare function zipWith<T, U, V, R>(arr2: readonly U[], arr3: readonly V[], combine: (item1: T, item2: U, item3: V, index: number) => R): (array: readonly T[]) => R[];
+/**
+ * Creates a function that zips the piped array with three configured arrays and combines each group.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template U - The type of elements in the second array.
+ * @template V - The type of elements in the third array.
+ * @template W - The type of elements in the fourth array.
+ * @template R - The type returned by the combiner.
+ * @param arr2 - The second array to zip.
+ * @param arr3 - The third array to zip.
+ * @param arr4 - The fourth array to zip.
+ * @param combine - Called with a value from each array and the index.
+ * @returns A function that maps the piped array to combined values.
+ */
+declare function zipWith<T, U, V, W, R>(arr2: readonly U[], arr3: readonly V[], arr4: readonly W[], combine: (item1: T, item2: U, item3: V, item4: W, index: number) => R): (array: readonly T[]) => R[];
+//#endregion
+export { zipWith };

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

@@ -0,0 +1,57 @@
+//#region src/fp/array/zipWith.d.ts
+/**
+ * Creates a function that maps each value in the piped array with its index.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template R - The type returned by the combiner.
+ * @param combine - Called with each value and index.
+ * @returns A function that maps the piped array to combined values.
+ *
+ * @example
+ * import { pipe, zipWith } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2], zipWith((value, index) => value + index));
+ * // => [1, 3]
+ */
+declare function zipWith<T, R>(combine: (item: T, index: number) => R): (array: readonly T[]) => R[];
+/**
+ * Creates a function that zips the piped array with one configured array and combines each group.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template U - The type of elements in the configured array.
+ * @template R - The type returned by the combiner.
+ * @param arr2 - The second array to zip.
+ * @param combine - Called with a value from each array and the index.
+ * @returns A function that maps the piped array to combined values.
+ */
+declare function zipWith<T, U, R>(arr2: readonly U[], combine: (item1: T, item2: U, index: number) => R): (array: readonly T[]) => R[];
+/**
+ * Creates a function that zips the piped array with two configured arrays and combines each group.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template U - The type of elements in the second array.
+ * @template V - The type of elements in the third array.
+ * @template R - The type returned by the combiner.
+ * @param arr2 - The second array to zip.
+ * @param arr3 - The third array to zip.
+ * @param combine - Called with a value from each array and the index.
+ * @returns A function that maps the piped array to combined values.
+ */
+declare function zipWith<T, U, V, R>(arr2: readonly U[], arr3: readonly V[], combine: (item1: T, item2: U, item3: V, index: number) => R): (array: readonly T[]) => R[];
+/**
+ * Creates a function that zips the piped array with three configured arrays and combines each group.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template U - The type of elements in the second array.
+ * @template V - The type of elements in the third array.
+ * @template W - The type of elements in the fourth array.
+ * @template R - The type returned by the combiner.
+ * @param arr2 - The second array to zip.
+ * @param arr3 - The third array to zip.
+ * @param arr4 - The fourth array to zip.
+ * @param combine - Called with a value from each array and the index.
+ * @returns A function that maps the piped array to combined values.
+ */
+declare function zipWith<T, U, V, W, R>(arr2: readonly U[], arr3: readonly V[], arr4: readonly W[], combine: (item1: T, item2: U, item3: V, item4: W, index: number) => R): (array: readonly T[]) => R[];
+//#endregion
+export { zipWith };

package/dist/fp/array/zipWith.js

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

package/dist/fp/array/zipWith.mjs

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

package/dist/fp/index.d.mts

@@ -0,0 +1,75 @@
+import { WindowedOptions } from "../array/windowed.mjs";
+import { at } from "./array/at.mjs";
+import { cartesianProduct } from "./array/cartesianProduct.mjs";
+import { chunk } from "./array/chunk.mjs";
+import { chunkBy } from "./array/chunkBy.mjs";
+import { combinations } from "./array/combinations.mjs";
+import { compact } from "./array/compact.mjs";
+import { countBy } from "./array/countBy.mjs";
+import { difference } from "./array/difference.mjs";
+import { differenceBy } from "./array/differenceBy.mjs";
+import { differenceWith } from "./array/differenceWith.mjs";
+import { drop } from "./array/drop.mjs";
+import { dropRight } from "./array/dropRight.mjs";
+import { dropRightWhile } from "./array/dropRightWhile.mjs";
+import { dropWhile } from "./array/dropWhile.mjs";
+import { filter } from "./array/filter.mjs";
+import { find } from "./array/find.mjs";
+import { findIndex } from "./array/findIndex.mjs";
+import { findLast } from "./array/findLast.mjs";
+import { findLastIndex } from "./array/findLastIndex.mjs";
+import { flatMap } from "./array/flatMap.mjs";
+import { flatMapDeep } from "./array/flatMapDeep.mjs";
+import { flatten } from "./array/flatten.mjs";
+import { flattenDeep } from "./array/flattenDeep.mjs";
+import { forEach } from "./array/forEach.mjs";
+import { groupBy } from "./array/groupBy.mjs";
+import { head } from "./array/head.mjs";
+import { initial } from "./array/initial.mjs";
+import { intersection } from "./array/intersection.mjs";
+import { intersectionBy } from "./array/intersectionBy.mjs";
+import { intersectionWith } from "./array/intersectionWith.mjs";
+import { isSubset } from "./array/isSubset.mjs";
+import { isSubsetWith } from "./array/isSubsetWith.mjs";
+import { join } from "./array/join.mjs";
+import { keyBy } from "./array/keyBy.mjs";
+import { last } from "./array/last.mjs";
+import { length } from "./array/length.mjs";
+import { map } from "./array/map.mjs";
+import { maxBy } from "./array/maxBy.mjs";
+import { minBy } from "./array/minBy.mjs";
+import { orderBy } from "./array/orderBy.mjs";
+import { partition } from "./array/partition.mjs";
+import { reverse } from "./array/reverse.mjs";
+import { sample } from "./array/sample.mjs";
+import { sampleSize } from "./array/sampleSize.mjs";
+import { shuffle } from "./array/shuffle.mjs";
+import { sortBy } from "./array/sortBy.mjs";
+import { tail } from "./array/tail.mjs";
+import { take } from "./array/take.mjs";
+import { takeRight } from "./array/takeRight.mjs";
+import { takeRightWhile } from "./array/takeRightWhile.mjs";
+import { takeWhile } from "./array/takeWhile.mjs";
+import { toFilled } from "./array/toFilled.mjs";
+import { union } from "./array/union.mjs";
+import { unionBy } from "./array/unionBy.mjs";
+import { unionWith } from "./array/unionWith.mjs";
+import { uniq } from "./array/uniq.mjs";
+import { uniqBy } from "./array/uniqBy.mjs";
+import { uniqWith } from "./array/uniqWith.mjs";
+import { unzip } from "./array/unzip.mjs";
+import { unzipWith } from "./array/unzipWith.mjs";
+import { windowed } from "./array/windowed.mjs";
+import { without } from "./array/without.mjs";
+import { xor } from "./array/xor.mjs";
+import { xorBy } from "./array/xorBy.mjs";
+import { xorWith } from "./array/xorWith.mjs";
+import { zip } from "./array/zip.mjs";
+import { zipObject } from "./array/zipObject.mjs";
+import { zipWith } from "./array/zipWith.mjs";
+import { add } from "./math/add.mjs";
+import { multiply } from "./math/multiply.mjs";
+import { omit } from "./object/omit.mjs";
+import { pick } from "./object/pick.mjs";
+import { pipe } from "./pipe.mjs";
+export { WindowedOptions, add, at, cartesianProduct, chunk, chunkBy, combinations, compact, countBy, difference, differenceBy, differenceWith, drop, dropRight, dropRightWhile, dropWhile, filter, find, findIndex, findLast, findLastIndex, flatMap, flatMapDeep, flatten, flattenDeep, forEach, groupBy, head, initial, intersection, intersectionBy, intersectionWith, isSubset, isSubsetWith, join, keyBy, last, length, map, maxBy, minBy, multiply, omit, orderBy, partition, pick, pipe, reverse, sample, sampleSize, shuffle, sortBy, tail, take, takeRight, takeRightWhile, takeWhile, toFilled, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unzip, unzipWith, windowed, without, xor, xorBy, xorWith, zip, zipObject, zipWith };

package/dist/fp/index.d.ts

@@ -0,0 +1,75 @@
+import { WindowedOptions } from "../array/windowed.js";
+import { at } from "./array/at.js";
+import { cartesianProduct } from "./array/cartesianProduct.js";
+import { chunk } from "./array/chunk.js";
+import { chunkBy } from "./array/chunkBy.js";
+import { combinations } from "./array/combinations.js";
+import { compact } from "./array/compact.js";
+import { countBy } from "./array/countBy.js";
+import { difference } from "./array/difference.js";
+import { differenceBy } from "./array/differenceBy.js";
+import { differenceWith } from "./array/differenceWith.js";
+import { drop } from "./array/drop.js";
+import { dropRight } from "./array/dropRight.js";
+import { dropRightWhile } from "./array/dropRightWhile.js";
+import { dropWhile } from "./array/dropWhile.js";
+import { filter } from "./array/filter.js";
+import { find } from "./array/find.js";
+import { findIndex } from "./array/findIndex.js";
+import { findLast } from "./array/findLast.js";
+import { findLastIndex } from "./array/findLastIndex.js";
+import { flatMap } from "./array/flatMap.js";
+import { flatMapDeep } from "./array/flatMapDeep.js";
+import { flatten } from "./array/flatten.js";
+import { flattenDeep } from "./array/flattenDeep.js";
+import { forEach } from "./array/forEach.js";
+import { groupBy } from "./array/groupBy.js";
+import { head } from "./array/head.js";
+import { initial } from "./array/initial.js";
+import { intersection } from "./array/intersection.js";
+import { intersectionBy } from "./array/intersectionBy.js";
+import { intersectionWith } from "./array/intersectionWith.js";
+import { isSubset } from "./array/isSubset.js";
+import { isSubsetWith } from "./array/isSubsetWith.js";
+import { join } from "./array/join.js";
+import { keyBy } from "./array/keyBy.js";
+import { last } from "./array/last.js";
+import { length } from "./array/length.js";
+import { map } from "./array/map.js";
+import { maxBy } from "./array/maxBy.js";
+import { minBy } from "./array/minBy.js";
+import { orderBy } from "./array/orderBy.js";
+import { partition } from "./array/partition.js";
+import { reverse } from "./array/reverse.js";
+import { sample } from "./array/sample.js";
+import { sampleSize } from "./array/sampleSize.js";
+import { shuffle } from "./array/shuffle.js";
+import { sortBy } from "./array/sortBy.js";
+import { tail } from "./array/tail.js";
+import { take } from "./array/take.js";
+import { takeRight } from "./array/takeRight.js";
+import { takeRightWhile } from "./array/takeRightWhile.js";
+import { takeWhile } from "./array/takeWhile.js";
+import { toFilled } from "./array/toFilled.js";
+import { union } from "./array/union.js";
+import { unionBy } from "./array/unionBy.js";
+import { unionWith } from "./array/unionWith.js";
+import { uniq } from "./array/uniq.js";
+import { uniqBy } from "./array/uniqBy.js";
+import { uniqWith } from "./array/uniqWith.js";
+import { unzip } from "./array/unzip.js";
+import { unzipWith } from "./array/unzipWith.js";
+import { windowed } from "./array/windowed.js";
+import { without } from "./array/without.js";
+import { xor } from "./array/xor.js";
+import { xorBy } from "./array/xorBy.js";
+import { xorWith } from "./array/xorWith.js";
+import { zip } from "./array/zip.js";
+import { zipObject } from "./array/zipObject.js";
+import { zipWith } from "./array/zipWith.js";
+import { add } from "./math/add.js";
+import { multiply } from "./math/multiply.js";
+import { omit } from "./object/omit.js";
+import { pick } from "./object/pick.js";
+import { pipe } from "./pipe.js";
+export { WindowedOptions, add, at, cartesianProduct, chunk, chunkBy, combinations, compact, countBy, difference, differenceBy, differenceWith, drop, dropRight, dropRightWhile, dropWhile, filter, find, findIndex, findLast, findLastIndex, flatMap, flatMapDeep, flatten, flattenDeep, forEach, groupBy, head, initial, intersection, intersectionBy, intersectionWith, isSubset, isSubsetWith, join, keyBy, last, length, map, maxBy, minBy, multiply, omit, orderBy, partition, pick, pipe, reverse, sample, sampleSize, shuffle, sortBy, tail, take, takeRight, takeRightWhile, takeWhile, toFilled, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unzip, unzipWith, windowed, without, xor, xorBy, xorWith, zip, zipObject, zipWith };