@vinicunca/perkakas 0.4.0 → 0.4.3

package/dist/types/array/sort-by.d.ts

@@ -1,98 +0,0 @@
-import type { IterableContainer, NonEmptyArray } from '../utils/types';
-import { type OrderRule } from '../utils/purry-order-rules';
-/**
- * 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.
- *
- * To maintain the shape of more complex inputs (like non-empty arrays, tuples, etc...) use the `strict` variant.
- *
- * 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 rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
- * @return - A shallow copy of the input array sorted by the provided rules.
- * @signature
- *    P.sortBy(...rules)(data)
- *    P.sortBy.strict(...rules)(data)
- * @example
- *    P.pipe(
- *      [{ a: 1 }, { a: 3 }, { a: 7 }, { a: 2 }],
- *      P.sortBy(x => x.a)
- *    ) // => [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 7 }] typed Array<{a:number}>
- *    P.pipe(
- *      [{ a: 1 }, { a: 3 }] as const,
- *      P.sortBy.strict(x => x.a)
- *    ) // => [{ a: 1 }, { a: 3 }] typed [{a: 1 | 3}, {a: 1 | 3}]
- * @dataLast
- * @category Array
- * @strict
- */
-export declare function sortBy<T>(...rules: Readonly<NonEmptyArray<OrderRule<T>>>): (data: ReadonlyArray<T>) => Array<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.
- *
- * To maintain the shape of more complex inputs (like non-empty arrays, tuples, etc...) use the `strict` variant.
- *
- * 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.
- * @return - A shallow copy of the input array sorted by the provided rules.
- * @signature
- *    P.sortBy(data, ...rules)
- *    P.sortBy.strict(data, ...rules)
- * @example
- *    P.sortBy(
- *      [{ a: 1 }, { a: 3 }, { a: 7 }, { a: 2 }],
- *      x => x.a
- *    )
- *    // => [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 7 }] typed Array<{a:number}>
- *
- *    P.sortBy(
- *     [
- *       {color: 'red', weight: 2},
- *       {color: 'blue', weight: 3},
- *       {color: 'green', weight: 1},
- *       {color: 'purple', weight: 1},
- *     ],
- *      [x => x.weight, 'asc'], x => x.color
- *    )
- *    // =>
- *    //   {color: 'green', weight: 1},
- *    //   {color: 'purple', weight: 1},
- *    //   {color: 'red', weight: 2},
- *    //   {color: 'blue', weight: 3},
- *    // typed Array<{color: string, weight: number}>
- *
- *    P.sortBy.strict(
- *      [{ a: 1 }, { a: 3 }] as const,
- *      x => x.a
- *    )
- *    // => [{ a: 1 }, { a: 3 }] typed [{a: 1 | 3}, {a: 1 | 3}]
- * @dataFirst
- * @category Array
- * @strict
- */
-export declare function sortBy<T>(array: ReadonlyArray<T>, ...sortRules: Readonly<NonEmptyArray<OrderRule<T>>>): Array<T>;
-interface Strict {
-    <T extends IterableContainer>(...sortRules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): (array: T) => SortedBy<T>;
-    <T extends IterableContainer>(array: T, ...sortRules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): SortedBy<T>;
-}
-type SortedBy<T extends IterableContainer> = {
-    -readonly [P in keyof T]: T[number];
-};
-export declare namespace sortBy {
-    const strict: Strict;
-}
-export {};
-//# sourceMappingURL=sort-by.d.ts.map

