@vinicunca/perkakas 1.7.1 → 1.8.0

package/dist/sorted-index-by-CyQx_bQb.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-CyQx_bQb.d.ts.map

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

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

@@ -0,0 +1 @@
+const e=require(`./curry-BPVIsvo3.cjs`),t=require(`./binary-search-cutoff-index-B3xuP0oe.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.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-B3xuP0oe.cjs`);const e=require(`./sorted-index-by-ywbBQhCr.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-CEUsUJdi.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-CyQx_bQb.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-QhLfC_4-.js";import{sortedIndexBy as e}from"./sorted-index-by-CLUr58al.js";export{e as sortedIndexBy};

package/dist/sorted-index-with-CGyMmjPN.d.ts

@@ -0,0 +1,72 @@
+//#region src/sorted-index-with.d.ts
+/**
+ * Performs a **binary search** for the index of the item at which the predicate
+ * stops returning `true`. This function assumes that the array is "sorted" in
+ * regards to the predicate, meaning that running the predicate as a mapper on
+ * it would result in an array `[...true[], ...false[]]`.
+ * This stricter requirement from the predicate provides us 2 benefits over
+ * `findIndex` which does a similar thing:
+ * 1. It would run at O(logN) time instead of O(N) time.
+ * 2. It always returns a value (it would return `data.length` if the
+ * predicate returns `true` for all items).
+ *
+ * This function is the basis for all other sortedIndex functions which search
+ * for a specific item in a sorted array, and it could be used to perform
+ * similar efficient searches.
+ * `sortedIndex` - scans a sorted array with a binary search, find the first suitable index.
+ * `sortedIndexBy` - like `sortedIndex`, but assumes sorting is based on a callbackfn.
+ * `sortedLastIndex` - scans a sorted array with a binary search, finding the last suitable index.
+ * `sortedLastIndexBy` - like `sortedLastIndex`, but assumes sorting is based on a callbackfn.
+ *
+ * See also:
+ * `findIndex` - scans a possibly unsorted array in-order (linear search).
+ * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.
+ *
+ * @param data - Array, "sorted" by `predicate`.
+ * @param predicate - A predicate which also defines the array's order.
+ * @returns Index (In the range 0..data.length).
+ * @signature
+ *    P.sortedIndexWith(data, predicate)
+ * @example
+ *    P.sortedIndexWith(['a','ab','abc'], (item) => item.length < 2) // => 1
+ * @dataFirst
+ * @category Array
+ * @see findIndex, sortedIndex, sortedIndexBy, sortedLastIndex, sortedLastIndexBy
+ */
+declare function sortedIndexWith<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): number;
+/**
+ * Performs a **binary search** for the index of the item at which the predicate
+ * stops returning `true`. This function assumes that the array is "sorted" in
+ * regards to the predicate, meaning that running the predicate as a mapper on
+ * it would result in an array `[...true[], ...false[]]`.
+ * This stricter requirement from the predicate provides us 2 benefits over
+ * `findIndex` which does a similar thing:
+ * 1. It would run at O(logN) time instead of O(N) time.
+ * 2. It always returns a value (it would return `data.length` if the
+ * predicate returns `true` for all items).
+ *
+ * This function is the basis for all other sortedIndex functions which search
+ * for a specific item in a sorted array, and it could be used to perform
+ * similar efficient searches.
+ * `sortedIndex` - scans a sorted array with a binary search, find the first suitable index.
+ * `sortedIndexBy` - like `sortedIndex`, but assumes sorting is based on a callbackfn.
+ * `sortedLastIndex` - scans a sorted array with a binary search, finding the last suitable index.
+ * `sortedLastIndexBy` - like `sortedLastIndex`, but assumes sorting is based on a callbackfn.
+ *
+ * See also:
+ * `findIndex` - scans a possibly unsorted array in-order (linear search).
+ * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.
+ *
+ * @param predicate - A predicate which also defines the array's order.
+ * @returns Index (In the range 0..data.length).
+ * @signature
+ *    P.sortedIndexWith(predicate)(data)
+ * @example
+ *    P.pipe(['a','ab','abc'], P.sortedIndexWith((item) => item.length < 2)) // => 1
+ * @dataLast
+ * @category Array
+ */
+declare function sortedIndexWith<T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): (data: ReadonlyArray<T>) => number;
+//#endregion
+export { sortedIndexWith };
+//# sourceMappingURL=sorted-index-with-CGyMmjPN.d.ts.map

package/dist/sorted-index-with-CGyMmjPN.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sorted-index-with-CGyMmjPN.d.ts","names":[],"sources":["../src/sorted-index-with.ts"],"sourcesContent":[],"mappings":";;AAqCA;;;;;;;;AAqCA;;;;;;;;;;;;;;;;;;;;;;;;;iBArCgB,yBACR,cAAc,uBACD,wBAAwB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmC3C,sCACK,wBAAwB,cAAc,wBACjD,cAAc"}

package/dist/sorted-index-with-Cy9W9sdh.d.cts

@@ -0,0 +1,72 @@
+//#region src/sorted-index-with.d.ts
+/**
+ * Performs a **binary search** for the index of the item at which the predicate
+ * stops returning `true`. This function assumes that the array is "sorted" in
+ * regards to the predicate, meaning that running the predicate as a mapper on
+ * it would result in an array `[...true[], ...false[]]`.
+ * This stricter requirement from the predicate provides us 2 benefits over
+ * `findIndex` which does a similar thing:
+ * 1. It would run at O(logN) time instead of O(N) time.
+ * 2. It always returns a value (it would return `data.length` if the
+ * predicate returns `true` for all items).
+ *
+ * This function is the basis for all other sortedIndex functions which search
+ * for a specific item in a sorted array, and it could be used to perform
+ * similar efficient searches.
+ * `sortedIndex` - scans a sorted array with a binary search, find the first suitable index.
+ * `sortedIndexBy` - like `sortedIndex`, but assumes sorting is based on a callbackfn.
+ * `sortedLastIndex` - scans a sorted array with a binary search, finding the last suitable index.
+ * `sortedLastIndexBy` - like `sortedLastIndex`, but assumes sorting is based on a callbackfn.
+ *
+ * See also:
+ * `findIndex` - scans a possibly unsorted array in-order (linear search).
+ * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.
+ *
+ * @param data - Array, "sorted" by `predicate`.
+ * @param predicate - A predicate which also defines the array's order.
+ * @returns Index (In the range 0..data.length).
+ * @signature
+ *    P.sortedIndexWith(data, predicate)
+ * @example
+ *    P.sortedIndexWith(['a','ab','abc'], (item) => item.length < 2) // => 1
+ * @dataFirst
+ * @category Array
+ * @see findIndex, sortedIndex, sortedIndexBy, sortedLastIndex, sortedLastIndexBy
+ */
+declare function sortedIndexWith<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): number;
+/**
+ * Performs a **binary search** for the index of the item at which the predicate
+ * stops returning `true`. This function assumes that the array is "sorted" in
+ * regards to the predicate, meaning that running the predicate as a mapper on
+ * it would result in an array `[...true[], ...false[]]`.
+ * This stricter requirement from the predicate provides us 2 benefits over
+ * `findIndex` which does a similar thing:
+ * 1. It would run at O(logN) time instead of O(N) time.
+ * 2. It always returns a value (it would return `data.length` if the
+ * predicate returns `true` for all items).
+ *
+ * This function is the basis for all other sortedIndex functions which search
+ * for a specific item in a sorted array, and it could be used to perform
+ * similar efficient searches.
+ * `sortedIndex` - scans a sorted array with a binary search, find the first suitable index.
+ * `sortedIndexBy` - like `sortedIndex`, but assumes sorting is based on a callbackfn.
+ * `sortedLastIndex` - scans a sorted array with a binary search, finding the last suitable index.
+ * `sortedLastIndexBy` - like `sortedLastIndex`, but assumes sorting is based on a callbackfn.
+ *
+ * See also:
+ * `findIndex` - scans a possibly unsorted array in-order (linear search).
+ * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.
+ *
+ * @param predicate - A predicate which also defines the array's order.
+ * @returns Index (In the range 0..data.length).
+ * @signature
+ *    P.sortedIndexWith(predicate)(data)
+ * @example
+ *    P.pipe(['a','ab','abc'], P.sortedIndexWith((item) => item.length < 2)) // => 1
+ * @dataLast
+ * @category Array
+ */
+declare function sortedIndexWith<T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): (data: ReadonlyArray<T>) => number;
+//#endregion
+export { sortedIndexWith };
+//# sourceMappingURL=sorted-index-with-Cy9W9sdh.d.cts.map

package/dist/sorted-index-with-Cy9W9sdh.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sorted-index-with-Cy9W9sdh.d.cts","names":[],"sources":["../src/sorted-index-with.ts"],"sourcesContent":[],"mappings":";;AAqCA;;;;;;;;AAqCA;;;;;;;;;;;;;;;;;;;;;;;;;iBArCgB,yBACR,cAAc,uBACD,wBAAwB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmC3C,sCACK,wBAAwB,cAAc,wBACjD,cAAc"}

package/dist/sorted-index-with-D5BcwSL_.cjs

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

package/dist/sorted-index-with-kTK8prmw.js

@@ -0,0 +1,2 @@
+import{curry as e}from"./curry-CzZjDrpv.js";import{binarySearchCutoffIndex as t}from"./binary-search-cutoff-index-QhLfC_4-.js";function n(...n){return e(t,n)}export{n as sortedIndexWith};
+//# sourceMappingURL=sorted-index-with-kTK8prmw.js.map

package/dist/sorted-index-with-kTK8prmw.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sorted-index-with-kTK8prmw.js","names":[],"sources":["../src/sorted-index-with.ts"],"sourcesContent":["import { curry } from './curry';\nimport { binarySearchCutoffIndex } from './internal/binary-search-cutoff-index';\n\n/**\n * Performs a **binary search** for the index of the item at which the predicate\n * stops returning `true`. This function assumes that the array is \"sorted\" in\n * regards to the predicate, meaning that running the predicate as a mapper on\n * it would result in an array `[...true[], ...false[]]`.\n * This stricter requirement from the predicate provides us 2 benefits over\n * `findIndex` which does a similar thing:\n * 1. It would run at O(logN) time instead of O(N) time.\n * 2. It always returns a value (it would return `data.length` if the\n * predicate returns `true` for all items).\n *\n * This function is the basis for all other sortedIndex functions which search\n * for a specific item in a sorted array, and it could be used to perform\n * similar efficient searches.\n * `sortedIndex` - scans a sorted array with a binary search, find the first suitable index.\n * `sortedIndexBy` - like `sortedIndex`, but assumes sorting is based on a callbackfn.\n * `sortedLastIndex` - scans a sorted array with a binary search, finding the last suitable index.\n * `sortedLastIndexBy` - like `sortedLastIndex`, but assumes sorting is based on a callbackfn.\n *\n * See also:\n * `findIndex` - scans a possibly unsorted array in-order (linear search).\n * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.\n *\n * @param data - Array, \"sorted\" by `predicate`.\n * @param predicate - A predicate which also defines the array's order.\n * @returns Index (In the range 0..data.length).\n * @signature\n *    P.sortedIndexWith(data, predicate)\n * @example\n *    P.sortedIndexWith(['a','ab','abc'], (item) => item.length < 2) // => 1\n * @dataFirst\n * @category Array\n * @see findIndex, sortedIndex, sortedIndexBy, sortedLastIndex, sortedLastIndexBy\n */\nexport function sortedIndexWith<T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): number;\n\n/**\n * Performs a **binary search** for the index of the item at which the predicate\n * stops returning `true`. This function assumes that the array is \"sorted\" in\n * regards to the predicate, meaning that running the predicate as a mapper on\n * it would result in an array `[...true[], ...false[]]`.\n * This stricter requirement from the predicate provides us 2 benefits over\n * `findIndex` which does a similar thing:\n * 1. It would run at O(logN) time instead of O(N) time.\n * 2. It always returns a value (it would return `data.length` if the\n * predicate returns `true` for all items).\n *\n * This function is the basis for all other sortedIndex functions which search\n * for a specific item in a sorted array, and it could be used to perform\n * similar efficient searches.\n * `sortedIndex` - scans a sorted array with a binary search, find the first suitable index.\n * `sortedIndexBy` - like `sortedIndex`, but assumes sorting is based on a callbackfn.\n * `sortedLastIndex` - scans a sorted array with a binary search, finding the last suitable index.\n * `sortedLastIndexBy` - like `sortedLastIndex`, but assumes sorting is based on a callbackfn.\n *\n * See also:\n * `findIndex` - scans a possibly unsorted array in-order (linear search).\n * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.\n *\n * @param predicate - A predicate which also defines the array's order.\n * @returns Index (In the range 0..data.length).\n * @signature\n *    P.sortedIndexWith(predicate)(data)\n * @example\n *    P.pipe(['a','ab','abc'], P.sortedIndexWith((item) => item.length < 2)) // => 1\n * @dataLast\n * @category Array\n */\nexport function sortedIndexWith<T>(\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): (data: ReadonlyArray<T>) => number;\n\nexport function sortedIndexWith(...args: ReadonlyArray<unknown>): unknown {\n  return curry(binarySearchCutoffIndex, args);\n}\n"],"mappings":"+HA8EA,SAAgB,EAAgB,GAAG,EAAuC,CACxE,OAAO,EAAM,EAAyB,EAAK"}

package/dist/sorted-index-with.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkORWRUK3Kcjs = require('./chunk-ORWRUK3K.cjs');require('./chunk-7TDMV2GO.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');require('./chunk-MBGSSEZN.cjs');exports.sortedIndexWith = _chunkORWRUK3Kcjs.a;
+require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`),require(`./binary-search-cutoff-index-B3xuP0oe.cjs`);const e=require(`./sorted-index-with-D5BcwSL_.cjs`);exports.sortedIndexWith=e.sortedIndexWith;

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

