@vinicunca/perkakas 1.8.0 → 1.9.0

package/dist/reduce-DeOCr-Lz.d.ts

@@ -0,0 +1,53 @@
+//#region src/reduce.d.ts
+/**
+ * Executes a user-supplied "reducer" callback function on each element of the
+ * array, in order, passing in the return value from the calculation on the
+ * preceding element. The final result of running the reducer across all
+ * elements of the array is a single value. Equivalent to
+ * `Array.prototype.reduce`.
+ *
+ * @param data - The items to reduce.
+ * @param callbackfn - A function to execute for each element in the array. Its
+ * return value becomes the value of the accumulator parameter on the next
+ * invocation of callbackFn. For the last invocation, the return value becomes
+ * the return value of reduce().
+ * @param initialValue - A value to which accumulator is initialized the first
+ * time the callback is called. CallbackFn starts executing with the first value
+ * in the array as currentValue.
+ * @returns The value that results from running the "reducer" callback function
+ * to completion over the entire array.
+ * @signature
+ *    P.reduce(data, callbackfn, initialValue)
+ * @example
+ *    P.reduce([1, 2, 3, 4, 5], (acc, x) => acc + x, 100) // => 115
+ * @dataFirst
+ * @category Array
+ */
+declare function reduce<T, U>(data: ReadonlyArray<T>, callbackfn: (previousValue: U, currentValue: T, currentIndex: number, data: ReadonlyArray<T>) => U, initialValue: U): U;
+/**
+ * Executes a user-supplied "reducer" callback function on each element of the
+ * array, in order, passing in the return value from the calculation on the
+ * preceding element. The final result of running the reducer across all
+ * elements of the array is a single value. Equivalent to
+ * `Array.prototype.reduce`.
+ *
+ * @param callbackfn - A function to execute for each element in the array. Its
+ * return value becomes the value of the accumulator parameter on the next
+ * invocation of callbackFn. For the last invocation, the return value becomes
+ * the return value of reduce().
+ * @param initialValue - A value to which accumulator is initialized the first
+ * time the callback is called. CallbackFn starts executing with the first value
+ * in the array as currentValue.
+ * @returns The value that results from running the "reducer" callback function
+ * to completion over the entire array.
+ * @signature
+ *    P.reduce(fn, initialValue)(array)
+ * @example
+ *    P.pipe([1, 2, 3, 4, 5], P.reduce((acc, x) => acc + x, 100)) // => 115
+ * @dataLast
+ * @category Array
+ */
+declare function reduce<T, U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, data: ReadonlyArray<T>) => U, initialValue: U): (data: ReadonlyArray<T>) => U;
+//#endregion
+export { reduce };
+//# sourceMappingURL=reduce-DeOCr-Lz.d.ts.map

package/dist/reduce-DeOCr-Lz.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reduce-DeOCr-Lz.d.ts","names":[],"sources":["../src/reduce.ts"],"sourcesContent":[],"mappings":";;AA0BA;;;;;;;;;;;;AAkCA;;;;;;;;;;;AAQgC,iBA1ChB,MA0CgB,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,IAAA,EAzCxB,aAyCwB,CAzCV,CAyCU,CAAA,EAAA,UAAA,EAAA,CAAA,aAAA,EAvCb,CAuCa,EAAA,YAAA,EAtCd,CAsCc,EAAA,YAAA,EAAA,MAAA,EAAA,IAAA,EApCtB,aAoCsB,CApCR,CAoCQ,CAAA,EAAA,GAnCzB,CAmCyB,EAAA,YAAA,EAlChB,CAkCgB,CAAA,EAjC7B,CAiC6B;;;;;;;;;;;;;;;;;;;;;;;;iBARhB,yCAEG,iBACD,+BAER,cAAc,OACjB,iBACS,WACN,cAAc,OAAO"}

package/dist/reduce-DsDQdDwu.js

@@ -0,0 +1,2 @@
+import{curry as e}from"./curry-CzZjDrpv.js";function t(...t){return e(n,t)}function n(e,t,n){return e.reduce(t,n)}export{t as reduce};
+//# sourceMappingURL=reduce-DsDQdDwu.js.map

package/dist/reduce-DsDQdDwu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reduce-DsDQdDwu.js","names":[],"sources":["../src/reduce.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Executes a user-supplied \"reducer\" callback function on each element of the\n * array, in order, passing in the return value from the calculation on the\n * preceding element. The final result of running the reducer across all\n * elements of the array is a single value. Equivalent to\n * `Array.prototype.reduce`.\n *\n * @param data - The items to reduce.\n * @param callbackfn - A function to execute for each element in the array. Its\n * return value becomes the value of the accumulator parameter on the next\n * invocation of callbackFn. For the last invocation, the return value becomes\n * the return value of reduce().\n * @param initialValue - A value to which accumulator is initialized the first\n * time the callback is called. CallbackFn starts executing with the first value\n * in the array as currentValue.\n * @returns The value that results from running the \"reducer\" callback function\n * to completion over the entire array.\n * @signature\n *    P.reduce(data, callbackfn, initialValue)\n * @example\n *    P.reduce([1, 2, 3, 4, 5], (acc, x) => acc + x, 100) // => 115\n * @dataFirst\n * @category Array\n */\nexport function reduce<T, U>(\n  data: ReadonlyArray<T>,\n  callbackfn: (\n    previousValue: U,\n    currentValue: T,\n    currentIndex: number,\n    data: ReadonlyArray<T>,\n  ) => U,\n  initialValue: U,\n): U;\n\n/**\n * Executes a user-supplied \"reducer\" callback function on each element of the\n * array, in order, passing in the return value from the calculation on the\n * preceding element. The final result of running the reducer across all\n * elements of the array is a single value. Equivalent to\n * `Array.prototype.reduce`.\n *\n * @param callbackfn - A function to execute for each element in the array. Its\n * return value becomes the value of the accumulator parameter on the next\n * invocation of callbackFn. For the last invocation, the return value becomes\n * the return value of reduce().\n * @param initialValue - A value to which accumulator is initialized the first\n * time the callback is called. CallbackFn starts executing with the first value\n * in the array as currentValue.\n * @returns The value that results from running the \"reducer\" callback function\n * to completion over the entire array.\n * @signature\n *    P.reduce(fn, initialValue)(array)\n * @example\n *    P.pipe([1, 2, 3, 4, 5], P.reduce((acc, x) => acc + x, 100)) // => 115\n * @dataLast\n * @category Array\n */\nexport function reduce<T, U>(\n  callbackfn: (\n    previousValue: U,\n    currentValue: T,\n    currentIndex: number,\n    data: ReadonlyArray<T>,\n  ) => U,\n  initialValue: U,\n): (data: ReadonlyArray<T>) => U;\n\nexport function reduce(...args: ReadonlyArray<unknown>): unknown {\n  return curry(reduceImplementation, args);\n}\n\nfunction reduceImplementation<T, U>(\n  data: ReadonlyArray<T>,\n  callbackfn: (\n    previousValue: U,\n    currentValue: T,\n    currentIndex: number,\n    data: ReadonlyArray<T>,\n  ) => U,\n  initialValue: U,\n): U {\n  return data.reduce(callbackfn, initialValue);\n}\n"],"mappings":"4CAsEA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,EAAK,CAG1C,SAAS,EACP,EACA,EAMA,EACG,CACH,OAAO,EAAK,OAAO,EAAY,EAAa"}

