@vinicunca/perkakas 1.13.2 → 1.14.0

package/dist/sorted-index.d.ts

@@ -1,45 +0,0 @@
-//#region src/sorted-index.d.ts
-/**
- * Find the insertion position (index) of an item in an array with items sorted
- * in ascending order; so that `splice(sortedIndex, 0, item)` would result in
- * maintaining the array's sort-ness. The array can contain duplicates.
- * If the item already exists in the array the index would be of the *first*
- * occurrence of the item.
- *
- * Runs in O(logN) time.
- *
- * @param data - The (ascending) sorted array.
- * @param item - The item to insert.
- * @returns Insertion index (In the range 0..array.length).
- * @signature
- *    P.sortedIndex(data, item)
- * @example
- *    P.sortedIndex(['a','a','b','c','c'], 'c') // => 3
- * @dataFirst
- * @category Array
- * @see sortedIndexBy, sortedIndexWith, sortedLastIndex, sortedLastIndexBy
- */
-declare function sortedIndex<T>(data: ReadonlyArray<T>, item: T): number;
-/**
- * Find the insertion position (index) of an item in an array with items sorted
- * in ascending order; so that `splice(sortedIndex, 0, item)` would result in
- * maintaining the array's sort-ness. The array can contain duplicates.
- * If the item already exists in the array the index would be of the *first*
- * occurrence of the item.
- *
- * Runs in O(logN) time.
- *
- * @param item - The item to insert.
- * @returns Insertion index (In the range 0..array.length).
- * @signature
- *    P.sortedIndex(item)(data)
- * @example
- *    P.pipe(['a','a','b','c','c'], P.sortedIndex('c')) // => 3
- * @dataLast
- * @category Array
- * @see sortedIndexBy, sortedIndexWith, sortedLastIndex, sortedLastIndexBy
- */
-declare function sortedIndex<T>(item: T): (data: ReadonlyArray<T>) => number;
-//#endregion
-export { sortedIndex };
-//# sourceMappingURL=sorted-index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"sorted-index.d.ts","names":[],"sources":["../src/sorted-index.ts"],"sourcesContent":[],"mappings":";;AAuBA;;;;;AAqBA;;;;;;;;;;;;;;iBArBgB,qBAAqB,cAAc,UAAU;;;;;;;;;;;;;;;;;;;;iBAqB7C,qBAAqB,WAAW,cAAc"}

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

@@ -1,72 +0,0 @@
-//#region src/sorted-last-index-by.d.ts
-/**
- * Find the insertion position (index) of an item in an array with items sorted
- * in ascending order using a value function; so that
- * `splice(sortedIndex, 0, item)` would result in maintaining the arrays sort-
- * ness. The array can contain duplicates.
- * If the item already exists in the array the index would be of the *last*
- * occurrence of the item.
- *
- * Runs in O(logN) time.
- *
- * See also:
- * `findIndex` - scans a possibly unsorted array in-order (linear search).
- * `sortedLastIndex` - a simplified version of this function, without a callbackfn.
- * `sortedIndexBy` - like this function, but returns the first suitable index.
- * `sortedIndex` - like `sortedLastIndex` but without a callbackfn.
- * `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.sortedLastIndexBy(data, item, valueFunction)
- * @example
- *    P.sortedLastIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1
- * @dataFirst
- * @category Array
- */
-declare function sortedLastIndexBy<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 *last*
- * occurrence of the item.
- *
- * Runs in O(logN) time.
- *
- * See also:
- * `findIndex` - scans a possibly unsorted array in-order (linear search).
- * `sortedLastIndex` - a simplified version of this function, without a callbackfn.
- * `sortedIndexBy` - like this function, but returns the first suitable index.
- * `sortedIndex` - like `sortedLastIndex` but without a callbackfn.
- * `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`.
- * @returns 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
- * @category Array
- * @see sortedIndex, sortedIndexBy, sortedIndexWith, sortedLastIndex
- */
-declare function sortedLastIndexBy<T>(item: T, valueFunction: (item: T, index: number | undefined, data: ReadonlyArray<T>) => NonNullable<unknown>): (data: ReadonlyArray<T>) => number;
-//#endregion
-export { sortedLastIndexBy };
-//# sourceMappingURL=sorted-last-index-by.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"sorted-last-index-by.d.cts","names":[],"sources":["../src/sorted-last-index-by.ts"],"sourcesContent":[],"mappings":";;AAoCA;;;;;;;;;AA2CA;;;;;;;;;;;;;;;;;;;;;;;iBA3CgB,2BACR,cAAc,UACd,yBAEE,oCAEA,cAAc,OACjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoCS,2BACR,yBAEE,oCAEA,cAAc,OACjB,8BACG,cAAc"}

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