package/dist/types/array/sort-by.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sort-by.d.ts","sourceRoot":"","sources":["../../../src/array/sort-by.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAmB,iBAAiB,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAExF,OAAO,EAAE,KAAK,SAAS,EAAmB,MAAM,4BAA4B,CAAC;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,MAAM,CAAC,CAAC,EACtB,GAAG,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,GAC9C,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,wBAAgB,MAAM,CAAC,CAAC,EACtB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,GAAG,SAAS,EAAE,QAAQ,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,GAClD,KAAK,CAAC,CAAC,CAAC,CAAC;AAWZ,UAAU,MAAM;IACd,CAAC,CAAC,SAAS,iBAAiB,EAC1B,GAAG,SAAS,EAAE,QAAQ,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAC1D,CAAC,KAAK,EAAE,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC;IAE7B,CAAC,CAAC,SAAS,iBAAiB,EAC1B,KAAK,EAAE,CAAC,EACR,GAAG,SAAS,EAAE,QAAQ,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAC1D,QAAQ,CAAC,CAAC,CAAC,CAAC;CAChB;AAED,KAAK,QAAQ,CAAC,CAAC,SAAS,iBAAiB,IAAI;IAC3C,CAAC,UAAU,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC;CACpC,CAAC;AAEF,yBAAiB,MAAM,CAAC;IACf,MAAM,MAAM,EAAE,MAAe,CAAC;CACtC"}

package/dist/types/array/sort.d.ts

@@ -1,52 +0,0 @@
-import type { IterableContainer } from '../utils/types';
-/**
- * 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. It's not guaranteed to be stable.
- *
- * If the input array is more complex (non-empty array, tuple, etc...) use the
- * strict mode to maintain it's shape.
- *
- * @param items the array to sort
- * @param cmp the comparator function
- * @signature
- *    P.sort(items, cmp)
- *    P.sort.strict(items, cmp)
- * @example
- *    P.sort([4, 2, 7, 5], (a, b) => a - b) // => [2, 4, 5, 7] typed Array<number>
- *    P.sort.strict([4, 2] as [number, number], (a, b) => a - b) // [2, 4] typed [number, number]
- * @dataFirst
- * @category Array
- * @strict
- */
-export declare function sort<T>(items: ReadonlyArray<T>, cmp: (a: T, b: T) => number): Array<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. It's not guaranteed to be stable.
- *
- * If the input array is more complex (non-empty array, tuple, etc...) use the
- * strict mode to maintain it's shape.
- *
- * @param cmp the comparator function
- * @signature
- *    P.sort(cmp)(items)
- *    P.sort.strict(cmp)(items)
- * @example
- *    P.pipe([4, 2, 7, 5], P.sort((a, b) => a - b)) // => [2, 4, 5, 7] typed Array<number>
- *    P.pipe([4, 2] as [number, number], P.sort.strict((a, b) => a - b)) // => [2, 4] typed [number, number]
- * @dataLast
- * @category Array
- * @strict
- */
-export declare function sort<T>(cmp: (a: T, b: T) => number): (items: ReadonlyArray<T>) => Array<T>;
-interface Strict {
-    <T extends IterableContainer>(items: T, cmp: (a: T[number], b: T[number]) => number): Sorted<T>;
-    <T extends IterableContainer>(cmp: (a: T[number], b: T[number]) => number): (items: T) => Sorted<T>;
-}
-type Sorted<T extends IterableContainer> = {
-    -readonly [P in keyof T]: T[number];
-};
-export declare namespace sort {
-    const strict: Strict;
-}
-export {};
-//# sourceMappingURL=sort.d.ts.map

package/dist/types/array/sort.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sort.d.ts","sourceRoot":"","sources":["../../../src/array/sort.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAIxD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EACpB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,GAC1B,KAAK,CAAC,CAAC,CAAC,CAAC;AAEZ;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EACpB,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,GAC1B,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;AAezC,UAAU,MAAM;IACd,CAAC,CAAC,SAAS,iBAAiB,EAC1B,KAAK,EAAE,CAAC,EACR,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,MAAM,GAC1C,MAAM,CAAC,CAAC,CAAC,CAAC;IAEb,CAAC,CAAC,SAAS,iBAAiB,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,MAAM,GAAG,CAC1E,KAAK,EAAE,CAAC,KACL,MAAM,CAAC,CAAC,CAAC,CAAC;CAChB;AAED,KAAK,MAAM,CAAC,CAAC,SAAS,iBAAiB,IAAI;IACzC,CAAC,UAAU,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC;CACpC,CAAC;AAEF,yBAAiB,IAAI,CAAC;IACb,MAAM,MAAM,EAAE,MAAa,CAAC;CACpC"}

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