package/dist/reduce-jhUIIUcp.d.cts

@@ -0,0 +1,53 @@
+//#region src/reduce.d.ts
+/**
+ * Executes a user-supplied "reducer" callback function on each element of the
+ * array, in order, passing in the return value from the calculation on the
+ * preceding element. The final result of running the reducer across all
+ * elements of the array is a single value. Equivalent to
+ * `Array.prototype.reduce`.
+ *
+ * @param data - The items to reduce.
+ * @param callbackfn - A function to execute for each element in the array. Its
+ * return value becomes the value of the accumulator parameter on the next
+ * invocation of callbackFn. For the last invocation, the return value becomes
+ * the return value of reduce().
+ * @param initialValue - A value to which accumulator is initialized the first
+ * time the callback is called. CallbackFn starts executing with the first value
+ * in the array as currentValue.
+ * @returns The value that results from running the "reducer" callback function
+ * to completion over the entire array.
+ * @signature
+ *    P.reduce(data, callbackfn, initialValue)
+ * @example
+ *    P.reduce([1, 2, 3, 4, 5], (acc, x) => acc + x, 100) // => 115
+ * @dataFirst
+ * @category Array
+ */
+declare function reduce<T, U>(data: ReadonlyArray<T>, callbackfn: (previousValue: U, currentValue: T, currentIndex: number, data: ReadonlyArray<T>) => U, initialValue: U): U;
+/**
+ * Executes a user-supplied "reducer" callback function on each element of the
+ * array, in order, passing in the return value from the calculation on the
+ * preceding element. The final result of running the reducer across all
+ * elements of the array is a single value. Equivalent to
+ * `Array.prototype.reduce`.
+ *
+ * @param callbackfn - A function to execute for each element in the array. Its
+ * return value becomes the value of the accumulator parameter on the next
+ * invocation of callbackFn. For the last invocation, the return value becomes
+ * the return value of reduce().
+ * @param initialValue - A value to which accumulator is initialized the first
+ * time the callback is called. CallbackFn starts executing with the first value
+ * in the array as currentValue.
+ * @returns The value that results from running the "reducer" callback function
+ * to completion over the entire array.
+ * @signature
+ *    P.reduce(fn, initialValue)(array)
+ * @example
+ *    P.pipe([1, 2, 3, 4, 5], P.reduce((acc, x) => acc + x, 100)) // => 115
+ * @dataLast
+ * @category Array
+ */
+declare function reduce<T, U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, data: ReadonlyArray<T>) => U, initialValue: U): (data: ReadonlyArray<T>) => U;
+//#endregion
+export { reduce };
+//# sourceMappingURL=reduce-jhUIIUcp.d.cts.map

package/dist/reduce-jhUIIUcp.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reduce-jhUIIUcp.d.cts","names":[],"sources":["../src/reduce.ts"],"sourcesContent":[],"mappings":";;AA0BA;;;;;;;;;;;;AAkCA;;;;;;;;;;;AAQgC,iBA1ChB,MA0CgB,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,IAAA,EAzCxB,aAyCwB,CAzCV,CAyCU,CAAA,EAAA,UAAA,EAAA,CAAA,aAAA,EAvCb,CAuCa,EAAA,YAAA,EAtCd,CAsCc,EAAA,YAAA,EAAA,MAAA,EAAA,IAAA,EApCtB,aAoCsB,CApCR,CAoCQ,CAAA,EAAA,GAnCzB,CAmCyB,EAAA,YAAA,EAlChB,CAkCgB,CAAA,EAjC7B,CAiC6B;;;;;;;;;;;;;;;;;;;;;;;;iBARhB,yCAEG,iBACD,+BAER,cAAc,OACjB,iBACS,WACN,cAAc,OAAO"}

package/dist/reduce.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./reduce-BXmHWGo2.cjs`);exports.reduce=e.reduce;
+require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./reduce-CrxiKHBX.cjs`);exports.reduce=e.reduce;

package/dist/reduce.d.cts

@@ -1,2 +1,2 @@
-import { reduce } from "./reduce-DYv-piI7.cjs";
+import { reduce } from "./reduce-jhUIIUcp.cjs";
 export { reduce };

package/dist/reduce.d.ts

@@ -1,2 +1,2 @@
-import { reduce } from "./reduce-RFXB_tDG.js";
+import { reduce } from "./reduce-DeOCr-Lz.js";
 export { reduce };

package/dist/reduce.js

@@ -1 +1 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{reduce as e}from"./reduce-RxP5hmH5.js";export{e as reduce};
+import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{reduce as e}from"./reduce-DsDQdDwu.js";export{e as reduce};

package/dist/reordered-array-BJFUtOkp.d.ts

@@ -0,0 +1,7 @@
+import { IterableContainer } from "./iterable-container-F9CDF7ym.js";
+
+//#region src/internal/types/reordered-array.d.ts
+type ReorderedArray<T extends IterableContainer> = { -readonly [P in keyof T]: T[number] };
+//#endregion
+export { ReorderedArray };
+//# sourceMappingURL=reordered-array-BJFUtOkp.d.ts.map

package/dist/reordered-array-BJFUtOkp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reordered-array-BJFUtOkp.d.ts","names":[],"sources":["../src/internal/types/reordered-array.ts"],"sourcesContent":[],"mappings":";;;KAEY,yBAAyB,6CACb,IAAI,WAD5B"}

