@vinicunca/perkakas 1.8.0 → 1.9.0

package/dist/sort-BZjbaFeJ.d.cts

@@ -0,0 +1,39 @@
+import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
+import { ReorderedArray } from "./reordered-array-ikr9o4WE.cjs";
+
+//#region src/sort.d.ts
+
+/**
+ * Sorts an array. The comparator function should accept two values at a time
+ * and return a negative number if the first value is smaller, a positive number
+ * if it's larger, and zero if they are equal. Sorting is based on a native
+ * `sort` function.
+ *
+ * @param items - The array to sort.
+ * @param cmp - The comparator function.
+ * @signature
+ *    P.sort(items, cmp)
+ * @example
+ *    P.sort([4, 2, 7, 5], (a, b) => a - b); // => [2, 4, 5, 7]
+ * @dataFirst
+ * @category Array
+ */
+declare function sort<T extends IterableContainer>(items: T, cmp: (a: T[number], b: T[number]) => number): ReorderedArray<T>;
+/**
+ * Sorts an array. The comparator function should accept two values at a time
+ * and return a negative number if the first value is smaller, a positive number
+ * if it's larger, and zero if they are equal. Sorting is based on a native
+ * `sort` function.
+ *
+ * @param cmp - The comparator function.
+ * @signature
+ *    P.sort(cmp)(items)
+ * @example
+ *    P.pipe([4, 2, 7, 5], P.sort((a, b) => a - b)) // => [2, 4, 5, 7]
+ * @dataLast
+ * @category Array
+ */
+declare function sort<T extends IterableContainer>(cmp: (a: T[number], b: T[number]) => number): (items: T) => ReorderedArray<T>;
+//#endregion
+export { sort };
+//# sourceMappingURL=sort-BZjbaFeJ.d.cts.map

package/dist/sort-BZjbaFeJ.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-BZjbaFeJ.d.cts","names":[],"sources":["../src/sort.ts"],"sourcesContent":[],"mappings":";;;;;;;AAmBA;;;;;;;;;AAmBA;;;;AACyB,iBApBT,IAoBS,CAAA,UApBM,iBAoBN,CAAA,CAAA,KAAA,EAnBhB,CAmBgB,EAAA,GAAA,EAAA,CAAA,CAAA,EAlBd,CAkBc,CAAA,MAAA,CAAA,EAAA,CAAA,EAlBA,CAkBA,CAAA,MAAA,CAAA,EAAA,GAAA,MAAA,CAAA,EAjBtB,cAiBsB,CAjBP,CAiBO,CAAA;;;;;;;;;;;;;;;iBADT,eAAe,4BACpB,cAAc,+BACd,MAAM,eAAe"}

package/dist/sort-BpxPLnEH.d.ts

@@ -0,0 +1,39 @@
+import { IterableContainer } from "./iterable-container-F9CDF7ym.js";
+import { ReorderedArray } from "./reordered-array-BJFUtOkp.js";
+
+//#region src/sort.d.ts
+
+/**
+ * Sorts an array. The comparator function should accept two values at a time
+ * and return a negative number if the first value is smaller, a positive number
+ * if it's larger, and zero if they are equal. Sorting is based on a native
+ * `sort` function.
+ *
+ * @param items - The array to sort.
+ * @param cmp - The comparator function.
+ * @signature
+ *    P.sort(items, cmp)
+ * @example
+ *    P.sort([4, 2, 7, 5], (a, b) => a - b); // => [2, 4, 5, 7]
+ * @dataFirst
+ * @category Array
+ */
+declare function sort<T extends IterableContainer>(items: T, cmp: (a: T[number], b: T[number]) => number): ReorderedArray<T>;
+/**
+ * Sorts an array. The comparator function should accept two values at a time
+ * and return a negative number if the first value is smaller, a positive number
+ * if it's larger, and zero if they are equal. Sorting is based on a native
+ * `sort` function.
+ *
+ * @param cmp - The comparator function.
+ * @signature
+ *    P.sort(cmp)(items)
+ * @example
+ *    P.pipe([4, 2, 7, 5], P.sort((a, b) => a - b)) // => [2, 4, 5, 7]
+ * @dataLast
+ * @category Array
+ */
+declare function sort<T extends IterableContainer>(cmp: (a: T[number], b: T[number]) => number): (items: T) => ReorderedArray<T>;
+//#endregion
+export { sort };
+//# sourceMappingURL=sort-BpxPLnEH.d.ts.map

package/dist/sort-BpxPLnEH.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-BpxPLnEH.d.ts","names":[],"sources":["../src/sort.ts"],"sourcesContent":[],"mappings":";;;;;;;AAmBA;;;;;;;;;AAmBA;;;;AACyB,iBApBT,IAoBS,CAAA,UApBM,iBAoBN,CAAA,CAAA,KAAA,EAnBhB,CAmBgB,EAAA,GAAA,EAAA,CAAA,CAAA,EAlBd,CAkBc,CAAA,MAAA,CAAA,EAAA,CAAA,EAlBA,CAkBA,CAAA,MAAA,CAAA,EAAA,GAAA,MAAA,CAAA,EAjBtB,cAiBsB,CAjBP,CAiBO,CAAA;;;;;;;;;;;;;;;iBADT,eAAe,4BACpB,cAAc,+BACd,MAAM,eAAe"}

package/dist/sort-D6nlyfod.js

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