@@ -1,70 +1,2 @@
-/**
- * Performs a **binary search** for the index of the item at which the predicate
- * stops returning `true`. This function assumes that the array is "sorted" in
- * regards to the predicate, meaning that running the predicate as a mapper on
- * it would result in an array `[...true[], ...false[]]`.
- * This stricter requirement from the predicate provides us 2 benefits over
- * `findIndex` which does a similar thing:
- * 1. It would run at O(logN) time instead of O(N) time.
- * 2. It always returns a value (it would return `data.length` if the
- * predicate returns `true` for all items).
- *
- * This function is the basis for all other sortedIndex functions which search
- * for a specific item in a sorted array, and it could be used to perform
- * similar efficient searches.
- * `sortedIndex` - scans a sorted array with a binary search, find the first suitable index.
- * `sortedIndexBy` - like `sortedIndex`, but assumes sorting is based on a callbackfn.
- * `sortedLastIndex` - scans a sorted array with a binary search, finding the last suitable index.
- * `sortedLastIndexBy` - like `sortedLastIndex`, but assumes sorting is based on a callbackfn.
- *
- * See also:
- * `findIndex` - scans a possibly unsorted array in-order (linear search).
- * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.
- *
- * @param data - Array, "sorted" by `predicate`.
- * @param predicate - A predicate which also defines the array's order.
- * @returns Index (In the range 0..data.length).
- * @signature
- *    P.sortedIndexWith(data, predicate)
- * @example
- *    P.sortedIndexWith(['a','ab','abc'], (item) => item.length < 2) // => 1
- * @dataFirst
- * @category Array
- * @see findIndex, sortedIndex, sortedIndexBy, sortedLastIndex, sortedLastIndexBy
- */
-declare function sortedIndexWith<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): number;
-/**
- * Performs a **binary search** for the index of the item at which the predicate
- * stops returning `true`. This function assumes that the array is "sorted" in
- * regards to the predicate, meaning that running the predicate as a mapper on
- * it would result in an array `[...true[], ...false[]]`.
- * This stricter requirement from the predicate provides us 2 benefits over
- * `findIndex` which does a similar thing:
- * 1. It would run at O(logN) time instead of O(N) time.
- * 2. It always returns a value (it would return `data.length` if the
- * predicate returns `true` for all items).
- *
- * This function is the basis for all other sortedIndex functions which search
- * for a specific item in a sorted array, and it could be used to perform
- * similar efficient searches.
- * `sortedIndex` - scans a sorted array with a binary search, find the first suitable index.
- * `sortedIndexBy` - like `sortedIndex`, but assumes sorting is based on a callbackfn.
- * `sortedLastIndex` - scans a sorted array with a binary search, finding the last suitable index.
- * `sortedLastIndexBy` - like `sortedLastIndex`, but assumes sorting is based on a callbackfn.
- *
- * See also:
- * `findIndex` - scans a possibly unsorted array in-order (linear search).
- * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.
- *
- * @param predicate - A predicate which also defines the array's order.
- * @returns Index (In the range 0..data.length).
- * @signature
- *    P.sortedIndexWith(predicate)(data)
- * @example
- *    P.pipe(['a','ab','abc'], P.sortedIndexWith((item) => item.length < 2)) // => 1
- * @dataLast
- * @category Array
- */
-declare function sortedIndexWith<T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): (data: ReadonlyArray<T>) => number;
-
-export { sortedIndexWith };
+import { sortedIndexWith } from "./sorted-index-with-Cy9W9sdh.cjs";
+export { sortedIndexWith };

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