package/dist/reordered-array-ikr9o4WE.d.cts

@@ -0,0 +1,7 @@
+import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
+
+//#region src/internal/types/reordered-array.d.ts
+type ReorderedArray<T extends IterableContainer> = { -readonly [P in keyof T]: T[number] };
+//#endregion
+export { ReorderedArray };
+//# sourceMappingURL=reordered-array-ikr9o4WE.d.cts.map

package/dist/reordered-array-ikr9o4WE.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reordered-array-ikr9o4WE.d.cts","names":[],"sources":["../src/internal/types/reordered-array.ts"],"sourcesContent":[],"mappings":";;;KAEY,yBAAyB,6CACb,IAAI,WAD5B"}

package/dist/reverse-BYHaMWmD.d.ts

@@ -0,0 +1,29 @@
+//#region src/reverse.d.ts
+type Reverse<T extends ReadonlyArray<unknown>, R extends ReadonlyArray<unknown> = []> = ReturnType<T extends IsNoTuple<T> ? () => [...T, ...R] : T extends readonly [infer F, ...infer L] ? () => Reverse<L, [F, ...R]> : () => R>;
+type IsNoTuple<T> = T extends readonly [unknown, ...Array<unknown>] ? never : T;
+/**
+ * Reverses array.
+ *
+ * @param array - The array.
+ * @signature
+ *    P.reverse(arr);
+ * @example
+ *    P.reverse([1, 2, 3]) // [3, 2, 1]
+ * @dataFirst
+ * @category Array
+ */
+declare function reverse<T extends ReadonlyArray<unknown>>(array: T): Reverse<T>;
+/**
+ * Reverses array.
+ *
+ * @signature
+ *    P.reverse()(array);
+ * @example
+ *    P.reverse()([1, 2, 3]) // [3, 2, 1]
+ * @dataLast
+ * @category Array
+ */
+declare function reverse<T extends ReadonlyArray<unknown>>(): (array: T) => Reverse<T>;
+//#endregion
+export { reverse };
+//# sourceMappingURL=reverse-BYHaMWmD.d.ts.map

package/dist/reverse-BYHaMWmD.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reverse-BYHaMWmD.d.ts","names":[],"sources":["../src/reverse.ts"],"sourcesContent":[],"mappings":";KAEK,kBACO,kCACA,+BACR,WACF,UAAU,UAAU,eACN,MAAM,KAChB,iDACQ,QAAQ,IAAI,MAAM,YAClB;KAGT,SAXO,CAAA,CAAA,CAAA,GAWQ,CAXR,SAAA,SAAA,CAAA,OAAA,EAAA,GAWwC,KAXxC,CAAA,OAAA,CAAA,CAAA,GAAA,KAAA,GAWkE,CAXlE;;;;;;;;;;;;AAOoB,iBAiBhB,OAjBgB,CAAA,UAiBE,aAjBF,CAAA,OAAA,CAAA,CAAA,CAAA,KAAA,EAiBiC,CAjBjC,CAAA,EAiBqC,OAjBrC,CAiB6C,CAjB7C,CAAA;;;;;AAJlB;;;;;;AAqBE,iBAYA,OAZO,CAAA,UAYW,aAZX,CAAA,OAAA,CAAA,CAAA,CAAA,CAAA,EAAA,CAAA,KAAA,EAad,CAbc,EAAA,GAclB,OAdkB,CAcV,CAdU,CAAA"}

package/dist/reverse-Qt4C74U1.js

@@ -0,0 +1,2 @@
+import{curry as e}from"./curry-CzZjDrpv.js";function t(...t){return e(n,t)}function n(e){return[...e].reverse()}export{t as reverse};
+//# sourceMappingURL=reverse-Qt4C74U1.js.map

package/dist/reverse-Qt4C74U1.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reverse-Qt4C74U1.js","names":[],"sources":["../src/reverse.ts"],"sourcesContent":["import { curry } from './curry';\n\ntype Reverse<\n  T extends ReadonlyArray<unknown>,\n  R extends ReadonlyArray<unknown> = [],\n> = ReturnType<\n  T extends IsNoTuple<T>\n    ? () => [...T, ...R]\n    : T extends readonly [infer F, ...infer L]\n      ? () => Reverse<L, [F, ...R]>\n      : () => R\n>;\n\ntype IsNoTuple<T> = T extends readonly [unknown, ...Array<unknown>] ? never : T;\n\n/**\n * Reverses array.\n *\n * @param array - The array.\n * @signature\n *    P.reverse(arr);\n * @example\n *    P.reverse([1, 2, 3]) // [3, 2, 1]\n * @dataFirst\n * @category Array\n */\nexport function reverse<T extends ReadonlyArray<unknown>>(array: T): Reverse<T>;\n\n/**\n * Reverses array.\n *\n * @signature\n *    P.reverse()(array);\n * @example\n *    P.reverse()([1, 2, 3]) // [3, 2, 1]\n * @dataLast\n * @category Array\n */\nexport function reverse<T extends ReadonlyArray<unknown>>(): (\n  array: T,\n) => Reverse<T>;\n\nexport function reverse(...args: ReadonlyArray<unknown>): unknown {\n  return curry(reverseImplementation, args);\n}\n\nfunction reverseImplementation<T>(array: ReadonlyArray<T>): Array<T> {\n  // TODO: When node 18 reaches end-of-life bump target lib to ES2023+ and use `Array.prototype.toReversed` here.\n  return [...array].reverse();\n}\n"],"mappings":"4CA0CA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAK,CAG3C,SAAS,EAAyB,EAAmC,CAEnE,MAAO,CAAC,GAAG,EAAM,CAAC,SAAS"}

package/dist/reverse-ntEUPfSi.d.cts

@@ -0,0 +1,29 @@
+//#region src/reverse.d.ts
+type Reverse<T extends ReadonlyArray<unknown>, R extends ReadonlyArray<unknown> = []> = ReturnType<T extends IsNoTuple<T> ? () => [...T, ...R] : T extends readonly [infer F, ...infer L] ? () => Reverse<L, [F, ...R]> : () => R>;
+type IsNoTuple<T> = T extends readonly [unknown, ...Array<unknown>] ? never : T;
+/**
+ * Reverses array.
+ *
+ * @param array - The array.
+ * @signature
+ *    P.reverse(arr);
+ * @example
+ *    P.reverse([1, 2, 3]) // [3, 2, 1]
+ * @dataFirst
+ * @category Array
+ */
+declare function reverse<T extends ReadonlyArray<unknown>>(array: T): Reverse<T>;
+/**
+ * Reverses array.
+ *
+ * @signature
+ *    P.reverse()(array);
+ * @example
+ *    P.reverse()([1, 2, 3]) // [3, 2, 1]
+ * @dataLast
+ * @category Array
+ */
+declare function reverse<T extends ReadonlyArray<unknown>>(): (array: T) => Reverse<T>;
+//#endregion
+export { reverse };
+//# sourceMappingURL=reverse-ntEUPfSi.d.cts.map

package/dist/reverse-ntEUPfSi.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reverse-ntEUPfSi.d.cts","names":[],"sources":["../src/reverse.ts"],"sourcesContent":[],"mappings":";KAEK,kBACO,kCACA,+BACR,WACF,UAAU,UAAU,eACN,MAAM,KAChB,iDACQ,QAAQ,IAAI,MAAM,YAClB;KAGT,SAXO,CAAA,CAAA,CAAA,GAWQ,CAXR,SAAA,SAAA,CAAA,OAAA,EAAA,GAWwC,KAXxC,CAAA,OAAA,CAAA,CAAA,GAAA,KAAA,GAWkE,CAXlE;;;;;;;;;;;;AAOoB,iBAiBhB,OAjBgB,CAAA,UAiBE,aAjBF,CAAA,OAAA,CAAA,CAAA,CAAA,KAAA,EAiBiC,CAjBjC,CAAA,EAiBqC,OAjBrC,CAiB6C,CAjB7C,CAAA;;;;;AAJlB;;;;;;AAqBE,iBAYA,OAZO,CAAA,UAYW,aAZX,CAAA,OAAA,CAAA,CAAA,CAAA,CAAA,EAAA,CAAA,KAAA,EAad,CAbc,EAAA,GAclB,OAdkB,CAcV,CAdU,CAAA"}

package/dist/reverse.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./reverse-l_bD9Y9C.cjs`);exports.reverse=e.reverse;
+require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./reverse-BC8XHQfI.cjs`);exports.reverse=e.reverse;

