@vinicunca/perkakas 0.4.1 → 0.4.3

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"}

package/dist/types/array/swap-indices.d.ts

@@ -1,68 +0,0 @@
-import type { IterableContainer } from '../utils/types';
-import type { Joined } from './join';
-/**
- * @link https://github.com/sindresorhus/type-fest/blob/main/source/is-equal.d.ts
- */
-type isEqual<A, B> = (<G>() => G extends A ? 1 : 2) extends <G>() => G extends B ? 1 : 2 ? true : false;
-type Difference<A extends number, B extends number> = TupleOfLength<A> extends [
-    ...infer U,
-    ...TupleOfLength<B>
-] ? U['length'] : never;
-type isLessThan<A extends number, B extends number> = isEqual<A, B> extends true ? false : 0 extends A ? true : 0 extends B ? false : isLessThan<Difference<A, 1>, Difference<B, 1>>;
-type TupleOfLength<L extends number, T extends IterableContainer = []> = T['length'] extends L ? T : TupleOfLength<L, [...T, unknown]>;
-type IsNonNegative<T extends number> = number extends T ? false : `${T}` extends `-${string}` ? false : true;
-type CharactersTuple<T extends string> = string extends T ? Array<string> : T extends `${infer C}${infer R}` ? [C, ...CharactersTuple<R>] : [];
-type SwapArrayInternal<T extends IterableContainer, Index1 extends number, Index2 extends number, Position extends ReadonlyArray<unknown> = [], Original extends IterableContainer = T> = T extends readonly [infer AtPosition, ...infer Rest] ? [
-    Position['length'] extends Index1 ? Original[Index2] : Position['length'] extends Index2 ? Original[Index1] : AtPosition,
-    ...SwapArrayInternal<Rest, Index1, Index2, [
-        unknown,
-        ...Position
-    ], Original>
-] : T;
-type SwapString<T extends string, K1 extends number, K2 extends number> = Joined<SwapArray<CharactersTuple<T>, K1, K2>, ''>;
-type SwapArray<T extends IterableContainer, K1 extends number, K2 extends number> = IsNonNegative<K1> extends false ? Array<T[number]> : IsNonNegative<K2> extends false ? Array<T[number]> : isLessThan<K1, T['length']> extends false ? T : isLessThan<K2, T['length']> extends false ? T : SwapArrayInternal<T, K1, K2>;
-type SwappedIndices<T extends IterableContainer | string, K1 extends number, K2 extends number> = T extends string ? SwapString<T, K1, K2> : T extends IterableContainer ? SwapArray<T, K1, K2> : never;
-/**
- * Swaps the positions of two elements in an array or string at the provided indices.
- *
- * Negative indices are supported and would be treated as an offset from the end of the array. The resulting type thought would be less strict than when using positive indices.
- *
- * If either index is out of bounds the result would be a shallow copy of the input, as-is.
- *
- * @param data the item to be manipulated. This can be an array, or a string.
- * @param index1 the first index
- * @param index2 the second index
- *
- * @signature
- *   swapIndices(data, index1, index2)
- *
- * @example
- *   swapIndices(['a', 'b', 'c'], 0, 1) // => ['b', 'a', 'c']
- *   swapIndices(['a', 'b', 'c'], 1, -1) // => ['c', 'b', 'a']
- *   swapIndices('abc', 0, 1) // => 'bac'
- *
- * @category Array
- *
- * @returns Returns the manipulated array or string.
- *
- * @dataFirst
- */
-export declare function swapIndices<T extends IterableContainer | string, K1 extends number, K2 extends number>(data: T, index1: K1, index2: K2): SwappedIndices<T, K1, K2>;
-/**
- * @param index1 the first index
- * @param index2 the second index
- *
- * @signature
- *   swapIndices(index1, index2)(data)
- *
- * @example
- *   swapIndices(0, 1)(['a', 'b', 'c']) // => ['b', 'a', 'c']
- *   swapIndices(0, -1)('abc') // => 'cba'
- *
- * @category Array
- * @returns Returns the manipulated array or string.
- * @dataLast
- */
-export declare function swapIndices<K1 extends number, K2 extends number>(index1: K1, index2: K2): <T extends IterableContainer | string>(data: T) => SwappedIndices<T, K1, K2>;
-export {};
-//# sourceMappingURL=swap-indices.d.ts.map

package/dist/types/array/swap-indices.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"swap-indices.d.ts","sourceRoot":"","sources":["../../../src/array/swap-indices.ts"],"names":[],"mappings":"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"}

package/dist/types/array/take-first-by.d.ts