@@ -1,72 +0,0 @@
-//#region src/sorted-last-index-by.d.ts
-/**
- * Find the insertion position (index) of an item in an array with items sorted
- * in ascending order using a value function; so that
- * `splice(sortedIndex, 0, item)` would result in maintaining the arrays sort-
- * ness. The array can contain duplicates.
- * If the item already exists in the array the index would be of the *last*
- * occurrence of the item.
- *
- * Runs in O(logN) time.
- *
- * See also:
- * `findIndex` - scans a possibly unsorted array in-order (linear search).
- * `sortedLastIndex` - a simplified version of this function, without a callbackfn.
- * `sortedIndexBy` - like this function, but returns the first suitable index.
- * `sortedIndex` - like `sortedLastIndex` but without a callbackfn.
- * `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.sortedLastIndexBy(data, item, valueFunction)
- * @example
- *    P.sortedLastIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1
- * @dataFirst
- * @category Array
- */
-declare function sortedLastIndexBy<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 *last*
- * occurrence of the item.
- *
- * Runs in O(logN) time.
- *
- * See also:
- * `findIndex` - scans a possibly unsorted array in-order (linear search).
- * `sortedLastIndex` - a simplified version of this function, without a callbackfn.
- * `sortedIndexBy` - like this function, but returns the first suitable index.
- * `sortedIndex` - like `sortedLastIndex` but without a callbackfn.
- * `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`.
- * @returns 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
- * @category Array
- * @see sortedIndex, sortedIndexBy, sortedIndexWith, sortedLastIndex
- */
-declare function sortedLastIndexBy<T>(item: T, valueFunction: (item: T, index: number | undefined, data: ReadonlyArray<T>) => NonNullable<unknown>): (data: ReadonlyArray<T>) => number;
-//#endregion
-export { sortedLastIndexBy };
-//# sourceMappingURL=sorted-last-index-by.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"sorted-last-index-by.d.ts","names":[],"sources":["../src/sorted-last-index-by.ts"],"sourcesContent":[],"mappings":";;AAoCA;;;;;;;;;AA2CA;;;;;;;;;;;;;;;;;;;;;;;iBA3CgB,2BACR,cAAc,UACd,yBAEE,oCAEA,cAAc,OACjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoCS,2BACR,yBAEE,oCAEA,cAAc,OACjB,8BACG,cAAc"}

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

@@ -1,45 +0,0 @@
-//#region src/sorted-last-index.d.ts
-/**
- * Find the insertion position (index) of an item in an array with items sorted
- * in ascending order; so that `splice(sortedIndex, 0, item)` would result in
- * maintaining the array's sort-ness. The array can contain duplicates.
- * If the item already exists in the array the index would be of the *last*
- * occurrence of the item.
- *
- * Runs in O(logN) time.
- *
- * @param data - The (ascending) sorted array.
- * @param item - The item to insert.
- * @returns Insertion index (In the range 0..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
- */
-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.
- * @returns 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
- */
-declare function sortedLastIndex<T>(item: T): (data: ReadonlyArray<T>) => number;
-//#endregion
-export { sortedLastIndex };
-//# sourceMappingURL=sorted-last-index.d.cts.map