package/dist/reverse.d.cts

@@ -1,2 +1,2 @@
-import { reverse } from "./reverse-Bu350kg_.cjs";
+import { reverse } from "./reverse-ntEUPfSi.cjs";
 export { reverse };

package/dist/reverse.d.ts

@@ -1,2 +1,2 @@
-import { reverse } from "./reverse-w5Ru5uLJ.js";
+import { reverse } from "./reverse-BYHaMWmD.js";
 export { reverse };

package/dist/reverse.js

@@ -1 +1 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{reverse as e}from"./reverse-DZc8DCPA.js";export{e as reverse};
+import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{reverse as e}from"./reverse-Qt4C74U1.js";export{e as reverse};

package/dist/round-BiiwjQ6h.d.cts

@@ -0,0 +1,39 @@
+//#region src/round.d.ts
+/**
+ * Rounds a given number to a specific precision.
+ * If you'd like to round to an integer (i.e. use this function with constant `precision === 0`),
+ * use `Math.round` instead, as it won't incur the additional library overhead.
+ *
+ * @param value - The number to round.
+ * @param precision - The precision to round to. Must be an integer between -15 and 15.
+ * @signature
+ *    P.round(value, precision);
+ * @example
+ *    P.round(123.9876, 3) // => 123.988
+ *    P.round(483.22243, 1) // => 483.2
+ *    P.round(8541, -1) // => 8540
+ *    P.round(456789, -3) // => 457000
+ * @dataFirst
+ * @category Number
+ */
+declare function round(value: number, precision: number): number;
+/**
+ * Rounds a given number to a specific precision.
+ * If you'd like to round to an integer (i.e. use this function with constant `precision === 0`),
+ * use `Math.round` instead, as it won't incur the additional library overhead.
+ *
+ * @param precision - The precision to round to. Must be an integer between -15 and 15.
+ * @signature
+ *    P.round(precision)(value);
+ * @example
+ *    P.round(3)(123.9876) // => 123.988
+ *    P.round(1)(483.22243) // => 483.2
+ *    P.round(-1)(8541) // => 8540
+ *    P.round(-3)(456789) // => 457000
+ * @dataLast
+ * @category Number
+ */
+declare function round(precision: number): (value: number) => number;
+//#endregion
+export { round };
+//# sourceMappingURL=round-BiiwjQ6h.d.cts.map

package/dist/round-BiiwjQ6h.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"round-BiiwjQ6h.d.cts","names":[],"sources":["../src/round.ts"],"sourcesContent":[],"mappings":";;AAoBA;AAkBA;;;;;;;;;;;;;;;iBAlBgB,KAAA;;;;;;;;;;;;;;;;;iBAkBA,KAAA"}

package/dist/round-CXiXOypy.d.ts

@@ -0,0 +1,39 @@
+//#region src/round.d.ts
+/**
+ * Rounds a given number to a specific precision.
+ * If you'd like to round to an integer (i.e. use this function with constant `precision === 0`),
+ * use `Math.round` instead, as it won't incur the additional library overhead.
+ *
+ * @param value - The number to round.
+ * @param precision - The precision to round to. Must be an integer between -15 and 15.
+ * @signature
+ *    P.round(value, precision);
+ * @example
+ *    P.round(123.9876, 3) // => 123.988
+ *    P.round(483.22243, 1) // => 483.2
+ *    P.round(8541, -1) // => 8540
+ *    P.round(456789, -3) // => 457000
+ * @dataFirst
+ * @category Number
+ */
+declare function round(value: number, precision: number): number;
+/**
+ * Rounds a given number to a specific precision.
+ * If you'd like to round to an integer (i.e. use this function with constant `precision === 0`),
+ * use `Math.round` instead, as it won't incur the additional library overhead.
+ *
+ * @param precision - The precision to round to. Must be an integer between -15 and 15.
+ * @signature
+ *    P.round(precision)(value);
+ * @example
+ *    P.round(3)(123.9876) // => 123.988
+ *    P.round(1)(483.22243) // => 483.2
+ *    P.round(-1)(8541) // => 8540
+ *    P.round(-3)(456789) // => 457000
+ * @dataLast
+ * @category Number
+ */
+declare function round(precision: number): (value: number) => number;
+//#endregion
+export { round };
+//# sourceMappingURL=round-CXiXOypy.d.ts.map

