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

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

@@ -0,0 +1,37 @@
+//#region src/fp/array/maxBy.d.ts
+/**
+ * Creates a function that returns the element with the maximum selected number from a non-empty array.
+ *
+ * If the selector returns NaN, the element that produced NaN is returned, matching
+ * the main {@link maxBy} behavior.
+ *
+ * @template T - The type of elements in the array.
+ * @param getValue - Selects a numeric value from each element, index, and array.
+ * @returns A function that maps a non-empty readonly array to the maximum element.
+ *
+ * @example
+ * import { maxBy, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([{ score: 10 }, { score: 20 }] as const, maxBy(item => item.score));
+ * // => { score: 20 }
+ */
+declare function maxBy<T>(getValue: (element: T, index: number, array: readonly T[]) => number): (array: readonly [T, ...T[]]) => T;
+/**
+ * Creates a function that returns the element with the maximum selected number.
+ *
+ * Empty arrays return undefined. If the selector returns NaN, the element that
+ * produced NaN is returned, matching the main {@link maxBy} behavior.
+ *
+ * @template T - The type of elements in the array.
+ * @param getValue - Selects a numeric value from each element, index, and array.
+ * @returns A function that maps a readonly array to the maximum element, or undefined.
+ *
+ * @example
+ * import { maxBy, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([] as Array<{ score: number }>, maxBy(item => item.score));
+ * // => undefined
+ */
+declare function maxBy<T>(getValue: (element: T, index: number, array: readonly T[]) => number): (array: readonly T[]) => T | undefined;
+//#endregion
+export { maxBy };

package/dist/fp/array/maxBy.js

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

package/dist/fp/array/maxBy.mjs

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

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

@@ -0,0 +1,37 @@
+//#region src/fp/array/minBy.d.ts
+/**
+ * Creates a function that returns the element with the minimum selected number from a non-empty array.
+ *
+ * If the selector returns NaN, the element that produced NaN is returned, matching
+ * the main {@link minBy} behavior.
+ *
+ * @template T - The type of elements in the array.
+ * @param getValue - Selects a numeric value from each element, index, and array.
+ * @returns A function that maps a non-empty readonly array to the minimum element.
+ *
+ * @example
+ * import { minBy, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([{ score: 10 }, { score: 20 }] as const, minBy(item => item.score));
+ * // => { score: 10 }
+ */
+declare function minBy<T>(getValue: (element: T, index: number, array: readonly T[]) => number): (array: readonly [T, ...T[]]) => T;
+/**
+ * Creates a function that returns the element with the minimum selected number.
+ *
+ * Empty arrays return undefined. If the selector returns NaN, the element that
+ * produced NaN is returned, matching the main {@link minBy} behavior.
+ *
+ * @template T - The type of elements in the array.
+ * @param getValue - Selects a numeric value from each element, index, and array.
+ * @returns A function that maps a readonly array to the minimum element, or undefined.
+ *
+ * @example
+ * import { minBy, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([] as Array<{ score: number }>, minBy(item => item.score));
+ * // => undefined
+ */
+declare function minBy<T>(getValue: (element: T, index: number, array: readonly T[]) => number): (array: readonly T[]) => T | undefined;
+//#endregion
+export { minBy };

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

@@ -0,0 +1,37 @@
+//#region src/fp/array/minBy.d.ts
+/**
+ * Creates a function that returns the element with the minimum selected number from a non-empty array.
+ *
+ * If the selector returns NaN, the element that produced NaN is returned, matching
+ * the main {@link minBy} behavior.
+ *
+ * @template T - The type of elements in the array.
+ * @param getValue - Selects a numeric value from each element, index, and array.
+ * @returns A function that maps a non-empty readonly array to the minimum element.
+ *
+ * @example
+ * import { minBy, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([{ score: 10 }, { score: 20 }] as const, minBy(item => item.score));
+ * // => { score: 10 }
+ */
+declare function minBy<T>(getValue: (element: T, index: number, array: readonly T[]) => number): (array: readonly [T, ...T[]]) => T;
+/**
+ * Creates a function that returns the element with the minimum selected number.
+ *
+ * Empty arrays return undefined. If the selector returns NaN, the element that
+ * produced NaN is returned, matching the main {@link minBy} behavior.
+ *
+ * @template T - The type of elements in the array.
+ * @param getValue - Selects a numeric value from each element, index, and array.
+ * @returns A function that maps a readonly array to the minimum element, or undefined.
+ *
+ * @example
+ * import { minBy, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([] as Array<{ score: number }>, minBy(item => item.score));
+ * // => undefined
+ */
+declare function minBy<T>(getValue: (element: T, index: number, array: readonly T[]) => number): (array: readonly T[]) => T | undefined;
+//#endregion
+export { minBy };

