@vinicunca/perkakas 0.5.3 → 1.0.0

package/dist/slice-string.d.cts

@@ -0,0 +1,39 @@
+/**
+ * Extracts a section of this string and returns it as a new string, without
+ * modifying the original string. Equivalent to `String.prototype.slice`.
+ *
+ * @param data - The string to extract from.
+ * @param indexStart - The index of the first character to include in the
+ * returned substring.
+ * @param indexEnd - The index of the first character to exclude from the
+ * returned substring.
+ * @returns A new string containing the extracted section of the string.
+ * @signature
+ *    P.sliceString(data, indexStart, indexEnd)
+ * @example
+ *    P.sliceString("abcdefghijkl", 1) // => `bcdefghijkl`
+ *    P.sliceString("abcdefghijkl", 4, 7) // => `efg`
+ * @dataLast
+ * @category String
+ */
+declare function sliceString(data: string, indexStart: number, indexEnd?: number): string;
+/**
+ * Extracts a section of this string and returns it as a new string, without
+ * modifying the original string. Equivalent to `String.prototype.slice`.
+ *
+ * @param indexStart - The index of the first character to include in the
+ * returned substring.
+ * @param indexEnd - The index of the first character to exclude from the
+ * returned substring, or `undefined` for the rest of the string.
+ * @returns A new string containing the extracted section of the string.
+ * @signature
+ *    P.sliceString(indexStart, indexEnd)(string)
+ * @example
+ *    P.sliceString(1)("abcdefghijkl") // => `bcdefghijkl`
+ *    P.sliceString(4, 7)("abcdefghijkl") // => `efg`
+ * @dataLast
+ * @category String
+ */
+declare function sliceString(indexStart: number, indexEnd?: number): (data: string) => string;
+
+export { sliceString };

package/dist/slice-string.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Extracts a section of this string and returns it as a new string, without
+ * modifying the original string. Equivalent to `String.prototype.slice`.
+ *
+ * @param data - The string to extract from.
+ * @param indexStart - The index of the first character to include in the
+ * returned substring.
+ * @param indexEnd - The index of the first character to exclude from the
+ * returned substring.
+ * @returns A new string containing the extracted section of the string.
+ * @signature
+ *    P.sliceString(data, indexStart, indexEnd)
+ * @example
+ *    P.sliceString("abcdefghijkl", 1) // => `bcdefghijkl`
+ *    P.sliceString("abcdefghijkl", 4, 7) // => `efg`
+ * @dataLast
+ * @category String
+ */
+declare function sliceString(data: string, indexStart: number, indexEnd?: number): string;
+/**
+ * Extracts a section of this string and returns it as a new string, without
+ * modifying the original string. Equivalent to `String.prototype.slice`.
+ *
+ * @param indexStart - The index of the first character to include in the
+ * returned substring.
+ * @param indexEnd - The index of the first character to exclude from the
+ * returned substring, or `undefined` for the rest of the string.
+ * @returns A new string containing the extracted section of the string.
+ * @signature
+ *    P.sliceString(indexStart, indexEnd)(string)
+ * @example
+ *    P.sliceString(1)("abcdefghijkl") // => `bcdefghijkl`
+ *    P.sliceString(4, 7)("abcdefghijkl") // => `efg`
+ * @dataLast
+ * @category String
+ */
+declare function sliceString(indexStart: number, indexEnd?: number): (data: string) => string;
+
+export { sliceString };

package/dist/slice-string.js

@@ -0,0 +1 @@
+import{a}from"./chunk-FGVDZJ7U.js";export{a as sliceString};

package/dist/slugify.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkEP626HCIcjs = require('./chunk-EP626HCI.cjs');exports.slugify = _chunkEP626HCIcjs.a;

package/dist/slugify.d.cts

@@ -0,0 +1,15 @@
+/**
+ * Turn any string into a URL/DOM safe string.
+ * @param str the string to slugify
+ * @signature
+ *  slugify(str)
+ * @example
+ *  import { slugify } from '@vinicunca/perkakas';
+ *
+ *  slugify('FooBar'); // => 'foobar'
+ *  slugify('This!-is*&%#@^up!'); // => 'this-is-up'
+ * @category String
+ */
+declare function slugify(str: string): string;
+
+export { slugify };

package/dist/slugify.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Turn any string into a URL/DOM safe string.
+ * @param str the string to slugify
+ * @signature
+ *  slugify(str)
+ * @example
+ *  import { slugify } from '@vinicunca/perkakas';
+ *
+ *  slugify('FooBar'); // => 'foobar'
+ *  slugify('This!-is*&%#@^up!'); // => 'this-is-up'
+ * @category String
+ */
+declare function slugify(str: string): string;
+
+export { slugify };

package/dist/slugify.js

@@ -0,0 +1 @@
+import{a}from"./chunk-XSSRBOMF.js";export{a as slugify};

package/dist/sort-by.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkNIYVDIEQcjs = require('./chunk-NIYVDIEQ.cjs');require('./chunk-FWQYL4Y4.cjs');exports.sortBy = _chunkNIYVDIEQcjs.a;

package/dist/sort-by.d.cts

@@ -0,0 +1,84 @@
+import { I as IterableContainer, N as NonEmptyArray, f as ReorderedArray } from './types-DCY4LHuA.cjs';
+import { O as OrderRule } from './curry-order-rules-BOMf1JS7.cjs';
+import 'type-fest';
+
+/**
+ * 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 };

package/dist/sort-by.d.ts

@@ -0,0 +1,84 @@
+import { I as IterableContainer, N as NonEmptyArray, f as ReorderedArray } from './types-DCY4LHuA.js';
+import { O as OrderRule } from './curry-order-rules-BOMf1JS7.js';
+import 'type-fest';
+
+/**
+ * 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 };

package/dist/sort-by.js

@@ -0,0 +1 @@
+import{a}from"./chunk-J3YPWVVQ.js";import"./chunk-JXXXUJM5.js";export{a as sortBy};

package/dist/sort.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkZ42U7NBMcjs = require('./chunk-Z42U7NBM.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.sort = _chunkZ42U7NBMcjs.a;

package/dist/sort.d.cts

@@ -0,0 +1,36 @@
+import { I as IterableContainer, f as ReorderedArray } from './types-DCY4LHuA.cjs';
+import 'type-fest';
+
+/**
+ * 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 };

package/dist/sort.d.ts

@@ -0,0 +1,36 @@
+import { I as IterableContainer, f as ReorderedArray } from './types-DCY4LHuA.js';
+import 'type-fest';
+
+/**
+ * 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 };

package/dist/sort.js

@@ -0,0 +1 @@
+import{a}from"./chunk-XUU6IYML.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as sort};

package/dist/sorted-index-by.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkNM55NELVcjs = require('./chunk-NM55NELV.cjs');require('./chunk-N4656YGQ.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.sortedIndexBy = _chunkNM55NELVcjs.a;

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

@@ -0,0 +1,68 @@
+/**
+ * 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 };

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

@@ -0,0 +1,68 @@
+/**
+ * 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 };

package/dist/sorted-index-by.js

@@ -0,0 +1 @@
+import{a}from"./chunk-EM2UX3KN.js";import"./chunk-YQTXLMPM.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as sortedIndexBy};

package/dist/sorted-index-with.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkGLAMUYBBcjs = require('./chunk-GLAMUYBB.cjs');require('./chunk-N4656YGQ.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.sortedIndexWith = _chunkGLAMUYBBcjs.a;

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

@@ -0,0 +1,70 @@
+/**
+ * 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 };