package/dist/round-CXiXOypy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"round-CXiXOypy.d.ts","names":[],"sources":["../src/round.ts"],"sourcesContent":[],"mappings":";;AAoBA;AAkBA;;;;;;;;;;;;;;;iBAlBgB,KAAA;;;;;;;;;;;;;;;;;iBAkBA,KAAA"}

package/dist/round-D2BDbobr.js

@@ -0,0 +1,2 @@
+import{curry as e}from"./curry-CzZjDrpv.js";import{withPrecision as t}from"./with-precision-BoiuafbM.js";function n(...n){return e(t(Math.round),n)}export{n as round};
+//# sourceMappingURL=round-D2BDbobr.js.map

package/dist/round-D2BDbobr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"round-D2BDbobr.js","names":[],"sources":["../src/round.ts"],"sourcesContent":["import { curry } from './curry';\nimport { withPrecision } from './internal/with-precision';\n\n/**\n * Rounds a given number to a specific precision.\n * If you'd like to round to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.round` instead, as it won't incur the additional library overhead.\n *\n * @param value - The number to round.\n * @param precision - The precision to round to. Must be an integer between -15 and 15.\n * @signature\n *    P.round(value, precision);\n * @example\n *    P.round(123.9876, 3) // => 123.988\n *    P.round(483.22243, 1) // => 483.2\n *    P.round(8541, -1) // => 8540\n *    P.round(456789, -3) // => 457000\n * @dataFirst\n * @category Number\n */\nexport function round(value: number, precision: number): number;\n\n/**\n * Rounds a given number to a specific precision.\n * If you'd like to round to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.round` instead, as it won't incur the additional library overhead.\n *\n * @param precision - The precision to round to. Must be an integer between -15 and 15.\n * @signature\n *    P.round(precision)(value);\n * @example\n *    P.round(3)(123.9876) // => 123.988\n *    P.round(1)(483.22243) // => 483.2\n *    P.round(-1)(8541) // => 8540\n *    P.round(-3)(456789) // => 457000\n * @dataLast\n * @category Number\n */\nexport function round(precision: number): (value: number) => number;\n\nexport function round(...args: ReadonlyArray<unknown>): unknown {\n  return curry(withPrecision(Math.round), args);\n}\n"],"mappings":"yGAwCA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAc,KAAK,MAAM,CAAE,EAAK"}

package/dist/round.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`),require(`./with-precision-BgF-Y_mF.cjs`);const e=require(`./round-CBhbfa_y.cjs`);exports.round=e.round;
+require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`),require(`./with-precision-BgF-Y_mF.cjs`);const e=require(`./round-h0B_SE5h.cjs`);exports.round=e.round;

package/dist/round.d.cts

@@ -1,2 +1,2 @@
-import { round } from "./round-rQiLyN4w.cjs";
+import { round } from "./round-BiiwjQ6h.cjs";
 export { round };

package/dist/round.d.ts

@@ -1,2 +1,2 @@
-import { round } from "./round-BDhuebcp.js";
+import { round } from "./round-CXiXOypy.js";
 export { round };

package/dist/round.js

@@ -1 +1 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import"./with-precision-BoiuafbM.js";import{round as e}from"./round-DhclizH1.js";export{e as round};
+import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import"./with-precision-BoiuafbM.js";import{round as e}from"./round-D2BDbobr.js";export{e as round};

package/dist/sample-BbYf0CTH.d.cts

@@ -0,0 +1,69 @@
+import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
+import { NTuple } from "./n-tuple-Co_jgwEn.cjs";
+import { PartialArray } from "./partial-array-CzOnr197.cjs";
+import { TupleParts } from "./tuple-parts-BIyABPYv.cjs";
+import { CoercedArray } from "./coerced-array-kVJtBrMl.cjs";
+import { FixedLengthArray, IsEqual, IsNever, NonNegativeInteger, Or, Writable } from "type-fest";
+
+//#region src/sample.d.ts
+type Sampled<T extends IterableContainer, N extends number> = Or<IsEqual<N, 0>, IsEqual<T['length'], 0>> extends true ? [] : IsNever<NonNegativeInteger<N>> extends true ? SampledPrimitive<T> : IsLongerThan<T, N> extends true ? SampledLiteral<T, N> : Writable<T>;
+/**
+ * When N is not a non-negative integer **literal** we can't use it in our
+ * reconstructing logic so we fallback to a simpler definition of the output of
+ * sample, which is any sub-tuple shape of T, of **any length**.
+ */
+type SampledPrimitive<T extends IterableContainer> = [...FixedSubTuples<TupleParts<T>['required']>, ...PartialArray<FixedSubTuples<TupleParts<T>['optional']>>, ...CoercedArray<TupleParts<T>['item']>, ...FixedSubTuples<TupleParts<T>['suffix']>];
+/**
+ * Knowing N is a non-negative literal integer we can construct all sub-tuples
+ * of T that are exactly N elements long.
+ */
+type SampledLiteral<T extends IterableContainer, N extends number> = Extract<FixedSubTuples<[...TupleParts<T>['required'], ...(IsNever<TupleParts<T>['item']> extends true ? [] : NTuple<TupleParts<T>['item'], N>), ...TupleParts<T>['suffix']]>, FixedLengthArray<unknown, N>> | SubSampled<TupleParts<T>['required'], TupleParts<T>['item'], TupleParts<T>['suffix'], N>;
+type SubSampled<Prefix extends ReadonlyArray<unknown>, Item, Suffix extends ReadonlyArray<unknown>, N extends number> = IsLongerThan<[...Prefix, ...Suffix], N> extends true ? never : [...Prefix, ...Suffix]['length'] extends N ? never : [...Prefix, ...Suffix] | SubSampled<[...Prefix, Item], Item, Suffix, N>;
+type IsLongerThan<T extends ReadonlyArray<unknown>, N extends number> = IsEqual<T[N], undefined> extends true ? false : true;
+type FixedSubTuples<T> = T extends readonly [infer Head, ...infer Rest] ? FixedSubTuples<Rest> | [Head, ...FixedSubTuples<Rest>] : [];
+/**
+ * Returns a random subset of size `sampleSize` from `array`.
+ *
+ * Maintains and infers most of the typing information that could be passed
+ * along to the output. This means that when using tuples, the output will be
+ * a tuple too, and when using literals, those literals would be preserved.
+ *
+ * The items in the result are kept in the same order as they are in the input.
+ * If you need to get a shuffled response you can pipe the shuffle function
+ * after this one.
+ *
+ * @param data - The array.
+ * @param sampleSize - The number of elements to take.
+ * @signature
+ *    P.sample(array, sampleSize)
+ * @example
+ *    P.sample(["hello", "world"], 1); // => ["hello"] // typed string[]
+ *    P.sample(["hello", "world"] as const, 1); // => ["world"] // typed ["hello" | "world"]
+ * @dataFirst
+ * @category Array
+ */
+declare function sample<const T extends IterableContainer, N extends number = number>(data: T, sampleSize: N): Sampled<T, N>;
+/**
+ * Returns a random subset of size `sampleSize` from `array`.
+ *
+ * Maintains and infers most of the typing information that could be passed
+ * along to the output. This means that when using tuples, the output will be
+ * a tuple too, and when using literals, those literals would be preserved.
+ *
+ * The items in the result are kept in the same order as they are in the input.
+ * If you need to get a shuffled response you can pipe the shuffle function
+ * after this one.
+ *
+ * @param sampleSize - The number of elements to take.
+ * @signature
+ *    P.sample(sampleSize)(array)
+ * @example
+ *    P.sample(1)(["hello", "world"]); // => ["hello"] // typed string[]
+ *    P.sample(1)(["hello", "world"] as const); // => ["world"] // typed ["hello" | "world"]
+ * @dataLast
+ * @category Array
+ */
+declare function sample<const T extends IterableContainer, N extends number = number>(sampleSize: N): (data: T) => Sampled<T, N>;
+//#endregion
+export { sample };
+//# sourceMappingURL=sample-BbYf0CTH.d.cts.map