package/dist/sorted-last-index.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sorted-last-index.d.cts","names":[],"sources":["../src/sorted-last-index.ts"],"sourcesContent":[],"mappings":";;AAuBA;;;;;AAqBA;;;;;;;;;;;;;;iBArBgB,yBAAyB,cAAc,UAAU;;;;;;;;;;;;;;;;;;;;iBAqBjD,yBAAyB,WAAW,cAAc"}

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

@@ -1,45 +0,0 @@
-//#region src/sorted-last-index.d.ts
-/**
- * Find the insertion position (index) of an item in an array with items sorted
- * in ascending order; so that `splice(sortedIndex, 0, item)` would result in
- * maintaining the array's sort-ness. The array can contain duplicates.
- * If the item already exists in the array the index would be of the *last*
- * occurrence of the item.
- *
- * Runs in O(logN) time.
- *
- * @param data - The (ascending) sorted array.
- * @param item - The item to insert.
- * @returns Insertion index (In the range 0..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
- */
-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.
- * @returns 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
- */
-declare function sortedLastIndex<T>(item: T): (data: ReadonlyArray<T>) => number;
-//#endregion
-export { sortedLastIndex };
-//# sourceMappingURL=sorted-last-index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"sorted-last-index.d.ts","names":[],"sources":["../src/sorted-last-index.ts"],"sourcesContent":[],"mappings":";;AAuBA;;;;;AAqBA;;;;;;;;;;;;;;iBArBgB,yBAAyB,cAAc,UAAU;;;;;;;;;;;;;;;;;;;;iBAqBjD,yBAAyB,WAAW,cAAc"}

package/dist/splice.d.cts

@@ -1,35 +0,0 @@
-//#region src/splice.d.ts
-/**
- * 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
- */
-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
- */
-declare function splice<T>(start: number, deleteCount: number, replacement: ReadonlyArray<T>): (items: ReadonlyArray<T>) => Array<T>;
-//#endregion
-export { splice };
-//# sourceMappingURL=splice.d.cts.map

package/dist/splice.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"splice.d.cts","names":[],"sources":["../src/splice.ts"],"sourcesContent":[],"mappings":";;AAiBA;;;;;;;;AAqBA;;;;;;AAIgC,iBAzBhB,MAyBgB,CAAA,CAAA,CAAA,CAAA,KAAA,EAxBvB,aAwBuB,CAxBT,CAwBS,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,WAAA,EAAA,MAAA,EAAA,WAAA,EArBjB,aAqBiB,CArBH,CAqBG,CAAA,CAAA,EApB7B,KAoB6B,CApBvB,CAoBuB,CAAA;;;;;;;;;;;;;;;iBAJhB,2DAGD,cAAc,aAClB,cAAc,OAAO,MAAM"}

package/dist/splice.d.ts

@@ -1,35 +0,0 @@
-//#region src/splice.d.ts
-/**
- * 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
- */
-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
- */
-declare function splice<T>(start: number, deleteCount: number, replacement: ReadonlyArray<T>): (items: ReadonlyArray<T>) => Array<T>;
-//#endregion
-export { splice };
-//# sourceMappingURL=splice.d.ts.map

package/dist/splice.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"splice.d.ts","names":[],"sources":["../src/splice.ts"],"sourcesContent":[],"mappings":";;AAiBA;;;;;;;;AAqBA;;;;;;AAIgC,iBAzBhB,MAyBgB,CAAA,CAAA,CAAA,CAAA,KAAA,EAxBvB,aAwBuB,CAxBT,CAwBS,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,WAAA,EAAA,MAAA,EAAA,WAAA,EArBjB,aAqBiB,CArBH,CAqBG,CAAA,CAAA,EApB7B,KAoB6B,CApBvB,CAoBuB,CAAA;;;;;;;;;;;;;;;iBAJhB,2DAGD,cAAc,aAClB,cAAc,OAAO,MAAM"}

package/dist/split-at.d.cts

@@ -1,31 +0,0 @@
-//#region src/split-at.d.ts
-/**
- * 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
- */
-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
- */
-declare function splitAt<T>(index: number): (array: ReadonlyArray<T>) => [Array<T>, Array<T>];
-//#endregion
-export { splitAt };
-//# sourceMappingURL=split-at.d.cts.map

