@vinicunca/perkakas 1.7.1 → 1.9.0

package/dist/rank-by.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkZLNSRDW7cjs = require('./chunk-ZLNSRDW7.cjs');require('./chunk-EROXO3T4.cjs');require('./chunk-MBGSSEZN.cjs');exports.rankBy = _chunkZLNSRDW7cjs.a;
+require(`./curry-order-rules-UcuuWkKd.cjs`);const e=require(`./rank-by-B_tfHDQl.cjs`);exports.rankBy=e.rankBy;

package/dist/rank-by.d.cts

@@ -1,42 +1,4 @@
-import { O as OrderRule } from './curry-order-rules-BKXCPBNx.cjs';
-import { N as NonEmptyArray } from './non-empty-array-C9Od1wmF.cjs';
-
-/**
- * Calculates the rank of an item in an array based on `rules`. The rank is the position where the item would appear in the sorted array. This function provides an efficient way to determine the rank in *O(n)* time, compared to *O(nlogn)* for the equivalent `sortedIndex(sortBy(data, ...rules), item)`.
- *
- * @param data - The input array.
- * @param item - The item whose rank is to be determined.
- * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
- * @returns The rank of the item in the sorted array in the range [0..data.length].
- * @signature
- *   P.rankBy(data, item, ...rules)
- * @example
- *   const DATA = [{ a: 5 }, { a: 1 }, { a: 3 }] as const;
- *   P.rankBy(DATA, 0, P.prop('a')) // => 0
- *   P.rankBy(DATA, 1, P.prop('a')) // => 1
- *   P.rankBy(DATA, 2, P.prop('a')) // => 1
- *   P.rankBy(DATA, 3, P.prop('a')) // => 2
- * @dataFirst
- * @category Array
- */
-declare function rankBy<T>(data: ReadonlyArray<T>, item: T, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): number;
-/**
- * Calculates the rank of an item in an array based on `rules`. The rank is the position where the item would appear in the sorted array. This function provides an efficient way to determine the rank in *O(n)* time, compared to *O(nlogn)* for the equivalent `sortedIndex(sortBy(data, ...rules), item)`.
- *
- * @param item - The item whose rank is to be determined.
- * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
- * @returns The rank of the item in the sorted array in the range [0..data.length].
- * @signature
- *   P.rankBy(item, ...rules)(data)
- * @example
- *   const DATA = [{ a: 5 }, { a: 1 }, { a: 3 }] as const;
- *   P.pipe(DATA, P.rankBy(0, P.prop('a'))) // => 0
- *   P.pipe(DATA, P.rankBy(1, P.prop('a'))) // => 1
- *   P.pipe(DATA, P.rankBy(2, P.prop('a'))) // => 1
- *   P.pipe(DATA, P.rankBy(3, P.prop('a'))) // => 2
- * @dataLast
- * @category Array
- */
-declare function rankBy<T>(item: T, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): (data: ReadonlyArray<T>) => number;
-
-export { rankBy };
+import "./non-empty-array-D3ZRHApS.cjs";
+import "./curry-order-rules-1zjlAgqa.cjs";
+import { rankBy } from "./rank-by-BbvZnY3X.cjs";
+export { rankBy };

package/dist/rank-by.d.ts