package/dist/sample-BbYf0CTH.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sample-BbYf0CTH.d.cts","names":[],"sources":["../src/sample.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/sample-Bxl7znd8.js

@@ -0,0 +1,2 @@
+import{curry as e}from"./curry-CzZjDrpv.js";function t(...t){return e(n,t)}function n(e,t){if(t<=0)return[];if(t>=e.length)return[...e];let n=Math.min(t,e.length-t),r=new Set;for(;r.size<n;){let t=Math.floor(Math.random()*e.length);r.add(t)}return t===n?[...r].sort((e,t)=>e-t).map(t=>e[t]):e.filter((e,t)=>!r.has(t))}export{t as sample};
+//# sourceMappingURL=sample-Bxl7znd8.js.map

package/dist/sample-Bxl7znd8.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sample-Bxl7znd8.js","names":[],"sources":["../src/sample.ts"],"sourcesContent":["import type {\n  FixedLengthArray,\n  IsEqual,\n  IsNever,\n  NonNegativeInteger,\n  Or,\n  Writable,\n} from 'type-fest';\nimport type { CoercedArray } from './internal/types/coerced-array';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { NTuple } from './internal/types/n-tuple';\nimport type { PartialArray } from './internal/types/partial-array';\nimport type { TupleParts } from './internal/types/tuple-parts';\nimport { curry } from './curry';\n\ntype Sampled<T extends IterableContainer, N extends number>\n  = Or<IsEqual<N, 0>, IsEqual<T['length'], 0>> extends true\n    // Short-circuit on trivial inputs.\n    ? []\n    : IsNever<NonNegativeInteger<N>> extends true\n      ? SampledPrimitive<T>\n      : IsLongerThan<T, N> extends true\n        ? SampledLiteral<T, N>\n        // If our tuple can never fulfil the sample size the only valid sample\n        // is the whole input tuple. Because it's a shallow clone we also\n        // strip any readonly-ness.\n        : Writable<T>;\n\n/**\n * When N is not a non-negative integer **literal** we can't use it in our\n * reconstructing logic so we fallback to a simpler definition of the output of\n * sample, which is any sub-tuple shape of T, of **any length**.\n */\ntype SampledPrimitive<T extends IterableContainer> = [\n  ...FixedSubTuples<TupleParts<T>['required']>,\n  // TODO: This might be accurate, but We currently have no tests that check optional elements!\n  ...PartialArray<FixedSubTuples<TupleParts<T>['optional']>>,\n  ...CoercedArray<TupleParts<T>['item']>,\n  ...FixedSubTuples<TupleParts<T>['suffix']>,\n];\n/**\n * Knowing N is a non-negative literal integer we can construct all sub-tuples\n * of T that are exactly N elements long.\n */\ntype SampledLiteral<T extends IterableContainer, N extends number>\n  = | Extract<\n      FixedSubTuples<\n        [\n          ...TupleParts<T>['required'],\n          // TODO: This deliberately ignores optional elements which we don't have tests for either. In order to handle optional elements we can treat the \"optional\" tuple-part as more required elements.\n          // We add N elements of the `item` type to the tuple so that we\n          // consider any combination possible of elements of the prefix items,\n          // any amount of rest items, and suffix items.\n          ...(IsNever<TupleParts<T>['item']> extends true\n            ? []\n            : NTuple<TupleParts<T>['item'], N>),\n          ...TupleParts<T>['suffix'],\n        ]\n      >,\n      // This is just [unknown, unknown, ..., unknown] with N elements.\n      FixedLengthArray<unknown, N>\n    >\n  // In addition to all sub-tuples of length N, we also need to consider all\n  // tuples where the input is shorter than N. This will contribute exactly\n  // one sub-tuple at each length from the minimum length of T and up to N-1.\n    | SubSampled<\n      TupleParts<T>['required'],\n      // TODO: This deliberately ignores optional elements which we don't have tests for either. In order to handle optional elements we can treat the \"optional\" tuple-part as more required elements.\n      TupleParts<T>['item'],\n      TupleParts<T>['suffix'],\n      N\n    >;\n\n// We want to create a union of all sub-tuples where we incrementally add an\n// additional element of the type of the rest element in the middle between the\n// prefix and suffix until we \"fill\" the tuple to size N.\ntype SubSampled<\n  Prefix extends ReadonlyArray<unknown>,\n  Item,\n  Suffix extends ReadonlyArray<unknown>,\n  N extends number,\n>\n  = IsLongerThan<[...Prefix, ...Suffix], N> extends true\n    // We need to prevent overflows in case Prefix and Suffix are already long enough\n    ? never\n    : [...Prefix, ...Suffix]['length'] extends N\n        ? never\n        : [...Prefix, ...Suffix] | SubSampled<[...Prefix, Item], Item, Suffix, N>;\n\ntype IsLongerThan<T extends ReadonlyArray<unknown>, N extends number>\n  // Checking for `undefined` is a neat trick to avoid needing to compare\n  // integer literals because if N overflows the tuple then the type for that\n  // element will be `undefined`. This only works for fixed tuples!\n  = IsEqual<T[N], undefined> extends true ? false : true;\n\n// Assuming T is a fixed tuple we build all it's possible sub-tuples.\ntype FixedSubTuples<T> = T extends readonly [infer Head, ...infer Rest]\n  // For each element we either take it or skip it, and recurse over the rest.\n  ? FixedSubTuples<Rest> | [Head, ...FixedSubTuples<Rest>]\n  : [];\n\n/**\n * Returns a random subset of size `sampleSize` from `array`.\n *\n * Maintains and infers most of the typing information that could be passed\n * along to the output. This means that when using tuples, the output will be\n * a tuple too, and when using literals, those literals would be preserved.\n *\n * The items in the result are kept in the same order as they are in the input.\n * If you need to get a shuffled response you can pipe the shuffle function\n * after this one.\n *\n * @param data - The array.\n * @param sampleSize - The number of elements to take.\n * @signature\n *    P.sample(array, sampleSize)\n * @example\n *    P.sample([\"hello\", \"world\"], 1); // => [\"hello\"] // typed string[]\n *    P.sample([\"hello\", \"world\"] as const, 1); // => [\"world\"] // typed [\"hello\" | \"world\"]\n * @dataFirst\n * @category Array\n */\nexport function sample<const T extends IterableContainer, N extends number = number>(\n  data: T,\n  sampleSize: N,\n): Sampled<T, N>;\n\n/**\n * Returns a random subset of size `sampleSize` from `array`.\n *\n * Maintains and infers most of the typing information that could be passed\n * along to the output. This means that when using tuples, the output will be\n * a tuple too, and when using literals, those literals would be preserved.\n *\n * The items in the result are kept in the same order as they are in the input.\n * If you need to get a shuffled response you can pipe the shuffle function\n * after this one.\n *\n * @param sampleSize - The number of elements to take.\n * @signature\n *    P.sample(sampleSize)(array)\n * @example\n *    P.sample(1)([\"hello\", \"world\"]); // => [\"hello\"] // typed string[]\n *    P.sample(1)([\"hello\", \"world\"] as const); // => [\"world\"] // typed [\"hello\" | \"world\"]\n * @dataLast\n * @category Array\n */\nexport function sample<const T extends IterableContainer, N extends number = number>(\n  sampleSize: N,\n): (data: T) => Sampled<T, N>;\n\nexport function sample(...args: ReadonlyArray<unknown>): unknown {\n  return curry(sampleImplementation, args);\n}\n\nfunction sampleImplementation<T>(\n  data: ReadonlyArray<T>,\n  sampleSize: number,\n): Array<T> {\n  if (sampleSize <= 0) {\n    // Trivial\n    return [];\n  }\n\n  if (sampleSize >= data.length) {\n    // Trivial\n    return [...data];\n  }\n\n  // We have 2 modes of sampling, depending on the size of the sample requested.\n  // 1. If sampleSize is _small_, we generate indices that we then use to\n  // *EXTRACT* individual elements from the array.\n  // 2. If sampleSize is _large_, we instead generate indices to *EXCLUDE* from\n  // a full scan of the input array (via filtering).\n  //\n  // This allows us 2 optimizations that are the core of how this function\n  // works:\n  // 1. It is hard to generate a large number of unique indices, as the more\n  // indices we generate the more likely we are to generate one that is already\n  // in the set, which would require more iterations of the generation loop.\n  // Capping our effective sampleSize at n/2 would put an upper limit to the\n  // average number of iterations required (as a function of n).\n  // 2. If sample size is small enough, we never need to actually iterate over\n  // the full input array at all; instead we simply project the values we need\n  // via random access into the array. This means that for sampleSize (K) less\n  // than n/2, we run at O(klogk). For large sampleSize we need to iterate over\n  // the full input array, but we don't need to sort the indices because we can\n  // use the Set's 'has' method, so we effectively run at O(n).\n  const actualSampleSize = Math.min(sampleSize, data.length - sampleSize);\n\n  const sampleIndices = new Set<number>();\n  while (sampleIndices.size < actualSampleSize) {\n    const randomIndex = Math.floor(Math.random() * data.length);\n    sampleIndices.add(randomIndex);\n  }\n\n  if (sampleSize === actualSampleSize) {\n    return [...sampleIndices]\n      .sort((a, b) => a - b)\n      .map((index) => data[index]!);\n  }\n\n  return data.filter((_, index) => !sampleIndices.has(index));\n}\n"],"mappings":"4CAuJA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,EAAK,CAG1C,SAAS,EACP,EACA,EACU,CACV,GAAI,GAAc,EAEhB,MAAO,EAAE,CAGX,GAAI,GAAc,EAAK,OAErB,MAAO,CAAC,GAAG,EAAK,CAsBlB,IAAM,EAAmB,KAAK,IAAI,EAAY,EAAK,OAAS,EAAW,CAEjE,EAAgB,IAAI,IAC1B,KAAO,EAAc,KAAO,GAAkB,CAC5C,IAAM,EAAc,KAAK,MAAM,KAAK,QAAQ,CAAG,EAAK,OAAO,CAC3D,EAAc,IAAI,EAAY,CAShC,OANI,IAAe,EACV,CAAC,GAAG,EAAc,CACtB,MAAM,EAAG,IAAM,EAAI,EAAE,CACrB,IAAK,GAAU,EAAK,GAAQ,CAG1B,EAAK,QAAQ,EAAG,IAAU,CAAC,EAAc,IAAI,EAAM,CAAC"}

