@vinicunca/perkakas 1.7.1 → 1.9.0

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

@@ -0,0 +1,72 @@
+//#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-tKmeBThm.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sorted-last-index-by-tKmeBThm.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-by.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkSNYQNW6Tcjs = require('./chunk-SNYQNW6T.cjs');require('./chunk-7TDMV2GO.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');require('./chunk-MBGSSEZN.cjs');exports.sortedLastIndexBy = _chunkSNYQNW6Tcjs.a;
+require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`),require(`./binary-search-cutoff-index-BZF3GL7H.cjs`);const e=require(`./sorted-last-index-by-Bwy_FXV3.cjs`);exports.sortedLastIndexBy=e.sortedLastIndexBy;

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

@@ -1,70 +1,2 @@
-/**
- * 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 };
+import { sortedLastIndexBy } from "./sorted-last-index-by-CypmQpWR.cjs";
+export { sortedLastIndexBy };

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

@@ -1,70 +1,2 @@
-/**
- * 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 };
+import { sortedLastIndexBy } from "./sorted-last-index-by-tKmeBThm.js";
+export { sortedLastIndexBy };

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

@@ -1 +1 @@
-import{a}from"./chunk-VJUK4I7J.js";import"./chunk-JZ463SIK.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";import"./chunk-EK7ODJWE.js";export{a as sortedLastIndexBy};
+import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import"./binary-search-cutoff-index-YVs_m4IY.js";import{sortedLastIndexBy as e}from"./sorted-last-index-by-D6I-_BRT.js";export{e as sortedLastIndexBy};

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

@@ -0,0 +1,2 @@
+import{curry as e}from"./curry-CzZjDrpv.js";import{binarySearchCutoffIndex as t}from"./binary-search-cutoff-index-YVs_m4IY.js";function n(...t){return e(r,t)}function r(e,n){return t(e,e=>e<=n)}export{n as sortedLastIndex};
+//# sourceMappingURL=sorted-last-index-eCG7G76u.js.map

package/dist/sorted-last-index-eCG7G76u.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sorted-last-index-eCG7G76u.js","names":[],"sources":["../src/sorted-last-index.ts"],"sourcesContent":["import { curry } from './curry';\nimport { binarySearchCutoffIndex } from './internal/binary-search-cutoff-index';\n\n/**\n * Find the insertion position (index) of an item in an array with items sorted\n * in ascending order; so that `splice(sortedIndex, 0, item)` would result in\n * maintaining the array's sort-ness. The array can contain duplicates.\n * If the item already exists in the array the index would be of the *last*\n * occurrence of the item.\n *\n * Runs in O(logN) time.\n *\n * @param data - The (ascending) sorted array.\n * @param item - The item to insert.\n * @returns Insertion index (In the range 0..data.length).\n * @signature\n *    P.sortedLastIndex(data, item)\n * @example\n *    P.sortedLastIndex(['a','a','b','c','c'], 'c') // => 5\n * @dataFirst\n * @category Array\n * @see sortedIndex, sortedIndexBy, sortedIndexWith, sortedLastIndexBy\n */\nexport function sortedLastIndex<T>(data: ReadonlyArray<T>, item: T): number;\n\n/**\n * Find the insertion position (index) of an item in an array with items sorted\n * in ascending order; so that `splice(sortedIndex, 0, item)` would result in\n * maintaining the array's sort-ness. The array can contain duplicates.\n * If the item already exists in the array the index would be of the *last*\n * occurrence of the item.\n *\n * Runs in O(logN) time.\n *\n * @param item - The item to insert.\n * @returns Insertion index (In the range 0..data.length).\n * @signature\n *    P.sortedLastIndex(item)(data)\n * @example\n *    P.pipe(['a','a','b','c','c'], sortedLastIndex('c')) // => 5\n * @dataLast\n * @category Array\n * @see sortedIndex, sortedIndexBy, sortedIndexWith, sortedLastIndexBy\n */\nexport function sortedLastIndex<T>(item: T): (data: ReadonlyArray<T>) => number;\n\nexport function sortedLastIndex(...args: ReadonlyArray<unknown>): unknown {\n  return curry(sortedLastIndexImplementation, args);\n}\n\nfunction sortedLastIndexImplementation<T>(\n  array: ReadonlyArray<T>,\n  item: T,\n): number {\n  return binarySearchCutoffIndex(\n    array,\n    // The only difference between the regular implementation and the \"last\"\n    // variation is that we consider the pivot with equality too, so that we\n    // skip all equal values in addition to the lower ones.\n    (pivot) => pivot <= item,\n  );\n}\n"],"mappings":"+HA8CA,SAAgB,EAAgB,GAAG,EAAuC,CACxE,OAAO,EAAM,EAA+B,EAAK,CAGnD,SAAS,EACP,EACA,EACQ,CACR,OAAO,EACL,EAIC,GAAU,GAAS,EACrB"}

package/dist/sorted-last-index.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkBX7F2U4Pcjs = require('./chunk-BX7F2U4P.cjs');require('./chunk-7TDMV2GO.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');require('./chunk-MBGSSEZN.cjs');exports.sortedLastIndex = _chunkBX7F2U4Pcjs.a;
+require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`),require(`./binary-search-cutoff-index-BZF3GL7H.cjs`);const e=require(`./sorted-last-index-CwZ0vU7v.cjs`);exports.sortedLastIndex=e.sortedLastIndex;

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