package/dist/sort-D6nlyfod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-D6nlyfod.js","names":[],"sources":["../src/sort.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { ReorderedArray } from './internal/types/reordered-array';\nimport { curry } from './curry';\n\n/**\n * Sorts an array. The comparator function should accept two values at a time\n * and return a negative number if the first value is smaller, a positive number\n * if it's larger, and zero if they are equal. Sorting is based on a native\n * `sort` function.\n *\n * @param items - The array to sort.\n * @param cmp - The comparator function.\n * @signature\n *    P.sort(items, cmp)\n * @example\n *    P.sort([4, 2, 7, 5], (a, b) => a - b); // => [2, 4, 5, 7]\n * @dataFirst\n * @category Array\n */\nexport function sort<T extends IterableContainer>(\n  items: T,\n  cmp: (a: T[number], b: T[number]) => number,\n): ReorderedArray<T>;\n\n/**\n * Sorts an array. The comparator function should accept two values at a time\n * and return a negative number if the first value is smaller, a positive number\n * if it's larger, and zero if they are equal. Sorting is based on a native\n * `sort` function.\n *\n * @param cmp - The comparator function.\n * @signature\n *    P.sort(cmp)(items)\n * @example\n *    P.pipe([4, 2, 7, 5], P.sort((a, b) => a - b)) // => [2, 4, 5, 7]\n * @dataLast\n * @category Array\n */\nexport function sort<T extends IterableContainer>(\n  cmp: (a: T[number], b: T[number]) => number,\n): (items: T) => ReorderedArray<T>;\n\nexport function sort(...args: ReadonlyArray<unknown>): unknown {\n  return curry(sortImplementation, args);\n}\n\nfunction sortImplementation<T extends IterableContainer>(\n  items: T,\n  cmp: (a: T[number], b: T[number]) => number,\n): ReorderedArray<T> {\n  const ret = [...items];\n  ret.sort(cmp);\n  return ret as ReorderedArray<T>;\n}\n"],"mappings":"4CA0CA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,EAAoB,EAAK,CAGxC,SAAS,EACP,EACA,EACmB,CACnB,IAAM,EAAM,CAAC,GAAG,EAAM,CAEtB,OADA,EAAI,KAAK,EAAI,CACN"}

package/dist/sort-by-8to821Mp.js

@@ -0,0 +1,2 @@
+import{curryOrderRules as e}from"./curry-order-rules-BuA7D1F4.js";function t(...t){return e(n,t)}function n(e,t){return[...e].sort(t)}export{t as sortBy};
+//# sourceMappingURL=sort-by-8to821Mp.js.map