@@ -1,42 +0,0 @@
-import type { NonEmptyArray } from '../utils/types';
-import { type OrderRule } from '../utils/purry-order-rules';
-/**
- * Take the first `n` items from `data` based on the provided ordering criteria.
- * This allows you to avoid sorting the array before taking the items.
- * The complexity of this function is *O(Nlogn)* where `N` is the length of the array.
- *
- * For the opposite operation (to drop `n` elements) see `dropFirstBy`.
- *
- * @params data - the input array
- * @params n - the number of items to take. If `n` is non-positive no items would be returned, if `n` is bigger then data.length a *clone* of `data` would be returned.
- * @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.
- * @returns a subset of the input array.
- * @signature
- *   P.takeFirstBy(data, n, ...rules);
- * @example
- *   P.takeFirstBy(['aa', 'aaaa', 'a', 'aaa'], 2, x => x.length); // => ['a', 'aa']
- * @dataFirst
- * @category Array
- */
-export declare function takeFirstBy<T>(data: ReadonlyArray<T>, n: number, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): Array<T>;
-/**
- * Take the first `n` items from `data` based on the provided ordering criteria.
- * This allows you to avoid sorting the array before taking the items.
- * The complexity of this function is *O(Nlogn)* where `N` is the length of the array.
- *
- * For the opposite operation (to drop `n` elements) see `dropFirstBy`.
- *
- * @params n - the number of items to take. If `n` is non-positive no items would be returned, if `n` is bigger then data.length a *clone* of `data` would be returned.
- * @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.
- * @returns a subset of the input array.
- * @signature
- *   P.takeFirstBy(n, ...rules)(data);
- * @example
- *   R.pipe(['aa', 'aaaa', 'a', 'aaa'], P.takeFirstBy(2, x => x.length)); // => ['a', 'aa']
- * @dataLast
- * @category Array
- */
-export declare function takeFirstBy<T>(n: number, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): (data: ReadonlyArray<T>) => Array<T>;
-//# sourceMappingURL=take-first-by.d.ts.map

package/dist/types/array/take-first-by.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"take-first-by.d.ts","sourceRoot":"","sources":["../../../src/array/take-first-by.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAmB,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAGrE,OAAO,EAAE,KAAK,SAAS,EAA+B,MAAM,4BAA4B,CAAC;AAEzF;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAC3B,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EACtB,CAAC,EAAE,MAAM,EACT,GAAG,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,GAC9C,KAAK,CAAC,CAAC,CAAC,CAAC;AAEZ;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAC3B,CAAC,EAAE,MAAM,EACT,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"}

package/dist/types/array/take-while.d.ts

@@ -1,24 +0,0 @@
-/**
- * Returns elements from the array until predicate returns false.
- * @param array the array
- * @param fn the predicate
- * @signature
- *    P.takeWhile(array, fn)
- * @example
- *    P.takeWhile([1, 2, 3, 4, 3, 2, 1], x => x !== 4) // => [1, 2, 3]
- * @dataFirst
- * @category Array
- */
-export declare function takeWhile<T>(array: ReadonlyArray<T>, fn: (item: T) => boolean): Array<T>;
-/**
- * Returns elements from the array until predicate returns false.
- * @param fn the predicate
- * @signature
- *    P.takeWhile(fn)(array)
- * @example
- *    P.pipe([1, 2, 3, 4, 3, 2, 1], P.takeWhile(x => x !== 4))  // => [1, 2, 3]
- * @dataLast
- * @category Array
- */
-export declare function takeWhile<T>(fn: (item: T) => boolean): (array: ReadonlyArray<T>) => Array<T>;
-//# sourceMappingURL=take-while.d.ts.map

package/dist/types/array/take-while.d.ts.map

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

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

@@ -1,30 +0,0 @@
-import type { LazyEvaluator } from '../function/pipe';
-/**
- * Returns the first `n` elements of `array`.
- * @param array the array
- * @param n the number of elements to take
- * @signature
- *    P.take(array, n)
- * @example
- *    P.take([1, 2, 3, 4, 3, 2, 1], 3) // => [1, 2, 3]
- * @dataFirst
- * @pipeable
- * @category Array
- */
-export declare function take<T>(array: ReadonlyArray<T>, n: number): Array<T>;
-/**
- * Returns the first `n` elements of `array`.
- * @param n the number of elements to take
- * @signature
- *    P.take(n)(array)
- * @example
- *    P.pipe([1, 2, 3, 4, 3, 2, 1], P.take(n)) // => [1, 2, 3]
- * @dataLast
- * @pipeable
- * @category Array
- */
-export declare function take<T>(n: number): (array: ReadonlyArray<T>) => Array<T>;
-export declare namespace take {
-    function lazy<T>(n: number): LazyEvaluator<T>;
-}
-//# sourceMappingURL=take.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"take.d.ts","sourceRoot":"","sources":["../../../src/array/take.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAKtD;;;;;;;;;;;GAWG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;AAEtE;;;;;;;;;;GAUG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;AAU1E,yBAAiB,IAAI,CAAC;IACpB,SAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,aAAa,CAAC,CAAC,CAAC,CAUnD;CACF"}