package/dist/sample-CaYEaqQj.d.ts

@@ -0,0 +1,69 @@
+import { IterableContainer } from "./iterable-container-F9CDF7ym.js";
+import { NTuple } from "./n-tuple-CU6777y4.js";
+import { PartialArray } from "./partial-array-DSctnYXY.js";
+import { TupleParts } from "./tuple-parts-Du2iVN8H.js";
+import { CoercedArray } from "./coerced-array-Fezc8pIu.js";
+import { FixedLengthArray, IsEqual, IsNever, NonNegativeInteger, Or, Writable } from "type-fest";
+
+//#region src/sample.d.ts
+type Sampled<T extends IterableContainer, N extends number> = Or<IsEqual<N, 0>, IsEqual<T['length'], 0>> extends true ? [] : IsNever<NonNegativeInteger<N>> extends true ? SampledPrimitive<T> : IsLongerThan<T, N> extends true ? SampledLiteral<T, N> : Writable<T>;
+/**
+ * When N is not a non-negative integer **literal** we can't use it in our
+ * reconstructing logic so we fallback to a simpler definition of the output of
+ * sample, which is any sub-tuple shape of T, of **any length**.
+ */
+type SampledPrimitive<T extends IterableContainer> = [...FixedSubTuples<TupleParts<T>['required']>, ...PartialArray<FixedSubTuples<TupleParts<T>['optional']>>, ...CoercedArray<TupleParts<T>['item']>, ...FixedSubTuples<TupleParts<T>['suffix']>];
+/**
+ * Knowing N is a non-negative literal integer we can construct all sub-tuples
+ * of T that are exactly N elements long.
+ */
+type SampledLiteral<T extends IterableContainer, N extends number> = Extract<FixedSubTuples<[...TupleParts<T>['required'], ...(IsNever<TupleParts<T>['item']> extends true ? [] : NTuple<TupleParts<T>['item'], N>), ...TupleParts<T>['suffix']]>, FixedLengthArray<unknown, N>> | SubSampled<TupleParts<T>['required'], TupleParts<T>['item'], TupleParts<T>['suffix'], N>;
+type SubSampled<Prefix extends ReadonlyArray<unknown>, Item, Suffix extends ReadonlyArray<unknown>, N extends number> = IsLongerThan<[...Prefix, ...Suffix], N> extends true ? never : [...Prefix, ...Suffix]['length'] extends N ? never : [...Prefix, ...Suffix] | SubSampled<[...Prefix, Item], Item, Suffix, N>;
+type IsLongerThan<T extends ReadonlyArray<unknown>, N extends number> = IsEqual<T[N], undefined> extends true ? false : true;
+type FixedSubTuples<T> = T extends readonly [infer Head, ...infer Rest] ? FixedSubTuples<Rest> | [Head, ...FixedSubTuples<Rest>] : [];
+/**
+ * Returns a random subset of size `sampleSize` from `array`.
+ *
+ * Maintains and infers most of the typing information that could be passed
+ * along to the output. This means that when using tuples, the output will be
+ * a tuple too, and when using literals, those literals would be preserved.
+ *
+ * The items in the result are kept in the same order as they are in the input.
+ * If you need to get a shuffled response you can pipe the shuffle function
+ * after this one.
+ *
+ * @param data - The array.
+ * @param sampleSize - The number of elements to take.
+ * @signature
+ *    P.sample(array, sampleSize)
+ * @example
+ *    P.sample(["hello", "world"], 1); // => ["hello"] // typed string[]
+ *    P.sample(["hello", "world"] as const, 1); // => ["world"] // typed ["hello" | "world"]
+ * @dataFirst
+ * @category Array
+ */
+declare function sample<const T extends IterableContainer, N extends number = number>(data: T, sampleSize: N): Sampled<T, N>;
+/**
+ * Returns a random subset of size `sampleSize` from `array`.
+ *
+ * Maintains and infers most of the typing information that could be passed
+ * along to the output. This means that when using tuples, the output will be
+ * a tuple too, and when using literals, those literals would be preserved.
+ *
+ * The items in the result are kept in the same order as they are in the input.
+ * If you need to get a shuffled response you can pipe the shuffle function
+ * after this one.
+ *
+ * @param sampleSize - The number of elements to take.
+ * @signature
+ *    P.sample(sampleSize)(array)
+ * @example
+ *    P.sample(1)(["hello", "world"]); // => ["hello"] // typed string[]
+ *    P.sample(1)(["hello", "world"] as const); // => ["world"] // typed ["hello" | "world"]
+ * @dataLast
+ * @category Array
+ */
+declare function sample<const T extends IterableContainer, N extends number = number>(sampleSize: N): (data: T) => Sampled<T, N>;
+//#endregion
+export { sample };
+//# sourceMappingURL=sample-CaYEaqQj.d.ts.map