package/dist/fp/array/minBy.js

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

package/dist/fp/array/minBy.mjs

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

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

@@ -0,0 +1,21 @@
+//#region src/fp/array/orderBy.d.ts
+/**
+ * Creates a function that sorts objects by criteria and order directions.
+ *
+ * Criteria can be object keys or selector functions. The returned function does not mutate
+ * the input array; it returns a sorted copy following the main {@link orderBy} behavior.
+ *
+ * @template T - The object type in the array.
+ * @param criteria - Keys or selector functions used for comparison.
+ * @param orders - Sort directions corresponding to the criteria.
+ * @returns A function that maps a readonly array to a sorted copy.
+ *
+ * @example
+ * import { orderBy, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([{ name: 'a', age: 2 }, { name: 'b', age: 1 }], orderBy(['age'], ['asc']));
+ * // => [{ name: 'b', age: 1 }, { name: 'a', age: 2 }]
+ */
+declare function orderBy<T extends object>(criteria: Array<((item: T) => unknown) | keyof T>, orders: Array<'asc' | 'desc'>): (array: readonly T[]) => T[];
+//#endregion
+export { orderBy };

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

@@ -0,0 +1,21 @@
+//#region src/fp/array/orderBy.d.ts
+/**
+ * Creates a function that sorts objects by criteria and order directions.
+ *
+ * Criteria can be object keys or selector functions. The returned function does not mutate
+ * the input array; it returns a sorted copy following the main {@link orderBy} behavior.
+ *
+ * @template T - The object type in the array.
+ * @param criteria - Keys or selector functions used for comparison.
+ * @param orders - Sort directions corresponding to the criteria.
+ * @returns A function that maps a readonly array to a sorted copy.
+ *
+ * @example
+ * import { orderBy, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([{ name: 'a', age: 2 }, { name: 'b', age: 1 }], orderBy(['age'], ['asc']));
+ * // => [{ name: 'b', age: 1 }, { name: 'a', age: 2 }]
+ */
+declare function orderBy<T extends object>(criteria: Array<((item: T) => unknown) | keyof T>, orders: Array<'asc' | 'desc'>): (array: readonly T[]) => T[];
+//#endregion
+export { orderBy };

package/dist/fp/array/orderBy.js

@@ -0,0 +1,26 @@
+const require_orderBy = require("../../array/orderBy.js");
+//#region src/fp/array/orderBy.ts
+/**
+* Creates a function that sorts objects by criteria and order directions.
+*
+* Criteria can be object keys or selector functions. The returned function does not mutate
+* the input array; it returns a sorted copy following the main {@link orderBy} behavior.
+*
+* @template T - The object type in the array.
+* @param criteria - Keys or selector functions used for comparison.
+* @param orders - Sort directions corresponding to the criteria.
+* @returns A function that maps a readonly array to a sorted copy.
+*
+* @example
+* import { orderBy, pipe } from 'es-toolkit/fp';
+*
+* pipe([{ name: 'a', age: 2 }, { name: 'b', age: 1 }], orderBy(['age'], ['asc']));
+* // => [{ name: 'b', age: 1 }, { name: 'a', age: 2 }]
+*/
+function orderBy(criteria, orders) {
+	return function(array) {
+		return require_orderBy.orderBy(array, criteria, orders);
+	};
+}
+//#endregion
+exports.orderBy = orderBy;

package/dist/fp/array/orderBy.mjs