@@ -1,42 +1,4 @@
-import { O as OrderRule } from './curry-order-rules-BKXCPBNx.js';
-import { N as NonEmptyArray } from './non-empty-array-C9Od1wmF.js';
-
-/**
- * Calculates the rank of an item in an array based on `rules`. The rank is the position where the item would appear in the sorted array. This function provides an efficient way to determine the rank in *O(n)* time, compared to *O(nlogn)* for the equivalent `sortedIndex(sortBy(data, ...rules), item)`.
- *
- * @param data - The input array.
- * @param item - The item whose rank is to be determined.
- * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
- * @returns The rank of the item in the sorted array in the range [0..data.length].
- * @signature
- *   P.rankBy(data, item, ...rules)
- * @example
- *   const DATA = [{ a: 5 }, { a: 1 }, { a: 3 }] as const;
- *   P.rankBy(DATA, 0, P.prop('a')) // => 0
- *   P.rankBy(DATA, 1, P.prop('a')) // => 1
- *   P.rankBy(DATA, 2, P.prop('a')) // => 1
- *   P.rankBy(DATA, 3, P.prop('a')) // => 2
- * @dataFirst
- * @category Array
- */
-declare function rankBy<T>(data: ReadonlyArray<T>, item: T, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): number;
-/**
- * Calculates the rank of an item in an array based on `rules`. The rank is the position where the item would appear in the sorted array. This function provides an efficient way to determine the rank in *O(n)* time, compared to *O(nlogn)* for the equivalent `sortedIndex(sortBy(data, ...rules), item)`.
- *
- * @param item - The item whose rank is to be determined.
- * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
- * @returns The rank of the item in the sorted array in the range [0..data.length].
- * @signature
- *   P.rankBy(item, ...rules)(data)
- * @example
- *   const DATA = [{ a: 5 }, { a: 1 }, { a: 3 }] as const;
- *   P.pipe(DATA, P.rankBy(0, P.prop('a'))) // => 0
- *   P.pipe(DATA, P.rankBy(1, P.prop('a'))) // => 1
- *   P.pipe(DATA, P.rankBy(2, P.prop('a'))) // => 1
- *   P.pipe(DATA, P.rankBy(3, P.prop('a'))) // => 2
- * @dataLast
- * @category Array
- */
-declare function rankBy<T>(item: T, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): (data: ReadonlyArray<T>) => number;
-
-export { rankBy };
+import "./non-empty-array-BfTfvDYg.js";
+import "./curry-order-rules-D2zI7gpB.js";
+import { rankBy } from "./rank-by-BAvkwO1T.js";
+export { rankBy };

package/dist/rank-by.js

@@ -1 +1 @@
-import{a}from"./chunk-G57ZPKMR.js";import"./chunk-7KBK2RWQ.js";import"./chunk-EK7ODJWE.js";export{a as rankBy};
+import"./curry-order-rules-BuA7D1F4.js";import{rankBy as e}from"./rank-by-C1qfJCHd.js";export{e as rankBy};

package/dist/reduce-CrxiKHBX.cjs

@@ -0,0 +1 @@
+const e=require(`./curry-BPVIsvo3.cjs`);function t(...t){return e.curry(n,t)}function n(e,t,n){return e.reduce(t,n)}Object.defineProperty(exports,`reduce`,{enumerable:!0,get:function(){return t}});

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 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkH6WDSTL3cjs = require('./chunk-H6WDSTL3.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');require('./chunk-MBGSSEZN.cjs');exports.reduce = _chunkH6WDSTL3cjs.a;
+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,51 +1,2 @@
-/**
- * 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;
-
-export { reduce };
+import { reduce } from "./reduce-jhUIIUcp.cjs";
+export { reduce };

package/dist/reduce.d.ts

@@ -1,51 +1,2 @@
-/**
- * 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;
-
-export { reduce };
+import { reduce } from "./reduce-DeOCr-Lz.js";
+export { reduce };

package/dist/reduce.js

@@ -1 +1 @@
-import{a}from"./chunk-IZWZPKOA.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";import"./chunk-EK7ODJWE.js";export{a 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-BC8XHQfI.cjs

@@ -0,0 +1 @@
+const e=require(`./curry-BPVIsvo3.cjs`);function t(...t){return e.curry(n,t)}function n(e){return[...e].reverse()}Object.defineProperty(exports,`reverse`,{enumerable:!0,get:function(){return t}});

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 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkVAU7HZPOcjs = require('./chunk-VAU7HZPO.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');require('./chunk-MBGSSEZN.cjs');exports.reverse = _chunkVAU7HZPOcjs.a;
+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,27 +1,2 @@
-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>;
-
-export { reverse };
+import { reverse } from "./reverse-ntEUPfSi.cjs";
+export { reverse };

package/dist/reverse.d.ts

@@ -1,27 +1,2 @@
-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>;
-
-export { reverse };
+import { reverse } from "./reverse-BYHaMWmD.js";
+export { reverse };

package/dist/reverse.js

@@ -1 +1 @@
-import{a}from"./chunk-JNQXGRDN.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";import"./chunk-EK7ODJWE.js";export{a 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