@@ -1,70 +1,2 @@
-/**
- * Performs a **binary search** for the index of the item at which the predicate
- * stops returning `true`. This function assumes that the array is "sorted" in
- * regards to the predicate, meaning that running the predicate as a mapper on
- * it would result in an array `[...true[], ...false[]]`.
- * This stricter requirement from the predicate provides us 2 benefits over
- * `findIndex` which does a similar thing:
- * 1. It would run at O(logN) time instead of O(N) time.
- * 2. It always returns a value (it would return `data.length` if the
- * predicate returns `true` for all items).
- *
- * This function is the basis for all other sortedIndex functions which search
- * for a specific item in a sorted array, and it could be used to perform
- * similar efficient searches.
- * `sortedIndex` - scans a sorted array with a binary search, find the first suitable index.
- * `sortedIndexBy` - like `sortedIndex`, but assumes sorting is based on a callbackfn.
- * `sortedLastIndex` - scans a sorted array with a binary search, finding the last suitable index.
- * `sortedLastIndexBy` - like `sortedLastIndex`, but assumes sorting is based on a callbackfn.
- *
- * See also:
- * `findIndex` - scans a possibly unsorted array in-order (linear search).
- * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.
- *
- * @param data - Array, "sorted" by `predicate`.
- * @param predicate - A predicate which also defines the array's order.
- * @returns Index (In the range 0..data.length).
- * @signature
- *    P.sortedIndexWith(data, predicate)
- * @example
- *    P.sortedIndexWith(['a','ab','abc'], (item) => item.length < 2) // => 1
- * @dataFirst
- * @category Array
- * @see findIndex, sortedIndex, sortedIndexBy, sortedLastIndex, sortedLastIndexBy
- */
-declare function sortedIndexWith<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): number;
-/**
- * Performs a **binary search** for the index of the item at which the predicate
- * stops returning `true`. This function assumes that the array is "sorted" in
- * regards to the predicate, meaning that running the predicate as a mapper on
- * it would result in an array `[...true[], ...false[]]`.
- * This stricter requirement from the predicate provides us 2 benefits over
- * `findIndex` which does a similar thing:
- * 1. It would run at O(logN) time instead of O(N) time.
- * 2. It always returns a value (it would return `data.length` if the
- * predicate returns `true` for all items).
- *
- * This function is the basis for all other sortedIndex functions which search
- * for a specific item in a sorted array, and it could be used to perform
- * similar efficient searches.
- * `sortedIndex` - scans a sorted array with a binary search, find the first suitable index.
- * `sortedIndexBy` - like `sortedIndex`, but assumes sorting is based on a callbackfn.
- * `sortedLastIndex` - scans a sorted array with a binary search, finding the last suitable index.
- * `sortedLastIndexBy` - like `sortedLastIndex`, but assumes sorting is based on a callbackfn.
- *
- * See also:
- * `findIndex` - scans a possibly unsorted array in-order (linear search).
- * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.
- *
- * @param predicate - A predicate which also defines the array's order.
- * @returns Index (In the range 0..data.length).
- * @signature
- *    P.sortedIndexWith(predicate)(data)
- * @example
- *    P.pipe(['a','ab','abc'], P.sortedIndexWith((item) => item.length < 2)) // => 1
- * @dataLast
- * @category Array
- */
-declare function sortedIndexWith<T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): (data: ReadonlyArray<T>) => number;
-
-export { sortedIndexWith };
+import { sortedIndexWith } from "./sorted-index-with-CGyMmjPN.js";
+export { sortedIndexWith };

package/dist/sorted-index-with.js

@@ -1 +1 @@
-import{a}from"./chunk-SGK2IP3C.js";import"./chunk-JZ463SIK.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";import"./chunk-EK7ODJWE.js";export{a as sortedIndexWith};
+import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import"./binary-search-cutoff-index-QhLfC_4-.js";import{sortedIndexWith as e}from"./sorted-index-with-kTK8prmw.js";export{e as sortedIndexWith};

package/dist/sorted-index.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkBASNU4JYcjs = require('./chunk-BASNU4JY.cjs');require('./chunk-7TDMV2GO.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');require('./chunk-MBGSSEZN.cjs');exports.sortedIndex = _chunkBASNU4JYcjs.a;
+require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`),require(`./binary-search-cutoff-index-B3xuP0oe.cjs`);const e=require(`./sorted-index-BFrWiZn3.cjs`);exports.sortedIndex=e.sortedIndex;

package/dist/sorted-index.d.cts

@@ -1,43 +1,2 @@
-/**
- * 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;
-
-export { sortedIndex };
+import { sortedIndex } from "./sorted-index-CTM_l6te.cjs";
+export { sortedIndex };