@@ -0,0 +1,26 @@
+import { orderBy as orderBy$1 } from "../../array/orderBy.mjs";
+//#region src/fp/array/orderBy.ts
+/**
+* Creates a function that sorts objects by criteria and order directions.
+*
+* Criteria can be object keys or selector functions. The returned function does not mutate
+* the input array; it returns a sorted copy following the main {@link orderBy} behavior.
+*
+* @template T - The object type in the array.
+* @param criteria - Keys or selector functions used for comparison.
+* @param orders - Sort directions corresponding to the criteria.
+* @returns A function that maps a readonly array to a sorted copy.
+*
+* @example
+* import { orderBy, pipe } from 'es-toolkit/fp';
+*
+* pipe([{ name: 'a', age: 2 }, { name: 'b', age: 1 }], orderBy(['age'], ['asc']));
+* // => [{ name: 'b', age: 1 }, { name: 'a', age: 2 }]
+*/
+function orderBy(criteria, orders) {
+	return function(array) {
+		return orderBy$1(array, criteria, orders);
+	};
+}
+//#endregion
+export { orderBy };

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

@@ -0,0 +1,39 @@
+//#region src/fp/array/partition.d.ts
+/**
+ * Creates a function that splits an array with a type-guard predicate.
+ *
+ * Values for which the predicate returns true are placed in the first array and
+ * narrowed to U. The remaining values are placed in the second array as Exclude<T, U>.
+ *
+ * @template T - The type of elements in the array.
+ * @template U - The narrowed element type accepted by the type guard.
+ * @param predicate - Type guard called with each value, index, and array.
+ * @returns A function that maps a readonly array to truthy and falsy partitions.
+ *
+ * @example
+ * import { partition, pipe } from 'es-toolkit/fp';
+ *
+ * const isString = (value: string | number): value is string => typeof value === 'string';
+ * pipe([1, 'a', 2, 'b'], partition(isString));
+ * // => [['a', 'b'], [1, 2]]
+ */
+declare function partition<T, U extends T>(predicate: (value: T, index: number, array: readonly T[]) => value is U): (array: readonly T[]) => [truthy: U[], falsy: Array<Exclude<T, U>>];
+/**
+ * Creates a function that splits an array by a predicate.
+ *
+ * Values for which the predicate returns true are placed in the first array; all
+ * other values are placed in the second array.
+ *
+ * @template T - The type of elements in the array.
+ * @param predicate - Predicate called with each value, index, and array.
+ * @returns A function that maps a readonly array to truthy and falsy partitions.
+ *
+ * @example
+ * import { partition, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3, 4], partition(value => value % 2 === 0));
+ * // => [[2, 4], [1, 3]]
+ */
+declare function partition<T>(predicate: (value: T, index: number, array: readonly T[]) => boolean): (array: readonly T[]) => [truthy: T[], falsy: T[]];
+//#endregion
+export { partition };

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

@@ -0,0 +1,39 @@
+//#region src/fp/array/partition.d.ts
+/**
+ * Creates a function that splits an array with a type-guard predicate.
+ *
+ * Values for which the predicate returns true are placed in the first array and
+ * narrowed to U. The remaining values are placed in the second array as Exclude<T, U>.
+ *
+ * @template T - The type of elements in the array.
+ * @template U - The narrowed element type accepted by the type guard.
+ * @param predicate - Type guard called with each value, index, and array.
+ * @returns A function that maps a readonly array to truthy and falsy partitions.
+ *
+ * @example
+ * import { partition, pipe } from 'es-toolkit/fp';
+ *
+ * const isString = (value: string | number): value is string => typeof value === 'string';
+ * pipe([1, 'a', 2, 'b'], partition(isString));
+ * // => [['a', 'b'], [1, 2]]
+ */
+declare function partition<T, U extends T>(predicate: (value: T, index: number, array: readonly T[]) => value is U): (array: readonly T[]) => [truthy: U[], falsy: Array<Exclude<T, U>>];
+/**
+ * Creates a function that splits an array by a predicate.
+ *
+ * Values for which the predicate returns true are placed in the first array; all
+ * other values are placed in the second array.
+ *
+ * @template T - The type of elements in the array.
+ * @param predicate - Predicate called with each value, index, and array.
+ * @returns A function that maps a readonly array to truthy and falsy partitions.
+ *
+ * @example
+ * import { partition, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3, 4], partition(value => value % 2 === 0));
+ * // => [[2, 4], [1, 3]]
+ */
+declare function partition<T>(predicate: (value: T, index: number, array: readonly T[]) => boolean): (array: readonly T[]) => [truthy: T[], falsy: T[]];
+//#endregion
+export { partition };

