@vinicunca/perkakas 0.5.4 → 1.0.1

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

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

package/dist/sorted-index-with.js

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

package/dist/sorted-index.cjs

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

package/dist/sorted-index.d.cts

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

package/dist/sorted-index.d.ts

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

package/dist/sorted-index.js

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

package/dist/sorted-last-index-by.cjs

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

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

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

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

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

package/dist/sorted-last-index-by.js

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

package/dist/sorted-last-index.cjs

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

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

@@ -0,0 +1,43 @@
+/**
+ * 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;
+
+export { sortedLastIndex };

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

@@ -0,0 +1,43 @@
+/**
+ * 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;
+
+export { sortedLastIndex };

package/dist/sorted-last-index.js

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

package/dist/splice.cjs

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

package/dist/splice.d.cts

@@ -0,0 +1,33 @@
+/**
+ * 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>;
+
+export { splice };

package/dist/splice.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 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>;
+
+export { splice };

package/dist/splice.js

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

package/dist/split-at.cjs

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

package/dist/split-at.d.cts

@@ -0,0 +1,29 @@
+/**
+ * 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>];
+
+export { splitAt };

package/dist/split-at.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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>];
+
+export { splitAt };

package/dist/split-at.js

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

package/dist/split-when.cjs

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

package/dist/split-when.d.cts

@@ -0,0 +1,27 @@
+/**
+ * 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>];
+
+export { splitWhen };

package/dist/split-when.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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>];
+
+export { splitWhen };

package/dist/split-when.js

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

package/dist/split.cjs

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