@vinicunca/perkakas 1.7.1 → 1.9.0

package/dist/sort-by.d.ts

@@ -1,85 +1,6 @@
-import { O as OrderRule } from './curry-order-rules-BKXCPBNx.js';
-import { I as IterableContainer } from './iterable-container-BTpDVdNc.js';
-import { N as NonEmptyArray } from './non-empty-array-C9Od1wmF.js';
-import { R as ReorderedArray } from './reordered-array-DVguhAmZ.js';
-
-/**
- * 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>;
-
-export { sortBy };
+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{a}from"./chunk-2GPOH4MN.js";import"./chunk-7KBK2RWQ.js";import"./chunk-EK7ODJWE.js";export{a 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 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkHIEVTRB4cjs = require('./chunk-HIEVTRB4.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');require('./chunk-MBGSSEZN.cjs');exports.sort = _chunkHIEVTRB4cjs.a;
+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,36 +1,4 @@
-import { I as IterableContainer } from './iterable-container-BTpDVdNc.cjs';
-import { R as ReorderedArray } from './reordered-array-DTkM8K3n.cjs';
-
-/**
- * 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>;
-
-export { sort };
+import "./iterable-container-V5sa0V_H.cjs";
+import "./reordered-array-ikr9o4WE.cjs";
+import { sort } from "./sort-BZjbaFeJ.cjs";
+export { sort };

package/dist/sort.d.ts

@@ -1,36 +1,4 @@
-import { I as IterableContainer } from './iterable-container-BTpDVdNc.js';
-import { R as ReorderedArray } from './reordered-array-DVguhAmZ.js';
-
-/**
- * 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>;
-
-export { sort };
+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{a}from"./chunk-ORBI2CZ3.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";import"./chunk-EK7ODJWE.js";export{a 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

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

@@ -0,0 +1 @@
+{"version":3,"file":"sorted-index-by-wSsKYW7Z.d.ts","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.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkJPW7GBE2cjs = require('./chunk-JPW7GBE2.cjs');require('./chunk-7TDMV2GO.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');require('./chunk-MBGSSEZN.cjs');exports.sortedIndexBy = _chunkJPW7GBE2cjs.a;
+require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`),require(`./binary-search-cutoff-index-BZF3GL7H.cjs`);const e=require(`./sorted-index-by-BGDi-4BL.cjs`);exports.sortedIndexBy=e.sortedIndexBy;

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

@@ -1,68 +1,2 @@
-/**
- * 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;
-
-export { sortedIndexBy };
+import { sortedIndexBy } from "./sorted-index-by-D9WveGrc.cjs";
+export { sortedIndexBy };

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

@@ -1,68 +1,2 @@
-/**
- * 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;
-
-export { sortedIndexBy };
+import { sortedIndexBy } from "./sorted-index-by-wSsKYW7Z.js";
+export { sortedIndexBy };

package/dist/sorted-index-by.js

@@ -1 +1 @@
-import{a}from"./chunk-BUVPABRX.js";import"./chunk-JZ463SIK.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";import"./chunk-EK7ODJWE.js";export{a as sortedIndexBy};
+import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import"./binary-search-cutoff-index-YVs_m4IY.js";import{sortedIndexBy as e}from"./sorted-index-by-C-5Yb-j2.js";export{e as sortedIndexBy};

package/dist/sorted-index-r_y0xd5n.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){return t.binarySearchCutoffIndex(e,e=>e<n)}Object.defineProperty(exports,`sortedIndex`,{enumerable:!0,get:function(){return n}});

package/dist/sorted-index-with-BAbLX5vT.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(...n){return e(t,n)}export{n as sortedIndexWith};
+//# sourceMappingURL=sorted-index-with-BAbLX5vT.js.map