package/dist/fp/array/partition.js

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

package/dist/fp/array/partition.mjs

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

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

@@ -0,0 +1,19 @@
+//#region src/fp/array/reverse.d.ts
+/**
+ * Creates a function that returns a reversed copy of an array.
+ *
+ * Unlike Array.prototype.reverse, the returned function does not mutate the input array.
+ * Use it with {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @returns A function that maps a readonly array to a reversed copy.
+ *
+ * @example
+ * import { pipe, reverse } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3], reverse());
+ * // => [3, 2, 1]
+ */
+declare function reverse<T>(): (array: readonly T[]) => T[];
+//#endregion
+export { reverse };

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

@@ -0,0 +1,19 @@
+//#region src/fp/array/reverse.d.ts
+/**
+ * Creates a function that returns a reversed copy of an array.
+ *
+ * Unlike Array.prototype.reverse, the returned function does not mutate the input array.
+ * Use it with {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @returns A function that maps a readonly array to a reversed copy.
+ *
+ * @example
+ * import { pipe, reverse } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3], reverse());
+ * // => [3, 2, 1]
+ */
+declare function reverse<T>(): (array: readonly T[]) => T[];
+//#endregion
+export { reverse };

package/dist/fp/array/reverse.js

@@ -0,0 +1,23 @@
+//#region src/fp/array/reverse.ts
+/**
+* Creates a function that returns a reversed copy of an array.
+*
+* Unlike Array.prototype.reverse, the returned function does not mutate the input array.
+* Use it with {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @returns A function that maps a readonly array to a reversed copy.
+*
+* @example
+* import { pipe, reverse } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3], reverse());
+* // => [3, 2, 1]
+*/
+function reverse() {
+	return function(array) {
+		return array.slice().reverse();
+	};
+}
+//#endregion
+exports.reverse = reverse;

package/dist/fp/array/reverse.mjs

@@ -0,0 +1,23 @@
+//#region src/fp/array/reverse.ts
+/**
+* Creates a function that returns a reversed copy of an array.
+*
+* Unlike Array.prototype.reverse, the returned function does not mutate the input array.
+* Use it with {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @returns A function that maps a readonly array to a reversed copy.
+*
+* @example
+* import { pipe, reverse } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3], reverse());
+* // => [3, 2, 1]
+*/
+function reverse() {
+	return function(array) {
+		return array.slice().reverse();
+	};
+}
+//#endregion
+export { reverse };

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

@@ -0,0 +1,18 @@
+//#region src/fp/array/sample.d.ts
+/**
+ * Creates a function that returns one random element from an array.
+ *
+ * The returned function follows the main {@link sample} behavior. Use it with {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @returns A function that maps a readonly array to a random element.
+ *
+ * @example
+ * import { pipe, sample } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3], sample());
+ * // => one of 1, 2, or 3
+ */
+declare function sample<T>(): (array: readonly T[]) => T;
+//#endregion
+export { sample };

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

@@ -0,0 +1,18 @@
+//#region src/fp/array/sample.d.ts
+/**
+ * Creates a function that returns one random element from an array.
+ *
+ * The returned function follows the main {@link sample} behavior. Use it with {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @returns A function that maps a readonly array to a random element.
+ *
+ * @example
+ * import { pipe, sample } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3], sample());
+ * // => one of 1, 2, or 3
+ */
+declare function sample<T>(): (array: readonly T[]) => T;
+//#endregion
+export { sample };

package/dist/fp/array/sample.js

@@ -0,0 +1,23 @@
+const require_sample = require("../../array/sample.js");
+//#region src/fp/array/sample.ts
+/**
+* Creates a function that returns one random element from an array.
+*
+* The returned function follows the main {@link sample} behavior. Use it with {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @returns A function that maps a readonly array to a random element.
+*
+* @example
+* import { pipe, sample } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3], sample());
+* // => one of 1, 2, or 3
+*/
+function sample() {
+	return function(array) {
+		return require_sample.sample(array);
+	};
+}
+//#endregion
+exports.sample = sample;