@@ -1,43 +1,2 @@
-/**
- * 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 };
+import { sortedLastIndex } from "./sorted-last-index-BXVeuqVW.cjs";
+export { sortedLastIndex };

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

@@ -1,43 +1,2 @@
-/**
- * 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 };
+import { sortedLastIndex } from "./sorted-last-index-DKDuZV51.js";
+export { sortedLastIndex };

package/dist/sorted-last-index.js

@@ -1 +1 @@
-import{a}from"./chunk-UXW7KBAK.js";import"./chunk-JZ463SIK.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";import"./chunk-EK7ODJWE.js";export{a as sortedLastIndex};
+import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import"./binary-search-cutoff-index-YVs_m4IY.js";import{sortedLastIndex as e}from"./sorted-last-index-eCG7G76u.js";export{e as sortedLastIndex};

package/dist/splice-BAV6QQGX.cjs

@@ -0,0 +1 @@
+const e=require(`./curry-BPVIsvo3.cjs`);function t(...t){return e.curry(n,t)}function n(e,t,n,r){let i=[...e];return i.splice(t,n,...r),i}Object.defineProperty(exports,`splice`,{enumerable:!0,get:function(){return t}});

package/dist/splice-Bqzh0vwZ.d.ts

@@ -0,0 +1,35 @@
+//#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-Bqzh0vwZ.d.ts.map

package/dist/splice-Bqzh0vwZ.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"splice-Bqzh0vwZ.d.ts","names":[],"sources":["../src/splice.ts"],"sourcesContent":[],"mappings":";;AAiBA;;;;;;;;;AAqBA;;;;;AAIW,iBAzBK,MAyBL,CAAA,CAAA,CAAA,CAAA,KAAA,EAxBF,aAwBE,CAxBY,CAwBZ,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,WAAA,EAAA,MAAA,EAAA,WAAA,EArBI,aAqBJ,CArBkB,CAqBlB,CAAA,CAAA,EApBR,KAoBQ,CApBF,CAoBE,CAAA;;;;;;;;;;;;;;;iBAJK,2DAGD,cAAc,aAClB,cAAc,OAAO,MAAM"}

package/dist/splice-Rtj9OHe-.d.cts

@@ -0,0 +1,35 @@
+//#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-Rtj9OHe-.d.cts.map

package/dist/splice-Rtj9OHe-.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"splice-Rtj9OHe-.d.cts","names":[],"sources":["../src/splice.ts"],"sourcesContent":[],"mappings":";;AAiBA;;;;;;;;;AAqBA;;;;;AAIW,iBAzBK,MAyBL,CAAA,CAAA,CAAA,CAAA,KAAA,EAxBF,aAwBE,CAxBY,CAwBZ,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,WAAA,EAAA,MAAA,EAAA,WAAA,EArBI,aAqBJ,CArBkB,CAqBlB,CAAA,CAAA,EApBR,KAoBQ,CApBF,CAoBE,CAAA;;;;;;;;;;;;;;;iBAJK,2DAGD,cAAc,aAClB,cAAc,OAAO,MAAM"}

package/dist/splice-jmQkkqUQ.js

@@ -0,0 +1,2 @@
+import{curry as e}from"./curry-CzZjDrpv.js";function t(...t){return e(n,t)}function n(e,t,n,r){let i=[...e];return i.splice(t,n,...r),i}export{t as splice};
+//# sourceMappingURL=splice-jmQkkqUQ.js.map

package/dist/splice-jmQkkqUQ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"splice-jmQkkqUQ.js","names":[],"sources":["../src/splice.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Removes elements from an array and, inserts new elements in their place.\n *\n * @param items - The array to splice.\n * @param start - The index from which to start removing elements.\n * @param deleteCount - The number of elements to remove.\n * @param replacement - The elements to insert into the array in place of the deleted elements.\n * @signature\n *    P.splice(items, start, deleteCount, replacement)\n * @example\n *    P.splice([1,2,3,4,5,6,7,8], 2, 3, []); //=> [1,2,6,7,8]\n *    P.splice([1,2,3,4,5,6,7,8], 2, 3, [9, 10]); //=> [1,2,9,10,6,7,8]\n * @dataFirst\n * @category Array\n */\nexport function splice<T>(\n  items: ReadonlyArray<T>,\n  start: number,\n  deleteCount: number,\n  replacement: ReadonlyArray<T>,\n): Array<T>;\n\n/**\n * Removes elements from an array and, inserts new elements in their place.\n *\n * @param start - The index from which to start removing elements.\n * @param deleteCount - The number of elements to remove.\n * @param replacement - The elements to insert into the array in place of the deleted elements.\n * @signature\n *    P.splice(start, deleteCount, replacement)(items)\n * @example\n *    P.pipe([1,2,3,4,5,6,7,8], P.splice(2, 3, [])) // => [1,2,6,7,8]\n *    P.pipe([1,2,3,4,5,6,7,8], P.splice(2, 3, [9, 10])) // => [1,2,9,10,6,7,8]\n * @dataLast\n * @category Array\n */\nexport function splice<T>(\n  start: number,\n  deleteCount: number,\n  replacement: ReadonlyArray<T>,\n): (items: ReadonlyArray<T>) => Array<T>;\n\nexport function splice(...args: ReadonlyArray<unknown>): unknown {\n  return curry(spliceImplementation, args);\n}\n\nfunction spliceImplementation<T>(\n  items: ReadonlyArray<T>,\n  start: number,\n  deleteCount: number,\n  replacement: ReadonlyArray<T>,\n): Array<T> {\n  // TODO: When node 18 reaches end-of-life bump target lib to ES2023+ and use `Array.prototype.toSpliced` here.\n  const result = [...items];\n  result.splice(start, deleteCount, ...replacement);\n  return result;\n}\n"],"mappings":"4CA4CA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,EAAK,CAG1C,SAAS,EACP,EACA,EACA,EACA,EACU,CAEV,IAAM,EAAS,CAAC,GAAG,EAAM,CAEzB,OADA,EAAO,OAAO,EAAO,EAAa,GAAG,EAAY,CAC1C"}

package/dist/splice.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkGSFIDOPZcjs = require('./chunk-GSFIDOPZ.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');require('./chunk-MBGSSEZN.cjs');exports.splice = _chunkGSFIDOPZcjs.a;
+require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./splice-BAV6QQGX.cjs`);exports.splice=e.splice;

package/dist/splice.d.cts

@@ -1,33 +1,2 @@
-/**
- * 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 };
+import { splice } from "./splice-Rtj9OHe-.cjs";
+export { splice };

package/dist/splice.d.ts

@@ -1,33 +1,2 @@
-/**
- * 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 };
+import { splice } from "./splice-Bqzh0vwZ.js";
+export { splice };

package/dist/splice.js

@@ -1 +1 @@
-import{a}from"./chunk-KZJPXI6A.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";import"./chunk-EK7ODJWE.js";export{a as splice};
+import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{splice as e}from"./splice-jmQkkqUQ.js";export{e as splice};

package/dist/split-4732uYSL.d.cts

@@ -0,0 +1,62 @@
+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
+ *   R.split(data, separator, limit);
+ * @example
+ *   R.split("a,b,c", ","); //=> ["a", "b", "c"]
+ *   R.split("a,b,c", ",", 2); //=> ["a", "b"]
+ *   R.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
+ *   R.split(separator, limit)(data);
+ * @example
+ *   R.pipe("a,b,c", R.split(",")); //=> ["a", "b", "c"]
+ *   R.pipe("a,b,c", R.split(",", 2)); //=> ["a", "b"]
+ *   R.pipe("a1b2c3d", R.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-4732uYSL.d.cts.map

package/dist/split-4732uYSL.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-4732uYSL.d.cts","names":[],"sources":["../src/split.ts"],"sourcesContent":[],"mappings":";;;KAOK,+GAIc,IACf,+BACe,YACb,+BACe,IACb,gBAEF,QAAQ,kBACJ,gBACA,WAIE,MAAU,GAAG,eAIb,mBAAmB,YAAY;;AAvBxB;;;;;;;;;;;;;;;;;;;AAoDnB;;;;;AAKA;AAAqB,iBALL,KAAA,CAKK,IAAA,EAAA,MAAA,EAAA,SAAA,EAHR,MAGQ,EAAA,KAAA,CAAA,EAAA,MAAA,CAAA,EADlB,KACkB,CAAA,MAAA,CAAA;AAIb,iBAJQ,KAIR,CAAA,UAAA,MAAA,EAAA,kBAAA,MAAA,EAAA,UAAA,MAAA,GAAA,SAAA,GAAA,SAAA,CAAA,CAAA,IAAA,EAAA,CAAA,EAAA,SAAA,EAAc,SAAd,EAAA,KAAA,CAAA,EAAiC,CAAjC,CAAA,EAAqC,OAArC,CAA2C,CAA3C,EAA8C,SAA9C,EAAyD,CAAzD,CAAA;;;;;;;;AA2BR;;;;;AAIA;;;;;;;;;;;;;iBAJgB,KAAA,YACH,2CAEQ;iBACL,uGAIH,mBAAmB,WAAW,MAAM,QAAM,GAAG,WAAW"}

package/dist/split-BCgeOz9S.cjs

@@ -0,0 +1 @@
+function e(e,t,n){return typeof t==`number`||t===void 0?n=>n.split(e,t):e.split(t,n)}Object.defineProperty(exports,`split`,{enumerable:!0,get:function(){return e}});