package/dist/sample-CaYEaqQj.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sample-CaYEaqQj.d.ts","names":[],"sources":["../src/sample.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/sample.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./sample-arGcBCIK.cjs`);exports.sample=e.sample;
+require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./sample-SB8BUKF1.cjs`);exports.sample=e.sample;

package/dist/sample.d.cts

@@ -4,5 +4,5 @@ import "./partial-array-CzOnr197.cjs";
 import "./perkakas-type-error-0tHtaPbi.cjs";
 import "./tuple-parts-BIyABPYv.cjs";
 import "./coerced-array-kVJtBrMl.cjs";
-import { sample } from "./sample-9vI5EmCM.cjs";
+import { sample } from "./sample-BbYf0CTH.cjs";
 export { sample };

package/dist/sample.d.ts

@@ -1,8 +1,8 @@
-import "./iterable-container-wtkYslN_.js";
-import "./n-tuple-BELi5yRe.js";
-import "./partial-array-IoGI5gCo.js";
-import "./perkakas-type-error-Da3ni385.js";
-import "./tuple-parts-BxpZLJ7r.js";
-import "./coerced-array-DyA0Yc12.js";
-import { sample } from "./sample-BHIZQL57.js";
+import "./iterable-container-F9CDF7ym.js";
+import "./n-tuple-CU6777y4.js";
+import "./partial-array-DSctnYXY.js";
+import "./perkakas-type-error-2yBU0Drj.js";
+import "./tuple-parts-Du2iVN8H.js";
+import "./coerced-array-Fezc8pIu.js";
+import { sample } from "./sample-CaYEaqQj.js";
 export { sample };

package/dist/sample.js

@@ -1 +1 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{sample as e}from"./sample-DEt8y7NC.js";export{e as sample};
+import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{sample as e}from"./sample-Bxl7znd8.js";export{e as sample};