package/dist/sort-by-8to821Mp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-by-8to821Mp.js","names":[],"sources":["../src/sort-by.ts"],"sourcesContent":["import type { OrderRule } from './internal/curry-order-rules';\nimport type { CompareFunction } from './internal/types/compare-function';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { NonEmptyArray } from './internal/types/non-empty-array';\nimport type { ReorderedArray } from './internal/types/reordered-array';\nimport { curryOrderRules } from './internal/curry-order-rules';\n\n/**\n * Sorts `data` using the provided ordering rules. The `sort` is done via the\n * native `Array.prototype.sort` but is performed on a shallow copy of the array\n * to avoid mutating the original data.\n *\n * There are several other functions that take order rules and **bypass** the\n * need to sort the array first (in *O(nlogn)* time):\n * `firstBy` === `first(sortBy(data, ...rules))`, O(n).\n * `takeFirstBy` === `take(sortBy(data, ...rules), k)`, O(nlogk).\n * `dropFirstBy` === `drop(sortBy(data, ...rules), k)`, O(nlogk).\n * `nthBy` === `sortBy(data, ...rules).at(k)`, O(n).\n * `rankBy` === `sortedIndex(sortBy(data, ...rules), item)`, O(n).\n * Refer to the docs for more details.\n *\n * @param sortRules - A variadic array of order rules defining the sorting\n * criteria. Each order rule is a projection function that extracts a comparable\n * value from the data. Sorting is based on these extracted values using the\n * native `<` and `>` operators. Earlier rules take precedence over later ones.\n * Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns A shallow copy of the input array sorted by the provided rules.\n * @signature\n *    P.sortBy(...rules)(data)\n * @example\n *    P.pipe(\n *      [{ a: 1 }, { a: 3 }, { a: 7 }, { a: 2 }],\n *      P.sortBy(P.prop('a')),\n *    ); // => [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 7 }]\n * @dataLast\n * @category Array\n */\nexport function sortBy<T extends IterableContainer>(\n  ...sortRules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): (array: T) => ReorderedArray<T>;\n\n/**\n * Sorts `data` using the provided ordering rules. The `sort` is done via the\n * native `Array.prototype.sort` but is performed on a shallow copy of the array\n * to avoid mutating the original data.\n *\n * There are several other functions that take order rules and **bypass** the\n * need to sort the array first (in *O(nlogn)* time):\n * `firstBy` === `first(sortBy(data, ...rules))`, O(n).\n * `takeFirstBy` === `take(sortBy(data, ...rules), k)`, O(nlogk).\n * `dropFirstBy` === `drop(sortBy(data, ...rules), k)`, O(nlogk).\n * `nthBy` === `sortBy(data, ...rules).at(k)`, O(n).\n * `rankBy` === `sortedIndex(sortBy(data, ...rules), item)`, O(n).\n * Refer to the docs for more details.\n *\n * @param array - The input array.\n * @param sortRules - A variadic array of order rules defining the sorting\n * criteria. Each order rule is a projection function that extracts a comparable\n * value from the data. Sorting is based on these extracted values using the\n * native `<` and `>` operators. Earlier rules take precedence over later ones.\n * Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns A shallow copy of the input array sorted by the provided rules.\n * @signature\n *    P.sortBy(data, ...rules)\n * @example\n *    P.sortBy(\n *      [{ a: 1 }, { a: 3 }, { a: 7 }, { a: 2 }],\n *      prop('a'),\n *    );  // => [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 7 }]\n *    P.sortBy(\n *      [\n *        {color: 'red', weight: 2},\n *        {color: 'blue', weight: 3},\n *        {color: 'green', weight: 1},\n *        {color: 'purple', weight: 1},\n *      ],\n *      [prop('weight'), 'asc'],\n *      prop('color'),\n *    ); // => [\n *    //   {color: 'green', weight: 1},\n *    //   {color: 'purple', weight: 1},\n *    //   {color: 'red', weight: 2},\n *    //   {color: 'blue', weight: 3},\n *    // ]\n * @dataFirst\n * @category Array\n */\nexport function sortBy<T extends IterableContainer>(\n  array: T,\n  ...sortRules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): ReorderedArray<T>;\n\nexport function sortBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryOrderRules(sortByImplementation, args);\n}\n\nfunction sortByImplementation<T>(\n  data: ReadonlyArray<T>,\n  compareFn: CompareFunction<T>,\n): Array<T> {\n  // TODO: When node 18 reaches end-of-life bump target lib to ES2023+ and use `Array.prototype.toSorted` here.\n  return [...data].sort(compareFn);\n}\n"],"mappings":"kEA4FA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAgB,EAAsB,EAAK,CAGpD,SAAS,EACP,EACA,EACU,CAEV,MAAO,CAAC,GAAG,EAAK,CAAC,KAAK,EAAU"}

package/dist/sort-by-CH6n9bWf.d.ts

@@ -0,0 +1,88 @@
+import { IterableContainer } from "./iterable-container-F9CDF7ym.js";
+import { NonEmptyArray } from "./non-empty-array-BfTfvDYg.js";
+import { OrderRule } from "./curry-order-rules-D2zI7gpB.js";
+import { ReorderedArray } from "./reordered-array-BJFUtOkp.js";
+
+//#region src/sort-by.d.ts
+
+/**
+ * Sorts `data` using the provided ordering rules. The `sort` is done via the
+ * native `Array.prototype.sort` but is performed on a shallow copy of the array
+ * to avoid mutating the original data.
+ *
+ * There are several other functions that take order rules and **bypass** the
+ * need to sort the array first (in *O(nlogn)* time):
+ * `firstBy` === `first(sortBy(data, ...rules))`, O(n).
+ * `takeFirstBy` === `take(sortBy(data, ...rules), k)`, O(nlogk).
+ * `dropFirstBy` === `drop(sortBy(data, ...rules), k)`, O(nlogk).
+ * `nthBy` === `sortBy(data, ...rules).at(k)`, O(n).
+ * `rankBy` === `sortedIndex(sortBy(data, ...rules), item)`, O(n).
+ * Refer to the docs for more details.
+ *
+ * @param sortRules - 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 A shallow copy of the input array sorted by the provided rules.
+ * @signature
+ *    P.sortBy(...rules)(data)
+ * @example
+ *    P.pipe(
+ *      [{ a: 1 }, { a: 3 }, { a: 7 }, { a: 2 }],
+ *      P.sortBy(P.prop('a')),
+ *    ); // => [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 7 }]
+ * @dataLast
+ * @category Array
+ */
+declare function sortBy<T extends IterableContainer>(...sortRules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): (array: T) => ReorderedArray<T>;
+/**
+ * Sorts `data` using the provided ordering rules. The `sort` is done via the
+ * native `Array.prototype.sort` but is performed on a shallow copy of the array
+ * to avoid mutating the original data.
+ *
+ * There are several other functions that take order rules and **bypass** the
+ * need to sort the array first (in *O(nlogn)* time):
+ * `firstBy` === `first(sortBy(data, ...rules))`, O(n).
+ * `takeFirstBy` === `take(sortBy(data, ...rules), k)`, O(nlogk).
+ * `dropFirstBy` === `drop(sortBy(data, ...rules), k)`, O(nlogk).
+ * `nthBy` === `sortBy(data, ...rules).at(k)`, O(n).
+ * `rankBy` === `sortedIndex(sortBy(data, ...rules), item)`, O(n).
+ * Refer to the docs for more details.
+ *
+ * @param array - The input array.
+ * @param sortRules - 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 A shallow copy of the input array sorted by the provided rules.
+ * @signature
+ *    P.sortBy(data, ...rules)
+ * @example
+ *    P.sortBy(
+ *      [{ a: 1 }, { a: 3 }, { a: 7 }, { a: 2 }],
+ *      prop('a'),
+ *    );  // => [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 7 }]
+ *    P.sortBy(
+ *      [
+ *        {color: 'red', weight: 2},
+ *        {color: 'blue', weight: 3},
+ *        {color: 'green', weight: 1},
+ *        {color: 'purple', weight: 1},
+ *      ],
+ *      [prop('weight'), 'asc'],
+ *      prop('color'),
+ *    ); // => [
+ *    //   {color: 'green', weight: 1},
+ *    //   {color: 'purple', weight: 1},
+ *    //   {color: 'red', weight: 2},
+ *    //   {color: 'blue', weight: 3},
+ *    // ]
+ * @dataFirst
+ * @category Array
+ */
+declare function sortBy<T extends IterableContainer>(array: T, ...sortRules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): ReorderedArray<T>;
+//#endregion
+export { sortBy };
+//# sourceMappingURL=sort-by-CH6n9bWf.d.ts.map

package/dist/sort-by-CH6n9bWf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-by-CH6n9bWf.d.ts","names":[],"sources":["../src/sort-by.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAqCA;;;;;;;;;;;AAkDA;;;;;;;;;;;;;;;;;iBAlDgB,iBAAiB,iCACjB,SAAS,cAAc,UAAU,uBACtC,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgDhB,iBAAiB,0BACxB,iBACO,SAAS,cAAc,UAAU,eAC9C,eAAe"}

package/dist/sort-by-DoBfFSu4.d.cts

@@ -0,0 +1,88 @@
+import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
+import { NonEmptyArray } from "./non-empty-array-D3ZRHApS.cjs";
+import { OrderRule } from "./curry-order-rules-1zjlAgqa.cjs";
+import { ReorderedArray } from "./reordered-array-ikr9o4WE.cjs";
+
+//#region src/sort-by.d.ts
+
+/**
+ * Sorts `data` using the provided ordering rules. The `sort` is done via the
+ * native `Array.prototype.sort` but is performed on a shallow copy of the array
+ * to avoid mutating the original data.
+ *
+ * There are several other functions that take order rules and **bypass** the
+ * need to sort the array first (in *O(nlogn)* time):
+ * `firstBy` === `first(sortBy(data, ...rules))`, O(n).
+ * `takeFirstBy` === `take(sortBy(data, ...rules), k)`, O(nlogk).
+ * `dropFirstBy` === `drop(sortBy(data, ...rules), k)`, O(nlogk).
+ * `nthBy` === `sortBy(data, ...rules).at(k)`, O(n).
+ * `rankBy` === `sortedIndex(sortBy(data, ...rules), item)`, O(n).
+ * Refer to the docs for more details.
+ *
+ * @param sortRules - 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 A shallow copy of the input array sorted by the provided rules.
+ * @signature
+ *    P.sortBy(...rules)(data)
+ * @example
+ *    P.pipe(
+ *      [{ a: 1 }, { a: 3 }, { a: 7 }, { a: 2 }],
+ *      P.sortBy(P.prop('a')),
+ *    ); // => [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 7 }]
+ * @dataLast
+ * @category Array
+ */
+declare function sortBy<T extends IterableContainer>(...sortRules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): (array: T) => ReorderedArray<T>;
+/**
+ * Sorts `data` using the provided ordering rules. The `sort` is done via the
+ * native `Array.prototype.sort` but is performed on a shallow copy of the array
+ * to avoid mutating the original data.
+ *
+ * There are several other functions that take order rules and **bypass** the
+ * need to sort the array first (in *O(nlogn)* time):
+ * `firstBy` === `first(sortBy(data, ...rules))`, O(n).
+ * `takeFirstBy` === `take(sortBy(data, ...rules), k)`, O(nlogk).
+ * `dropFirstBy` === `drop(sortBy(data, ...rules), k)`, O(nlogk).
+ * `nthBy` === `sortBy(data, ...rules).at(k)`, O(n).
+ * `rankBy` === `sortedIndex(sortBy(data, ...rules), item)`, O(n).
+ * Refer to the docs for more details.
+ *
+ * @param array - The input array.
+ * @param sortRules - 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 A shallow copy of the input array sorted by the provided rules.
+ * @signature
+ *    P.sortBy(data, ...rules)
+ * @example
+ *    P.sortBy(
+ *      [{ a: 1 }, { a: 3 }, { a: 7 }, { a: 2 }],
+ *      prop('a'),
+ *    );  // => [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 7 }]
+ *    P.sortBy(
+ *      [
+ *        {color: 'red', weight: 2},
+ *        {color: 'blue', weight: 3},
+ *        {color: 'green', weight: 1},
+ *        {color: 'purple', weight: 1},
+ *      ],
+ *      [prop('weight'), 'asc'],
+ *      prop('color'),
+ *    ); // => [
+ *    //   {color: 'green', weight: 1},
+ *    //   {color: 'purple', weight: 1},
+ *    //   {color: 'red', weight: 2},
+ *    //   {color: 'blue', weight: 3},
+ *    // ]
+ * @dataFirst
+ * @category Array
+ */
+declare function sortBy<T extends IterableContainer>(array: T, ...sortRules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): ReorderedArray<T>;
+//#endregion
+export { sortBy };
+//# sourceMappingURL=sort-by-DoBfFSu4.d.cts.map

package/dist/sort-by-DoBfFSu4.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-by-DoBfFSu4.d.cts","names":[],"sources":["../src/sort-by.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAqCA;;;;;;;;;;;AAkDA;;;;;;;;;;;;;;;;;iBAlDgB,iBAAiB,iCACjB,SAAS,cAAc,UAAU,uBACtC,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgDhB,iBAAiB,0BACxB,iBACO,SAAS,cAAc,UAAU,eAC9C,eAAe"}

package/dist/sort-by.cjs

@@ -1 +1 @@
-require(`./curry-order-rules-UcuuWkKd.cjs`);const e=require(`./sort-by-DBCZSbb4.cjs`);exports.sortBy=e.sortBy;
+require(`./curry-order-rules-UcuuWkKd.cjs`);const e=require(`./sort-by-CtJoPjKN.cjs`);exports.sortBy=e.sortBy;

package/dist/sort-by.d.cts

@@ -1,6 +1,6 @@
 import "./iterable-container-V5sa0V_H.cjs";
 import "./non-empty-array-D3ZRHApS.cjs";
 import "./curry-order-rules-1zjlAgqa.cjs";
-import "./reordered-array-CNK-grX0.cjs";
-import { sortBy } from "./sort-by-CrMqBzvd.cjs";
+import "./reordered-array-ikr9o4WE.cjs";
+import { sortBy } from "./sort-by-DoBfFSu4.cjs";
 export { sortBy };

package/dist/sort-by.d.ts

@@ -1,6 +1,6 @@
-import "./iterable-container-wtkYslN_.js";
-import "./non-empty-array-D3HWDPMt.js";
-import "./curry-order-rules-Cthu8rj4.js";
-import "./reordered-array-BJtughHE.js";
-import { sortBy } from "./sort-by-ovbQMg9U.js";
+import "./iterable-container-F9CDF7ym.js";
+import "./non-empty-array-BfTfvDYg.js";
+import "./curry-order-rules-D2zI7gpB.js";
+import "./reordered-array-BJFUtOkp.js";
+import { sortBy } from "./sort-by-CH6n9bWf.js";
 export { sortBy };

package/dist/sort-by.js

@@ -1 +1 @@
-import"./curry-order-rules-BuA7D1F4.js";import{sortBy as e}from"./sort-by-DPlbBz7L.js";export{e as sortBy};
+import"./curry-order-rules-BuA7D1F4.js";import{sortBy as e}from"./sort-by-8to821Mp.js";export{e as sortBy};

package/dist/sort.cjs

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

package/dist/sort.d.cts

@@ -1,4 +1,4 @@
 import "./iterable-container-V5sa0V_H.cjs";
-import "./reordered-array-CNK-grX0.cjs";
-import { sort } from "./sort-CTZy6xBq.cjs";
+import "./reordered-array-ikr9o4WE.cjs";
+import { sort } from "./sort-BZjbaFeJ.cjs";
 export { sort };

package/dist/sort.d.ts

@@ -1,4 +1,4 @@
-import "./iterable-container-wtkYslN_.js";
-import "./reordered-array-BJtughHE.js";
-import { sort } from "./sort-CVjvrZjo.js";
+import "./iterable-container-F9CDF7ym.js";
+import "./reordered-array-BJFUtOkp.js";
+import { sort } from "./sort-BpxPLnEH.js";
 export { sort };

package/dist/sort.js

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

package/dist/sorted-index-C7n8fUow.d.ts

@@ -0,0 +1,45 @@
+//#region src/sorted-index.d.ts
+/**
+ * Find the insertion position (index) of an item in an array with items sorted
+ * in ascending order; so that `splice(sortedIndex, 0, item)` would result in
+ * maintaining the array's sort-ness. The array can contain duplicates.
+ * If the item already exists in the array the index would be of the *first*
+ * occurrence of the item.
+ *
+ * Runs in O(logN) time.
+ *
+ * @param data - The (ascending) sorted array.
+ * @param item - The item to insert.
+ * @returns Insertion index (In the range 0..array.length).
+ * @signature
+ *    P.sortedIndex(data, item)
+ * @example
+ *    P.sortedIndex(['a','a','b','c','c'], 'c') // => 3
+ * @dataFirst
+ * @category Array
+ * @see sortedIndexBy, sortedIndexWith, sortedLastIndex, sortedLastIndexBy
+ */
+declare function sortedIndex<T>(data: ReadonlyArray<T>, item: T): number;
+/**
+ * Find the insertion position (index) of an item in an array with items sorted
+ * in ascending order; so that `splice(sortedIndex, 0, item)` would result in
+ * maintaining the array's sort-ness. The array can contain duplicates.
+ * If the item already exists in the array the index would be of the *first*
+ * occurrence of the item.
+ *
+ * Runs in O(logN) time.
+ *
+ * @param item - The item to insert.
+ * @returns Insertion index (In the range 0..array.length).
+ * @signature
+ *    P.sortedIndex(item)(data)
+ * @example
+ *    P.pipe(['a','a','b','c','c'], P.sortedIndex('c')) // => 3
+ * @dataLast
+ * @category Array
+ * @see sortedIndexBy, sortedIndexWith, sortedLastIndex, sortedLastIndexBy
+ */
+declare function sortedIndex<T>(item: T): (data: ReadonlyArray<T>) => number;
+//#endregion
+export { sortedIndex };
+//# sourceMappingURL=sorted-index-C7n8fUow.d.ts.map

package/dist/sorted-index-C7n8fUow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sorted-index-C7n8fUow.d.ts","names":[],"sources":["../src/sorted-index.ts"],"sourcesContent":[],"mappings":";;AAuBA;;;;;;AAqBA;;;;;;;;;;;;;iBArBgB,qBAAqB,cAAc,UAAU;;;;;;;;;;;;;;;;;;;;iBAqB7C,qBAAqB,WAAW,cAAc"}

package/dist/sorted-index-Cb-4kSWR.js

@@ -0,0 +1,2 @@
+import{curry as e}from"./curry-CzZjDrpv.js";import{binarySearchCutoffIndex as t}from"./binary-search-cutoff-index-YVs_m4IY.js";function n(...t){return e(r,t)}function r(e,n){return t(e,e=>e<n)}export{n as sortedIndex};
+//# sourceMappingURL=sorted-index-Cb-4kSWR.js.map

package/dist/sorted-index-Cb-4kSWR.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sorted-index-Cb-4kSWR.js","names":[],"sources":["../src/sorted-index.ts"],"sourcesContent":["import { curry } from './curry';\nimport { binarySearchCutoffIndex } from './internal/binary-search-cutoff-index';\n\n/**\n * Find the insertion position (index) of an item in an array with items sorted\n * in ascending order; so that `splice(sortedIndex, 0, item)` would result in\n * maintaining the array's sort-ness. The array can contain duplicates.\n * If the item already exists in the array the index would be of the *first*\n * occurrence of the item.\n *\n * Runs in O(logN) time.\n *\n * @param data - The (ascending) sorted array.\n * @param item - The item to insert.\n * @returns Insertion index (In the range 0..array.length).\n * @signature\n *    P.sortedIndex(data, item)\n * @example\n *    P.sortedIndex(['a','a','b','c','c'], 'c') // => 3\n * @dataFirst\n * @category Array\n * @see sortedIndexBy, sortedIndexWith, sortedLastIndex, sortedLastIndexBy\n */\nexport function sortedIndex<T>(data: ReadonlyArray<T>, item: T): number;\n\n/**\n * Find the insertion position (index) of an item in an array with items sorted\n * in ascending order; so that `splice(sortedIndex, 0, item)` would result in\n * maintaining the array's sort-ness. The array can contain duplicates.\n * If the item already exists in the array the index would be of the *first*\n * occurrence of the item.\n *\n * Runs in O(logN) time.\n *\n * @param item - The item to insert.\n * @returns Insertion index (In the range 0..array.length).\n * @signature\n *    P.sortedIndex(item)(data)\n * @example\n *    P.pipe(['a','a','b','c','c'], P.sortedIndex('c')) // => 3\n * @dataLast\n * @category Array\n * @see sortedIndexBy, sortedIndexWith, sortedLastIndex, sortedLastIndexBy\n */\nexport function sortedIndex<T>(item: T): (data: ReadonlyArray<T>) => number;\n\nexport function sortedIndex(...args: ReadonlyArray<unknown>): unknown {\n  return curry(sortedIndexImplementation, args);\n}\n\nfunction sortedIndexImplementation<T>(\n  array: ReadonlyArray<T>,\n  item: T,\n): number {\n  return binarySearchCutoffIndex(array, (pivot) => pivot < item);\n}\n"],"mappings":"+HA8CA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,EAA2B,EAAK,CAG/C,SAAS,EACP,EACA,EACQ,CACR,OAAO,EAAwB,EAAQ,GAAU,EAAQ,EAAK"}

package/dist/sorted-index-WmPsJZWy.d.cts

@@ -0,0 +1,45 @@
+//#region src/sorted-index.d.ts
+/**
+ * Find the insertion position (index) of an item in an array with items sorted
+ * in ascending order; so that `splice(sortedIndex, 0, item)` would result in
+ * maintaining the array's sort-ness. The array can contain duplicates.
+ * If the item already exists in the array the index would be of the *first*
+ * occurrence of the item.
+ *
+ * Runs in O(logN) time.
+ *
+ * @param data - The (ascending) sorted array.
+ * @param item - The item to insert.
+ * @returns Insertion index (In the range 0..array.length).
+ * @signature
+ *    P.sortedIndex(data, item)
+ * @example
+ *    P.sortedIndex(['a','a','b','c','c'], 'c') // => 3
+ * @dataFirst
+ * @category Array
+ * @see sortedIndexBy, sortedIndexWith, sortedLastIndex, sortedLastIndexBy
+ */
+declare function sortedIndex<T>(data: ReadonlyArray<T>, item: T): number;
+/**
+ * Find the insertion position (index) of an item in an array with items sorted
+ * in ascending order; so that `splice(sortedIndex, 0, item)` would result in
+ * maintaining the array's sort-ness. The array can contain duplicates.
+ * If the item already exists in the array the index would be of the *first*
+ * occurrence of the item.
+ *
+ * Runs in O(logN) time.
+ *
+ * @param item - The item to insert.
+ * @returns Insertion index (In the range 0..array.length).
+ * @signature
+ *    P.sortedIndex(item)(data)
+ * @example
+ *    P.pipe(['a','a','b','c','c'], P.sortedIndex('c')) // => 3
+ * @dataLast
+ * @category Array
+ * @see sortedIndexBy, sortedIndexWith, sortedLastIndex, sortedLastIndexBy
+ */
+declare function sortedIndex<T>(item: T): (data: ReadonlyArray<T>) => number;
+//#endregion
+export { sortedIndex };
+//# sourceMappingURL=sorted-index-WmPsJZWy.d.cts.map

package/dist/sorted-index-WmPsJZWy.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sorted-index-WmPsJZWy.d.cts","names":[],"sources":["../src/sorted-index.ts"],"sourcesContent":[],"mappings":";;AAuBA;;;;;;AAqBA;;;;;;;;;;;;;iBArBgB,qBAAqB,cAAc,UAAU;;;;;;;;;;;;;;;;;;;;iBAqB7C,qBAAqB,WAAW,cAAc"}

package/dist/sorted-index-by-BGDi-4BL.cjs

@@ -0,0 +1 @@
+const e=require(`./curry-BPVIsvo3.cjs`),t=require(`./binary-search-cutoff-index-BZF3GL7H.cjs`);function n(...t){return e.curry(r,t)}function r(e,n,r){let i=r(n,void 0,e);return t.binarySearchCutoffIndex(e,(t,n)=>r(t,n,e)<i)}Object.defineProperty(exports,`sortedIndexBy`,{enumerable:!0,get:function(){return n}});

package/dist/sorted-index-by-C-5Yb-j2.js

@@ -0,0 +1,2 @@
+import{curry as e}from"./curry-CzZjDrpv.js";import{binarySearchCutoffIndex as t}from"./binary-search-cutoff-index-YVs_m4IY.js";function n(...t){return e(r,t)}function r(e,n,r){let i=r(n,void 0,e);return t(e,(t,n)=>r(t,n,e)<i)}export{n as sortedIndexBy};
+//# sourceMappingURL=sorted-index-by-C-5Yb-j2.js.map

package/dist/sorted-index-by-C-5Yb-j2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sorted-index-by-C-5Yb-j2.js","names":[],"sources":["../src/sorted-index-by.ts"],"sourcesContent":["import { curry } from './curry';\nimport { binarySearchCutoffIndex } from './internal/binary-search-cutoff-index';\n\n/**\n * Find the insertion position (index) of an item in an array with items sorted\n * in ascending order using a value function; so that\n * `splice(sortedIndex, 0, item)` would result in maintaining the arrays sort-\n * ness. The array can contain duplicates.\n * If the item already exists in the array the index would be of the *first*\n * occurrence of the item.\n *\n * Runs in O(logN) time.\n *\n * See also:\n * `findIndex` - scans a possibly unsorted array in-order (linear search).\n * `sortedIndex` - like this function, but doesn't take a callbackfn.\n * `sortedLastIndexBy` - like this function, but finds the last suitable index.\n * `sortedLastIndex` - like `sortedIndex`, but finds the last suitable index.\n * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.\n *\n * @param data - The (ascending) sorted array.\n * @param item - The item to insert.\n * @param valueFunction - All comparisons would be performed on the result of\n * calling this function on each compared item. Preferably this function should\n * return a `number` or `string`. This function should be the same as the one\n * provided to sortBy to sort the array. The function is called exactly once on\n * each items that is compared against in the array, and once at the beginning\n * on `item`. When called on `item` the `index` argument is `undefined`.\n * @returns Insertion index (In the range 0..data.length).\n * @signature\n *    P.sortedIndexBy(data, item, valueFunction)\n * @example\n *    P.sortedIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1\n * @dataFirst\n * @category Array\n */\nexport function sortedIndexBy<T>(\n  data: ReadonlyArray<T>,\n  item: T,\n  valueFunction: (\n    item: T,\n    index: number | undefined,\n    data: ReadonlyArray<T>,\n  ) => NonNullable<unknown>,\n): number;\n\n/**\n * Find the insertion position (index) of an item in an array with items sorted\n * in ascending order using a value function; so that\n * `splice(sortedIndex, 0, item)` would result in maintaining the arrays sort-\n * ness. The array can contain duplicates.\n * If the item already exists in the array the index would be of the *first*\n * occurrence of the item.\n *\n * Runs in O(logN) time.\n *\n * See also:\n * `findIndex` - scans a possibly unsorted array in-order (linear search).\n * `sortedIndex` - like this function, but doesn't take a callbackfn.\n * `sortedLastIndexBy` - like this function, but finds the last suitable index.\n * `sortedLastIndex` - like `sortedIndex`, but finds the last suitable index.\n * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.\n *\n * @param item - The item to insert.\n * @param valueFunction - All comparisons would be performed on the result of\n * calling this function on each compared item. Preferably this function should\n * return a `number` or `string`. This function should be the same as the one\n * provided to sortBy to sort the array. The function is called exactly once on\n * each items that is compared against in the array, and once at the beginning\n * on `item`. When called on `item` the `index` argument is `undefined`.\n * @signature\n *    P.sortedIndexBy(data, item, valueFunction)\n * @example\n *    P.sortedIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1\n * @dataLast\n * @category Array\n */\nexport function sortedIndexBy<T>(\n  item: T,\n  valueFunction: (\n    item: T,\n    index: number | undefined,\n    data: ReadonlyArray<T>,\n  ) => NonNullable<unknown>,\n): (data: ReadonlyArray<T>) => number;\n\nexport function sortedIndexBy(...args: ReadonlyArray<unknown>): unknown {\n  return curry(sortedIndexByImplementation, args);\n}\n\nfunction sortedIndexByImplementation<T>(\n  data: ReadonlyArray<T>,\n  item: T,\n  valueFunction: (\n    item: T,\n    index: number | undefined,\n    data: ReadonlyArray<T>,\n  ) => NonNullable<unknown>,\n): number {\n  const value = valueFunction(item, undefined /* index */, data);\n  return binarySearchCutoffIndex(\n    data,\n    (pivot, index) => valueFunction(pivot, index, data) < value,\n  );\n}\n"],"mappings":"+HAsFA,SAAgB,EAAc,GAAG,EAAuC,CACtE,OAAO,EAAM,EAA6B,EAAK,CAGjD,SAAS,EACP,EACA,EACA,EAKQ,CACR,IAAM,EAAQ,EAAc,EAAM,IAAA,GAAuB,EAAK,CAC9D,OAAO,EACL,GACC,EAAO,IAAU,EAAc,EAAO,EAAO,EAAK,CAAG,EACvD"}

package/dist/sorted-index-by-D9WveGrc.d.cts

@@ -0,0 +1,70 @@
+//#region src/sorted-index-by.d.ts
+/**
+ * Find the insertion position (index) of an item in an array with items sorted
+ * in ascending order using a value function; so that
+ * `splice(sortedIndex, 0, item)` would result in maintaining the arrays sort-
+ * ness. The array can contain duplicates.
+ * If the item already exists in the array the index would be of the *first*
+ * occurrence of the item.
+ *
+ * Runs in O(logN) time.
+ *
+ * See also:
+ * `findIndex` - scans a possibly unsorted array in-order (linear search).
+ * `sortedIndex` - like this function, but doesn't take a callbackfn.
+ * `sortedLastIndexBy` - like this function, but finds the last suitable index.
+ * `sortedLastIndex` - like `sortedIndex`, but finds the last suitable index.
+ * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.
+ *
+ * @param data - The (ascending) sorted array.
+ * @param item - The item to insert.
+ * @param valueFunction - All comparisons would be performed on the result of
+ * calling this function on each compared item. Preferably this function should
+ * return a `number` or `string`. This function should be the same as the one
+ * provided to sortBy to sort the array. The function is called exactly once on
+ * each items that is compared against in the array, and once at the beginning
+ * on `item`. When called on `item` the `index` argument is `undefined`.
+ * @returns Insertion index (In the range 0..data.length).
+ * @signature
+ *    P.sortedIndexBy(data, item, valueFunction)
+ * @example
+ *    P.sortedIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1
+ * @dataFirst
+ * @category Array
+ */
+declare function sortedIndexBy<T>(data: ReadonlyArray<T>, item: T, valueFunction: (item: T, index: number | undefined, data: ReadonlyArray<T>) => NonNullable<unknown>): number;
+/**
+ * Find the insertion position (index) of an item in an array with items sorted
+ * in ascending order using a value function; so that
+ * `splice(sortedIndex, 0, item)` would result in maintaining the arrays sort-
+ * ness. The array can contain duplicates.
+ * If the item already exists in the array the index would be of the *first*
+ * occurrence of the item.
+ *
+ * Runs in O(logN) time.
+ *
+ * See also:
+ * `findIndex` - scans a possibly unsorted array in-order (linear search).
+ * `sortedIndex` - like this function, but doesn't take a callbackfn.
+ * `sortedLastIndexBy` - like this function, but finds the last suitable index.
+ * `sortedLastIndex` - like `sortedIndex`, but finds the last suitable index.
+ * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.
+ *
+ * @param item - The item to insert.
+ * @param valueFunction - All comparisons would be performed on the result of
+ * calling this function on each compared item. Preferably this function should
+ * return a `number` or `string`. This function should be the same as the one
+ * provided to sortBy to sort the array. The function is called exactly once on
+ * each items that is compared against in the array, and once at the beginning
+ * on `item`. When called on `item` the `index` argument is `undefined`.
+ * @signature
+ *    P.sortedIndexBy(data, item, valueFunction)
+ * @example
+ *    P.sortedIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1
+ * @dataLast
+ * @category Array
+ */
+declare function sortedIndexBy<T>(item: T, valueFunction: (item: T, index: number | undefined, data: ReadonlyArray<T>) => NonNullable<unknown>): (data: ReadonlyArray<T>) => number;
+//#endregion
+export { sortedIndexBy };
+//# sourceMappingURL=sorted-index-by-D9WveGrc.d.cts.map

package/dist/sorted-index-by-D9WveGrc.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sorted-index-by-D9WveGrc.d.cts","names":[],"sources":["../src/sorted-index-by.ts"],"sourcesContent":[],"mappings":";;AAoCA;;;;;;;;;;AAyCA;;;;;;;;;;;;;;;;;;;;;;iBAzCgB,uBACR,cAAc,UACd,yBAEE,oCAEA,cAAc,OACjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkCS,uBACR,yBAEE,oCAEA,cAAc,OACjB,8BACG,cAAc"}

package/dist/sorted-index-by-wSsKYW7Z.d.ts

@@ -0,0 +1,70 @@
+//#region src/sorted-index-by.d.ts
+/**
+ * Find the insertion position (index) of an item in an array with items sorted
+ * in ascending order using a value function; so that
+ * `splice(sortedIndex, 0, item)` would result in maintaining the arrays sort-
+ * ness. The array can contain duplicates.
+ * If the item already exists in the array the index would be of the *first*
+ * occurrence of the item.
+ *
+ * Runs in O(logN) time.
+ *
+ * See also:
+ * `findIndex` - scans a possibly unsorted array in-order (linear search).
+ * `sortedIndex` - like this function, but doesn't take a callbackfn.
+ * `sortedLastIndexBy` - like this function, but finds the last suitable index.
+ * `sortedLastIndex` - like `sortedIndex`, but finds the last suitable index.
+ * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.
+ *
+ * @param data - The (ascending) sorted array.
+ * @param item - The item to insert.
+ * @param valueFunction - All comparisons would be performed on the result of
+ * calling this function on each compared item. Preferably this function should
+ * return a `number` or `string`. This function should be the same as the one
+ * provided to sortBy to sort the array. The function is called exactly once on
+ * each items that is compared against in the array, and once at the beginning
+ * on `item`. When called on `item` the `index` argument is `undefined`.
+ * @returns Insertion index (In the range 0..data.length).
+ * @signature
+ *    P.sortedIndexBy(data, item, valueFunction)
+ * @example
+ *    P.sortedIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1
+ * @dataFirst
+ * @category Array
+ */
+declare function sortedIndexBy<T>(data: ReadonlyArray<T>, item: T, valueFunction: (item: T, index: number | undefined, data: ReadonlyArray<T>) => NonNullable<unknown>): number;
+/**
+ * Find the insertion position (index) of an item in an array with items sorted
+ * in ascending order using a value function; so that
+ * `splice(sortedIndex, 0, item)` would result in maintaining the arrays sort-
+ * ness. The array can contain duplicates.
+ * If the item already exists in the array the index would be of the *first*
+ * occurrence of the item.
+ *
+ * Runs in O(logN) time.
+ *
+ * See also:
+ * `findIndex` - scans a possibly unsorted array in-order (linear search).
+ * `sortedIndex` - like this function, but doesn't take a callbackfn.
+ * `sortedLastIndexBy` - like this function, but finds the last suitable index.
+ * `sortedLastIndex` - like `sortedIndex`, but finds the last suitable index.
+ * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.
+ *
+ * @param item - The item to insert.
+ * @param valueFunction - All comparisons would be performed on the result of
+ * calling this function on each compared item. Preferably this function should
+ * return a `number` or `string`. This function should be the same as the one
+ * provided to sortBy to sort the array. The function is called exactly once on
+ * each items that is compared against in the array, and once at the beginning
+ * on `item`. When called on `item` the `index` argument is `undefined`.
+ * @signature
+ *    P.sortedIndexBy(data, item, valueFunction)
+ * @example
+ *    P.sortedIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1
+ * @dataLast
+ * @category Array
+ */
+declare function sortedIndexBy<T>(item: T, valueFunction: (item: T, index: number | undefined, data: ReadonlyArray<T>) => NonNullable<unknown>): (data: ReadonlyArray<T>) => number;
+//#endregion
+export { sortedIndexBy };
+//# sourceMappingURL=sorted-index-by-wSsKYW7Z.d.ts.map