package/dist/split-at.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"split-at.d.cts","names":[],"sources":["../src/split-at.ts"],"sourcesContent":[],"mappings":";;AAeA;;;;;;;;AAiBA;;;;AAEiC,iBAnBjB,OAmBiB,CAAA,CAAA,CAAA,CAAA,KAAA,EAlBxB,aAkBwB,CAlBV,CAkBU,CAAA,EAAA,KAAA,EAAA,MAAA,CAAA,EAAA,CAhB7B,KAgB6B,CAhBvB,CAgBuB,CAAA,EAhBnB,KAgBmB,CAhBb,CAgBa,CAAA,CAAA;;;;;;;;;;;;;iBAFjB,mCAEL,cAAc,QAAQ,MAAM,IAAI,MAAM"}

package/dist/split-at.d.ts

@@ -1,31 +0,0 @@
-//#region src/split-at.d.ts
-/**
- * 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
- */
-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
- */
-declare function splitAt<T>(index: number): (array: ReadonlyArray<T>) => [Array<T>, Array<T>];
-//#endregion
-export { splitAt };
-//# sourceMappingURL=split-at.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"split-at.d.ts","names":[],"sources":["../src/split-at.ts"],"sourcesContent":[],"mappings":";;AAeA;;;;;;;;AAiBA;;;;AAEiC,iBAnBjB,OAmBiB,CAAA,CAAA,CAAA,CAAA,KAAA,EAlBxB,aAkBwB,CAlBV,CAkBU,CAAA,EAAA,KAAA,EAAA,MAAA,CAAA,EAAA,CAhB7B,KAgB6B,CAhBvB,CAgBuB,CAAA,EAhBnB,KAgBmB,CAhBb,CAgBa,CAAA,CAAA;;;;;;;;;;;;;iBAFjB,mCAEL,cAAc,QAAQ,MAAM,IAAI,MAAM"}

package/dist/split-when.d.cts

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

package/dist/split-when.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"split-when.d.cts","names":[],"sources":["../src/split-when.ts"],"sourcesContent":[],"mappings":";;AAcA;;;;;;;;;;;AAgBgB,iBAhBA,SAgBS,CAAA,CAAA,CAAA,CAAA,IAAA,EAfjB,aAeiB,CAfH,CAeG,CAAA,EAAA,SAAA,EAAA,CAAA,IAAA,EAdL,CAcK,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAdmB,aAcnB,CAdiC,CAcjC,CAAA,EAAA,GAAA,OAAA,CAAA,EAAA,CAbrB,KAaqB,CAbf,CAae,CAAA,EAbX,KAaW,CAbL,CAaK,CAAA,CAAA;;;;;;;;;;;;iBAAT,+BACI,wBAAwB,cAAc,yBAC/C,cAAc,QAAQ,MAAM,IAAI,MAAM"}

package/dist/split-when.d.ts

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"split-when.d.ts","names":[],"sources":["../src/split-when.ts"],"sourcesContent":[],"mappings":";;AAcA;;;;;;;;;;;AAgBgB,iBAhBA,SAgBS,CAAA,CAAA,CAAA,CAAA,IAAA,EAfjB,aAeiB,CAfH,CAeG,CAAA,EAAA,SAAA,EAAA,CAAA,IAAA,EAdL,CAcK,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAdmB,aAcnB,CAdiC,CAcjC,CAAA,EAAA,GAAA,OAAA,CAAA,EAAA,CAbrB,KAaqB,CAbf,CAae,CAAA,EAbX,KAaW,CAbL,CAaK,CAAA,CAAA;;;;;;;;;;;;iBAAT,+BACI,wBAAwB,cAAc,yBAC/C,cAAc,QAAQ,MAAM,IAAI,MAAM"}

package/dist/split.d.cts