package/dist/fp/array/sample.mjs

@@ -0,0 +1,23 @@
+import { sample as sample$1 } from "../../array/sample.mjs";
+//#region src/fp/array/sample.ts
+/**
+* Creates a function that returns one random element from an array.
+*
+* The returned function follows the main {@link sample} behavior. Use it with {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @returns A function that maps a readonly array to a random element.
+*
+* @example
+* import { pipe, sample } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3], sample());
+* // => one of 1, 2, or 3
+*/
+function sample() {
+	return function(array) {
+		return sample$1(array);
+	};
+}
+//#endregion
+export { sample };

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

@@ -0,0 +1,20 @@
+//#region src/fp/array/sampleSize.d.ts
+/**
+ * Creates a function that returns random elements from an array.
+ *
+ * The returned function follows the main {@link sampleSize} behavior and returns a new array.
+ * Use it with {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @param size - The number of elements to sample.
+ * @returns A function that maps a readonly array to sampled elements.
+ *
+ * @example
+ * import { pipe, sampleSize } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3, 4], sampleSize(2));
+ * // => two random elements
+ */
+declare function sampleSize<T>(size: number): (array: readonly T[]) => T[];
+//#endregion
+export { sampleSize };

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

@@ -0,0 +1,20 @@
+//#region src/fp/array/sampleSize.d.ts
+/**
+ * Creates a function that returns random elements from an array.
+ *
+ * The returned function follows the main {@link sampleSize} behavior and returns a new array.
+ * Use it with {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @param size - The number of elements to sample.
+ * @returns A function that maps a readonly array to sampled elements.
+ *
+ * @example
+ * import { pipe, sampleSize } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3, 4], sampleSize(2));
+ * // => two random elements
+ */
+declare function sampleSize<T>(size: number): (array: readonly T[]) => T[];
+//#endregion
+export { sampleSize };

package/dist/fp/array/sampleSize.js

@@ -0,0 +1,25 @@
+const require_sampleSize = require("../../array/sampleSize.js");
+//#region src/fp/array/sampleSize.ts
+/**
+* Creates a function that returns random elements from an array.
+*
+* The returned function follows the main {@link sampleSize} behavior and returns a new array.
+* Use it with {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @param size - The number of elements to sample.
+* @returns A function that maps a readonly array to sampled elements.
+*
+* @example
+* import { pipe, sampleSize } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3, 4], sampleSize(2));
+* // => two random elements
+*/
+function sampleSize(size) {
+	return function(array) {
+		return require_sampleSize.sampleSize(array, size);
+	};
+}
+//#endregion
+exports.sampleSize = sampleSize;

package/dist/fp/array/sampleSize.mjs

@@ -0,0 +1,25 @@
+import { sampleSize as sampleSize$1 } from "../../array/sampleSize.mjs";
+//#region src/fp/array/sampleSize.ts
+/**
+* Creates a function that returns random elements from an array.
+*
+* The returned function follows the main {@link sampleSize} behavior and returns a new array.
+* Use it with {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @param size - The number of elements to sample.
+* @returns A function that maps a readonly array to sampled elements.
+*
+* @example
+* import { pipe, sampleSize } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3, 4], sampleSize(2));
+* // => two random elements
+*/
+function sampleSize(size) {
+	return function(array) {
+		return sampleSize$1(array, size);
+	};
+}
+//#endregion
+export { sampleSize };

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

@@ -0,0 +1,19 @@
+//#region src/fp/array/shuffle.d.ts
+/**
+ * Creates a function that returns a shuffled copy of an array.
+ *
+ * The returned function uses the main {@link shuffle} implementation and does not mutate
+ * the input array. Use it with {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @returns A function that maps a readonly array to a shuffled copy.
+ *
+ * @example
+ * import { pipe, shuffle } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3], shuffle());
+ * // => the same values in random order
+ */
+declare function shuffle<T>(): (array: readonly T[]) => T[];
+//#endregion
+export { shuffle };