@@ -1,62 +0,0 @@
-/**
- * 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.
- *
- * @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.
- * @return - 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
- * @indexed
- * @category Array
- *
- * @see sortedIndex, sortedIndexWith, sortedLastIndex, sortedLastIndexBy
- */
-export declare function sortedIndexBy<T>(data: ReadonlyArray<T>, item: T, valueFunction: (item: 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.
- *
- * @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.
- * @return - 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
- * @dataLast
- * @indexed
- * @category Array
- *
- * @see sortedIndex, sortedIndexWith, sortedLastIndex, sortedLastIndexBy
- */
-export declare function sortedIndexBy<T>(item: T, valueFunction: (item: T) => NonNullable<unknown>): (data: ReadonlyArray<T>) => number;
-export declare namespace sortedIndexBy {
-    function indexed<T>(data: ReadonlyArray<T>, item: T, valueFunction: (item: T, index?: number) => NonNullable<unknown>): number;
-    function indexed<T>(item: T, valueFunction: (item: T, index?: number) => NonNullable<unknown>): (data: ReadonlyArray<T>) => number;
-}
-//# sourceMappingURL=sorted-index-by.d.ts.map

package/dist/types/array/sorted-index-by.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sorted-index-by.d.ts","sourceRoot":"","sources":["../../../src/array/sorted-index-by.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAC7B,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EACtB,IAAI,EAAE,CAAC,EACP,aAAa,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,WAAW,CAAC,OAAO,CAAC,GAC/C,MAAM,CAAC;AAEV;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAC7B,IAAI,EAAE,CAAC,EACP,aAAa,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,WAAW,CAAC,OAAO,CAAC,GAC/C,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC;AAMtC,yBAAiB,aAAa,CAAC;IAC7B,SAAgB,OAAO,CAAC,CAAC,EACvB,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EACtB,IAAI,EAAE,CAAC,EACP,aAAa,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,WAAW,CAAC,OAAO,CAAC,GAC/D,MAAM,CAAC;IACV,SAAgB,OAAO,CAAC,CAAC,EACvB,IAAI,EAAE,CAAC,EACP,aAAa,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,WAAW,CAAC,OAAO,CAAC,GAC/D,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC;CAIvC"}

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

@@ -1,64 +0,0 @@
-/**
- * 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.
- *
- * @param data - Array, "sorted" by `predicate`
- * @param predicate - A predicate which also defines the array's order
- * @return - Index (In the range 0..data.length)
- *
- * @signature
- *    P.sortedIndexWith(data, predicate)
- * @example
- *    P.sortedIndexWith(['a','ab','abc'], (item) => item.length < 2) // => 1
- * @dataFirst
- * @indexed
- * @category Array
- *
- * @see findIndex, sortedIndex, sortedIndexBy, sortedLastIndex, sortedLastIndexBy
- */
-export declare function sortedIndexWith<T>(data: ReadonlyArray<T>, predicate: (item: 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 `false` 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.
- *
- * @param predicate - A predicate which also defines the array's order
- * @return - 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
- * @indexed
- * @category Array
- *
- * @see findIndex, sortedIndex, sortedIndexBy, sortedLastIndex, sortedLastIndexBy
- */
-export declare function sortedIndexWith<T>(predicate: (item: T) => boolean): (data: ReadonlyArray<T>) => number;
-export declare namespace sortedIndexWith {
-    function indexed<T>(data: ReadonlyArray<T>, predicate: (item: T, index: number) => NonNullable<unknown>): number;
-    function indexed<T>(predicate: (item: T, index: number) => NonNullable<unknown>): (data: ReadonlyArray<T>) => number;
-}
-//# sourceMappingURL=sorted-index-with.d.ts.map

package/dist/types/array/sorted-index-with.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sorted-index-with.d.ts","sourceRoot":"","sources":["../../../src/array/sorted-index-with.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAC/B,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EACtB,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GAC9B,MAAM,CAAC;AAEV;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAC/B,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GAC9B,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC;AAMtC,yBAAiB,eAAe,CAAC;IAC/B,SAAgB,OAAO,CAAC,CAAC,EACvB,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EACtB,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,WAAW,CAAC,OAAO,CAAC,GAC1D,MAAM,CAAC;IACV,SAAgB,OAAO,CAAC,CAAC,EACvB,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,WAAW,CAAC,OAAO,CAAC,GAC1D,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC;CAIvC"}

package/dist/types/array/sorted-index.d.ts

@@ -1,46 +0,0 @@
-/**
- * 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.
- * @return - 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
- */
-export 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.
- * @return - 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
- */
-export declare function sortedIndex<T>(item: T): (data: ReadonlyArray<T>) => number;
-//# sourceMappingURL=sorted-index.d.ts.map

package/dist/types/array/sorted-index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sorted-index.d.ts","sourceRoot":"","sources":["../../../src/array/sorted-index.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,MAAM,CAAC;AAExE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC"}

package/dist/types/array/sorted-last-index-by.d.ts

@@ -1,62 +0,0 @@
-/**
- * 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 *last*
- * occurrence of the item.
- *
- * Runs in O(logN) time.
- *
- * @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.
- * @return - Insertion index (In the range 0..data.length)
- *
- * @signature
- *    P.sortedLastIndexBy(data, item, valueFunction)
- * @example
- *    P.sortedLastIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1
- * @dataFirst
- * @indexed
- * @category Array
- *
- * @see sortedIndex, sortedIndexBy, sortedIndexWith, sortedLastIndex
- */
-export declare function sortedLastIndexBy<T>(data: ReadonlyArray<T>, item: T, valueFunction: (item: 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 *last*
- * occurrence of the item.
- *
- * Runs in O(logN) time.
- *
- * @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.
- * @return - Insertion index (In the range 0..data.length)
- *
- * @signature
- *    P.sortedLastIndexBy(item, valueFunction)(data)
- * @example
- *    P.pipe([{age:20},{age:22}],sortedLastIndexBy({age:21},prop('age'))) // => 1
- * @dataLast
- * @indexed
- * @category Array
- *
- * @see sortedIndex, sortedIndexBy, sortedIndexWith, sortedLastIndex
- */
-export declare function sortedLastIndexBy<T>(item: T, valueFunction: (item: T) => NonNullable<unknown>): (data: ReadonlyArray<T>) => number;
-export declare namespace sortedLastIndexBy {
-    function indexed<T>(data: ReadonlyArray<T>, item: T, valueFunction: (item: T, index?: number) => NonNullable<unknown>): number;
-    function indexed<T>(item: T, valueFunction: (item: T, index?: number) => NonNullable<unknown>): (data: ReadonlyArray<T>) => number;
-}
-//# sourceMappingURL=sorted-last-index-by.d.ts.map

package/dist/types/array/sorted-last-index-by.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sorted-last-index-by.d.ts","sourceRoot":"","sources":["../../../src/array/sorted-last-index-by.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EACtB,IAAI,EAAE,CAAC,EACP,aAAa,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,WAAW,CAAC,OAAO,CAAC,GAC/C,MAAM,CAAC;AAEV;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,IAAI,EAAE,CAAC,EACP,aAAa,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,WAAW,CAAC,OAAO,CAAC,GAC/C,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC;AAMtC,yBAAiB,iBAAiB,CAAC;IACjC,SAAgB,OAAO,CAAC,CAAC,EACvB,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EACtB,IAAI,EAAE,CAAC,EACP,aAAa,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,WAAW,CAAC,OAAO,CAAC,GAC/D,MAAM,CAAC;IACV,SAAgB,OAAO,CAAC,CAAC,EACvB,IAAI,EAAE,CAAC,EACP,aAAa,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,WAAW,CAAC,OAAO,CAAC,GAC/D,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC;CAIvC"}

package/dist/types/array/sorted-last-index.d.ts

@@ -1,46 +0,0 @@
-/**
- * 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 *last*
- * occurrence of the item.
- *
- * Runs in O(logN) time.
- *
- * @param data - The (ascending) sorted array.
- * @param item - The item to insert.
- * @return - Insertion index (In the range 0..data.length)
- *
- * @signature
- *    P.sortedLastIndex(data, item)
- * @example
- *    P.sortedLastIndex(['a','a','b','c','c'], 'c') // => 5
- * @dataFirst
- * @category Array
- *
- * @see sortedIndex, sortedIndexBy, sortedIndexWith, sortedLastIndexBy
- */
-export declare function sortedLastIndex<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 *last*
- * occurrence of the item.
- *
- * Runs in O(logN) time.
- *
- * @param item - The item to insert.
- * @return - Insertion index (In the range 0..data.length)
- *
- * @signature
- *    P.sortedLastIndex(item)(data)
- * @example
- *    P.pipe(['a','a','b','c','c'], sortedLastIndex('c')) // => 5
- * @dataLast
- * @category Array
- *
- * @see sortedIndex, sortedIndexBy, sortedIndexWith, sortedLastIndexBy
- */
-export declare function sortedLastIndex<T>(item: T): (data: ReadonlyArray<T>) => number;
-//# sourceMappingURL=sorted-last-index.d.ts.map

package/dist/types/array/sorted-last-index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sorted-last-index.d.ts","sourceRoot":"","sources":["../../../src/array/sorted-last-index.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,MAAM,CAAC;AAE5E;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC"}

package/dist/types/array/splice.d.ts

@@ -1,32 +0,0 @@
-/**
- * Removes elements from an array and, inserts new elements in their place.
- *
- * @param items the array to splice.
- * @param start the index from which to start removing elements.
- * @param deleteCount the number of elements to remove.
- * @param replacement the elements to insert into the array in place of the deleted elements.
- * @signature
- *    P.splice(items, start, deleteCount, replacement)
- * @example
- *    P.splice([1,2,3,4,5,6,7,8], 2, 3, []); //=> [1,2,6,7,8]
- *    P.splice([1,2,3,4,5,6,7,8], 2, 3, [9, 10]); //=> [1,2,9,10,6,7,8]
- * @dataFirst
- * @category Array
- */
-export declare function splice<T>(items: ReadonlyArray<T>, start: number, deleteCount: number, replacement: ReadonlyArray<T>): Array<T>;
-/**
- * Removes elements from an array and, inserts new elements in their place.
- *
- * @param start the index from which to start removing elements.
- * @param deleteCount the number of elements to remove.
- * @param replacement the elements to insert into the array in place of the deleted elements.
- * @signature
- *    P.splice(start, deleteCount, replacement)(items)
- * @example
- *    P.pipe([1,2,3,4,5,6,7,8], P.splice(2, 3, [])) // => [1,2,6,7,8]
- *    P.pipe([1,2,3,4,5,6,7,8], P.splice(2, 3, [9, 10])) // => [1,2,9,10,6,7,8]
- * @dataLast
- * @category Array
- */
-export declare function splice<T>(start: number, deleteCount: number, replacement: ReadonlyArray<T>): (items: ReadonlyArray<T>) => Array<T>;
-//# sourceMappingURL=splice.d.ts.map

package/dist/types/array/splice.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"splice.d.ts","sourceRoot":"","sources":["../../../src/array/splice.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CAAC,CAAC,EACtB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,aAAa,CAAC,CAAC,CAAC,GAC5B,KAAK,CAAC,CAAC,CAAC,CAAC;AAEZ;;;;;;;;;;;;;GAaG;AACH,wBAAgB,MAAM,CAAC,CAAC,EACtB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,aAAa,CAAC,CAAC,CAAC,GAC5B,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC"}

package/dist/types/array/split-at.d.ts

@@ -1,28 +0,0 @@
-/**
- * Splits a given array at a given index.
- *
- * @param array the array to split
- * @param index the index to split at
- * @signature
- *    P.splitAt(array, index)
- * @example
- *    P.splitAt([1, 2, 3], 1) // => [[1], [2, 3]]
- *    P.splitAt([1, 2, 3, 4, 5], -1) // => [[1, 2, 3, 4], [5]]
- * @dataFirst
- * @category Array
- */
-export declare function splitAt<T>(array: ReadonlyArray<T>, index: number): [Array<T>, Array<T>];
-/**
- * Splits a given array at a given index.
- *
- * @param index the index to split at
- * @signature
- *    P.splitAt(index)(array)
- * @example
- *    P.splitAt(1)([1, 2, 3]) // => [[1], [2, 3]]
- *    P.splitAt(-1)([1, 2, 3, 4, 5]) // => [[1, 2, 3, 4], [5]]
- * @dataLast
- * @category Array
- */
-export declare function splitAt<T>(index: number): (array: ReadonlyArray<T>) => [Array<T>, Array<T>];
-//# sourceMappingURL=split-at.d.ts.map

package/dist/types/array/split-at.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"split-at.d.ts","sourceRoot":"","sources":["../../../src/array/split-at.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,KAAK,EAAE,MAAM,GACZ,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AAExB;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,MAAM,GACZ,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC"}

package/dist/types/array/split-when.d.ts

@@ -1,24 +0,0 @@
-/**
- * Splits a given array at the first index where the given predicate returns true.
- * @param array the array to split
- * @param fn the predicate
- * @signature
- *    P.splitWhen(array, fn)
- * @example
- *    P.splitWhen([1, 2, 3], x => x === 2) // => [[1], [2, 3]]
- * @dataFirst
- * @category Array
- */
-export declare function splitWhen<T>(array: ReadonlyArray<T>, fn: (item: T) => boolean): [Array<T>, Array<T>];
-/**
- * Splits a given array at an index where the given predicate returns true.
- * @param fn the predicate
- * @signature
- *    P.splitWhen(fn)(array)
- * @example
- *    P.splitWhen(x => x === 2)([1, 2, 3]) // => [[1], [2, 3]]
- * @dataLast
- * @category Array
- */
-export declare function splitWhen<T>(fn: (item: T) => boolean): (array: ReadonlyArray<T>) => [Array<T>, Array<T>];
-//# sourceMappingURL=split-when.d.ts.map

package/dist/types/array/split-when.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"split-when.d.ts","sourceRoot":"","sources":["../../../src/array/split-when.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GACvB,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AAExB;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GACvB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC"}

package/dist/types/array/sum-by.d.ts

@@ -1,39 +0,0 @@
-import type { PredIndexed } from '../utils/types';
-/**
- * Returns the sum of the elements of an array using the provided predicate.
- * @param fn predicate function
- * @signature
- *   P.sumBy(fn)(array)
- *   P.sumBy.indexed(fn)(array)
- * @example
- *    P.pipe(
- *      [{a: 5}, {a: 1}, {a: 3}],
- *      P.sumBy(x => x.a)
- *    ) // 9
- * @dataLast
- * @indexed
- * @category Array
- */
-export declare function sumBy<T>(fn: (item: T) => number): (items: ReadonlyArray<T>) => number;
-/**
- * Returns the sum of the elements of an array using the provided predicate.
- * @param items the array
- * @param fn predicate function
- * @signature
- *   P.sumBy(array, fn)
- *   P.sumBy.indexed(array, fn)
- * @example
- *    P.sumBy(
- *      [{a: 5}, {a: 1}, {a: 3}],
- *      x => x.a
- *    ) // 9
- * @dataFirst
- * @indexed
- * @category Array
- */
-export declare function sumBy<T>(items: ReadonlyArray<T>, fn: (item: T) => number): number;
-export declare namespace sumBy {
-    function indexed<T>(array: ReadonlyArray<T>, fn: PredIndexed<T, number>): number;
-    function indexed<T>(fn: PredIndexed<T, number>): (array: ReadonlyArray<T>) => number;
-}
-//# sourceMappingURL=sum-by.d.ts.map

package/dist/types/array/sum-by.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sum-by.d.ts","sourceRoot":"","sources":["../../../src/array/sum-by.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAuB,MAAM,gBAAgB,CAAC;AAgBvE;;;;;;;;;;;;;;GAcG;AAEH,wBAAgB,KAAK,CAAC,CAAC,EACrB,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GACtB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC;AAEvC;;;;;;;;;;;;;;;GAeG;AAEH,wBAAgB,KAAK,CAAC,CAAC,EACrB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GACtB,MAAM,CAAC;AAMV,yBAAiB,KAAK,CAAC;IACrB,SAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,MAAM,CAAC,GACzB,MAAM,CAAC;IAEV,SAAgB,OAAO,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,MAAM,CAAC,GACzB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC;CAKxC"}