@@ -1,62 +0,0 @@
-import { ArraySlice, IsFloat, NonNegative, Split } from "type-fest";
-
-//#region src/split.d.ts
-type Split$1<S extends string, Separator extends string, N extends number | undefined = undefined> = string extends S ? Array<string> : string extends Separator ? Array<string> : number extends N ? Array<string> : IsFloat<N> extends true ? Array<string> : ArraySlice<Split<S, Separator>, 0, N extends number ? NonNegative<N> : never>;
-/**
- * Takes a pattern and divides this string into an ordered list of substrings by
- * searching for the pattern, puts these substrings into an array, and returns
- * the array. This function mirrors the built-in [`String.prototype.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split)
- * method.
- *
- * @param data - The string to split.
- * @param separator - The pattern describing where each split should occur. Can
- * be a string, or a regular expression.
- * @param limit - A non-negative integer specifying a limit on the number of
- * substrings to be included in the array. If provided, splits the string at
- * each occurrence of the specified separator, but stops when limit entries have
- * been placed in the array. Any leftover text is not included in the array at
- * all. The array may contain fewer entries than limit if the end of the string
- * is reached before the limit is reached. If limit is 0, [] is returned.
- * @returns An Array of strings, split at each point where the separator occurs
- * in the given string.
- * @signature
- *   P.split(data, separator, limit);
- * @example
- *   P.split("a,b,c", ","); //=> ["a", "b", "c"]
- *   P.split("a,b,c", ",", 2); //=> ["a", "b"]
- *   P.split("a1b2c3d", /\d/u); //=> ["a", "b", "c", "d"]
- * @dataFirst
- * @category String
- */
-declare function split(data: string, separator: RegExp, limit?: number): Array<string>;
-declare function split<S extends string, Separator extends string, N extends number | undefined = undefined>(data: S, separator: Separator, limit?: N): Split$1<S, Separator, N>;
-/**
- * Takes a pattern and divides this string into an ordered list of substrings by
- * searching for the pattern, puts these substrings into an array, and returns
- * the array. This function mirrors the built-in [`String.prototype.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split)
- * method.
- *
- * @param separator - The pattern describing where each split should occur. Can
- * be a string, or a regular expression.
- * @param limit - A non-negative integer specifying a limit on the number of
- * substrings to be included in the array. If provided, splits the string at
- * each occurrence of the specified separator, but stops when limit entries have
- * been placed in the array. Any leftover text is not included in the array at
- * all. The array may contain fewer entries than limit if the end of the string
- * is reached before the limit is reached. If limit is 0, [] is returned.
- * @returns An Array of strings, split at each point where the separator occurs
- * in the given string.
- * @signature
- *   P.split(separator, limit)(data);
- * @example
- *   P.pipe("a,b,c", P.split(",")); //=> ["a", "b", "c"]
- *   P.pipe("a,b,c", P.split(",", 2)); //=> ["a", "b"]
- *   P.pipe("a1b2c3d", P.split(/\d/u)); //=> ["a", "b", "c", "d"]
- * @dataLast
- * @category String
- */
-declare function split(separator: RegExp, limit?: number): (data: string) => Array<string>;
-declare function split<S extends string, Separator extends string, N extends number | undefined = undefined>(separator: Separator, limit?: N): (data: S) => Split$1<S, Separator, N>;
-//#endregion
-export { split };
-//# sourceMappingURL=split.d.cts.map

package/dist/split.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"split.d.cts","names":[],"sources":["../src/split.ts"],"sourcesContent":[],"mappings":";;;KAOK,+GAIc,IACf,+BACe,YACb,+BACe,IACb,gBAEA,QAAQ,kBACN,gBACA,WAIA,MAAU,GAAG,eAIb,mBAAmB,YAAY;;AAvBtB;;;;;;;;;;;;;;;;;;AAoDnB;AAKA;;;;;;AAIiE,iBATjD,KAAA,CASiD,IAAA,EAAA,MAAA,EAAA,SAAA,EAPpD,MAOoD,EAAA,KAAA,CAAA,EAAA,MAAA,CAAA,EAL9D,KAK8D,CAAA,MAAA,CAAA;AAApB,iBAJ7B,KAI6B,CAAA,UAAA,MAAA,EAAA,kBAAA,MAAA,EAAA,UAAA,MAAA,GAAA,SAAA,GAAA,SAAA,CAAA,CAAA,IAAA,EAArC,CAAqC,EAAA,SAAA,EAAvB,SAAuB,EAAA,KAAA,CAAA,EAAJ,CAAI,CAAA,EAAA,OAAA,CAAM,CAAN,EAAS,SAAT,EAAoB,CAApB,CAAA;;AA2B7C;AAIA;;;;;;;;;;;;;;;;;;;;;;;iBAJgB,KAAA,YACH,2CAEQ;iBACL,uGAIH,mBAAmB,WAAW,MAAM,QAAM,GAAG,WAAW"}

package/dist/split.d.ts

@@ -1,62 +0,0 @@
-import { ArraySlice, IsFloat, NonNegative, Split } from "type-fest";
-
-//#region src/split.d.ts
-type Split$1<S extends string, Separator extends string, N extends number | undefined = undefined> = string extends S ? Array<string> : string extends Separator ? Array<string> : number extends N ? Array<string> : IsFloat<N> extends true ? Array<string> : ArraySlice<Split<S, Separator>, 0, N extends number ? NonNegative<N> : never>;
-/**
- * Takes a pattern and divides this string into an ordered list of substrings by
- * searching for the pattern, puts these substrings into an array, and returns
- * the array. This function mirrors the built-in [`String.prototype.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split)
- * method.
- *
- * @param data - The string to split.
- * @param separator - The pattern describing where each split should occur. Can
- * be a string, or a regular expression.
- * @param limit - A non-negative integer specifying a limit on the number of
- * substrings to be included in the array. If provided, splits the string at
- * each occurrence of the specified separator, but stops when limit entries have
- * been placed in the array. Any leftover text is not included in the array at
- * all. The array may contain fewer entries than limit if the end of the string
- * is reached before the limit is reached. If limit is 0, [] is returned.
- * @returns An Array of strings, split at each point where the separator occurs
- * in the given string.
- * @signature
- *   P.split(data, separator, limit);
- * @example
- *   P.split("a,b,c", ","); //=> ["a", "b", "c"]
- *   P.split("a,b,c", ",", 2); //=> ["a", "b"]
- *   P.split("a1b2c3d", /\d/u); //=> ["a", "b", "c", "d"]
- * @dataFirst
- * @category String
- */
-declare function split(data: string, separator: RegExp, limit?: number): Array<string>;
-declare function split<S extends string, Separator extends string, N extends number | undefined = undefined>(data: S, separator: Separator, limit?: N): Split$1<S, Separator, N>;
-/**
- * Takes a pattern and divides this string into an ordered list of substrings by
- * searching for the pattern, puts these substrings into an array, and returns
- * the array. This function mirrors the built-in [`String.prototype.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split)
- * method.
- *
- * @param separator - The pattern describing where each split should occur. Can
- * be a string, or a regular expression.
- * @param limit - A non-negative integer specifying a limit on the number of
- * substrings to be included in the array. If provided, splits the string at
- * each occurrence of the specified separator, but stops when limit entries have
- * been placed in the array. Any leftover text is not included in the array at
- * all. The array may contain fewer entries than limit if the end of the string
- * is reached before the limit is reached. If limit is 0, [] is returned.
- * @returns An Array of strings, split at each point where the separator occurs
- * in the given string.
- * @signature
- *   P.split(separator, limit)(data);
- * @example
- *   P.pipe("a,b,c", P.split(",")); //=> ["a", "b", "c"]
- *   P.pipe("a,b,c", P.split(",", 2)); //=> ["a", "b"]
- *   P.pipe("a1b2c3d", P.split(/\d/u)); //=> ["a", "b", "c", "d"]
- * @dataLast
- * @category String
- */
-declare function split(separator: RegExp, limit?: number): (data: string) => Array<string>;
-declare function split<S extends string, Separator extends string, N extends number | undefined = undefined>(separator: Separator, limit?: N): (data: S) => Split$1<S, Separator, N>;
-//#endregion
-export { split };
-//# sourceMappingURL=split.d.ts.map